C++ 嵌套类模板组织

我正在研究一个双链表类。我实现了一个节点类，其中包含指向下一个元素的指针、指向上一个元素的指针以及一个数据节（类型由模板参数“type”定义）

最初，我将其实现为两个类。一个类定义了一个节点，另一个类定义了节点链表（rList）。我想将节点类模板作为rList的私有成员包括在内，因为节点应该隐藏在列表中，并且只由rList管理

Node类只有一个构造函数，用于初始化数据节并将指针设置为null

我试图将Node类放在rList类的private部分，但我似乎无法获得正确的组织。我被语法错误所困扰。下面是我当前的实现

template<typename Type>
class Node
{
    Node* next;
    Node* prev;

public:
    Node(Type);
    template<typename Type> friend class rList;
    Type data;
};

template<typename Type>
Node<Type>::Node(Type d):data(d), next(0), prev(0)
{}


template<typename Type>
class rList
{
private:
    Node<Type>* head;
    Node<Type>* tail;
    int size;

public:

    rList<Type>();
    ~rList();
    void push_front(const Type&);
    void push_back(const Type&);
    void insert(Node<Type>*, const Type&); //needs to be changed after merge
    void erase(Node<Type>*); //needs to be changed after merge
    void clear();
};

template<typename Type>
rList<Type>::rList():head(0), tail(0), size(0)
{}


template<typename Type>
rList<Type>::~rList()
{
    clear();
}


template<typename Type>
void rList<Type>::clear()
{
    while(head != 0)
    {
        Node<Type>* nextNode = head->next;
        delete head;
        head = nextNode;
    }
}


