static_assert fails compilation even though template function is called nowhere

by

The standard says in [temp.res]/8

No diagnostic shall be issued for a template definition for which a valid specialization can be generated. If no valid specialization can be generated for a template definition, and that template is not instantiated, the template definition is ill-formed, no diagnostic required. … [ Note: If a template is instantiated, errors will be diagnosed according to the other
rules in this Standard. Exactly when these errors are diagnosed is a quality of implementation issue. — end note ]

There is no possible way to instantiate your function template that will compile, so the template definition is ill-formed and so the compiler is allowed (but not required) to reject it even if it isn’t instantiated.

You could make it work like this:

template<typename T>
struct foobar : std::false_type
{ };

template <typename T>
inline T getValue(AnObject&)
{
    static_assert( foobar<T>::value , "this function has to be implemented for desired type");
}

Now the compiler cannot reject the function template immediately, because until it is instantiated it doesn’t know whether there will be a specialization of foobar that has value == true. When instantiated the relevant specialization of foobar<T> will be instantiated and the static assertion will still fail, as desired.

More Related Contents:

  1. std::enable_if to conditionally compile a member function
  2. C++11 make_pair with specified template parameters doesn’t compile
  3. std::enable_if : parameter vs template parameter
  4. How to emulate C array initialization “int arr[] = { e1, e2, e3, … }” behaviour with std::array?
  5. using extern template (C++11)
  6. SFINAE working in return type but not as template parameter
  7. What is “Expression SFINAE”?
  8. constexpr if and static_assert
  9. Specifying one type for all arguments passed to variadic function or variadic template function w/out using array, vector, structs, etc?
  10. Detecting constexpr with SFINAE
  11. Alias template specialisation
  12. What do compilers do with compile-time branching?
  13. Is it possible to “store” a template parameter pack without expanding it?
  14. C++11: Compile Time Calculation of Array
  15. How to reverse the order of arguments of a variadic template function?
  16. Doing a static_assert that a template type is another template
  17. Template specialization and enable_if problems [duplicate]
  18. error: use of deleted function
  19. Populate An Array Using Constexpr at Compile-time
  20. Why do auto and template type deduction differ for braced initializers?
  21. A class name introduced inside a class is not treated as a nested class name
  22. Forwarding all constructors in C++0x
  23. How to compile C++ with C++11 support in Mac Terminal
  24. How to make a variadic is_same?
  25. std::remove_const with const references
  26. Why can’t I use with g++ 4.9.2?
  27. Partial specialization of function templates
  28. Why does stack not compile in g++? [duplicate]
  29. Dynamic dispatching of template functions?
  30. get part of std::tuple

Leave a Comment