Subclassing a template causes problems

[Dijkstra]

Hi! I am writing a program in which I need to keep track of how many objects of a given class exists at a time. The task is to do it using templates. The objects to be counted are of the class Note:

class Note : public Countable<Note> {
private:
...
public:
Note();
Note(double points, int time);
Note(double points, string time);
~Note();
...
};

Where Countable template is given as:

template<typename T> class Countable {
    protected:
        static int _currentCounter;
    public:
        Countable();
        Countable(const Countable& c);
        virtual ~Countable();
        static int currentCounter();
};
 
template<typename T> int Countable<T>::_currentCounter = 0;
template<typename T> int Countable<T>::_allCounter = 0;

The Countable template is implemented as:

template<typename T> Countable<T>::Countable() {
    ++_currentCounter;
}
 
template<typename T> Countable<T>::Countable(const Countable& c) {
    ++_currentCounter;
}
 
template<typename T> Countable<T>::~Countable() {
    --_currentCounter;
}
 
template<typename T> int Countable<T>::currentCounter()  {
    return _currentCounter;
}

For Node class the constructors all call superclass constructors:

Note::Note() : Countable<Note>() {
    points = 0;
    time = 0;
}

and similarly for other constructors. The ~Note() destructor is empty

Note::~Note() {}

The task was to modify a previous program and add this option - to count the Node objects. Earlier the whole program was working fine, but now, after introducing Countable and subclassing it by Note I get linker errors like:

Note.o: In function `Note::Note(not-in-charge)()':
Note.cpp:(.text+0xbcd): undefined reference to `Countable<Note>::Countable(not-in-charge)()'
Note.o: In function `Note::Note(in-charge)(double, std::basic_string<char, std::char_traits<char>, std::allocator<char> >)':
Note.cpp:(.text+0xd1b): undefined reference to `Countable<Note>::Countable(not-in-charge)()'
Note.cpp:(.text+0xd88): undefined reference to `Countable<Note>::~Countable (not-in-charge)()'
Note.o: In function `Note::~Note (not-in-charge)()':
Note.cpp:(.text+0xdaa): undefined reference to `Countable<Note>::~Countable (not-in-charge)()'

And so on, wich [not-in-charge] errors. What does that mean? Is there something wrong with calling these constructors and destructors?
The Note objects are always created as Note - no class "knows" in any way that Note is a subclass of Countable. Maybe here lies a mistake - should I create the objects in some other way? Thanks for any help.

PS. The task *has* to be solved using such form of template subclassing...