根据模板基类，为其成员存在的类定义构造函数

Question

我正在研究一个类来识别纹理中的图像，如下所示：

using level_t = ...
using layer_t = ...
using face_t = ...

template <bool>
struct levels {};

template <>
struct levels<true> {
    level_t level = level_t{0};
};

template <bool>
struct layers {};

template <>
struct layers<true> {
    layer_t layer = layer_t{0};
};

template <bool>
struct faces {};

template <>
struct faces<true> {
    face_t face = face_t{0};
};

template <bool HasLevels, bool HasLayers, bool HasFaces>
struct index : levels<HasLevels>, layers<HasLayers>, faces<HasFaces> {};

level_t、layer_t 和 face_t 是 int 的一种“强类型定义”（基本上是不同的类型，看起来像 int 但没有隐式转换）。

现在我可以像这样使用我的类型了：

using Index1 = index<true, true, false>;
void f(Index1);

Index1 v;
v.level = level_t{1};
v.layer = layer_t[1};
f(v);

但为了让我的用户的生活更轻松，我想允许此代码：

f({level_t{1}, layer_t{1}};

由于基类，聚合初始化已经失效，所以我需要自己编写一个构造函数；编写支持所有参数组合（但不支持重新排序）的构造函数的最佳/最智能方法是什么？

Answer 1

如果您传递错误的类型或参数数量，错误消息会有点糟糕，所以我不确定这是否值得，但是... p>

需要一种方法来过滤和随机访问一组类型；实际上，我会为此使用Brigand 或Boost.Hana，但我会在这里坚持使用std::tuple<> 来保持这个标准：

namespace detail {
    template<template<bool> class Holder, bool B>
    std::integral_constant<bool, B> holder_value_(Holder<B>);

    template<typename HolderT>
    constexpr decltype(detail::holder_value_(std::declval<HolderT>())) holder_value() {
        return {};
    }

    template<typename UnfilteredT, typename FilteredT>
    struct filter_holders;

    template<typename UnfilteredT, typename FilteredT = std::tuple<>>
    using filter_holders_t = typename filter_holders<UnfilteredT, FilteredT>::type;

    template<typename... Fs>
    struct filter_holders<std::tuple<>, std::tuple<Fs...>> {
        using type = std::tuple<Fs...>;
    };

    template<typename U, typename... Us, typename... Fs>
    struct filter_holders<std::tuple<U, Us...>, std::tuple<Fs...>> : filter_holders<
        std::tuple<Us...>,
        std::conditional_t<holder_value<U>(), std::tuple<Fs..., U>, std::tuple<Fs...>>
    > { };
}

需要的另一件事是找到一个'holder'-type正在包装的intlike-type（例如levels<true>包装level_t等）。这可以非侵入性地完成，但在这里我假设一个内部的value_type typedef。

有了这些就相当简单了——我们得到一个模板参数为true的基类型包，并编写一个构造函数，其初始化器只是该包的扩展：

namespace detail {
    template<typename... HolderTs>
    std::tuple<typename HolderTs::value_type...> value_types_(std::tuple<HolderTs...>);

    template<typename HoldersT>
    using value_types_t = decltype(detail::value_types_(std::declval<HoldersT>()));
}

template<bool HasLevels, bool HasLayers, bool HasFaces>
struct index : levels<HasLevels>, layers<HasLayers>, faces<HasFaces> {
private:
    using bases_t = std::tuple<levels<HasLevels>, layers<HasLayers>, faces<HasFaces>>;
    using true_bases_t = detail::filter_holders_t<bases_t>;
    using arg_types_t = detail::value_types_t<true_bases_t>;

    template<std::size_t... Is, typename... ArgTs>
    index(std::index_sequence<Is...>, ArgTs&&... args)
    : std::tuple_element_t<Is, true_bases_t>{std::forward<ArgTs>(args)}... { }

public:
    index() = default;

    template<
        typename... ArgTs,
        std::size_t S = sizeof...(ArgTs),
        typename = std::enable_if_t<
            S && std::is_same<std::tuple<std::decay_t<ArgTs>...>, arg_types_t>{}
        >
    >
    index(ArgTs&&... args)
    : index{std::make_index_sequence<S>{}, std::forward<ArgTs>(args)...} { }
};

Online Demo

编辑：更新了更严格的实现，不允许可转换但不相同的参数类型，并且不会错误地干扰复制/移动构造。

Answer 2

这是一个允许代码的演示代码。

#include <iostream>
#include <type_traits>

struct A {
  A() = default;
  A(const A &) {
    std::cout << "A" << std::endl;
  }
};

struct B {
  B() = default;
  B(const B &) {
    std::cout << "B" << std::endl;
  }
};

struct C {
  C() = default;
  C(const C &) {
    std::cout << "C" << std::endl;
  }
};

template <class... Base>
struct Hyper : public Base... {
  template <class... Args>
  Hyper(Args&&... args) : Base(std::forward<Args>(args))... {}
};

template <class... Base>
auto factory(Base&&... args) {
  return Hyper<std::decay_t<Base>...>(std::forward<Base>(args)...);
}

int main() {
  auto obj = factory(A{}, B{}, C{});
  return 0;
}

Hyper 的所有基类都是复制/移动构造的。

一些static_assert 可以添加到factory 以防止它生成任何怪异的类。

正如评论所说，这不是一个好主意。如果你做对了，一切都会好起来的，但如果你做错了，即使是一个小错误，模板+多继承都可能是你的噩梦。 （您最终可能会收到 100000 行编译器错误消息。）