如何在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成员的默认构造函数。

如果要显式构造成员，请在构造函数的初始值设定项列表中进行操作 ：

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;
};

数据成员Node * prev应该被排除。

同样，如果Node类是STack类的内部类，那就更好了。