Como se especializar parcialmente um modelo de classe para todos os tipos derivados?
-
06-07-2019 - |
Pergunta
Eu quero especializar parcialmente um modelo existente que eu não posso mudar (std::tr1::hash
) para uma classe base e todas as classes derivadas. A razão é que eu estou usando a configuração padrão curiosamente recorrente para o polimorfismo, e a função hash é implementado na classe base CRTP. Se eu só quer se especializar parcialmente para uma classe base CRTP, então é fácil, eu só posso escrever:
namespace std { namespace tr1 {
template <typename Derived>
struct hash<CRTPBase<Derived> >
{
size_t operator()(const CRTPBase<Derived> & base) const
{
return base.hash();
}
};
} }
Mas esta especialização não corresponde classes derivadas reais, única CRTPBase<Derived>
. O que eu quero é uma maneira de escrever uma especialização parcial para Derived
se e somente se ela deriva CRTPBase<Derived>
. Meu pseudo-código é
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();
}
};
} }
... mas isso não funciona porque o compilador não pode dizer que enable_if<condition, Derived>::type
é Derived
. Se eu pudesse mudar std::tr1::hash
, eu tinha acabado de adicionar outro parâmetro do modelo fictício para uso boost::enable_if
, como recomendado pela documentação enable_if
, mas isso não é, obviamente, uma solução muito boa. Existe uma maneira de contornar este problema? Eu tenho que especificar um modelo de hash personalizado em cada unordered_set
ou unordered_map
eu crio, ou totalmente especializar hash
para cada classe derivada?
Solução
Existem duas variantes no código a seguir. Você pode escolher o mais apropriado para você.
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
}
Outras dicas
Em vez de modificar std::tr1::hash
você deve fazer o seu próprio namespace e definir lá nova estrutura hash
que herdou de std::tr1::hash
ou é especializado para CRTPBase<Derived>
.
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
}