没有公共继承的类之间的链式转换

Question

我有一系列约 10 个模板类 A、B、C、D...

我想启用从一个类到该系列中以前的类的转换：

• D -> C、B 或 A
• C -> B，或 A
• 乙->甲

如何在不使用公共继承的情况下实现这一点？

Test 1（公共继承）

• 我不想继承公共方法。

Test 2（定义 1 + 2 + ... n 个转换运算符）：

• 为第n个模板类定义n个转换运算符 模板类。
• 非常乏味

Test 3（每个类 1 个转换运算符）：

• 只允许从下一个级别的类型到本级别的类型的转换。

例如，这可以实现从 D 到 C 的转换，但不能从 D 到 B 的转换。

测试（也在上帝螺栓.org):

template <typename Convertible>
class A {
public:
    operator Convertible() { return Convertible(); }
};

using B = A<int>;
using C = A<B>;
using D = A<C>;

int main() {
    D d;
    auto b = B(d);
    return 0;
}

编译错误：

error: no matching function for call to ‘A<int>::A(D&)’
     auto b = B(d);
                 ^

实际用例

A、B、C、D ... 是由对象 S 的一层创建的每个节点（代理）。

• 类型 1 层定义图节点的内存组织 （指针/数组）。

• Type 2 层将一个层转换为另一个容器。 （例如，具有哈希值的层，用于通过键对节点进行索引并跟踪节点的交换。）

用户可以通过多种方式堆叠层来创建对象S。

我希望一层的节点转换为前一层的节点。

这是可能的，因为指向节点内容的指针/索引将是相同的。

您可以通过使用约束模板化构造函数（将在转换中使用）来实现此目的std::enable_if和一些模板元编程：

template <template <class> typename BaseTemplate,
          typename From,
          typename To,
          typename Enable = void>
struct may_convert
    : public std::false_type {};

template <template <class> typename BaseTemplate,
          typename T>
struct may_convert<BaseTemplate, BaseTemplate<T>, BaseTemplate<T>, void>
    : public std::true_type {};

template <template <class> typename BaseTemplate,
          typename T,
          typename U>
struct may_convert<BaseTemplate, BaseTemplate<T>, BaseTemplate<U>, 
                   typename std::enable_if<!std::is_same<T, U>::value>::type>
    : public may_convert<BaseTemplate, T, BaseTemplate<U>> {};

may_convert将走上模板From模板参数直到它等于To（在这种情况下它继承自std::true_type, i.e. may_convert<...>::value is true），或者直到模板用完（在这种情况下may_convert<...>::value is false).

现在，剩下的就是适当地限制你的构造函数：

template <typename Convertible>
class A {
public:
    A() {}

    template <typename T,
              typename = typename std::enable_if<
                  may_convert<A, T, A<Convertible>>::value>::type>
    A(const T&) {}
};

这样，构造函数仅在以下情况下存在：may_convert<...>::value is true。否则，转换将会失败。

Examples

以下是如何操作的示例may_convert在您的示例中有效（从D = A<A<A<int>>> to B = A<int>):

• 构造函数仅存在于may_convert<A, D, B>::value is true

• may_convert<A, D, B>匹配最后一个专业化（因为D = A<C> and B = A<int>，参数推导为T = C and U = int）并继承自may_convert<A, C, B>

• may_convert<A, C, B>再次匹配最后一个专业化（T = B, U = int）并继承自may_convert<A, B, B>

• 这次，这两种类型是相等的，因此第一个特化匹配，并且整个事物继承自std::true_type，启用构造函数。

另一方面，想象一个using E = A<double>不应该转换为B:

• 仅在以下情况下才会启用构造函数may_convert<A, E, B>::value is true

• may_convert<A, E, B>匹配最后一个专业化，并继承自may_convert<A, double, B>

• Because double不是一个A<...>，没有一个专业化匹配，所以我们回退到默认情况，它继承自std::false_type.

• 所以，may_convert<A, E, B>::value is false，并且转换失败。