Question

我正在试图弄清楚我做错了什么来获得以下编译器错误，我正在使用Bloodshed Dev-C ++ 4.9.9.2：

阅读错误： 'stackType :: stackType（const stackType＆amp;）'的原型与我的复制构造函数的一个定义中的任何类'stackType'和非模板'stackType :: stackType（const stackType＆amp;）'的模板定义不匹配

stackType<Type>::stackType(const stackType<Type>& otherStack) //definition of copy constructor
{
     list = NULL;
     copyStack(otherStack);
}

另一个错误是stackType :: stackType（int）但它没有说明代码的任何进一步定义构造函数的错误是这样的：

template <class Type>
stackType<Type>::stackType(int stackSize) //definition of constructor
{
     if (stackSize <= 0)
     {
          cout << "Size of the array holding the stack must be positive." << endl;
          cout << "Creating an array of size 100." << endl;
          maxStackSize = 100;
     }
     else
          maxStackSize = stackSize; //sets stack size to value specified by parameter stackSize
          stackTop = 0; //sets stackTop to 0
          list = new Type[maxStackSize]; //creates array to hold elements of the stack
}

我的最终错误，我正在获取状态在C：\ Users \ Owner \ Desktop \ SD254 \ SD254 Unit7B.cpp中包含的文件中，并且再次没有进一步说明。上面显然是主文件存储在我的计算机上的目录，但为什么这是一个问题？我的完整代码如下。

头文件：

#ifndef H_StackType
#define H_StackType
#include <iostream>
#include <cassert>


using namespace std;

template <class Type>
class stackADT
{
      public:
             virtual void initializeStack() = 0; //initialize stack
             virtual bool isEmptyStack() const = 0; //determines whether stack is empty or not
             virtual bool isFullStack() const = 0; //determines whether stack is full or not
             virtual void push(const Type& newItem) = 0; //adds new item to the stack
             virtual Type top() const = 0; //returns the top element to the stack
             virtual void pop() = 0; //removes the top element of the stack
};
template <class Type>
class stackType: public stackADT<Type>
{
      public:
             const stackType<Type>& operator=(const stackType<Type>&); //overloads assignment operator
             void initializeStack(); //initializes stack to empty state
             bool isEmptyStack() const; //determines stack is empty
             bool isFullStack() const; //determines stack is not full
             void push(const Type& newItem); //adds new item to stack
             Type top() const; //return the top element of the stack
             void pop(); //removes top element of the stack
             stackType(int stackSize = 100); //constructor and creates array with default size of 100
             ~stackType(); //destructor and removes all elements from the stack
             void copyStack(const stackType<Type>& otherStack); //copies other stack
      private:
              int maxStackSize; //stores maximum stack size
              int stackTop; //point to the top of the stack
              Type *list; //pointer to the array that holds the stack elements

};
template <class Type>
void stackType<Type>::initializeStack() //definition of function intializeStack
{
     stackTop = 0;
}
template <class Type>
bool stackType<Type>::isEmptyStack() const //definition of function isEmptyStack
{
     return(stackTop == 0);
}
template <class Type>
bool stackType<Type>::isFullStack() const //definition of function isFullStack
{
      return (stackTop == maxStackSize);
}
template <class Type>
void stackType<Type>::push(const Type& newItem) //definition of push function
{
     if (!isFullStack())
     {
          list[stackTop] = newItem; //adds new item to top of stack
          stackTop++; //increments stackTop
     }
     else
          cout << "Cannot add to a full stack." << endl;
}
template <class Type>
Type stackType<Type>::top() const //definition of top-returns the top element to the stack
{
     assert(stackTop != 0); //if stack is empty terminate program
     return list[stackTop - 1]; //return element of the stack indicated by stackTop -1
}
template <class Type>
void stackType<Type>::pop() //definition of function pop
{
     if (!isEmptyStack())
          stackTop--; //decrement stackTop
     else
          cout << "Cannot remove from an empty stack." << endl;
}
template <class Type>
void stackType<Type>::copyStack(const stackType<Type>& otherStack) //definition to make copy of stack
{
     delete [] list;
     maxStackSize = otherStack.maxStackSize;
     stackTop = otherStack.stackTop;
     list = new Type[maxStackSize]; //copies otherStack into this one
     for (int j = 0; j < stackTop; j++)
          list[j] = otherStack.list[j];
}
template <class Type>
stackType<Type>::stackType(int stackSize) //definition of constructor
{
     if (stackSize <= 0)
     {
          cout << "Size of the array holding the stack must be positive." << endl;
          cout << "Creating an array of size 100." << endl;
          maxStackSize = 100;
     }
     else
          maxStackSize = stackSize; //sets stack size to value specified by parameter stackSize
          stackTop = 0; //sets stackTop to 0
          list = new Type[maxStackSize]; //creates array to hold elements of the stack
 }
template <class Type>
stackType<Type>::~stackType() //definition of destructor
{
     delete [] list; //deallocates the memory occupied by the array
}
template <class Type>
stackType<Type>::stackType(const stackType<Type>& otherStack) //definition of copy constructor
{
     list = NULL;
     copyStack(otherStack);
}
template <class Type>
const stackType<Type>& stackType<Type>::operator=(const stackType<Type>& otherStack) //overload assignment operator
{
      if (this != &otherStack) 
           copyStack(otherStack);
      return *this;
}
#endif

实际的程序文件是：

#include <iostream>
#include "myStack.h"

using namespace std;
void testCopyConstructor(stackType<int> otherStack);
int main()
{
    stackType<int> stack(25);
    stackType<int> copyStack(25);
    stackType<int> dummyStack(50);

    stack.initializeStack();
    stack.push(15);
    stack.push(10);
    stack.push(20);
    copyStack = stack; //copies stack into copyStack

    cout << "The elements of copyStack: " ;
    while (!copyStack.isEmptyStack()) //prints copyStack
    {
          cout << copyStack.top() << " ";
          copyStack.pop();
    }
    cout << endl;
    copyStack = stack;
    testCopyConstructor(stack); //tests the copy constructor
    if (!stack.isEmptyStack())
         cout << "The original stack is not empty." << endl; 
         cout << "The top element of the original stack: " << copyStack.top() << endl;
    dummyStack = stack; //copies stack into dummyStack
    cout << "The elements of dummyStack: ";
    while (!dummyStack.isEmptyStack()) //prints dummyStack
    {
          cout << dummyStack.top() << " " ;
          dummyStack.pop();
    }
    cout << endl;
    return 0;
 }
void testCopyConstructor(stackType<int> otherStack)
{
     if (!otherStack.isEmptyStack())
         cout << "otherStack is not empty." << endl; 
         cout << "The top element of otherStack: " << otherStack.top() << endl;
}

任何人都可以帮我弄清楚如何修复错误，这样我就可以正确编译和构建错误，提前感谢我收到的任何帮助。

Answer 1

您必须在类定义中为复制构造函数添加声明;你不能只是明确地定义它。

类定义应该类似于

template<typename Type>
class stackType: public stackADT<Type>
{
public:
    stackType(const stackType&);
    // ... all the other stuff
};

然后将识别下面的功能定义。

BloodShed Dev C ++上的C ++编译器错误

1 个答案: