"Undefined reference to" template class constructor [duplicate]

Question

I have no idea why this is happenning, since I think I have everything properly declared and defined.

I have the following program, designed with templates. It's a simple implementation of a queue, with the member functions "add", "substract" and "print".

I have defined the node for the queue in the fine "nodo_colaypila.h":

#ifndef NODO_COLAYPILA_H
#define NODO_COLAYPILA_H

#include <iostream>

template <class T> class cola;

template <class T> class nodo_colaypila
{
        T elem;
        nodo_colaypila<T>* sig;
        friend class cola<T>;
    public:
        nodo_colaypila(T, nodo_colaypila<T>*);

};

Then the implementation in "nodo_colaypila.cpp"

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

template <class T> nodo_colaypila<T>::nodo_colaypila(T a, nodo_colaypila<T>* siguiente = NULL)
{
    elem = a;
    sig = siguiente;//ctor
}

Afterwards, the definition and declaration of the queue template class and its functions:

"cola.h":

#ifndef COLA_H
#define COLA_H

#include "nodo_colaypila.h"

template <class T> class cola
{
        nodo_colaypila<T>* ult, pri;
    public:
        cola<T>();
        void anade(T&);
        T saca();
        void print() const;
        virtual ~cola();

};


#endif // COLA_H

"cola.cpp":

#include "cola.h"
#include "nodo_colaypila.h"

#include <iostream>

using namespace std;

template <class T> cola<T>::cola()
{
    pri = NULL;
    ult = NULL;//ctor
}

template <class T> void cola<T>::anade(T& valor)
{
    nodo_colaypila <T> * nuevo;

    if (ult)
    {
        nuevo = new nodo_colaypila<T> (valor);
        ult->sig = nuevo;
        ult = nuevo;
    }
    if (!pri)
    {
        pri = nuevo;
    }
}

template <class T> T cola<T>::saca()
{
    nodo_colaypila <T> * aux;
    T valor;

    aux = pri;
    if (!aux)
    {
        return 0;
    }
    pri = aux->sig;
    valor = aux->elem;
    delete aux;
    if(!pri)
    {
        ult = NULL;
    }
    return valor;
}

template <class T> cola<T>::~cola()
{
    while(pri)
    {
        saca();
    }//dtor
}

template <class T> void cola<T>::print() const
{
    nodo_colaypila <T> * aux;
    aux = pri;
    while(aux)
    {
        cout << aux->elem << endl;
        aux = aux->sig;
    }
}

Then, I have a program to test these functions as follows:

"main.cpp"

#include <iostream>
#include "cola.h"
#include "nodo_colaypila.h"

using namespace std;

int main()
{
    float a, b, c;
    string d, e, f;
    cola<float> flo;
    cola<string> str;

    a = 3.14;
    b = 2.71;
    c = 6.02;
    flo.anade(a);
    flo.anade(b);
    flo.anade(c);
    flo.print();
    cout << endl;

    d = "John";
    e = "Mark";
    f = "Matthew";
    str.anade(d);
    str.anade(e);
    str.anade(f);
    cout << endl;

    c = flo.saca();
    cout << "First In First Out Float: " << c << endl;
    cout << endl;

    f = str.saca();
    cout << "First In First Out String: " << f << endl;
    cout << endl;

    flo.print();
    cout << endl;
    str.print();

    cout << "Hello world!" << endl;
    return 0;
}

But when I build, the compiler throws errors in every instance of the template class:

