47

I have the following code that compiles and works well:

template<typename T> T GetGlobal(const char *name); template<> int GetGlobal<int>(const char *name); template<> double GetGlobal<double>(const char *name);

However I want to remove the "default" function. That is, I want to make all calls to GetGlobal<t> where 't' is not an int or a double an error.

For example, GetGlobal<char>() should be a compile time error.

I tried to just delete the default function, but, as I imagined, I received a lot of errors.. So is there a way to "disable" it and allow calls only to the specialized versions of the function?

Thanks!

Improve this question

5 Answers 5

Reset to default
44

Though it is an old and outdated question, it may worth noting that C++11 had solved this issue using deleted functions:

template<typename T> T GetGlobal(const char *name) = delete; template<> int GetGlobal<int>(const char *name);

UPDATE

This will not compile under MacOS llvm 8. It is due to a still hanging 4 years old defect (see this bug report).

The following workaround will fit the issue (using a static_assert construct).

template<typename T> T GetGlobal(const char *name) { static_assert(sizeof(T) == 0, "Only specializations of GetGlobal can be used"); } template<> int GetGlobal<int>(const char *name);

UPDATE

Visual studio 15.9 has the same bug. Use the previous workaround for it.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

This is the best, thanks! It might also be relevant here: stackoverflow.com/questions/12629191/…
llvm 5.0 and 3.9 have fixed this bug.
34

To get a compile-time error implement it as:

template<typename T> T GetGlobal(const char *name) { T::unimplemented_function; } // `unimplemented_function` identifier should be undefined

If you use Boost you could make it more elegant:

template<typename T> T GetGlobal(const char *name) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }

C++ Standard guarantees that there is no such type which has sizeof equal to 0, so you'll get a compile-time error.

As sbi suggested in his comments the last could be reduced to:

template<typename T> T GetGlobal(const char *name) { char X[!sizeof(T)]; }

I prefer the first solution, because it gives more clear error message (at least in Visual C++) than the others.

Improve this answer

8 Comments

In order for the first case to fail at compile-time, Koper would need an undeclared function, not an undefined one. And the only way to get this to compile is to make it dependent on T. Something like T::some_thing_that_is_definitely_undeclared might do. (The second one could probably be mimicked with char dummy[!sizeof(T)];.)
Using unimplemented_function gives more clear error message (at least in Visual C++) than using T::unimplemented_function.
@Kirill: Using unimplemented_function won't work in a compiler that does two-phase lookup. (Currently, VC doesn't do this.) Such a compiler won't compile the template definition, even though it's never instantiated.
-1: SBI is correct. The identifier is looked up and as it is not a fucntion call with a dependent argument (ie. an ADL call) then it will be an error. Please fix the example - and get your point back! :)
Something like this template<typename T> struct not_defined : mpl::false_ { }; template<typename T> T GetGlobal(char const *name) { BOOST_MPL_ASSERT(( not_defined<T> )); } will give some nice error: codepad.org/rq30wdeq .
|
6

If you don't implement it, you'll at least get a linker error. If you want a compile-time error, you could do this with class templates: 

template<typename T> struct GlobalGetter; template<> struct GlobalGetter<int> { static int GetGlobal(const char *name); }; template<> struct GlobalGetter<double> { static double GetGlobal(const char *name); }; template<typename T> T GetGlobal(const char *name) { return GlobalGetter<T>::GetGlobal(name); }
Improve this answer

5 Comments

Any idea why a template function forward declaration doesn't yield a compiler error, while a template class forward declaration does?
Too much writings if you have much more specializations than for 'int' and 'double'.
What is GlobalGetter<T>(name)? Constructor? There is no constructor with single argument in GlobalGetter<int> and GlobalGetter<double>.
@xtofl: Because a function template declaration is all that you need to compile calls to a function. (Whereas for classes you need the definition.)
@Kiril: Instead of writing a function template specialization, you write a specialization for a class template which only contains one stat function. Yes, it's a few more keystrokes to type, but it's not that bad. However, your second solution (the one using STATIC_ASSRT I like, too.
3

I would suggest not to actually provide an implementation, just a bare declaration of the method.

The other option would be to use a compile-time assert. Boost has a number of such beasts.

namespace mpl = boost::mpl; BOOST_MPL_ASSERT((mpl::or_< boost::same_type<T, double>, boost::same_type<T, int> >));

There is also its message version counterpart, which would help.

Improve this answer

Comments

2

The following are alternative techniques to using boost:

Declare a typedef to a dependent name

This works because name lookup for DONT only occurs when 'T' has been replaced. This is a similar (but legal) version of the example given by Kirill

template <typename T> T GetGlobal (const char * name) { typedef typename T::DONT CALL_THIS_FUNCTION; }

Use an incomplete return type

This technique doesn't work for specializations, but it will work for overloads. The idea is that its legal to declare a function which returns an incomplete type, but not to call it:

template <typename T> class DONT_CALL_THIS_FUNCTION GetGlobal (const char * name);
Improve this answer

Comments