Шаблонная специализация на основе наследуемого класса

Question

Я хочу сделать эту специализированную без смены основной. Можно ли специализировать что-либо на основе его базового класса? Я надеюсь на это.

-edit-

У меня будет несколько классов, которые наследуются от SomeTag. Я не хочу писать одну и ту же специализацию для каждой из них.

class SomeTag {};
class InheritSomeTag : public SomeTag {};

template <class T, class Tag=T>
struct MyClass
{
};

template <class T>
struct MyClass<T, SomeTag>
{
    typedef int isSpecialized;
};

int main()
{
    MyClass<SomeTag>::isSpecialized test1; //ok
    MyClass<InheritSomeTag>::isSpecialized test2; //how do i make this specialized w/o changing main()
    return 0;
}

Answer 1

В этой статье описан хитрый трюк: http://www.gotw.ca/publications/mxc++-item-4.htm

Вот основная идея. Сначала вам нужен класс IsDerivedFrom (он обеспечивает проверку времени выполнения и компиляции):

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

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

  static void Constraints(D* p) { B* pb = p; pb = p; } 

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

  IsDerivedFrom() { void(*p)(D*) = Constraints; }
};

Тогда вашему MyClass нужна потенциально специализированная реализация:

template<typename T, int>
class MyClassImpl
{
  // general case: T is not derived from SomeTag
}; 

template<typename T>
class MyClassImpl<T, 1>
{
  // T is derived from SomeTag
  public:
     typedef int isSpecialized;
}; 

и MyClass на самом деле выглядит так:

template<typename T>
class MyClass: public MyClassImpl<T, IsDerivedFrom<T, SomeTag>::Is>
{
};

Тогда с вашим основным будет все в порядке:

int main()
{
    MyClass<SomeTag>::isSpecialized test1; //ok
    MyClass<InheritSomeTag>::isSpecialized test2; //ok also
    return 0;
}

Answer 2

Что ж, статья в ответе выше появилась в феврале 2002 года. Пока она работает, сегодня мы знаем, что есть лучшие способы. Кроме того, вы можете использовать enable_if:

template<bool C, typename T = void>
struct enable_if {
  typedef T type;
};

template<typename T>
struct enable_if<false, T> { };

template<typename, typename>
struct is_same {
    static bool const value = false;
};

template<typename A>
struct is_same<A, A> {
    static bool const value = true;
};

template<typename B, typename D>                                 
struct is_base_of {                                                       
    static D * create_d();                     
    static char (& chk(B *))[1]; 
    static char (& chk(...))[2];           
    static bool const value = sizeof chk(create_d()) == 1 &&  
                              !is_same<B    volatile const, 
                                       void volatile const>::value;
};

struct SomeTag { };
struct InheritSomeTag : SomeTag { };

template<typename T, typename = void>
struct MyClass { /* T not derived from SomeTag */ };

template<typename T>
struct MyClass<T, typename enable_if<is_base_of<SomeTag, T>::value>::type> {
    typedef int isSpecialized;
};

int main() {
    MyClass<SomeTag>::isSpecialized test1;        /* ok */
    MyClass<InheritSomeTag>::isSpecialized test2; /* ok */
}

Answer 3

И теперь короткая версия, 2014, с использованием C ++ - 11:

#include <type_traits>

struct SomeTag { };
struct InheritSomeTag : SomeTag { };

template<typename T, bool = std::is_base_of<SomeTag, T>::value>
struct MyClass { };

template<typename T>
struct MyClass<T, true> {
    typedef int isSpecialized;
};

int main() {
    MyClass<SomeTag>::isSpecialized test1;        /* ok */
    MyClass<InheritSomeTag>::isSpecialized test2; /* ok */
}

Answer 4

В вашем случае, единственный способ, который я вижу, это явно специализировать MyClass для InheritSomeTag. Однако в документе SeqAn предлагается механизм, называемый «подклассом шаблонов», который делает то, что вы хотите - хотя и с другим синтаксисом наследования, поэтому код не совместим с вашей текущей функцией main.

// Base class
template <typename TSpec = void>
class SomeTag { };

// Type tag, NOT part of the inheritance chain
template <typename TSpec = void>
struct InheritSomeTag { };

// Derived class, uses type tag
template <typename TSpec>
class SomeTag<InheritSomeTag<TSpec> > : public SomeTag<void> { };

template <class T, class Tag=T>
struct MyClass { };

template <class T, typename TSpec>
struct MyClass<T, SomeTag<TSpec> >
{
    typedef int isSpecialized;
};

int main()
{
    MyClass<SomeTag<> >::isSpecialized test1; //ok
    MyClass<SomeTag<InheritSomeTag<> > >::isSpecialized test2; //ok
}

Это, конечно, выглядит странно и очень громоздко, но допускает механизм истинного наследования с полиморфными функциями, который выполняется во время компиляции. Если вы хотите увидеть это в действии, взгляните на некоторые примеры SeqAn .

При этом я считаю, что SeqAn является особым случаем, и не многие приложения извлекут выгоду из этого чрезвычайно сложного синтаксиса (расшифровка ошибок, связанных с SeqAn, является настоящей болью в * ss!)