Thread: Splitting template class to header .h file and implementation .cpp file

Hi.
What is the right syntax for implementing the .cpp of a template class?

Consider this LinkedList.h file:

Code:

#include<iostream>
#include"Iterator.h"

template <class T>
class LinkedList {

public:
    LinkedList();
    virtual ~LinkedList();
    // more List-related methods here...

private:

    template <class T>
    class Node {
    public:
        Node(T d, Node<T>* n=NULL, Node<T>* p=NULL):
            data(d),
            next(n),
            prev(p){}

        Node<T>* next;
        Node<T>* prev;
        T data;
    };

    template <class T>
    class ListIterator: public Iterator<T> {
    public:
        virtual T& operator*();
        virtual T* operator->();
        virtual void operator++();
        virtual void operator--();
    private:
        Node<T>* current;
    };

};

How should the implementation for the LinkedList constructor, for example, should look like in the LinkedList.cpp file?

I tried this:

Code:

#include "LinkedList.h"

template <class T>
LinkedList<T>::LinkedList<T>() {
    // constructor
}

LinkedList<T>::~LinkedList<T>() {
    // destructor
}

But the compiler wouldn't accept it.

C Programmer here; but, I thought most templates (if not all) can NOT be split between header and cpp file.

Tim S.

Tim is (mostly) correct. You can separate the declaration from the definition, providing that each translation unit (source file) that instantiates a template can see both. One common way is to put the declarations in a .h file, and the definitions in a .tcc or some other such file, which is included at the bottom of the .h file.

The "export" keyword was in the original C++ standard, and was intended to alleviate such things. Catch is, only a couple of compilers ever properly implemented the functionality (apparently quite difficult to do so) and it has now been deprecated in the latest standard.

There are compilers that support "explicit template instantiation" or similar concepts which - in effect - support what you describe. Unfortunately, the specific techniques (coding needed to do it) and means of enabling such capabilities (command line options, etc) are compiler specific. And there are plenty of other gotchas too.