Compile Time Template restriction C++

Question

Basically I have 4 classes:

OverVoid
Meta: that inherits OverVoid
Physical: which has nothing to do with the above
Move: a templated class

I want move's template to accept objects of only OverVoid type i.e. OverVoid and Meta.

class OverVoid{
public:

    virtual ~OverVoid(){
    };
};

class Meta: public OverVoid{

};

class Physical{
public:
};

template<typename _Ty>
class Move{

};

I want an error to be trown at compile time, I know there is a way with boost but I cannot use Boost (dev issues with my company)

any ideas?

Maybe put a tag in the OverVoid class and then do a static assert in the template — shuttle87, May 15 '15 at 14:42

score 6 · Answer 1 · answered May 15 '15 at 14:47

6

The simplest thing is just a static_assert:

template<typename _Ty>
class Move {
    static_assert(std::is_base_of<OverVoid, _Ty>::value, 
                  "_Ty must inherit from OverVoid.");
};

Note that this allows OverVoid to be a private or inaccessible base. If you want to require that it's a public base, you could instead require:

    static_assert(std::is_convertible<_Ty*, OverVoid*>::value, 
                  "_Ty must inherit publicly from OverVoid.");

answered May 15 '15 at 14:47

Barry

286,269
29
621
977

Hello i tried your way but it requires /EHsc flag with msvc++ which i cannot use because fo dev issues but thanks anyway :) – Wissam Y. Khalil May 15 '15 at 15:16

score 1 · Accepted Answer · answered May 15 '15 at 14:54

1

You can hide the template definition for classes not of type OverVoid

template<typename _Ty, 
         class = typename std::enable_if<std::is_base_of<OverVoid, _Ty>::value>::type>
class Move{

};

You then get an error when attempting to compile a class of non-OverVoid type.

int main() {

  Move<Meta> a;
  Move<OverVoid> b;
  Move<Physical> c;
  // your code goes here
  return 0;
}

Error:

prog.cpp: In function 'int main()':
prog.cpp:29:15: error: no type named 'type' in 'struct std::enable_if<false,    void>'
Move<Physical> c;

answered May 15 '15 at 14:54

lcs

4,227
17
36

Thanks for the help but what if _Ty is actually Meta*, it doesnt work, so is there a workaround? – Wissam Y. Khalil May 15 '15 at 15:22
You can use `std::remove_pointer<_Ty>` to remove the pointer and get the base type. – lcs May 15 '15 at 15:40
`class = typename std::enable_if::type>::value>::type>` – lcs May 15 '15 at 15:41

Mateusz Grzejek · Answer 3 · 2015-05-15T15:03:18.323

Use std::enable_if:

template <typename T>
struct is_overvoid_or_meta
{
     static const bool value = false;
};

template <> struct is_overvoid_or_meta<OverVoid>
{
     static const bool value = true;
};

template <> struct is_overvoid_or_meta<Meta>
{
     static const bool value = true;
};

//Add specialization for all valid types - this allows you to more precisely tell, what types can be used as a template argument for Move

And then:

template<typename _Ty>
class Move
{
     typedef std::enable_if<is_overvoid_or_meta<_Ty>::value, _Ty>::type Type;
};

You will get compile-time error for every type, that is not OverVoid or Meta (or, more general, for every T, for which is_overvoid_or_meta<T>::value is false - if you will add more of them in the future, you may want to chnge is_overvoid_or_meta to more general, like is_acceptable_by_move or something):

int main()
{
    Move<OverVoid> m1;
    Move<Meta> m2;
    Move<int> m3;
    return 0;
}

Output:

error: no type named 'type' in 'struct std::enable_if'

typedef typename std::enable_if::value, _Ty>::type Type;

Live sample.

This is very nice solution, because it cannot be tricked - additional template parameter for Move can always be specified manually (unless OverVoid and Meta are not exposed to client).

Compile Time Template restriction C++

3 Answers3

Linked