Check traits for all variadic template arguments

by

Define all_true as

template <bool...> struct bool_pack;

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

And rewrite your constructor to

// 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()...}
{}

Alternatively, under C++17, 

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

I am afraid that if I use a predicate like std::is_base_of, I will get
a different instantiation of the constructor for each set of
parameters, which could increase compiled code size…

enable_if_t<…> will always yield the type void (with only one template argument given), so this cannot be is_base_ofs fault. However, when Args has different types, i.e. the types of the arguments are distinct, then subsequently different specializations will be instantiated. I would expect a compiler to optimize here though.

If you want the constructor to take precisely N arguments, you can use a somewhat easier method. Define

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

And now partially specialize C as

// 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...>>
{ /* … */ };

The definition of the constructor inside the partial specialization now becomes trivial

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

Also, you do not have to worry about a ton of specializations anymore.

More Related Contents:

  1. check variadic templates parameters for uniqueness
  2. Why compiler gives the message "call of overloaded function is ambiguous" here in C++11?
  3. “unpacking” a tuple to call a matching function pointer
  4. Implementation C++14 make_integer_sequence
  5. make_unique and perfect forwarding
  6. Variadic template pack expansion
  7. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  8. How to implement make_unique function in C++11? [duplicate]
  9. Pointers in c++ after delete
  10. C++11: Correct std::array initialization?
  11. What are the rules for the “…” token in the context of variadic templates?
  12. What is the meaning of “… …” token? i.e. double ellipsis operator on parameter pack
  13. What do compilers do with compile-time branching?
  14. Is it possible to “store” a template parameter pack without expanding it?
  15. Pass by value vs pass by rvalue reference
  16. How to create the Cartesian product of a type list?
  17. Default, value and zero initialization mess
  18. Is #pragma once part of the C++11 standard?
  19. How to reverse the order of arguments of a variadic template function?
  20. effective way to select last parameter of variadic template
  21. How to extract the source filename without path and suffix at compile time?
  22. Is there a name for this tuple-creation idiom?
  23. How can I have multiple parameter packs in a variadic template?
  24. details of std::make_index_sequence and std::index_sequence
  25. C++11: Number of Variadic Template Function Parameters?
  26. How to make a variadic is_same?
  27. generic member function pointer as a template parameter
  28. Why does constexpr static member (of type class) require a definition?
  29. Generating one class member per variadic template argument
  30. using declaration in variadic template

Leave a Comment