基于继承类的模板特化

Question

我想让这个专业化而不改变主要。 是否有可能根据其基类来专门化某些东西？ 但愿如此。

-编辑-

我将有几个继承自 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

使用 C++20 中的概念和 require 关键字是一种更简单、更具表现力的方法，而无需像 C++11 中那样引入冗余的布尔非类型模板参数：

// C++20:
#include <concepts>
#include <iostream>

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

template<typename T>
struct MyClass 
{ 
    void Print()
    {
        std::cout << "Not derived from someTag\n";
    }
};

// std::derived_from is a predefined concept already included in the STL
template<typename T>
    requires std::derived_from<T, SomeTag> 
struct MyClass<T> 
{
    void Print()
    {
        std::cout << "derived from someTag\n";
    }
};

int main() 
{
    MyClass<InheritSomeTag> test1;
    test1.Print();      // derived from someTag
    MyClass<int> test2;        
    test2.Print();      // Not derived from someTag

    // Note how even the base tag itself returns true from std::derived_from:
    MyClass<SomeTag> test3;          
    test3.Print();      // derived from someTag 

}

Answer 2

使用 C++-20 更新概念：

#include <concepts>

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

template<typename T>
concept ConceptSomeTag = std::is_base_of_v<SomeTag, T>;

template<class T>
struct MyClass {
};

// Specialization.
template<ConceptSomeTag ST>
struct MyClass<ST> {
    using isSpecialized = int;
};

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

我 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 3

本文描述了一个巧妙的技巧：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>
{
};

然后您的 main 就可以了：

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

Answer 4

嗯，上面答案中的文章发表于 2002 年 2 月。虽然它有效，但今天我们知道还有更好的方法。 或者，您可以使用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 5

就您而言，我看到的唯一方法是显式专门化 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 中真正的痛苦！）