I have a question about the c++ template function extinction. Monsters, please crying

#pragma once
template <typename Elem>
class NodeList{
public:
    class Node {
    public:
        Elem elem;
        Node* prev;
        Node* next;

    };
    //template <typename Elem> friend class NodeSequence;
public :
    Elem& operator*() { return v->elem; };
    bool operator==(const Node* p) const { return v == p.v; };
    bool operator!=(const Node* p) const { return v != p.v; };
    Node* operator++() { v = v->next; return *this; };
    Node* operator--() { v = v->prev; return *this; };
private: 
    Node* v;
public:
    NodeList() {
        n = 0;
        header = new Node;
        trailer = new Node;
        header->next = trailer;
        trailer->prev = header;
    };
    virtual ~NodeList() {
        while (!empty()) {
            eraseFront();
        }
    };
    int size() const {
        return n;
    };
    bool empty() const {
        return (n == 0);
    };
    Node* begin() const {
        return header->next;
    }
    ;
    Node* end() const {
        return (trailer);
    };
    void insertFront(const Elem& e) { insert(begin(), e); };
    void insertBack(const Elem& e) { insert(end(), e); };
    void insert( Node* const p,const Elem& e) {
        Node*w = p;
        Node*u = w->prev;
        Node*v = new Node;
        v->elem = e;
        v->next = w; w->prev = v;
        v->prev = u; u->next = v;
        n++;
    };
    void eraseFront() {
        erase(begin());
    };
    void eraseBack() {
        erase(--end());
    };
    void erase(Node* const p) {
        Node* w = p->next;
        Node* u =p->prev;
        u->next = w; w->prev = u;
        delete v;
        n--;
    };
private:
    int n;
    Node* header;
    Node* trailer;
};
template <typename Elem>
class NodeSequence :public NodeList<Elem> {
public:
    NodeSequence() {
        typename NodeSequence::NodeList::NodeList(); };
     ~NodeSequence() { typename NodeSequence::NodeList::~NodeList<Elem>(); };
    typename NodeList<Elem>::Node* atIndex(int i) const {
        typename NodeSequence::NodeList::Node* p= typename NodeSequence::begin();
        for (int j = 0; j < i; j++)++p;
        return p;
    };
    int indexof(const typename NodeList<Elem>::Node* p)const {
        typename NodeSequence::NodeList::Node* q = typename NodeSequence::begin();
        int j = 0;
        while (q != p) {
            ++q; ++j;
        }
        return j;
    }
};

#include <iostream>
using namespace std;

#include "sequence.h"

void main() {
    typedef NodeSequence<int> IntSequence;
    typedef NodeSequence<int>::Node* IntSequenceNodePtr;
    int a[] = { 6, 7, 2, 5, 1, 4, 3 };
    IntSequence ns;
    for (int i = 0; i < 7; i++) ns.insertFront(a[i]);
    cout << "A sequence of size = " << ns.size() << endl;
    system("pause");
}