Ограничения шаблона C ++

Question

Интересно, есть ли способ установить ограничения на класс шаблона?
Укажите, что каждый тип, замещаемый в шаблоне, должен иметь определенного предка (реализовать некоторый интерфейс).

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();
    }
};

Мне нравится => в Haskell

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

Answer 1

Будущая версия C ++ будет поддерживать это изначально с использованием концепций (которые не вошли в C ++ 11).

Одним из способов решения этой проблемы является использование специализации для фиктивного параметра шаблона:

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>

Я поместил отдельные определения enable_if и is_base_and_derived здесь .

Answer 2

Следующее работает в VC10 с использованием static_assert.Я только что видел, как это используется, и не особо разбирался в том, что на самом деле делает static_assert - возможно, кто-то другой может ответить на это.

#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;
}

Вывод компилятора:

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>          ]

Answer 3

Вы можете использовать такой трюк (если вы не хотите использовать Boost):

class Base
   {
   public:
      static const int TEMPLATE_REQUIRES_BASE_CLASS = 0;
   };

class Correct : public Base
   {
   };

class Incorrect
   {
   };

template <typename T>
class TMPL
   {
   static const int TEMPLATE_REQUIRES_BASE_CLASS = T::TEMPLATE_REQUIRES_BASE_CLASS;
   T *m_t;
   };

void main()
{
TMPL<Correct> one;      // OK
TMPL<Incorrect> two;    // Will not compile
}

Первая строка будет скомпилирована. Второй не скомпилируется и выдаст следующую ошибку:

test.cpp
test.cpp(18) : error C2039: 'TEMPLATE_REQUIRES_BASE_CLASS' : is not a member of 'Incorrect'
        test.cpp(12) : see declaration of 'Incorrect'
        test.cpp(25) : see reference to class template instantiation 'TMPL<T>' being compiled
        with
        [
            T=Incorrect
        ]
test.cpp(18) : error C2065: 'TEMPLATE_REQUIRES_BASE_CLASS' : undeclared identifier
test.cpp(18) : error C2057: expected constant expression

Answer 4

Вы можете использовать BOOST_STATIC_ASSERT или подобную библиотеку, чтобы установить ограничения на параметр шаблона.

Например:

#include <limits>
#include <boost/static_assert.hpp>

template <class UnsignedInt>
class myclass
{
private:
   BOOST_STATIC_ASSERT((std::numeric_limits<UnsignedInt>::digits >= 16)
                        && std::numeric_limits<UnsignedInt>::is_specialized
                        && std::numeric_limits<UnsignedInt>::is_integer
                        && !std::numeric_limits<UnsignedInt>::is_signed);
public:
   /* details here */
};

РЕДАКТИРОВАТЬ : Например, вы можете написать

template < class B >
class A {
    BOOST_STATIC_ASSERT(boost::is_base_of<C, B>);

public:
    B * obj;
    int f() {
        return B::x + this->obj->f();
    }
};

Answer 5

Шаблоны - это своего рода утка, набираемая в C ++.

Если ваш класс поддерживает все, что использует шаблон, то он может использоваться как аргумент шаблона, в противном случае он не может.Если у вас есть что-то вроде

C *instance;

void foo(T *t)
{
  instance = t;
}

, то вы принудительно указываете, что T получен из C (или, по крайней мере, совместим с присвоением для указателей)