patterncppCritical

Why can templates only be implemented in the header file?

Submitted by: @import:stackoverflow-api·Mar 10, 2026·

Viewed 0 times

templatesimplementedwhyheadertheonlyfilecan

Problem

Quote from The C++ standard library: a tutorial and handbook:

The only portable way of using templates at the moment is to implement them in header files by using inline functions.

Why is this?

(Clarification: header files are not the only portable solution. But they are the most convenient portable solution.)

Solution

Caveat: It is not necessary to put the implementation in the header file, see the alternative solution at the end of this answer.

Anyway, the reason your code is failing is that, when instantiating a template, the compiler creates a new class with the given template argument. For example:

template
struct Foo
{
    T bar;
    void doSomething(T param) {/* do stuff using T */}
};

// somewhere in a .cpp
Foo f;

When reading this line, the compiler will create a new class (let's call it FooInt), which is equivalent to the following:

struct FooInt
{
    int bar;
    void doSomething(int param) {/* do stuff using int */}
};

Consequently, the compiler needs to have access to the implementation of the methods, to instantiate them with the template argument (in this case int). If these implementations were not in the header, they wouldn't be accessible, and therefore the compiler wouldn't be able to instantiate the template.

A common solution to this is to write the template declaration in a header file, then implement the class in an implementation file (for example .tpp), and include this implementation file at the end of the header.

Foo.h

template 
struct Foo
{
    void doSomething(T param);
};

#include "Foo.tpp"

Foo.tpp

template 
void Foo::doSomething(T param)
{
    //implementation
}

This way, implementation is still separated from declaration, but is accessible to the compiler.
Alternative solution

Another solution is to keep the implementation separated, and explicitly instantiate all the template instances you'll need:

Foo.h

// no implementation
template  struct Foo { ... };

Foo.cpp

// implementation of Foo's methods

// explicit instantiations
template class Foo;
template class Foo;
// You will only be able to use Foo with int or float

If my explanation isn't clear enough, you can have a look at the C++ Super-FAQ on this subject.

Code Snippets

template<typename T>
struct Foo
{
    T bar;
    void doSomething(T param) {/* do stuff using T */}
};

// somewhere in a .cpp
Foo<int> f;

struct FooInt
{
    int bar;
    void doSomething(int param) {/* do stuff using int */}
};

template <typename T>
struct Foo
{
    void doSomething(T param);
};

#include "Foo.tpp"

template <typename T>
void Foo<T>::doSomething(T param)
{
    //implementation
}

// no implementation
template <typename T> struct Foo { ... };

Context

Stack Overflow Q#495021, score: 2046

Revisions (0)

No revisions yet.