Question

I have the following problem using template instantiation [*].

file foo.h

class Foo { public:     template <typename F>     void func(F f)  private:     int member_; }; 

file foo.cc

template <typename F> Foo::func(F f) {      f(member_); } 

file caller.cc

Foo::func(boost::bind(&Bar::bar_func, bar_instance, _1)); 

While this compiles fine, the linker complains about an undefined symbol:

void Foo::func<boost::_bi::bind_t...>

How can I instantiate the function Foo::func? Since it takes a function as argument, I am little bit confused. I tried to add an instantiation function in foo.cc, as I am used to with regular non-function types:

instantiate() {     template<> void Foo::func<boost::function<void(int)> >(boost::function<void(int)>); } 

Obviously, this does not work. I would appreciate if someone can point me in the right direction.

Thanks!

[*] Yes, I read the parashift FAQ lite.

Answer 1

The answer to this is compiler dependent. Some versions of the Sun C++ compiler would handle this automatically by building a cache of template function implementations that would be shared across separate translation units.

If you’re using Visual C++, and any other compiler that can’t do this, you may as well put the function definition in the header.

Don’t worry about duplicate definitions if the header is included by multiple .cc files. The compiler marks template-generated methods with a special attribute so the linker knows to throw away duplicates instead of complaining. This is one reason why C++ has the ‘one definition rule’.

Edit: The above comments apply in the general case where your template must be capable of linking given any type parameters. If you know a closed set of types that clients will use, you can ensure they are available by using explicit instantiation in the template’s implementation file, which will cause the compiler to generate definitions for other files to link against. But in the general case where your template needs to work with types possibly only known to the client, then there is little point in separating the template into a header file and and implementation file; any client needs to include both parts anyway. If you want to isolate clients from complex dependencies, hide those dependencies behind non-templated functions and then call into them from the template code.