c++ - 我可以使用元编程将类型列表转换为对列表中的每种类型具有特定隐式转换行为的新类型吗？

Question

我有一个包含多种类型的 boost::mpl::vector，例如

typedef boost::mpl::vector<T1, T2, T3, T4> list_type;

对于一些已知类型 T1、T2、T3、T4。有没有办法使用元编程将这个列表转换为表示直接线性继承的类型，按照 vector 中类型的顺序？我想合成一个具有与此一致的行为的类型:

struct T1 { };
struct T2 : T1 { };
struct T3 : T2 { };
struct T4 : T3 { };
struct synthesized_type : T4 { };

有boost::mpl::inherit_linearly这给了我类似的行为，但不完全是我想要的。使用它产生的类型更像是:

struct synthesized_type : T1, T2, T3, T4 { };

在某些情况下表现不同。例如，假设您有一个函数在 T1、T2、T3、T4 类型的某些子集上重载:

void foo(T1) { }
void foo(T3) { }

foo(synthesized_type()); // I would like to be able to do this

有了我上面给出的第一个(期望的)层次结构，重载决策就没有歧义了；我可以将 synthesized_type 传递给 foo()，它会调用 foo(T3)，因为 T3 是最synthesized_type 的祖先中的派生类型。

然而，在我使用 boost::mpl::inherit_linearly 的情况下，由于在父类型之间没有指定优先级，因此由于重载决策的歧义导致编译器错误；编译器无法在 foo(T1) 和 foo(T3) 之间进行选择。

有什么办法可以达到我想要的效果吗？更正式地说:

Given a list of types, I would like to use metaprogramming to synthesize some type that has the properties of the first hierarchy I described above (namely, that the synthesized type is implicitly convertible to each type T1, T2, T3, T4, with priority in that order, so T4 is preferred to T3, which is preferred to T2, and so on). Is this possible?

Answer 1

如果您的类型都是 CRTP 类型，您可以执行此操作:

#include <iostream>

template< template<class> class... Ts >
struct TVec { };

struct EmptyClass { };

template< class T >
struct Inheritor;

template< template<template<class> class> class U, template<class> class T>
struct Inheritor< U<T> >
  : public T<EmptyClass> { };

template< template<template<class> class...> class U, template<class> class T, template<class> class... Ts>
struct Inheritor< U<T, Ts... > >
  : public T<Inheritor< U<Ts...> > > { } ;

template< typename Base >
struct T1
  : public Base { };

template< typename Base >
struct T2
  : public Base { };

template< typename Base >
struct T3 
  : public Base { };

template<typename X>
void foo(T1<X> t) {
  std::cout << "T1" << std::endl;
}

template<typename X>
void foo(T2<X> t) {
  std::cout << "T2" << std::endl;
}

template<typename X>
void foo(T3<X> t) {
  std::cout << "T3" << std::endl;
}

int main() {
  using Types = TVec< T1, T2, T3 >;
  using Types2 = TVec< T3, T2, T1 >;

  using Derived = Inheritor<Types>;
  using Derived2 = Inheritor<Types2>;

  //Inheritor<TVec< T1, T2, T3>> x;
  Derived x;
  Derived2 x2;

  foo(x); // T1 overload
  foo(x2); // T3 overload
}

您无法得到那个确切的行为，因为它会涉及重新定义 T1、T2...这足够接近了吗？

template< class T >
struct Inheritor { };

template< class T, template<class> class U >
struct Inheritor< U<T> >
  : public T { };

template< template<class...> class U, class T, class... Ts >
struct Inheritor< U<T, Ts...> >
  : public T
  , public Inheritor< U< Ts... > > { };