c++；在节点内存储对数据对象的引用，而不复制数据我对C++是非常新的，并且尝试构造一个基本的链接列表节点，以便基本上理解整个指针/引用的东西。_C++

c++；在节点内存储对数据对象的引用，而不复制数据我对C++是非常新的，并且尝试构造一个基本的链接列表节点，以便基本上理解整个指针/引用的东西。

c++

c++；在节点内存储对数据对象的引用，而不复制数据我对C++是非常新的，并且尝试构造一个基本的链接列表节点，以便基本上理解整个指针/引用的东西。,c++,C++,我试图在我的节点类中存储对传递给构造函数的对象的引用我还创建了一个复制构造函数，以便查看何时复制节点（用于测试目的）节点代码如下： #include <iostream> using namespace std; template<typename T> struct Node { Node(const T &d): data(d), next(nullptr), prev(nullptr){ ; cout <

我试图在我的节点类中存储对传递给构造函数的对象的引用

我还创建了一个复制构造函数，以便查看何时复制节点（用于测试目的）

节点代码如下：

#include <iostream>
using namespace std;


template<typename T>
struct Node {

    Node(const T &d): data(d), next(nullptr), prev(nullptr){
        ;
        cout << "created Node obj" << endl;
    };

    Node (const Node &node) {
        cout << "Copied Node obj" << endl;
    }

    void setNext(Node *next){ this->next = next; };
    void setPrev(Node *prev){ this->prev = prev; };
    Node* getNext(){ return next ;};
    Node* getPrev(){ return prev ;};
    T& getData(){ return  data ;};

private:
    Node *next;
    Node *prev;
    T data;

};

更新首先，感谢大家的承诺，我正在考虑关于存储指针，甚至是副本的注意事项（我现在看到，这有时更有意义）

但是上面的代码主要用于指针/引用的实践，所以至少现在我想继续使用引用成员

尝试@underline\u d将成员类型更新为T&I的建议后，得到了以下结果：

首先，这个想法（CLION）让我更新复制构造函数-现在它必须更新初始化列表中的数据成员。我猜这是因为引用应该在创建时分配-有人可以批准/澄清这一点吗

因此，代码如下：

template<typename T>
struct Node {

    Node(const T & d): data(d), next(nullptr), prev(nullptr){

        cout << "created Node obj" << endl;
    };

    Node (const Node &node): data(node.getData()) {
        cout << "Copied Node obj" << endl;
    }

    void setNext(Node *next){ this->next = next; };
    void setPrev(Node *prev){ this->prev = prev; };
    Node* getNext() const { return next ;};
    Node* getPrev() const { return prev ;};
    T& getData() const { return  data ;};

private:
    Node *next;
    Node *prev;
    T& data;

};

模板
结构节点{
节点（常数T&d）：数据（d）、下一个（空PTR）、上一个（空PTR）{
CUT我的C++已经生锈了，但是我相信，节点内的值被复制的事实是因为你定义了属性：
T data;

也就是说，类T
的对象。因此在（1）中，当创建节点时，它将引用参数（我指const T&d
）复制到属性data
，正如您在构造函数中用data（d）
声明的那样
可能一个T*data
as属性会有所帮助。在这种情况下，您可以选择：
a、 更改构造函数以接收T*作为参数，而不是引用T&（以及正确的相关代码）
b、 在构造函数中接收T&T，但在内部转换对指针的引用。为此，在构造函数中写入data（&d）
作为初始化。记住更改为T&getData（）{return*data；}
（以及任何相关内容）
关于它为什么显示：
created Node obj
Copied Node obj
created Node obj

这是因为：

在（1）中显示了第一个“创建节点obj”，因为Noden1{v1}；
创建节点n1
在（2）中，它显示了其他两条消息，因为：

Node>nn1{n1}；
复制节点n1
，因为数据（d）
其中d=n1并显示“复制的节点对象”
之后，执行构造函数的其余部分，其中显示“createnodeobj”


--编辑：
我支持@underline\d使用指针代替引用，这样可以避免很多问题：）
（@下划线_d，请不要删除您的评论，它们是解释性的）
--编辑2：
如果我没有错的话，关于你的问题：
error: binding 'const std::vector<int>' to reference of type 'std::vector<int>&' discards qualifiers

在构造函数中，您有一个const
参数，您不会复制它，而是引用它：
Node(const T & d): data(d)
Node (const Node &node): data(node.getData())

 C++中的引用不是指针，而是相同的对象。所以实际上，在一个地方有一个“const BrasBLAH”和一个“BLALBLAH”。你可以把非const转换成const，而不是另一种方法。
int a = 5;         // You can modify it
const int& b = a ; // and who cares if you are not going to
                   // modify 'b' (which is 'a' at the same time)

但不是：
const int a = 5; // You can't modify it
int& b = a;      // and no, we are not going to let you modify it 
                 // because you would modify 'a', but 'a' is const.

解决方案？要么去掉常量参数，要么尝试使常量成为节点的成员（但您将无法在中修改数据！）
我希望我没有错：
< p>我的C++已经生锈了，但是我相信，节点内的值被复制的事实是因为你定义了属性：
T data;

也就是说，类T
的对象。因此在（1）中，当创建节点时，它将引用参数（我指const T&d
）复制到属性data
，正如您在构造函数中用data（d）
声明的那样
可能一个T*data
as属性会有所帮助。在这种情况下，您可以选择：
a、 更改构造函数以接收T*作为参数，而不是引用T&（以及正确的相关代码）
b、 在构造函数中接收T&T，但在内部转换对指针的引用。为此，在构造函数中写入data（&d）
作为初始化。记住更改为T&getData（）{return*data；}
（以及任何相关内容）
关于它为什么显示：
created Node obj
Copied Node obj
created Node obj

这是因为：

在（1）中显示了第一个“创建节点obj”，因为Noden1{v1}；
创建节点n1
在（2）中，它显示了其他两条消息，因为：

Node>nn1{n1}；
复制节点n1
，因为数据（d）
其中d=n1并显示“复制的节点对象”
之后，执行构造函数的其余部分，其中显示“createnodeobj”


--编辑：
我支持@underline\d使用指针代替引用，这样可以避免很多问题：）
（@下划线_d，请不要删除您的评论，它们是解释性的）
--编辑2：
如果我没有错的话，关于你的问题：
error: binding 'const std::vector<int>' to reference of type 'std::vector<int>&' discards qualifiers

在构造函数中，您有一个const
参数，您不会复制它，而是引用它：
Node(const T & d): data(d)
Node (const Node &node): data(node.getData())

 C++中的引用不是指针，而是相同的对象。所以实际上，在一个地方有一个“const BrasBLAH”和一个“BLALBLAH”。你可以把非const转换成const，而不是另一种方法。
int a = 5;         // You can modify it
const int& b = a ; // and who cares if you are not going to
                   // modify 'b' (which is 'a' at the same time)

但不是：
const int a = 5; // You can't modify it
int& b = a;      // and no, we are not going to let you modify it 
                 // because you would modify 'a', but 'a' is const.

解决方案？要么去掉常量参数，要么尝试使常量成为节点的成员（但您将无法在中修改数据！）
我希望我没有错：）
正在复制向量，因为您正在使用常量T&初始化类型为T的对象。如果您只想存储对T的引用，则应该声明成员T&或常量T&而不是T。对于将节点传递到它复制的构造函数中的节点，也会发生同样的情况