Question

In current g++, I typically include all my templated functions that take the template parameter as an argument because they have to be compiled for each instance.

template<typename T>
class A {
public:
  void f() { ... }
};

So in a different source, I would write:

#include <A.hh>
A<int> a1;
a1.f();

A<double> a2;
a2.f();

Sometimes, when I’ve been desperate to not inline big methods, I’ve manually specified which classes will be used in the source file, but it’s really obnoxious:

template<typename T>
A::A() { ... }

template<typename T>
void A::f() { ... }

A<int>; // manually trigger code generation for int and double
A<double>; 

Obviously different IDEs and compilers have mechanisms to support this. Is there anything standard that has been mandated, and/or does g++ support anything like this?

Answer 1

There’s nothing in the proposed C++0x standard. In fact, export template has been removed (few compilers implemented it anyway).

As far as inlining is concerned, it’s a total non-issue. The compiler is smart enough not to inline functions which are too big, even if they’re marked inline and put into a header file.

If you’re looking at increased compile times from header files grown bloated from templates, use precompiled headers. These aren’t standard, but almost all current compilers provide such a mechanism.