[英]How to partially specialize a class template for all derived types?
I want to partially specialize an existing template that I cannot change ( std::tr1::hash
) for a base class and all derived classes.我想为基类和所有派生类部分专门化我无法更改的现有模板(
std::tr1::hash
)。 The reason is that I'm using the curiously-recurring template pattern for polymorphism, and the hash function is implemented in the CRTP base class.原因是我使用奇怪重复的模板模式来实现多态性,并且哈希函数是在 CRTP 基类中实现的。 If I only want to partially specialize for a the CRTP base class, then it's easy, I can just write:
如果我只想部分专注于 CRTP 基类,那很容易,我可以写:
namespace std { namespace tr1 {
template <typename Derived>
struct hash<CRTPBase<Derived> >
{
size_t operator()(const CRTPBase<Derived> & base) const
{
return base.hash();
}
};
} }
But this specialization doesn't match actual derived classes, only CRTPBase<Derived>
.但是这种专业化与实际派生类不匹配,仅匹配
CRTPBase<Derived>
。 What I want is a way of writing a partial specialization for Derived
if and only if it derives from CRTPBase<Derived>
.我想要的是一种为
Derived
编写部分专业化的方法,当且仅当它派生自CRTPBase<Derived>
。 My pseudo-code is我的伪代码是
namespace std { namespace tr1 {
template <typename Derived>
struct hash<typename boost::enable_if<std::tr1::is_base_of<CRTPBase<Derived>, Derived>,
Derived>::type>
{
size_t operator()(const CRTPBase<Derived> & base) const
{
return base.hash();
}
};
} }
...but that doesn't work because the compiler can't tell that enable_if<condition, Derived>::type
is Derived
. ...但这不起作用,因为编译器无法判断
enable_if<condition, Derived>::type
是Derived
。 If I could change std::tr1::hash
, I'd just add another dummy template parameter to use boost::enable_if
, as recommended by the enable_if
documentation, but that's obviously not a very good solution.如果我可以更改
std::tr1::hash
,我只需按照enable_if
文档的建议添加另一个虚拟模板参数来使用boost::enable_if
,但这显然不是一个很好的解决方案。 Is there a way around this problem?有没有办法解决这个问题? Do I have to specify a custom hash template on every
unordered_set
or unordered_map
I create, or fully specialize hash
for every derived class?我是否必须在我创建的每个
unordered_set
或unordered_map
上指定自定义哈希模板,或者为每个派生类完全专门化hash
?
There are two variants in the following code.以下代码中有两种变体。 You could choose more appropriated for you.
你可以选择更适合你的。
template <typename Derived>
struct CRTPBase
{
size_t hash() const {return 0; }
};
// First case
//
// Help classes
struct DummyF1 {};
struct DummyF2 {};
struct DummyF3 {};
template<typename T> struct X;
// Main classes
template<> struct X<DummyF1> : CRTPBase< X<DummyF1> > {
int a1;
};
template<> struct X<DummyF2> : CRTPBase< X<DummyF2> > {
int b1;
};
// typedefs
typedef X<DummyF1> F1;
typedef X<DummyF2> F2;
typedef DummyF3 F3; // Does not work
namespace std { namespace tr1 {
template<class T>
struct hash< X<T> > {
size_t operator()(const CRTPBase< X<T> > & base) const
{
return base.hash();
}
};
}} // namespace tr1 // namespace std
//
// Second case
struct DummyS1 : CRTPBase <DummyS1> {
int m1;
};
//
template<typename T>
struct Y : T {};
//
typedef Y<DummyS1> S1;
namespace std { namespace tr1 {
template<class T>
struct hash< Y<T> > {
size_t operator()(const CRTPBase<T> & base) const
{
return base.hash();
}
};
}} // namespace tr1 // namespace std
void main1()
{
using std::tr1::hash;
F1 f1;
F2 f2;
F3 f3;
hash<F1> hf1; size_t v1 = hf1(f1); // custom hash functor
hash<F2> hf2; size_t v2 = hf2(f2); // custom hash functor
hash<F3> hf3; size_t v3 = hf3(f3); // error: standard hash functor
S1 s1;
hash<S1> hs1; size_t w1 = hs1(s1); // custom hash functor
}
Instead of modifying std::tr1::hash
you should make your own namespace and define there new structure hash
which inherited from std::tr1::hash
or is specialized for CRTPBase<Derived>
.而不是修改
std::tr1::hash
您应该创建自己的命名空间并在那里定义从std::tr1::hash
继承或专门用于CRTPBase<Derived>
的新结构hash
。
template <typename Derived>
struct CRTPBase
{
size_t hash() {return 0; }
};
struct AA : CRTPBase <AA> {};
struct BB {};
//
namespace mynamespace {
template <typename Some, typename Dummy=char>
struct hash : std::tr1::hash<Some> {};
//
template <typename Derived>
struct hash<Derived,
typename boost::enable_if< std::tr1::is_base_of<CRTPBase<Derived>, Derived>, char>::type >
{
size_t operator()(const CRTPBase<Derived> & base) const
{
return base.hash();
}
};
} // namespace mynamespace {}
//
//
void ff()
{
using namespace mynamespace;
hash<AA> aa; // my hash
hash<BB> bb; // std::tr1::hash
}
C++20 edition: C++20 版:
#include <concepts>
#include <functional>
#include <unordered_set> // just for demo in main()
template <class T>
class Base {};
class Derived final : public Base<Derived> {};
template<class T>
requires std::derived_from<T, Base<T>>
struct std::hash<T> {
// constexpr is optional
constexpr size_t operator() (const T& value) const noexcept {
return 0xDEADBEEF; // FIXME: do something better :)
}
};
int main() {
// If operator() weren't constexpr, this couldn't be a *static* assert
static_assert(std::hash<Derived>()(Derived {}) == 0xDEADBEEF);
std::unordered_set<Derived> usageTest;
return 0;
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.