检查所有可变模板参数的特征。

Question

背景：我创建了以下类C，其构造函数应该接受类型为B&的N个变量：

class A;
class B
{
    A* getA();
};

template<size_t N>
class C
{
public:
    template<typename... Args>
    inline C(Args&... args) :
        member{args.getA()...}
    {}
private:
    std::array<A*, N> member;
};

问题：我的问题是如何限制可变参数Args的类型都是B？

我的部分解决方案：我想定义一个谓词，像这样：

template <typename T, size_t N, typename... Args>
struct is_range_of :
    std::true_type // if Args is N copies of T
    std::false_type // otherwise
{};

并相应地重新定义我的构造函数：

template <typename... Args,
          typename = typename std::enable_if<is_range_of_<B, N, Args...>::value>::type
         >
inline C(Args&... args);

我在这篇文章中看到了一个可能的解决方案：https://dev59.com/HXA65IYBdhLWcg3wqAat#11414631，它定义了一个通用的check_all谓词：

template <template<typename> class Trait, typename... Args>
struct check_all :
    std::false_type
{};

template <template<typename> class Trait>
struct check_all<Trait> :
    std::true_type
{};

template <template<typename> class Trait, typename T, typename... Args>
struct check_all<Trait, T, Args...> :
    std::integral_constant<bool, Trait<T>::value && check_all<Trait, Args...>::value>
{};

所以，我可以写出类似这样的内容：

template <typename T, size_t N, typename... Args>
struct is_range_of :
    std::integral_constant<bool,
        sizeof...(Args) == N &&
        check_all<Trait, Args...>::value
    >
{};

问题1：我不知道如何定义Trait，因为我需要以某种方式将std::is_same与B绑定为第一个参数。在我的情况下是否有使用通用的check_all的方法，或者C++的当前语法不兼容？

问题2：我的构造函数也应该接受B的派生类（通过对B的引用），这会影响模板参数推断吗？我担心如果我使用像std::is_base_of这样的谓词，我将为每组参数获得不同的构造函数实例化，这可能会增加编译后代码的大小...

编辑：例如，我有从B继承的B1和B2，我在代码中调用C<2>(b1, b1)和C<2>(b1, b2)，它会创建两个实例（C<2>::C<B1, B1>和C<2>::C<B1, B2>）吗？我只想要C<2>::C<B, B>的实例。

- Steakfly

---

你希望它们是从 B 派生的，还是只是隐式转换为 B？ - Deduplicator

我希望它们派生自B，请看我的编辑。我需要一个模板泛化到一个定义构造函数C（B＆b）的类的N个参数。 - Steakfly

从 B 派生的参数既是比可转换更强的约束条件，也是更弱的约束条件。因为两者之间互不蕴含。 - Deduplicator

您IP地址为143.198.54.68，由于运营成本限制，当前对于免费用户的使用频率限制为每个IP每72小时10次对话，如需解除限制，请点击左下角设置图标按钮（手机用户先点击左上角菜单按钮）。 - Ivan Aksamentov - Drop

Answer 1

将all_true定义为：

template <bool...> struct bool_pack;

template <bool... v>
using all_true = std::is_same<bool_pack<true, v...>, bool_pack<v..., true>>;

并重写您的构造函数为

// Check convertibility to B&; also, use the fact that getA() is non-const
template<typename... Args,
       typename = std::enable_if_t<all_true<std::is_convertible<Args&, B&>{}...>>
C(Args&... args) :
    member{args.getA()...}
{}

在C++17中，还有一种替代方式，

template<typename... Args,
       typename = std::enable_if_t<(std::is_convertible_v<Args&, B&> && ...)>>
C(Args&... args) :
    member{args.getA()...}
{}

我担心如果我使用像std :: is_base_of这样的谓词，每组参数都会得到不同的构造函数实例化，这可能会增加编译代码大小...

enable_if_t <...>将始终产生类型void（仅给出一个模板参数），因此这不能是is_base_of的错。 但是，当Args具有不同的类型时，即参数的类型不同，则随后将实例化不同的专业化。 我希望编译器可以在这里进行优化。

如果您想使构造函数精确地采用N个参数，则可以使用一种相对较简单的方法。 定义

template <std::size_t, typename T>
using ignore_val = T;

现在我们部分地将 C 进行特化，如下：

// Unused primary template
template <size_t N, typename=std::make_index_sequence<N>> class C;
// Partial specialization
template <size_t N, std::size_t... indices>
class C<N, std::index_sequence<indices...>>
{ /* … */ };

在部分特化中，构造函数的定义现在变得非常简单。

C(ignore_val<indices, B&>... args) :
    member{args.getA()...}
{}

此外，你不再需要担心大量的专业知识了。

- Columbo

---

嘿，all_true 比递归好多了。不过，我不确定是否应该使用 is_base_of，因为它也接受无法访问或模糊的基类。 - T.C.

all_true 的技巧不错，感谢 C++14 语法！ - Steakfly

@Steakfly，我添加了另一种可能更适合你的方法。 - Columbo

@Columbo在引用上使用is_convertible允许用户定义的转换。在指针上使用它。 - T.C.

@T.C. 我最初确实这样做了，但构造函数的语义不一定应该排除用户定义的转换，对比第二种方法呢？ - Columbo

Answer 2

namespace detail {
    template <bool...> struct bool_pack;
    template <bool... v>
    using all_true = std::is_same<bool_pack<true, v...>, bool_pack<v..., true>>;
    template<class X> constexpr X implicit_cast(std::enable_if_t<true, X> x) {return x;}
};

implicit_cast也在Boost中，bool_pack从Columbo中窃取。

// Only callable with static argument-types `B&`, uses SFINAE
template<typename... ARGS, typename = std::enable_if_t<
    detail::all_true<std::is_same<B, ARGS>...>>>
C(ARGS&... args) noexcept : member{args.getA()...} {}

选项一，如果它可以隐式转换，那就足够好了。

template<typename... ARGS, typename = std::enable_if_t<
    detail::all_true<!std::is_same<
    decltype(detail::implicit_cast<B&>(std::declval<ARGS&>())), ARGS&>...>>
C(ARGS&... args) noexcept(noexcept(implicit_cast<B&>(args)...))
    : C(implicit_cast<B&>(args)...) {}

选项二，只有当它们是从B公开派生并且可以明确转换时才适用：

// Otherwise, convert to base and delegate
template<typename... ARGS, typename = decltype(
    detail::implicit_cast<B*>(std::declval<ARGS*>())..., void())>
C(ARGS&... args) noexcept : C(implicit_cast<B&>(args)...) {}

在任何成功的替换中，未命名的ctor-template-argument-type都是void。

- Deduplicator

---

那么为什么你要使Args变得腐朽呢？ - Columbo

顺便问一下，为什么不直接使用enable_if_t<std::is_convertible<Args*，B*>{}>？ - Columbo

remove_reference_t 在我看来是多余的。Args 永远不可能被推导为引用类型，这只有在转发引用时才可能发生。 - Columbo

@Deduplicator：当使用不同类型时，这个实现会生成多个实例，对吗？（尽管它们都委托给第一个构造函数） - Steakfly

@Steakfly：无论你选择哪个第二个模板，那么多实例化是不可避免的。但它们都是彻底的平凡的转发器，如果它们不是直接与被转发的构造函数合并，那么它们肯定会被内联和消除而没有任何痕迹。同时添加了noexcept说明符。 - Deduplicator