undefined reference to `cola(float)::cola()'... (it's actually cola'<'float'>'::cola(), but this doesn't let me use it like that.)

And so on. Altogether, 17 warnings, counting the ones for the member functions being called in the program.

Why is this? Those functions and constructors WERE defined. I thought that the compiler could replace the "T" in the template with "float", "string" or whatever; that was the advantage of using templates.

I read somewhere here that I should put the declaration of each function in the header file for some reason. Is that right? And if so, why?

Sen

You are missing an #endif at the end of nodo_colaypila.h – Galactic

and maybe nodo_colaypila<T>* ult, pri; should be nodo_colaypila<T> *ult, *pri;. Both should be pointers, right? – Galactic

And there's a third minor typo: If the parameter to a function has a default value, then this should be defined in the header file, not in the implementation. (More precisely, the (first) declaration should have the default.) – Galactic

@LightnessRacesinOrbit, answered often yes. Not always fully correctly though :-) There are ways to keep the implementation of a template's member functions in one translation unit, while allowing other translation units to link to them. See my answer. – Galactic

@AaronMcDaid: Yes, there are. That has been said a million times, too! – Translative

@LightnessRacesinOrbit: Answered a million times, perhaps! but you didn't even provide a single link and marked this as duplicate... – Fluidics

Answer 1

This is a common question in C++ programming. There are two valid answers to this. There are advantages and disadvantages to both answers and your choice will depend on context. The common answer is to put all the implementation in the header file, but there's another approach will will be suitable in some cases. The choice is yours.

The code in a template is merely a 'pattern' known to the compiler. The compiler won't compile the constructors cola<float>::cola(...) and cola<string>::cola(...) until it is forced to do so. And we must ensure that this compilation happens for the constructors at least once in the entire compilation process, or we will get the 'undefined reference' error. (This applies to the other methods of cola<T> also.)

Understanding the problem

The problem is caused by the fact that main.cpp and cola.cpp will be compiled separately first. In main.cpp, the compiler will implicitly instantiate the template classes cola<float> and cola<string> because those particular instantiations are used in main.cpp. The bad news is that the implementations of those member functions are not in main.cpp, nor in any header file included in main.cpp, and therefore the compiler can't include complete versions of those functions in main.o. When compiling cola.cpp, the compiler won't compile those instantiations either, because there are no implicit or explicit instantiations of cola<float> or cola<string>. Remember, when compiling cola.cpp, the compiler has no clue which instantiations will be needed; and we can't expect it to compile for every type in order to ensure this problem never happens! (cola<int>, cola<char>, cola<ostream>, cola< cola<int> > ... and so on ...)

The two answers are:

• Tell the compiler, at the end of cola.cpp, which particular template classes will be required, forcing it to compile cola<float> and cola<string>.
• Put the implementation of the member functions in a header file that will be included every time any other 'translation unit' (such as main.cpp) uses the template class.

Answer 1: Explicitly instantiate the template, and its member definitions

At the end of cola.cpp, you should add lines explicitly instantiating all the relevant templates, such as

template class cola<float>;
template class cola<string>;

and you add the following two lines at the end of nodo_colaypila.cpp:

template class nodo_colaypila<float>;
template class nodo_colaypila<std :: string>;

This will ensure that, when the compiler is compiling cola.cpp that it will explicitly compile all the code for the cola<float> and cola<string> classes. Similarly, nodo_colaypila.cpp contains the implementations of the nodo_colaypila<...> classes.

In this approach, you should ensure that all the of the implementation is placed into one .cpp file (i.e. one translation unit) and that the explicit instantation is placed after the definition of all the functions (i.e. at the end of the file).

Answer 2: Copy the code into the relevant header file

The common answer is to move all the code from the implementation files cola.cpp and nodo_colaypila.cpp into cola.h and nodo_colaypila.h. In the long run, this is more flexible as it means you can use extra instantiations (e.g. cola<char>) without any more work. But it could mean the same functions are compiled many times, once in each translation unit. This is not a big problem, as the linker will correctly ignore the duplicate implementations. But it might slow down the compilation a little.

Summary

The default answer, used by the STL for example and in most of the code that any of us will write, is to put all the implementations in the header files. But in a more private project, you will have more knowledge and control of which particular template classes will be instantiated. In fact, this 'bug' might be seen as a feature, as it stops users of your code from accidentally using instantiations you have not tested for or planned for ("I know this works for cola<float> and cola<string>, if you want to use something else, tell me first and will can verify it works before enabling it.").

Finally, there are three other minor typos in the code in your question:

• You are missing an #endif at the end of nodo_colaypila.h
• in cola.h nodo_colaypila<T>* ult, pri; should be nodo_colaypila<T> *ult, *pri; - both are pointers.
• nodo_colaypila.cpp: The default parameter should be in the header file nodo_colaypila.h, not in this implementation file.

Galactic

To clear the confusion, this approach is not a hack, it is perfectly valid and explicit template instantation is supported & approved by the C++ standard.However, it is not the cleanest approach(my perspective): It needs you to know all types needed by the program and One needs to provide explicit instantiations for all types that you will ever use,in a big project this can be a considerable overhead while creating the possibility where you end up breaking the ODR. – Fluidics

Thanks @Als, I've edited my answer into a much longer answer and tried to describe both approaches correctly (and fairly?). Any feedback appreciated. – Galactic

Thanks, that seems to be the consensus I found online. Although, I never read any reasons behind it until now. – Sen

@AaronMcDaid: For someone reason I missed your comment before. This is a good answer which explains the semantics in a simple manner. You earn my +1. – Fluidics

You would think that someone would have simplified c++ generics by now. +1 for the detailed explanation though! :) – Rex

I found a nicer approach. Instead of having declared implementation in the header, I moved it to a separate «.cpp» file, added a header guard there, and in the end of the header included it. Actually I had a big (≈800 lines) implementation, and I changed just a few functions to use the same template instead of unsafe void* as it was. And it would be really awful to move all the class implementation to a header just because of a few functions. – Imine

I wish I find this prior to 1h of research. Thanks your clearing my problem. I'll buy you dinner if I ever get to meet you – Trifurcate

@Hi-Angel: The common and probably intended use is to provide separate header and implementation files. Whenever you need a new template instantiation you can just include the implementation in a small wrapper cpp file which adds an explicit instantiation. This avoids inlining unnecessary functions which iis both a waste of compile time and code memory in many cases. – Sibyls

Answer 2

You will have to define the functions inside your header file.
You cannot separate definition of template functions in to the source file and declarations in to header file.

When a template is used in a way that triggers its intstantation, a compiler needs to see that particular templates definition. This is the reason templates are often defined in the header file in which they are declared.

Reference:
C++03 standard, § 14.7.2.4:

The definition of a non-exported function template, a non-exported member function template, or a non-exported member function or static data member of a class template shall be present in every translation unit in which it is explicitly instantiated.

EDIT:
To clarify the discussion on the comments:
Technically, there are three ways to get around this linking problem:

• To move the definition to the .h file
• Add explicit instantiations in the .cpp file.
• #include the .cpp file defining the template at the .cpp file using the template.

Each of them have their pros and cons,

Moving the defintions to header files may increase the code size(modern day compilers can avoid this) but will increase the compilation time for sure.

Using the explicit instantiation approach is moving back on to traditional macro like approach.Another disadvantage is that it is necessary to know which template types are needed by the program. For a simple program this is easy but for complicated program this becomes difficult to determine in advance.

While including cpp files is confusing at the same time shares the problems of both above approaches.

I find first method the easiest to follow and implement and hence advocte using it.

Fluidics

Not quite true. This issue has come up before, but I can't find the relevant line. If you know which templates will be instantiated, you can put them into a cpp file as usual. See my answer. – Galactic

@AaronMcDaid: Then find the relevant line/examples/samples, quote the same and enlighten us before downvoting. – Fluidics

Ah. interesting. Is there a distinction between 'explicitly instantiated' and merely 'instantiated'. The explicit instantiation at the end of my answer satisfies this, in that the definition is present in cola.cpp. When the template is instantiated in main.cpp, perhaps that is a non-explicit instantiation, and maybe my answer stands up? – Galactic

PS: when I gave a similar answer on that other thread, nobody complained. I therefore became more confident it was correct. (Maybe I'm wrong, but curious about the word 'explicit') – Galactic

@Aaron McDaid Explicit instantiation is what you've done: You've explicitly told the compiler to generate source for those instances of the cola template. HOWEVER: C/C++ translation units colloquially correspond to cpp files, hence your definition of the cola templates will be absent until the linker kicks in and finds them in a different translation unit. This is why your solution works, it creates something for the linker to find. – Multivibrator

@user1021915, that makes a lot of sense. I think I could even (given a decade) implement a compiler and linker to do all that. But the comment from Als suggests that this behaviour is beyond the behaviour which is required by the standard. I think we all understand the compilation of cola.cpp, when my explicit instanation is included. The question boils down to: what happens when main.cpp is compiled? Before linking, can we say that main.cpp is able to correctly compile, even though the definition hasn't been seen? I think the answer is Yes, because the instantiations are non-explicit. – Galactic

@Als, this page on implicit instantiation seems relevant. And the corresponding explicit instantation. I can't claim to have read all of both pages, but it does suggest that explicit-versus-implicit is a relevant distinction. – Galactic

Answer 3

This link explains where you're going wrong:

[35.12] Why can't I separate the definition of my templates class from its declaration and put it inside a .cpp file?

Place the definition of your constructors, destructors methods and whatnot in your header file, and that will correct the problem.

This offers another solution:

How can I avoid linker errors with my template functions?

However this requires you to anticipate how your template will be used and, as a general solution, is counter-intuitive. It does solve the corner case though where you develop a template to be used by some internal mechanism, and you want to police the manner in which it is used.

Multivibrator

Your link provided the perfect understanding and solution. Thanks. – Pickings