How to prevent non-specialized template instantiation?

Question

I have a templated class (call it Foo) which has several specializations. I would like the compilation to fail if someone tries to use an unspecialized version of Foo.

Here is what I actually have:

template <typename Type> class Foo {   Foo() { cannot_instantiate_an_unspecialized_Foo(); }    // This method is NEVER defined to prevent linking.   // Its name was chosen to provide a clear explanation why the compilation failed.   void cannot_instantiate_an_unspecialized_Foo(); };  template <> class Foo<int> {    };  template <> class Foo<double> {    }; 

So that:

int main() {   Foo<int> foo; } 

Works while:

int main() {   Foo<char> foo; } 

Does not.

Obviously, the compiler chain only complains when the linking process takes place. But is there a way to make it complain before ?

I can use boost.

Answer 1

Just don't define the class:

template <typename Type> class Foo;  template <> class Foo<int> { };  int main(int argc, char *argv[])  {     Foo<int> f; // Fine, Foo<int> exists     Foo<char> fc; // Error, incomplete type     return 0; } 

Why does this work? Simply because there isn't any generic template. Declared, yes, but not defined.

Answer 2

You can simply not define the base case:

template <typename> class Foo;             // no definition!  template <> class Foo<int> { /* ... */ };  // Foo<int> is OK