C++ 返回指向成员变量的指针？

我试图为我的链表节点类实现封装，但似乎我做错了什么。如何使函数返回指向类内成员变量的指针

template <typename T>
class DoublyLinkListNode
{
public:
    using value_type = T;
    using reference = value_type&;
    using const_reference = const value_type&;
    using size_type = size_t;

    DoublyLinkListNode() :m_value(value_type()), m_prev(nullptr), m_next(nullptr) {}
    DoublyLinkListNode(const_reference p_value) : m_value(p_value), m_prev(nullptr), m_next(nullptr) {}
    DoublyLinkListNode(const_reference p_value, DoublyLinkListNode* p_prev, DoublyLinkListNode* p_next) : m_value(p_value), m_prev(p_prev), m_next(p_next) {}
    DoublyLinkListNode(value_type&& p_value, DoublyLinkListNode* p_prev, DoublyLinkListNode* p_next) : m_value(p_value), m_prev(p_prev), m_next(p_next) { p_value = value_type(); }

    // Dereference that allows us to write/read into Elem.
    reference operator*() { return m_value; }
    const_reference operator*() const { return m_value; }

    DoublyLinkListNode* previous() { return m_prev; }
    //const DoublyLinkListNode* previous() const { return m_prev; }
    DoublyLinkListNode* next() { return m_next; }
    //const DoublyLinkListNode* next() const { return m_next; }

    private:
    DoublyLinkListNode* m_prev; // previous link.
    DoublyLinkListNode* m_next; // succesor (next) link.
    T m_value;
};
int main()
{
    DoublyLinkListNode<double>* node = new DoublyLinkListNode(5.5);
    DoublyLinkListNode<double> node2(5.5);
    DoublyLinkListNode<double>* node3 = new DoublyLinkListNode(5.5);

    // expression must be a modifiable lvalue?
    node->previous() = node3;

    std::cout << node->operator*() << std::endl;
    return 0;
}

模板
类DoublyLinkListNode
{
公众：
使用值_type=T；
使用引用=值\类型&；
使用const_reference=const value_type&；
使用大小\类型=大小\ t；
DoublyLinkListNode（）：m_值（value_type（）），m_prev（nullptr），m_next（nullptr）{
DoublyLinkListNode（常量参考p_值）：m_值（p_值）、m_上一个（nullptr）、m_下一个（nullptr）{
DoublyLinkListNode（常数参考p_值，DoublyLinkListNode*p_prev，DoublyLinkListNode*p_next）：m_值（p_值），m_prev（p_prev），m_next（p_next）{}
DoublyLinkListNode（值类型和p值，DoublyLinkListNode*p值上一个，DoublyLinkListNode*p值下一个）：m值（p值），m值上一个（p值上一个），m值下一个（p值下一个）{p值=值类型（）
//允许我们写入/读取元素的解引用。
引用运算符*（）{返回m_值；}
常量引用运算符*（）常量{返回m_值；}
DoublyLinkListNode*previous（）{return m_prev；}
//const DoublyLinkListNode*previous（）const{return m_prev；}
DoublyLinkListNode*next（）{return m_next；}
//const DoublyLinkListNode*next（）const{return m_next；}
私人：
DoublyLinkListNode*m_prev；//上一个链接。
DoublyLinkListNode*m_next；//成功（下一个）链接。
T m_值；
};
int main（）
{
DoublyLinkListNode*节点=新的DoublyLinkListNode（5.5）；
双点状节点2（5.5）；
DoublyLinkListNode*node3=新的DoublyLinkListNode（5.5）；
//表达式必须是可修改的左值？
node->previous（）=node3；
std:：cout operator*（）“如何使函数返回指向类内成员变量的指针？”

你说的是
mu prev
。
mu prev
的类型是
doublylinkistnode*
。指向此变量的指针的类型是
doublylinkistnode**
。函数必须返回
doublylinkistnode**
：

DoublyLinkListNode** previous() { return &m_prev; }

你可以把它当作

*(node->previous()) = node3;

node->previous() = node3;

<>但是C++方式返回引用而不是指针：

DoublyLinkListNode*& previous() { return m_prev; }

你可以把它当作

*(node->previous()) = node3;

node->previous() = node3;

目前的执行情况

DoublyLinkListNode* previous() { return m_prev; }

返回一个临时副本（R值）

但是，与其使用getter和setter或返回指针/引用的函数，不如将成员公开：
“如何使函数返回指向类内成员变量的指针？”

你说的是
mu prev
。
mu prev
的类型是
doublylinkistnode*
。指向此变量的指针的类型是
doublylinkistnode**
。函数必须返回
doublylinkistnode**
：

DoublyLinkListNode** previous() { return &m_prev; }

你可以把它当作

*(node->previous()) = node3;

node->previous() = node3;

<>但是C++方式返回引用而不是指针：

DoublyLinkListNode*& previous() { return m_prev; }

你可以把它当作

*(node->previous()) = node3;

node->previous() = node3;

目前的执行情况

DoublyLinkListNode* previous() { return m_prev; }

返回一个临时副本（R值）

但是，您应该公开成员，而不是返回指针/引用的getter和setter或函数：
什么是
reference
和
const\u reference
？请道歉，我只是为它添加了一个完整版本。
previous
和
next
需要通过引用返回指针以允许赋值然而，如果你要这样做，为什么不公开成员呢？我只是想通过OOP进行封装。在这种情况下，你在
main
中尝试做的事情似乎不正确。只有类可以修改上一个和下一个指针。允许程序的其他部分这样做会破坏封装。我所做的是什么s
reference
和
const\u reference
？请道歉，我只是为它添加了一个完整版本。
previous
和
next
需要通过引用返回指针以允许赋值。但是，如果要这样做，为什么不将成员公开？我只想遵循OOP的封装。在这方面在这种情况下，您试图在
main
中执行的操作似乎不正确。只有类才能修改上一个和下一个指针。允许程序的其他部分执行此操作会破坏封装。