template<typename Type>
void rList<Type>::push_front(const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        newOne->next = head;
        head = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::push_back(const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        tail->next = newOne;
        newOne->prev = tail; 
        tail = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::insert(Node<Type>* itr, const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else 
    {   
        newOne->next = itr;
        (itr->prev)->next = newOne;
        newOne->prev = itr->prev;
        itr->prev = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::erase(Node<Type>* itr)
{
    if(itr == tail)
    {
        tail = itr->prev;
        tail->next = 0;
        delete itr;
    }

    else if(itr == head)
    {
        head = itr->next;
        head->prev = 0;
        delete itr;
    }

    else
    {
        (itr->prev)->next = itr->next;
        (itr->next)->prev = itr->prev;
        delete itr;
    }
    size--;
}


template<typename Type>
Node<Type>* rList<Type>::begin()
{
    return head;
}


template<typename Type>
Node<Type>* rList<Type>::end()
{
    return tail;
}


template<typename Type>
Node<Type>* rList<Type>::nextElem(Node<Type>* node)
{
    return node->next;
}

模板
类节点
{
节点*下一步；
节点*prev；
公众：
节点（类型）；
模板类rList；
类型数据；
};
模板
节点：：节点（类型d）：数据（d）、下一个（0）、上一个（0）
{}
模板
类列表
{
私人：
节点*头；
节点*尾部；
整数大小；
公众：
rList（）；
~rList（）；
无效前推（常数类型&）；
无效推回（常数类型&）；
void insert（Node*，const Type&）；//合并后需要更改
void erase（节点*）；//合并后需要更改
无效清除（）；
};
模板
rList:：rList（）：头部（0）、尾部（0）、大小（0）
{}
模板
rList:：~rList（）
{
清除（）；
}
模板
void rList:：clear（）
{
while（头！=0）
{
节点*nextNode=head->next；
删除标题；
头=下一个节点；
}
}
模板
void rList:：push_front（常量类型和数据）
{
Node*newOne=新节点（数据）；
如果（头==0）
{
头=新的；
尾=头；
}
其他的
{
新建->下一个=头部；
头=新的；
}
大小++；
}
模板
void rList:：push_back（常量类型和数据）
{
Node*newOne=新节点（数据）；
如果（头==0）
{
头=新的；
尾=头；
}
其他的
{
tail->next=newOne；
newOne->prev=尾部；
尾巴=新的；
}
大小++；
}
模板
void rList:：insert（节点*itr、常量类型和数据）
{
Node*newOne=新节点（数据）；
如果（头==0）
{
头=新的；
尾=头；
}
其他的
{   
newOne->next=itr；
（itr->prev）->next=newOne；
newOne->prev=itr->prev；
itr->prev=newOne；
}
大小++；
}
模板
void rList:：擦除（节点*itr）
{
如果（itr==尾部）
{
tail=itr->prev；
尾部->下一步=0；
删除itr；
}
否则如果（itr==水头）
{
head=itr->next；
head->prev=0；
删除itr；
}
其他的
{
（itr->prev）->next=itr->next；
（itr->next）->prev=itr->prev；
删除itr；
}
大小--；
}
模板
Node*rList:：begin（）
{
回流头；
}
模板
Node*rList:：end（）
{
返回尾；
}
模板
Node*rList:：nextElem（Node*Node）
{
返回节点->下一步；
}

我意识到这会破坏一些东西，因为节点*不能在rList类之外定义。我计划稍后使用一个迭代器类来访问rList中的节点，从而对此进行更改。但首先，如何用这种安排组织模板和成员函数定义？下面是我的尝试：

template<typename Type>
class rList //rList class template
{
private:
    template<typename Type>
    class Node //Node class template
    {
        Node* next;
        Node* prev;

    public:
        Type data; //can be any POD type or class/struct
        Node(Type);
        template<typename Type> friend class rList; //so rList can access private Node pointers
    };
    Node<Type>* head;
    Node<Type>* tail;
    int size;

public:
    rList<Type>();
    ~rList();
    void push_front(const Type&);
    void push_back(const Type&);
    void insert(Node<Type>*, const Type&);
    void erase(Node<Type>*);
    clear();
};

template<typename Type>
rList<Type>::rList():head(0), tail(0), size(0)
{}


template<typename Type>
rList<Type>::~rList()
{
    clear();
}

template<typename Type>
void rList<Type>::clear()
{
    while(head != 0)
    {
        Node<Type>* nextNode = head->next;
        delete head;
        head = nextNode;
    }
}

template<typename Type>
void rList<Type>::push_front(const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        newOne->next = head;
        head = newOne;
    }
    size++;
}

template<typename Type>
void rList<Type>::push_back(const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        tail->next = newOne;
        newOne->prev = tail; 
        tail = newOne;
    }
    size++;
}

template<typename Type>
void rList<Type>::insert(Node<Type>* itr, const Type& data)
{
    Node<Type>* newOne = new Node<Type>(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else 
    {   
        newOne->next = itr;
        (itr->prev)->next = newOne;
        newOne->prev = itr->prev;
        itr->prev = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::erase(Node<Type>* itr)
{
    if(itr == tail)
    {
        tail = itr->prev;
        tail->next = 0;
        delete itr;
    }

    else if(itr == head)
    {
        head = itr->next;
        head->prev = 0;
        delete itr;
    }

    else
    {
        (itr->prev)->next = itr->next;
        (itr->next)->prev = itr->prev;
        delete itr;
    }
    size--;
}


//constructor for Node
template<typename Type>
rList<Type>::Node<Type>::Node(Type d):data(d), next(0), prev(0)
{}

模板
类rList//rList类模板
{
私人：
模板
类节点//节点类模板
{
节点*下一步；
节点*prev；
公众：
类型数据；//可以是任何POD类型或类/结构
节点（类型）；
模板友元类rList；//因此rList可以访问私有节点指针
};
节点*头；
节点*尾部；
整数大小；
公众：
rList（）；
~rList（）；
无效前推（常数类型&）；
无效推回（常数类型&）；
无效插入（节点*，常量类型&）；
无效擦除（节点*）；
清除（）；
};
模板
rList:：rList（）：头部（0）、尾部（0）、大小（0）
{}
模板
rList:：~rList（）
{
清除（）；
}
模板
void rList:：clear（）
{
while（头！=0）
{
节点*nextNode=head->next；
删除标题；
头=下一个节点；
}
}
模板
void rList:：push_front（常量类型和数据）
{
Node*newOne=新节点（数据）；
如果（头==0）
{
头=新的；
尾=头；
}
其他的
{
新建->下一个=头部；
头=新的；
}
大小++；
}
模板
void rList:：push_back（常量类型和数据）
{
Node*newOne=新节点（数据）；
如果（头==0）
{
头=新的；
尾=头；
}
其他的
{
tail->next=newOne；
newOne->prev=尾部；
尾巴=新的；
}
大小++；
}
模板
void rList:：insert（节点*itr、常量类型和数据）
{
Node*newOne=新节点（数据）；
如果（头==0）
{
头=新的；
尾=头；
}
其他的
{   
newOne->next=itr；
（itr->prev）->next=newOne；
newOne->prev=itr->prev；
itr->prev=newOne；
}
大小++；
}
模板
void rList:：擦除（节点*itr）
{
如果（itr==尾部）
{
tail=itr->prev；
尾部->下一步=0；
删除itr；
}
否则如果（itr==水头）
{
head=itr->next；
head->prev=0；
删除itr；
}
其他的
{
（itr->prev）->next=itr->next；
（itr->next）->prev=itr->prev；
删除itr；
}
大小--；
}
//节点的构造函数
模板
rList:：Node:：Node（类型d）：数据（d）、下一个（0）、上一个（0）
{}

我感谢你的意见

*更新代码* 下面的代码是根据建议修改的。它正在工作，似乎正在隐藏相应的成员。请评论您注意到的任何改进！ 再次感谢

template<typename Type>
class rList
{
private:

    class Node
    {
        Node* next;
        Node* prev;

    public:
        Type data;
        Node(Type d);
        template<typename Type> friend class rList;
    };

    Node* head;
    Node* tail;
    int size;

public:
    rList<Type>();
    ~rList();
    void push_front(const Type&);
    void push_back(const Type&);
    void insert(Node*, const Type&);
    void erase(Node*);
    void clear();
};

template<typename Type>
rList<Type>::rList():head(0), tail(0), size(0)
{}


template<typename Type>
rList<Type>::~rList()
{
    clear();
}

template<typename Type>
void rList<Type>::clear()
{
    while(head != 0)
    {
        Node* nextNode = head->next;
        delete head;
        head = nextNode;
    }
}

template<typename Type>
void rList<Type>::push_front(const Type& data)
{
    Node* newOne = new Node(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        newOne->next = head;
        head = newOne;
    }
    size++;
}

template<typename Type>
void rList<Type>::push_back(const Type& data)
{
    Node* newOne = new Node(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else
    {
        tail->next = newOne;
        newOne->prev = tail; 
        tail = newOne;
    }
    size++;
}

template<typename Type>
void rList<Type>::insert(Node* itr, const Type& data)
{
    Node* newOne = new Node(data);

    if(head == 0)
    {
        head = newOne;
        tail = head;
    }
    else 
    {   
        newOne->next = itr;
        (itr->prev)->next = newOne;
        newOne->prev = itr->prev;
        itr->prev = newOne;
    }
    size++;
}


template<typename Type>
void rList<Type>::erase(Node* itr)
{
    if(itr == tail)
    {
        tail = itr->prev;
        tail->next = 0;
        delete itr;
    }

    else if(itr == head)
    {
        head = itr->next;
        head->prev = 0;
        delete itr;
    }

    else
    {
        (itr->prev)->next = itr->next;
        (itr->next)->prev = itr->prev;
        delete itr;
    }
    size--;
}

template<typename Type>
rList<Type>::Node::Node(Type d):data(d), next(0), prev(0)
{}

模板
类列表
{
私人：
类节点
{
节点*下一步；
节点*prev；
公众：
类型数据；
节点（d型）；
模板类rList；
};
节点*头；