Question

我有一个“stack.h”和一个“stack.cpp”文件，用于定义手工堆栈类。

我现在要做的是创建另一个类“名称”，其中包含“nr”堆栈的向量，我不知道从哪里开始。

depou.h：

#pragma once
#include <vector>
#include "stiva.h"

template <class T>
class depou {
private:
    int nr;
    std::vector<stiva<T> > depouArray;

public:
    depou (int x, int lungTren);
};

template <class T>
depou<T>::depou (int x, int lungTren){
    int i;
    nr = x;
    depouArray = new std::vector<stiva<T> > (nr);
/*  for (i=0; i<nr; i++){
        depouArray[i] = stiva<T> (lungTren);
    } this is incorrect */
}

我的name.h不编译我只是想知道是否可以做这种矢量。

我的堆栈标题名为“stiva”，所以我根据这个编辑了“name.h”文件。

stiva.h

#pragma once

template <class T>
class stiva {
private:
    int top;
    int size;
    T *stackArray;

public:
    stiva();
    stiva (int s);
    ~stiva (){ delete [] stackArray; }
    int push (const T&);
    int pop (T&);
  int topElem (T&);
    int isEmpty (){return top == -1;}
    int isFull () {return top == size -1;}
    int search (T x);
    void setSize (const int& sz){
        size=sz;
    }
};

template <class T>
stiva<T>::stiva (){
    size = 10;
    top = -1;
    stackArray = new T[size];
}

template <class T>
stiva<T>::stiva (int s){
    size = s>0 && s<1000? s : 10;
    top = -1;
    stackArray = new T[size];
}

template <class T>
int stiva<T>::push (const T& x){
    if (!isFull()){
        stackArray[++top] = x;
        return 1;
    }
    else{
        size *= 2;
        stackArray = (T*) realloc (stackArray, 2*size * sizeof(T));
        stackArray[++top] = x;
        return 1;
    }
    return 0;
}

template <class T>
int stiva<T>::pop (T& popValue){
    if (!isEmpty ()){
        popValue = stackArray[top--];
        return 1;
    }
    return 0;
}

template <class T>
int stiva<T>::topElem (T& topValue){
    if (!isEmpty ()){
        topValue = stackArray[top];
        return 1;
    }
    return 0;
}

在main中我初始化如下：

depou d（5,10）;

Answer 1

您不需要在该代码中使用calloc（如果编译它，它也可能是恶意的）。

事实上，如果您的代码只需要将类似std::vector<std::stack<T>>的类型重命名为更具可读性的类型，则可以使用：

template<typename T> using name = std::vector<stack<T>>;

代替。

否则，您只需使用以下命令修复当前代码：

name (int x)
    : nr(x)
    , nameArray(nr)
    {}

Answer 2

只要nameArray接受模板参数，stack的声明即可。但你错误地使用nameArray。试试这个：

name (int x){
  nr = x;
  nameArray.resize(x);
}

Answer 3

您可以在构造函数的成员初始值设定项中将向量初始化为给定大小：

template <class T>
class name {
private:
    int nr;
    std::vector<stack<T> > nameArray;

public:
    name (int x) : nr(x), nameArray(nr) {}
    //other methods
};

这里的工作示例：http://codepad.org/ZT9iuQEg

Answer 4

在构造函数中，您有：

    nameArray = (stack<T>*) calloc (nr, sizeof(stack<T>) );

这一行有几个问题。

在此声明中，您将stack<T>*分配给std :: vector＆gt;。编译器应该告诉你这不是一个有效的任务。
尝试在C ++中使用new和delete运算符。

您可以通过将构造函数更改为更简单的形式来解决问题：

name (int x) : nr(x), nameArray(x) {}

是否可以在模板类中使用，类堆栈元素的向量？

4 个答案: