C++ 继承中的语法错误

我在尝试继承这些节点时遇到了一些问题。我在网上看了很多例子，但不知道我错了什么

我的编译器正在给我以下消息：

error: expected identifier before 'public'
error: expected '{' before 'public'
error: expected unqualified-id before 'public'

任何帮助都将不胜感激：）

模板
类节点
{
受保护的：
节点*下一步；
节点*prev；
T*数据；
公众：
Node（）；
~Node（）；
节点*getNext（）；
节点*getPrev（）；
void setNext（节点*）；
void setPrev（节点*）；
T*getData（）；
无效设置数据（T*）；
};
模板
类头节点：公共节点
{
公众：
头节点（）；
~HeadNode（）；
};
模板
类TailNode：公共节点
{
公众：
尾节点（节点*）；
~TailNode（）；
};
模板
类内部节点：公共节点
{
公众：
内部节点（节点*，节点*，T*）；
~InternalNode（）；
};
模板
Node:：Node（）
{
next=0；
prev=0；
数据=0；
}
模板
节点：：~Node（）
{
//删除数据；
}
模板
Node*Node:：getNext（）
{
下一步返回；
}
模板
Node*Node:：getPrev（）
{
返回上一个；
}
模板
void节点：：setNext（节点*n）
{
next=n；
}
模板
void节点：：setPrev（节点*n）
{
prev=n；
}
模板
T*Node:：getData（）
{
返回数据；
}
模板
void节点：：setData（T*nda）
{
删除数据；
数据=数据；
}
模板
HeadNode:：HeadNode（）：公共节点（）
{
下一步=新的尾节点（本）；
}
模板
HeadNode:：~HeadNode（）
{
}
模板
TailNode:：TailNode（Node*p）：公共节点（）
{
prev=p；
}
模板
TailNode:：~TailNode（）
{
}
模板
InternalNode:：InternalNode（Node*n，Node*p，T*nda）：公共节点（）
{
next=n；
prev=p；
数据=数据；
}
模板
InternalNode:：~InternalNode（）
{
//删除数据；
}
<>代码>我不擅长C++，但这通过了编译器。< /P>

从构造函数的初始化中删除
public
将
节点：：
添加到子类要使用父类成员的位置
将
virtual
添加到
节点的析构函数中
，以便在删除时调用子类的析构函数


模板
类节点
{
受保护的：
节点*下一步；
节点*prev；
T*数据；
公众：
Node（）；
virtual~Node（）；//添加虚拟节点
节点*getNext（）；
节点*getPrev（）；
void setNext（节点*）；
void setPrev（节点*）；
T*getData（）；
无效设置数据（T*）；
};
模板
类头节点：公共节点
{
公众：
头节点（）；
~HeadNode（）；
};
模板
类TailNode：公共节点
{
公众：
尾节点（节点*）；
~TailNode（）；
};
模板
类内部节点：公共节点
{
公众：
内部节点（节点*，节点*，T*）；
~InternalNode（）；
};
模板
Node:：Node（）
{
next=0；
prev=0；
数据=0；
}
模板
节点：：~Node（）
{
//删除数据；
}
模板
Node*Node:：getNext（）
{
下一步返回；
}
模板
Node*Node:：getPrev（）
{
返回上一个；
}
模板
void节点：：setNext（节点*n）
{
next=n；
}
模板
void节点：：setPrev（节点*n）
{
prev=n；
}
模板
T*Node:：getData（）
{
返回数据；
}
模板
void节点：：setData（T*nda）
{
删除数据；
数据=数据；
}
模板
HeadNode:：HeadNode（）：Node（）//删除公共
{
Node:：next=newtailnode（this）；//添加节点：：
}
模板
HeadNode:：~HeadNode（）
{
}
模板
TailNode:：TailNode（Node*p）：Node（）//删除公共
{
Node:：prev=p；//添加节点：：
}
模板
TailNode:：~TailNode（）
{
}
模板
InternalNode:：InternalNode（Node*n，Node*p，T*nda）：Node（）//删除公共
{
Node:：next=n；//添加节点：：
Node:：prev=p；//添加节点：：
节点：：数据=数据；//添加节点：：
}
模板
InternalNode:：~InternalNode（）
{
//删除数据；
}
无法复制，投票关闭。哦，对不起，我没有复制整个源代码。撤回了近距离投票。这赢得了喝彩，还有关于毁灭者的好建议：）
template <typename T>
class Node
{
    protected:
        Node<T>* next;
        Node<T>* prev;
        T* data;
    public:
        Node();
        ~Node();
        Node* getNext();
        Node* getPrev();
        void setNext(Node<T>*);
        void setPrev(Node<T>*);
        T* getData();
        void setData(T*);
};
template <typename T>
class HeadNode : public Node<T>
{
    public:
        HeadNode();
        ~HeadNode();
};
template <typename T>
class TailNode : public Node<T>
{
    public:
        TailNode(Node<T>*);
        ~TailNode();
};
template <typename T>
class InternalNode : public Node<T>
{
    public:
        InternalNode(Node<T>*, Node<T>*, T*);
        ~InternalNode();
};

template <typename T>
Node<T>::Node()
{
    next = 0;
    prev = 0;
    data = 0;
}
template <typename T>
Node<T>::~Node()
{
    //delete data;
}
template <typename T>
Node<T>* Node<T>::getNext()
{
    return next;
}
template <typename T>
Node<T>* Node<T>::getPrev()
{
    return prev;
}
template <typename T>
void Node<T>::setNext(Node<T>* n)
{
    next = n;
}
template <typename T>
void Node<T>::setPrev(Node<T>* n)
{
    prev = n;
}
template <typename T>
T* Node<T>::getData()
{
    return data;
}
template <typename T>
void Node<T>::setData(T* nData)
{
    delete data;
    data = nData;
}
template <typename T>
HeadNode<T>::HeadNode() : public Node<T>()
{
    next = new TailNode<T>(this);
}
template <typename T>
HeadNode<T>::~HeadNode()
{
}
template <typename T>
TailNode<T>::TailNode(Node<T>* p) : public Node<T>()
{
    prev = p;
}
template <typename T>
TailNode<T>::~TailNode()
{
}
template <typename T>
InternalNode<T>::InternalNode(Node<T>* n, Node<T>* p, T* nData):         public Node<T>()
{
    next = n;
    prev = p;
    data = nData;
}
template <typename T>
InternalNode<T>::~InternalNode()
{
    //delete data;
}

template <typename T>
class Node
{
    protected:
        Node<T>* next;
        Node<T>* prev;
        T* data;
    public:
        Node();
        virtual ~Node(); // add virtual
        Node* getNext();
        Node* getPrev();
        void setNext(Node<T>*);
        void setPrev(Node<T>*);
        T* getData();
        void setData(T*);
};
template <typename T>
class HeadNode : public Node<T>
{
    public:
        HeadNode();
        ~HeadNode();
};
template <typename T>
class TailNode : public Node<T>
{
    public:
        TailNode(Node<T>*);
        ~TailNode();
};
template <typename T>
class InternalNode : public Node<T>
{
    public:
        InternalNode(Node<T>*, Node<T>*, T*);
        ~InternalNode();
};

template <typename T>
Node<T>::Node()
{
    next = 0;
    prev = 0;
    data = 0;
}
template <typename T>
Node<T>::~Node()
{
    //delete data;
}
template <typename T>
Node<T>* Node<T>::getNext()
{
    return next;
}
template <typename T>
Node<T>* Node<T>::getPrev()
{
    return prev;
}
template <typename T>
void Node<T>::setNext(Node<T>* n)
{
    next = n;
}
template <typename T>
void Node<T>::setPrev(Node<T>* n)
{
    prev = n;
}
template <typename T>
T* Node<T>::getData()
{
    return data;
}
template <typename T>
void Node<T>::setData(T* nData)
{
    delete data;
    data = nData;
}
template <typename T>
HeadNode<T>::HeadNode() : Node<T>() // remove public
{
    Node<T>::next = new TailNode<T>(this); // add Node<T>::
}
template <typename T>
HeadNode<T>::~HeadNode()
{
}
template <typename T>
TailNode<T>::TailNode(Node<T>* p) :  Node<T>() // remove public
{
    Node<T>::prev = p; // add Node<T>::
}
template <typename T>
TailNode<T>::~TailNode()
{
}
template <typename T>
InternalNode<T>::InternalNode(Node<T>* n, Node<T>* p, T* nData): Node<T>() // remove public
{
    Node<T>::next = n; // add Node<T>::
    Node<T>::prev = p; // add Node<T>::
    Node<T>::data = nData; // add Node<T>::
}
template <typename T>
InternalNode<T>::~InternalNode()
{
    //delete data;
}