带有自定义 BaseNode 多态性的 C++ LinkedList

如何解决带有自定义 BaseNode 多态性的 C++ LinkedList

使用链表探索形成性 C++ 数据结构的边界让我迷失了方向。

我的基本结构为节点和节点将保存的数据类型使用模板：

template <template<typename> class N,typename T>  // N MUST use class and not typename
class LinkedList
{
    N<T> _sentinel; // We'll use this as the tail and the head,so it will act as our root
                    // There's no need to forcibly store this on the heap by utilizing raw pointer for the sentinel/root
                    // if the client wants it on the stack then it'll be on the stack,if it's stored heap then sentinel will be on the heap
};

利用模板特化，我根据传入的节点定义每个函数：

template<typename T>
class LinkedList<sll_Datanode,T>
{
    Node<T> _sentinel;
public:
    LinkedList<Node,T>() : _sentinel(&_sentinel){}
    
    void emplace_back(T value)
    {
        
    }

    Node<T>* const pop()
    {

    }
...
    
};

template<typename T>
class LinkedList<DLL_Datanode,T>
{
    DLL_Datanode<T> _sentinel;
    ...
};

在模板外定义具有不同属性的节点以支持形成性定义的节点类型，例如 SinglyLinkedList 和 DoublyLinkedList：

template<typename T>
struct Node
{
public:
    Node() : T(){}
    Node(Node* nextNode) : next(nextNode) { }
    Node<T>* next;
    
    ~Node() = default;  // do not delete next,we have no idea if we're going to pop the node off
                                    // If we pop off the node,we will transfer ownership and deleting next will cause a memory access violation
};

template<typename T>
struct sll_Datanode : Node<T>   // We'll use this as defacto heap stored node that holds our data
{
    using m_next = typename Node<T>::template next<T>;  // ::template is needed because a dependent template is used in Node's template. Node<T>::
                                                        // typename is needed because it is a dependent typename. next<T>
    
    sll_Datanode(Node<T>* nextNode,T value) : m_next(nextNode)
    {
    }

    Node<T>* Next() { return Node<T>::template next<T>; }
};

template<typename T>
struct DLL_Datanode: Node<T>
{
    using m_next = typename Node<T>::template next<T>;
    Node<T>* prev;
    
};

我很快发现，即使我要依赖 static_cast 消歧，或者从具有与其派生 Node 不同的功能的基节点继承的自定义 type_traits 也不值得努力定义。

例如：DoublyLinkedList 节点必须使用 DLL_Node 隐藏其父 next 成员变量，以便向后遍历，除非每次我收到它的 prev 成员时我都会 static_cast 消除歧义，因为它传递给我的是 Node* 而不是 DLL_Node* .

我收到了一些建议，也许 Node 接口会更有帮助，但我很好奇这整个努力是否会违背最佳使用方法，因为我有一个能够做到这一点的链表：

LinkedList<sll_Node,int> singlyLinkedList();
LinkedList<DLL_Node,char> doublyLinkedList();