Шаблон класса С++ для определенного базового слоя

Скажем, у меня есть классы:

class Base{};

class A: public Base{
    int i;
};

class B:public Base{
    bool b;
};

И теперь я хочу определить шаблонный класс:

template < typename T1, typename T2 >
class BasePair{
    T1 first;
    T2 second;
};

Но я хочу определить его таким образом, чтобы в качестве шаблона шаблона могли использоваться только декодеры класса Base.

Как я могу это сделать?

Ответ 1

Точнее:

class B {};
class D1 : public B {};
class D2 : public B {};
class U {};

template <class X, class Y> class P {
    X x;
    Y y;
public:
    P() {
        (void)static_cast<B*>((X*)0);
        (void)static_cast<B*>((Y*)0);
    }
};

int main() {
    P<D1, D2> ok;
    P<U, U> nok; //error
}

Ответ 2

С++ 11 представляет <type_traits>

template <typename T1, typename T2>
class BasePair{
static_assert(std::is_base_of<Base, T1>::value, "T1 must derive from Base");
static_assert(std::is_base_of<Base, T2>::value, "T2 must derive from Base");

    T1 first;
    T2 second;
};

Ответ 3

С++ еще не позволяет это напрямую. Вы можете реализовать это косвенно, используя STATIC_ASSERT и тип проверки внутри класса:

template < typename T1, typename T2 >
class BasePair{
    BOOST_STATIC_ASSERT(boost::is_base_of<Base, T1>);
    BOOST_STATIC_ASSERT(boost::is_base_of<Base, T2>);
    T1 first;
    T2 second;
};

Ответ 4

Это был отличный вопрос! Изучая это с помощью link, я придумал следующее, что, по общему признанию, не сильно отличается от предоставленного решения. Узнайте что-нибудь каждый день... проверьте!

#include <iostream>
#include <string>
#include <boost/static_assert.hpp>

using namespace std;

template<typename D, typename B>
class IsDerivedFrom
{
  class No { };
  class Yes { No no[3]; };

  static Yes Test(B*); // declared, but not defined
  static No Test(...); // declared, but not defined

public:
  enum { IsDerived = sizeof(Test(static_cast<D*>(0))) == sizeof(Yes) };
};


class Base
{
public:
    virtual ~Base() {};
};

class A : public Base
{
    int i;
};

class B : public Base
{
    bool b;
};

class C
{
    string z;
};


template <class T1, class T2>
class BasePair
{
public:
    BasePair(T1 first, T2 second)
        :m_first(first),
         m_second(second)
    {
        typedef IsDerivedFrom<T1, Base> testFirst;
        typedef IsDerivedFrom<T2, Base> testSecond;

        // Compile time check do...
        BOOST_STATIC_ASSERT(testFirst::IsDerived == true);
        BOOST_STATIC_ASSERT(testSecond::IsDerived == true);

        // For runtime check do..
        if (!testFirst::IsDerived)
            cout << "\tFirst is NOT Derived!\n";
        if (!testSecond::IsDerived)
            cout << "\tSecond is NOT derived!\n";

    }

private:
    T1 m_first;
    T2 m_second;
};


int main(int argc, char *argv[])
{
    A a;
    B b;
    C c;

    cout << "Creating GOOD pair\n";
    BasePair<A, B> good(a, b);

    cout << "Creating BAD pair\n";
    BasePair<C, B> bad(c, b);
    return 1;
}

Ответ 5

Сначала зафиксируйте объявление

template < class T1, class T2 >
class BasePair{
    T1 first;
    T2 second;
};

Затем вы можете объявить в базовом классе некоторую закрытую функцию Foo(); и скажите базовому классу, что BasePair является другом; то в конструкторе друзей вам просто нужно вызвать эту функцию. Таким образом вы получите ошибку времени компиляции, когда кто-то пытается использовать другие классы в качестве параметров шаблона.

Ответ 6

class B
{
};
class D : public B
{
};
class U
{
};

template <class X, class Y> class P
{
    X x;
    Y y;
public:
    P()
    {
        (void)static_cast<X*>((Y*)0);
    }
};

Ответ 7

В ответе, предложенном неизвестным (yahoo), нет необходимости фактически иметь переменные типа X и Y в качестве членов. Эти строки достаточны в конструкторе:

static_cast<B*>((X*)0);
static_cast<B*>((Y*)0);