explicit-instantiation

Consider the following header file: // Foo.h class Foo { public: template <typename T> void read(T& value); }; I want to explicitly instantiate the Foo::read member function template in a source file for all types included in a boost::mpl::vector : // Foo.cc #include <boost/mpl/vector.hpp> #include <boost/mpl/begin_end.hpp> #include "Foo.h" template <typename T> void Foo::read(T& value) { /* do something */ } typedef boost::mpl::vector<int, long, float> types; // template Foo::read<int >(int&); // template Foo::read<long >(long&); // template Foo::read<float>(float&); // instantiate

Summary This question is about achieving separate compilation of a single template class instantiation in a several different translation units. Question For non-template classes one can put definitions in several .cpp files and compile them separately. For instance: file A.h: class A { public: void func1(); void func2(); void func3() { /* defined in class declaration */} } file A1.cpp: void A::func1() { /* do smth */ } file A2.cpp: void A::func2() { /* do smth else */ } Now I tried to do something similar with template classes. Since I know exactly which instances I will need, I'm explicitly

I am uncertain if it is a bug in Clang 3.2 or a violation of C++03, but it appears that explicit instantiation of templated constructors for template classes fails, but explicit instantiation of templated member functions of template classes succeeds. For instance, the following compiles without a problem with both clang++ and g++: template<typename T> class Foo { public: template<typename S> void Bar( const Foo<S>& foo ) { } }; template class Foo<int>; template class Foo<float>; template void Foo<int>::Bar( const Foo<int>& foo ); template void Foo<int>::Bar( const Foo<float>& foo ); template

I've just been reading about template explicit instantiation: template struct MyStruct<long>; It was described as "quite rare", so under what circumstances would it be useful? One of the use cases is to hide definitions from the end-user. tpl.h : template<typename T> void func(); // Declaration tpl.cpp : template<typename T> void func() { // Definition } template void func<int>(); // explicit instantiation for int template void func<double>(); // explicit instantiation for double main.cpp #include "tpl.h" int main() { func<double>(); // OK func<int>(); // OK // func<char>(); - Linking ERROR }