Проверьте признаки для всех аргументов шаблона переменной

Фон: я создал следующий класс Cчей конструктор должен взять N переменные типа B&:

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);

Я видел возможное решение в этом посте: /questions/19861226/ukazanie-odnogo-tipa-dlya-vseh-argumentov-peredavaemyih-v-funktsiyu-s-peremennyimi-chislami-ili-funktsiyu-s-peremennyimi-shablonami-bez-ispolzovaniya-massiva-vektora-struktur-i-t-d/19861244#19861244, который определяет общий 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Я получу разные экземпляры конструктора для каждого набора параметров, которые могут увеличить размер скомпилированного кода...

Изменить: например, у меня есть B1 а также B2 что наследует от B, Я звоню C<2>(b1, b1) а также C<2>(b1, b2) в моем коде, это создаст два экземпляра (из C<2>::C<B1, B1> а также C<2>::C<B1, B2>) Я хочу только случаи C<2>::C<B, B>,

Источник

2 ответа

Решение

Определять 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()...}
{}

Кроме того, вам больше не нужно беспокоиться о куче специализаций.

Источник 
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 украден из Коломбо.

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

Безымянный тип-аргумента-шаблона void в любой удачной замене.

Источник
Другие вопросы по тегам