我想让这个专业化而不改变主要。是否有可能根据其基类来专门化某些东西?我希望如此。
-编辑-
我将有几个继承自 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;
}
使用 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 */
}
本文介绍了一个巧妙的技巧: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;
}
嗯,上面答案中的文章发表于 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 */
}
就您而言,我认为唯一的方法是明确将
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 中真正的痛苦!)
使用 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
}