How can I create a compile time assertion that a template is of specific types?

Question

I have a template function and wish to ensure at compile time that it is not instantiated on a subtype or supertype of a particular class.

How can I cause a C++ compiler error if this is violated?

class base {
};
class derived : public base {
};
class lowest : public derived {
};

template <typename T>
bool isCorrect(const T& obj) {
  typedef foo<T> D;
  foo<T> *def = foo<T>::find();
  return (def && def->getAnswer(object));
}

I want isCorrect to only be available for class derived, but not base or lowest. Note there could be many other lowest classes and a string of base classes to be excluded as well as alternative derived classes that are acceptable.

Is there a way in C++ to limit the template to only apply to the derived classes I explicitly specify?

possible duplicate of [Template Constraints C++](http://stackoverflow.com/questions/122316/template-constraints-c) — Stuart Golodetz, Dec 15 '11 at 00:48
Specifically, this might be useful: http://www.boost.org/doc/libs/1_48_0/libs/concept_check/concept_check.htm — Stuart Golodetz, Dec 15 '11 at 00:50
@GMan There are a lot of sub types, so the list would be pretty long, so I'm looking for way to instead positively declare the acceptable ones. — WilliamKF, Dec 15 '11 at 13:06

score 10 · Answer 1 · answered Dec 15 '11 at 00:52

Type traits, specifically is_base_of.

#include <type_traits>

template <typename T>
bool isCorrect(const T& obj) {
  static bool const is_base = std::is_base_of<base, T>::value;
  static bool const derives = std::is_base_of<derived, T>::value;
  // specify allowed types here
  static bool const is_derived = std::is_same<T, derived>::value;
  // ---
  static_assert((!is_base && !derives) || is_derived, "wrong argument type");

  typedef foo<T> D;
  foo<T> *def = foo<T>::find();
  return (def && def->getAnswer(object));
}

Note that this is C++11 specific, but you can get the same behaviour with Boost.TypeTraits.

Jon · Accepted Answer · 2011-12-15T01:18:04.737

4

Here's one technique that I know of.

First, make another template class policy_enforcer. Declare this class without defining it, and also provide a specialization of it for derived that is also defined:

template<typename T> struct policy_enforcer;
template<> struct policy_enforcer<derived> { };

Then, within the function you wish to lock down, include the expression sizeof(policy_enforcer<T>). Since sizeof on incomplete types is a compilation error, this will prevent the code from compiling.

Updated with live code: using base, using derived, using lowest.

edited Dec 15 '11 at 01:18

answered Dec 15 '11 at 00:49

Jon

428,835
81
738
806

A bit obtuse, but it would work. Hopefully someone will post a way that is not so obscure. – WilliamKF Dec 15 '11 at 00:53

score 1 · Answer 3 · answered Dec 15 '11 at 00:56

You can use template specialization.

You can implement only the isCorrect only for types that you want to be able to work with.

For the other types you can implement dummy method, returning false for example, or not implement isCorrect at all, in which case it will not compile for other types.

#include <iostream>

using namespace std;

class base {
};
class derived : public base {
};
class lowest : public derived {
};

// using this it will fail if you try to pass anything
// else than `derived`
//  template <typename T>
//     bool isCorrect(const T& obj);

template <typename T>
bool isCorrect(const T& obj) {
    cout << __PRETTY_FUNCTION__ << endl;
    return false;
}

template <>
bool isCorrect<derived>(const derived& obj) {
    cout << __PRETTY_FUNCTION__ << endl;
    return true;
//  typedef foo<derived> D;
//  foo<derived> *def = foo<derived>::find();
//  return (def && def->getAnswer(object));
}

Test:

int main()
{
    base b;
    derived d;
    lowest l;

    cout << isCorrect(b) << endl;
    cout << isCorrect(d) << endl;
    cout << isCorrect(l) << endl;
}

Output:

bool isCorrect(const T&) [with T = base]
0
bool isCorrect(const T&) [with T = derived]
1
bool isCorrect(const T&) [with T = lowest]
0

`__func__` is the C++11 equivalent of `__FUNCTION__`, `__PRETTY_FUNCTION__` etc. — Xeo, Dec 15 '11 at 00:57
It is not equivalent .... Firstly, I don't see any requirement for C++11, anything wrong with `__PRETTY_FUNCTION__` , it wasn't part of the question, btw thanks for the info :) ? With `__func__` or `__FUNCTION__` you only get `isCorrect` or `isCorrect` so you don't see the other types that called the non-specialized version .... — stefanB, Dec 15 '11 at 01:09
Nothing wrong, I just wanted to mention that, since C++11 is the current standard. Everything else (`__FUNCTION__`, `__PRETTY_FUNCTION__`, etc) is non-standard and non-portable most of the time. :) — Xeo, Dec 15 '11 at 01:11

How can I create a compile time assertion that a template is of specific types?

3 Answers3