如何在 C++ 中调用另一个类中的类的构造函数？

Question

这是我的代码：

template<class Datatype>
class Node
{
    public:
        Node()
        {
            next = NULL;
            prev = NULL;
        }
        Node* getNext()
        {
            return next;
        }
        Node* getPrev()
        {
            return prev;
        }
        Datatype* getData()
        {
            return &data;
        }
        void changeNext()
        {
            next = NULL;
        }
        void changeNext(Node& nextNode)
        {
            next = &nextNode;
        }
        void changePrev()
        {
            prev = NULL;
        }
        void changePrev(Node& prevNode)
        {
            prev = &prevNode;
        }
        Node* addNext(Node &);
        Node* addPrev(Node &);
        void nodeDel();
        void addData(Datatype &);
    private:
        Node* next;
        Node* prev;
        Datatype data;
};

template<class Datatype>
class Stack
{
    public:
        Stack()
        {
            node.Node();
        }
        int push(Datatype &);
        Datatype pop();
        Datatype* peek();
    private:
        Node<Datatype> node;
};

编译错误是这样的：

my_node.h: In constructor ‘Stack<Datatype>::Stack() [with Datatype = float]’:
test.cpp:8:15:   instantiated from here
my_node.h:58:4: error: invalid use of ‘Node<float>::Node’

一开始，我并没有为 Stack 编写构造函数。但是，我感觉实际上我定义的node的构造函数并没有被调用，因为next和prev指针中有一些值。所以我尝试编写一个 Stack 的构造函数，它显式调用 Node 的构造函数。不幸的是，出现了上面显示的编译错误。我想知道如何调用另一个类中的类的构造函数。

谢谢， 周凯文

Answer 1

这个：

Stack()
{
    node.Node();
}

不是调用成员构造函数的正确方法。改用初始化列表：

Stack(): node()
{
}

需要注意的是，不需要显式调用默认构造函数。这意味着只有在调用自定义构造函数时才真正需要使用初始化列表。

Answer 2

如果你什么都不做，node 成员的默认构造函数将被调用。

如果你想显式构造一个成员，你可以在构造函数initializer list：

Stack()
    : node()
{}

由于无论如何都会调用默认构造函数，因此显式构造成员仅在需要将参数传递给构造函数（即调用它们的非默认构造函数）时才有用。

Answer 3

只需按照下面的方式更改类Stack的定义，因为你对类的定义是错误的

template<class Datatype>
class Stack
{
    public:
        Stack() : head( nullptr )
        {
        }
        int push(Datatype &);
        Datatype pop();
        Datatype* peek();
    private:
        Node<Datatype> *head;
};

考虑到堆栈节点应该只有一个对下一个节点的引用。所以类Node应该有以下数据成员

class Node
{
//...
    private:
        Node* next;
        Datatype data;
};

应排除数据成员节点 *prev。

如果 Node 类是 STack 类的内部类会更好。