我读了维基百科的文章,内容是关于C++中奇怪的重复出现的模板模式,用于执行静态(阅读:编译时)多态性。我想概括它,以便我可以根据派生类型更改函数的返回类型。(这似乎是可能的,因为基类型知道模板参数的派生类型)。不幸的是,以下代码无法使用 MSVC 2010 进行编译(我现在无法轻松访问 gcc,所以我还没有尝试过)。有人知道为什么吗?
template <typename derived_t>
class base {
public:
typedef typename derived_t::value_type value_type;
value_type foo() {
return static_cast<derived_t*>(this)->foo();
}
};
template <typename T>
class derived : public base<derived<T> > {
public:
typedef T value_type;
value_type foo() {
return T(); //return some T object (assumes T is default constructable)
}
};
int main() {
derived<int> a;
}
顺便说一句,我有一个使用额外模板参数的解决方法,但我不喜欢它---在继承链上传递许多类型时它会变得非常冗长。
template <typename derived_t, typename value_type>
class base { ... };
template <typename T>
class derived : public base<derived<T>,T> { ... };
编辑:
MSVC 2010 在此情况下给出的错误消息是error C2039: 'value_type' : is not a member of 'derived<T>'
G ++ 4.1.2(通过 codepad.org)说error: no type named 'value_type' in 'class derived<int>'
当您将其用作模板参数以base
其基类列表中时,derived
是不完整的。
常见的解决方法是使用特征类模板。 这是你的例子,特征化。 这显示了如何通过特征使用派生类中的类型和函数。
// Declare a base_traits traits class template:
template <typename derived_t>
struct base_traits;
// Define the base class that uses the traits:
template <typename derived_t>
struct base {
typedef typename base_traits<derived_t>::value_type value_type;
value_type base_foo() {
return base_traits<derived_t>::call_foo(static_cast<derived_t*>(this));
}
};
// Define the derived class; it can use the traits too:
template <typename T>
struct derived : base<derived<T> > {
typedef typename base_traits<derived>::value_type value_type;
value_type derived_foo() {
return value_type();
}
};
// Declare and define a base_traits specialization for derived:
template <typename T>
struct base_traits<derived<T> > {
typedef T value_type;
static value_type call_foo(derived<T>* x) {
return x->derived_foo();
}
};
您只需为用于模板参数derived_t
base
的任何类型专门化base_traits
,并确保每个专用化都提供base
所需的所有成员。
使用特征的一个小缺点是必须为每个派生类声明一个特征。您可以编写一个不那么冗长和令人讨厌的解决方法,如下所示:
template <template <typename> class Derived, typename T>
class base {
public:
typedef T value_type;
value_type foo() {
return static_cast<Derived<T>*>(this)->foo();
}
};
template <typename T>
class Derived : public base<Derived, T> {
public:
typedef T value_type;
value_type foo() {
return T(); //return some T object (assumes T is default constructable)
}
};
int main() {
Derived<int> a;
}
在 C++14 中,您可以删除typedef
并使用返回类型推导auto
函数:
template <typename derived_t>
class base {
public:
auto foo() {
return static_cast<derived_t*>(this)->foo();
}
};
这是有效的,因为返回类型的base::foo
的扣除会延迟到derived_t
完成。
需要较少样板的类型特征的替代方法是将派生类嵌套在保存 typedefs(或使用)的包装类中,并将包装器作为模板参数传递给基类。
template <typename Outer>
struct base {
using derived = typename Outer::derived;
using value_type = typename Outer::value_type;
value_type base_func(int x) {
return static_cast<derived *>(this)->derived_func(x);
}
};
// outer holds our typedefs, derived does the rest
template <typename T>
struct outer {
using value_type = T;
struct derived : public base<outer> { // outer is now complete
value_type derived_func(int x) { return 5 * x; }
};
};
// If you want you can give it a better name
template <typename T>
using NicerName = typename outer<T>::derived;
int main() {
NicerName<long long> obj;
return obj.base_func(5);
}
这基本上是您发现并且不喜欢的解决方法,但我想记录它,并说它基本上是此问题的当前解决方案。
我一直在寻找一种方法来做到这一点,但从未找到一个好的解决方案。事实上,这是不可能的,这就是为什么最终,像boost::iterator_facade<Self, different_type, value_type, ...>
这样的东西需要许多参数的原因。
当然,我们希望这样的东西可以工作:
template<class CRTP>
struct incrementable{
void operator++(){static_cast<CRTP&>(*this).increment();}
using ptr_type = typename CRTP::value_type*; // doesn't work, A is incomplete
};
template<class T>
struct A : incrementable<A<T>>{
void increment(){}
using value_type = T;
value_type f() const{return value_type{};}
};
int main(){A<double> a; ++a;}
如果可能,派生类的所有特征都可以隐式传递到基类。我发现获得相同效果的习语是将特征完全传递给基类。
template<class CRTP, class ValueType>
struct incrementable{
void operator++(){static_cast<CRTP&>(*this).increment();}
using value_type = ValueType;
using ptr_type = value_type*;
};
template<class T>
struct A : incrementable<A<T>, T>{
void increment(){}
typename A::value_type f() const{return typename A::value_type{};}
// using value_type = typename A::value_type;
// value_type f() const{return value_type{};}
};
int main(){A<double> a; ++a;}
https://godbolt.org/z/2G4w7d
缺点是派生类中的特征必须使用限定typename
访问或通过 using
重新启用。