Question

因此，我尝试使用链表作为父级来实现堆栈，并编写了以下两个类：

template <class T>
class LL {
    public:
        struct Node {
            Node* next = nullptr;
            T data = 0;
        };
        Node* head;
    public:
        LL();
        ~LL();
        void insert(T item);
        void append(T item);
        virtual void disp();
};

template<class T>
LL<T>::LL(){ head = nullptr; }

template<class T>
void LL<T>::insert(T item)
{
    Node* newNode = new Node;
    newNode->data = item;
    
    if (head == nullptr) head = newNode;
    else
    {
        Node* loop = head;
        Node* prev = nullptr;
        while (loop != nullptr && loop->data < item) {
            prev = loop;
            loop = loop->next;
        }

        if (prev == nullptr) { //head
            newNode->next = head;
            head = newNode;
        }
        else { //insert
            newNode->next = prev->next;
            prev->next = newNode;
        }
    }
}

template<class T>
void LL<T>::append(T item)
{
    Node* newNode = new Node;
    newNode->data = item;

    if (head == nullptr) head = newNode;
    else
    {
        Node* loop = head;
        while(loop->next != nullptr)
            loop = loop->next;
        loop->next = newNode;
    }
}

template<class T>
void LL<T>::disp()
{
    cout << "[";

    if (head) {
        if (head->next == nullptr)
            cout << head->data;
        else {
            Node* loop = head;
            while (loop->next != nullptr)
            {
                cout << loop->data << ",";
                loop = loop->next;
            }
            cout << loop->data;
        }
    }

    cout << "]" << endl;
}

template<class T>
LL<T>::~LL()
{
    if (head != nullptr) {
        while (head != nullptr) {
            Node* temp = head;
            head = head->next;
            delete temp;
            temp = nullptr;
        }
    }
}

template<class T>
class stack: public LL<T> {
    private: 
        
    public:
        stack();
        ~stack();
        virtual void push(T item);
        void pop(T ret);
        bool empty();
        void disp();
};

template<class T>
stack<T>::stack():LL<T>()
{
    
}

template<class T>
stack<T>::~stack()
{
}

template<class T>
void stack<T>::push(T item){ this->append(item); }

template<class T>
void stack<T>::pop(T ret)
{
    ret = this->head->data;
    this->head = this->head->next;
}

template<class T>
bool stack<T>::empty() { return false;}

template<class T>
void stack<T>::disp()
{
    Node<T>* loop = this->head;
    cout << "-" << endl;
    while (loop) {
        cout << loop->data << endl;
        loop = loop->next;
    }
    cout << "-";
}

问题出现在最后一个函数“disp()”中，它没有让我访问 Node 结构。它给了我错误“'节点'：未找到标识符”。这会阻止我声明所需的“循环”变量。据我所知，Node 结构应该从 LL 类继承并在堆栈类中受到保护。因此，我应该可以直接访问它。

有什么想法吗？

Answer 1

好的，所以我使用这篇文章解决了这个问题： Declaring a struct in a template class, undefined for member functions

我的 disp() 函数现在看起来像这样：

template<class T>
void stack<T>::disp()
{
    typename LL<T>::Node* loop = this->head;
    cout << "-" << endl;
    while (loop) {
        cout << loop->data << endl;
        loop = loop->next;
    }
    cout << "-";
}

无法从子类访问受保护的变量

1 个答案: