Disallow a specific function template instantiation

Question

I would like to define a template function but disallow instantiation with a particular type. Note that in general all types are allowed and the generic template works, I just want to disallow using a few specific types.

For example, in the code below I wish to prevent using double with the template. This doesn't actually prevent the instantiation, but just causes a linker error by not having the function defined.

template<typename T>
T convert( char const * in )
{ return T(); }

//this way creates a linker error
template<>
double convert<double>( char const * in );

int main()
{
    char const * str = "1234";

    int a = convert<int>( str );
    double b = convert<double>( str );
}

The code is just a demonstration, obviously the convert function must do something more.

Question: In the above code how can I produce a compiler error when trying to use the convert<double> instantiation?

The closest related question I can find is How to intentionally cause a compile-time error on template instantiation It deals with a class, not a function.

The reason I need to do this is because the types I wish to block will actually compile and do something with the generic version. That's however not supposed to be part of the contract of the function and may not be supported on all platforms/compilers and in future versions. Thus I'd like to prevent using it at all.

No, that gives a linker error about a missing function. That error won't tell you where the problem is either, it'll just tell you which module it is in. — edA-qa mort-ora-y, Apr 22 '11 at 11:05
You could trigger a compile-time error using `static_assert`: `template <> foo(const char*) { static_assert(false, "not allowed"); }` — evnu, Apr 22 '11 at 11:10
@edA-qa mort-ora-y: what do you understand by "disallowing instantiation"? — Nawaz, Apr 22 '11 at 11:12
@evnu: This can be problematic, see here: http://stackoverflow.com/q/5246049/572743 — Damon, Apr 22 '11 at 11:13
@Damon: Yes. Maybe one could trigger a simple compile error (like char a[0] or sth.) — evnu, Apr 22 '11 at 11:26
@Nawaz, I differentiate between compile and link-time. Since errors at link time are generally useless. — edA-qa mort-ora-y, Apr 22 '11 at 13:16
@envu that approach doesn't work since it is a specialize template. The error will be produced whether that version is used or not. — edA-qa mort-ora-y, Apr 22 '11 at 13:31

wheaties · Accepted Answer · 2011-04-22T12:56:34.913

3

I would use a static assert within your function call to create the proper failure during function instantiation:

template<typename T>
class is_double{ static const int value = false; }

template<>
class is_double<double>{ static const int value = true; }

template<typename T>
T convert( const char *argument ){
    BOOST_STATIC_ASSERT( !is_double<T>::value );
    //rest of code
}

And that should work within a function.

edited Apr 22 '11 at 12:56

answered Apr 22 '11 at 11:27

wheaties

35,646
15
94
131

Should be `static bool const value`. :) – Xeo Apr 22 '11 at 11:50
Ah yes. I feel silly since I use static assert in many places, somehow it just escaped my mind here. – edA-qa mort-ora-y Apr 22 '11 at 13:18
1

I wish GCC could give a better error message than `invalid application of ‘sizeof’ to incomplete type ‘boost::STATIC_ASSERTION_FAILURE’` Oh well, it'll do. – edA-qa mort-ora-y Apr 22 '11 at 13:27
I use this method now, though I've used a boost trait: `BOOST_STATIC_ASSERT(!(boost::is_same::value));` – edA-qa mort-ora-y Apr 22 '11 at 13:34
@edA-qa mort-ora-y Ahmen to that. But at least it hones in right where the error is happening intead of some of the other messages I've seen where there are 50 million template parameters thrown up on my screen. – wheaties Apr 22 '11 at 13:50
2

C++11 now has a built in static_assert, no boost required. – Pharap Dec 15 '14 at 00:13

Kirill V. Lyadvinsky · Answer 2 · 2011-04-22T11:26:56.323

You could use a functor instead of a function:

template<typename T>
struct convert { 
    T operator()(char const * in) const { return T(); } 
};
template<> struct convert<double>;

int main()
{
    char const * str = "1234";

    int a = convert<int>()( str );
    double b = convert<double>()( str ); // error in this line

    return 0;
}

This will give you an error at the point of instantiation.

By adding helper function you will get the wanted behaviour:

template<typename T>
struct convert_helper { 
    T operator()(char const * in) const { return T(); } 
};
template<> struct convert_helper<double>;

template<typename T>
T convert( char const * in ) { return convert_helper<T>()( in ); }

int main()
{
    char const * str = "1234";

    int a = convert<int>( str );
    double b = convert<double>( str );

    return 0;
}

This is a also a good option since I already have essentially the second scheme for other reasons. — edA-qa mort-ora-y, Apr 22 '11 at 13:19

score 1 · Answer 3 · answered Apr 22 '11 at 11:26

1

If you don't want to rely on static_assert or make the code portable pre-C++0x, use this:

template<class T>
void func(){
    typedef char ERROR_in_the_matrix[std::is_same<T,double>::value? -1 : 1];
}

int main(){
  func<int>(); // no error
  func<double>(); // error: negative subscript
}

answered Apr 22 '11 at 11:26

Xeo

129,499
52
291
397

I didn't think `std:is_same` was available pre-C++11 (or C++0x as it was back here) – Pharap Dec 15 '14 at 00:16

score 0 · Answer 4 · edited May 23 '17 at 11:52

Consider Boost disable_if and Boost TypeTraits

Take a look at How can I write a function template for all types with a particular type trait?

This is an example:

#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>

template<typename T>
T convert( char const * in, 
           typename boost::disable_if<boost::is_floating_point<T>, T>::type* = 0 )
{ return T(); }


int main()
{
    char const * str = "1234";

    int a = convert<int>( str );
    double b = convert<double>( str );
    return 0;
}

This is the compilation error for the string

double b = convert<double>( str );

1>.\simple_no_stlport.cpp(14) : error C2770: invalid explicit template argument(s) for 'T convert(const char *,boost::disable_if,T>::type *)' 1> .\simple_no_stlport.cpp(5) : see declaration of 'convert'

Disallow a specific function template instantiation

4 Answers4

Linked