我试图找出我的代码有什么问题。我无法更改函数定义，我必须按原样使用它们。我应该重载运算符==，它位于代码的最底层。
我一直收到这个错误：
错误C2662＆＃39; void stackType :: copyStack（const stackType＆amp;）＆＃39;：无法转换＆＃39;这个＆＃39;指针来自＆＃39; const stackType＆＃39;到＆＃39; stackType＆amp;＆＃39;
这是我的代码：
//Header file: myStack.h
#ifndef H_StackType
#define H_StackType
#include <iostream>
#include <cassert>
#include "stackADT.h"
using namespace std;
//*************************************************************
// This class specifies the basic operation on a stack as an
// array.
//*************************************************************
template <class Type>
class stackType: public stackADT<Type>
{
public:
const stackType<Type>& operator=(const stackType<Type>&);
//Overload the assignment operator.
void initializeStack();
//Function to initialize the stack to an empty state.
//Postcondition: stackTop = 0;
bool isEmptyStack() const;
//Function to determine whether the stack is empty.
//Postcondition: Returns true if the stack is empty,
// otherwise returns false.
bool isFullStack() const;
//Function to determine whether the stack is full.
//Postcondition: Returns true if the stack is full,
// otherwise returns false.
void push(const Type& newItem);
//Function to add newItem to the stack.
//Precondition: The stack exists and is not full.
//Postcondition: The stack is changed and newItem is
// added to the top of the stack.
Type top() const;
//Function to return the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: If the stack is empty, the program
// terminates; otherwise, the top element of the stack
// is returned.
void pop();
//Function to remove the top element of the stack.
//Precondition: The stack exists and is not empty.
//Postcondition: The stack is changed and the top element is
// removed from the stack.
bool operator==(const stackType<Type>& otherStack) const;
stackType(int stackSize = 100);
//Constructor
//Create an array of the size stackSize to hold
//the stack elements. The default stack size is 100.
//Postcondition: The variable list contains the base address
// of the array, stackTop = 0, and maxStackSize = stackSize
stackType(const stackType<Type>& otherStack);
//Copy constructor
~stackType();
//Destructor
//Remove all the elements from the stack.
//Postcondition: The array (list) holding the stack
// elements is deleted.
private:
int maxStackSize; //variable to store the maximum stack size
int stackTop; //variable to point to the top of the stack
Type *list; //pointer to the array that holds the stack elements
void copyStack(const stackType<Type>& otherStack);
//Function to make a copy of otherStack.
//Postcondition: A copy of otherStack is created and assigned
// to this stack.
};
template <class Type>
void stackType<Type>::initializeStack()
{
stackTop = 0;
}//end initializeStack
template <class Type>
bool stackType<Type>::isEmptyStack() const
{
return(stackTop == 0);
}//end isEmptyStack
template <class Type>
bool stackType<Type>::isFullStack() const
{
return(stackTop == maxStackSize);
} //end isFullStack
template <class Type>
void stackType<Type>::push(const Type& newItem)
{
if (!isFullStack())
{
list[stackTop] = newItem; //add newItem to the
//top of the stack
stackTop++; //increment stackTop
}
else
cout << "Cannot add to a full stack." << endl;
}//end push
template <class Type>
Type stackType<Type>::top() const
{
assert(stackTop != 0); //if stack is empty,
//terminate the program
return list[stackTop - 1]; //return the element of the
//stack indicated by
//stackTop - 1
}//end top
template <class Type>
void stackType<Type>::pop()
{
if (!isEmptyStack())
stackTop--; //decrement stackTop
else
cout << "Cannot remove from an empty stack." << endl;
}//end pop
template <class Type>
stackType<Type>::stackType(int stackSize)
{
if (stackSize <= 0)
{
cout << "Size of the array to hold the stack must "
<< "be positive." << endl;
cout << "Creating an array of size 100." << endl;
maxStackSize = 100;
}
else
maxStackSize = stackSize; //set the stack size to
//the value specified by
//the parameter stackSize
stackTop = 0; //set stackTop to 0
list = new Type[maxStackSize]; //create the array to
//hold the stack elements
}//end constructor
template <class Type>
stackType<Type>::~stackType() //destructor
{
delete[] list; //deallocate the memory occupied
//by the array
}//end destructor
template <class Type>
void stackType<Type>::copyStack(const stackType<Type>& otherStack)
{
delete[] list;
maxStackSize = otherStack.maxStackSize;
stackTop = otherStack.stackTop;
list = new Type[maxStackSize];
//copy otherStack into this stack
for (int j = 0; j < stackTop; j++)
list[j] = otherStack.list[j];
} //end copyStack
template <class Type>
stackType<Type>::stackType(const stackType<Type>& otherStack)
{
list = NULL;
copyStack(otherStack);
}//end copy constructor
template <class Type>
const stackType<Type>& stackType<Type>::operator= (const stackType<Type>& otherStack)
{
if (this != &otherStack) //avoid self-copy
copyStack(otherStack);
return *this;
} //end operator=
template <class Type>
bool stackType<Type>::operator== (const stackType<Type>& otherStack) const
{
stackType<Type> stackA, stackB;
bool result = false;
copyStack(stackA);
otherStack.copyStack(stackB);
while (!stackA.isEmptyStack() && !stackB.isEmptyStack())
{
if (stackA.top() == stackB.top())
{
stackA.pop();
stackB.pop();
if (stackA.isEmptyStack() && stackB.isEmptyStack())
{
result = true;
}
}
else
{
result = false;
}
}
return result;
}
#endif
答案 0 :(得分：2)
copyStack(stackA);
您的operator== const方法调用copyStack()方法，这是一种非const方法。
const方法只能调用其他const方法。对您的代码进行简要检查似乎表明您打算这样做
stackA.copyStack(*this);
代替。您的operator==显然打算先将要比较的对象复制到临时Stacktype个对象中。
答案 1 :(得分：1)
看起来您对要拨打copyStack的内容感到困惑。
我相信这两行：
copyStack(stackA);
otherStack.copyStack(stackB);
应该是
stackA.copyStack(*this);
stackB.copyStack(otherStack);
否则，您将空stackA复制到自己，然后stackB复制到otherStack。由于copyStack的接收者是非const（即copyStack是非const成员函数），因此失败。这似乎是一种实现operator==的奇怪方式，因为您可以比较现有元素，而不是重复复制和弹出。