c++栈实现(家庭作业)

进展顺利。我现在的问题是关于拷贝构造和深度拷贝。我的堆栈目前一直在崩溃，我有一种感觉，它正在这样做，因为它所依赖的类不允许复制构造和操作符重载。但无论如何，这是我的代码(我为代码量道歉，但它可能是必要的，以了解我失败的地方):

依赖类，链表

#ifndef linkList_H
#define linkList_H

//
// Create an object to represent a Node in the linked list object
// (For now, the objects to be put in the list will be integers)
//
struct Node
{
    int   number;
    Node* next;
    Node* prev;
    // needs copy constructor?
    // needs overloaded assignment operators for copying?
    // needs overloaded operators for incrementing and decrementing?
};

//
// Create an object to keep track of all parts in the list
//
class List
{
public:
    //
    // Contstructor intializes all member data
    //
    List() : m_size(0), m_listHead(0) {}
    //
    // methods to return size of list and list head
    //
    Node*    getListHead() const { return m_listHead; }
    unsigned getListSize() const { return m_size; }
    //
    // methods for adding and inserting a new node to the linked list, 
    // retrieving and deleting a specified node in the list
    //
    void  addNode(int num);
    void  deleteNode(Node* current);
    void  insertHead(Node* current);
    void  insertAfter(Node* current, int newValue);
    void  insertBefore(Node* current, int newValue);
    Node* retrieveNode(unsigned position);
private:
    //
    // member data consists of an unsigned integer representing
    // the list size and a pointer to a Node object representing head
    //
    Node*    m_listHead;
    unsigned m_size;
};
#endif

linkedList的实现

#include "linkList.h"
#include <iostream>
using namespace std;

//
// Adds a new node to the linked list
//
void List::addNode(int num)
{
    Node *newNode = new Node;
    newNode->number = num;
    newNode->next = m_listHead;
    if( m_listHead )
        m_listHead->prev = newNode;
    m_listHead = newNode;
    ++m_size;
}

//
// Inserts a node which has already been set to front
// of the list
//
void List::insertHead(Node* current)
{
    int value = current->number;
    deleteNode(current);
    addNode(value);
}

//
// Inserts a node which has already been set before a
// specified location in the list
//
void List::insertBefore(Node* current, int newValue)
{
    current = current->prev;
    current->number = newValue;
}

//
// Inserts a node which has already been set before a
// specified location in the list
//
void List::insertAfter(Node* current, int newValue)
{
    current = current->next;
    current->number = newValue;
}

//
// Deletes a node from a specified position in linked list
//
void List::deleteNode(Node* current)
{
    --m_size;
    if(current == m_listHead) 
        m_listHead = current->next;
    if(current->prev) 
        current->prev->next = current->next;
    if(current->next) 
       current->next->prev = current->prev;
}

//
// Retrieves a specified node from the list
//
Node* List::retrieveNode(unsigned position)
{
    if(position > (m_size-1) || position < 0)
    {
        cout << "Can't access node; out of list bounds";
        cout << endl;
        cout << endl;
        exit(EXIT_FAILURE);
    }
    Node* current = m_listHead;
    unsigned pos = 0;
    while(current != 0 && pos != position)
    {
        current = current->next;
        ++pos;
    }
    return current;
}

下面是堆栈类:

#ifndef stack_H
#define stack_H
#include "linkList.h"

class Stack
{
public:
    //
    // Constructor, copy constructor and destructor to initialize stack 
    // data, copy data and clear up memory, respectively
    //
   Stack() : m_top(0), m_stack(new List()) {}
   Stack(const Stack &rhs);
   ~Stack() { delete [] m_stack; }
    //
    // functionality to determine if stack is empty
    //
    bool isEmpty();
    //
    // methods for pushing data on to stack and for
    // popping data from the stack
    //
    void push(int newValue);
    int  pop();
    //
    // accessor functions for retrieving the value on top of stack
    // and for returning the stack size
    //
    int getTop() const { return m_top->number; }
    int getSize() const { return m_stack->getListSize(); }
    //
    // overloaded assignment operator for copying stack
    //
    Stack& operator=(const Stack &rhs);
private:
    //
    // member data which represent the stack, the top
    // of the stack and the size of the stack
    //
    Node* m_top;
    List* m_stack;
};
#endif

最后，这里是堆栈实现

#include "stack.h"
#include <iostream>
using namespace std;
//
// Copy constructor
//
Stack::Stack(const Stack &rhs)
    : m_top(rhs.m_top), m_stack(rhs.m_stack)
{
}
//
// if the Top of stack is zero, return true
//
bool Stack::isEmpty()
{
    if( m_top == 0 ) return true;
    else return false;
}
//
// increment stack pointer, place new value in stack
//
void Stack::push(int newValue)
{
    ++m_top;               
    m_top->number = newValue;   // crashes on this statement
}
//
// if the stack is empty, throw an error message
//
int Stack::pop()
{
    if( isEmpty() )
    {
        cout << "Error: stack underflow" << endl;
        exit(EXIT_FAILURE);
    }
    --m_top;
    return (m_top + 1)->number;
}

Stack& Stack::operator=(const Stack &rhs)
{
    if( this != &rhs )
        delete [] m_stack;
    m_stack = new List();
    m_stack = rhs.m_stack;
    m_top = rhs.m_top;
   return *this;
}

程序在主程序中执行以下简单代码后崩溃:

Stack stack;
stack.push(1);

再次为这里的代码量感到抱歉。我相信我这里的问题是，节点对象需要重载操作符，以便"增量"或"减量"创建/删除节点时，一个值被推/弹出到堆栈。是这样吗?另外，我不确定是否需要Node对象的复制构造函数。这里可能有更多的问题(也许算法是不正确的?也许复制构造是不正确的堆栈?)。什么好主意吗?