C++ template restrictions

Question

I wondering is there any way to set restrictions on template class?
Specify that every type substituted in template must have specific ancestor (realize some interface).

template < class B > //and every B must be a child of abstract C
class A {
public:
    B * obj;
    int f() {
        return B::x + this->obj->f();
    }
};

Like => in haskell

func :: (Ord a, Show b) => a -> b -> c

Answer 1

A future version of C++ will support this natively using concepts (which didn't make it into C++11).

One way to approach the problem is to use specialisation on a dummy template parameter:

class C {};
template <class B, class dummy=void>
class A;

template <class B>
class A<B, typename enable_if<is_base_and_derived<C, B> >::type>
{
    // class definition here
};

struct D : C {};

A<D> d;     // fine
A<int> n;   // compile error - undefined class A<B>

I've put stand-alone definitions of enable_if and is_base_and_derived here.

Answer 2

The following works in VC10 using static_assert. I've just seen this used and haven't really dug around much into what static_assert actually does - perhaps someone else can answer that.

#include <type_traits>

class Base
{

};

class Derived : public Base
{

};

class SomeRandomClass
{

};

template<typename T>
class A
{
    static_assert(std::tr1::is_base_of<Base, T>::value, "T not derived from Base");
};



int _tmain(int argc, _TCHAR* argv[])
{
    argc; argv;  

    //
    //  This will compile
    A<Derived> a;

    //
    //  This will throw a compilation error
    A<SomeRandomClass> b; 

    return 0;
}

The compiler output being:

1>d:\temp\aaa\aaa\aaa.cpp(25): error C2338: T not derived from Base
1>          d:\temp\aaa\aaa\aaa.cpp(41) : see reference to class template instantiation 'A<T>' being compiled
1>          with
1>          [
1>              T=SomeRandomClass
1>          ]