Проблема с вызовом шаблона переменной функции при передаче аргументов списка инициализатора фигурной скобки

Question

Рассмотрим этот шаблон функции:

template <class... T>
void foo (std::tuple<T, char, double> ... x);

Этот вызов работает:

using K = std::tuple<int, char, double>;
foo ( K{1,'2',3.0}, K{4,'5',6.0}, K{7,'8',9.0} );

Этот не:

foo ( {1,'2',3.0}, {4,'5',6.0}, {7,'8',9.0} );

(gcc и clang обапожаловаться на слишком много аргументов для foo)

Почему второй вызов - проблема?Могу ли я переписать объявление foo так, чтобы второй вызов также был принят?

Тебе параметр шаблона T используется только для реализации вариабельности.Фактический тип известен и фиксирован, меняется только количество аргументов.В реальной жизни типы отличаются от int, char, double, это всего лишь пример.

Я не могу использовать C ++ 17 для этого.C ++ 11-совместимое решение является наиболее предпочтительным.

Answer 1

Создание перегруженного набора конструкторов:

#include <tuple>
#include <cstddef>

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

template <typename T, std::size_t M, std::size_t... Is>
struct initializer : initializer<T, M, sizeof...(Is) + 1, Is...>
{    
    using initializer<T, M, sizeof...(Is) + 1, Is...>::initializer;

    initializer(indexed<T, Is>... ts)
    {
        // ts is a pack of std::tuple<int, char, double>
    }
};

template <typename T, std::size_t M, std::size_t... Is>
struct initializer<T, M, M, Is...> {};

using foo = initializer<std::tuple<int, char, double>, 20>;
//                                   tuples limit+1 ~~~^

int main()
{
    foo({1,'2',3.0});
    foo({1,'2',3.0}, {4,'5',6.0});
    foo({1,'2',3.0}, {4,'5',6.0}, {7,'8',9.0});
}

DEMO

---

Создание перегруженного набора операторов вызова функций:

#include <tuple>
#include <cstddef>

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

template <typename T, std::size_t M, std::size_t... Is>
struct initializer : initializer<T, M, sizeof...(Is) + 1, Is...>
{    
    using initializer<T, M, sizeof...(Is) + 1, Is...>::operator();

    int operator()(indexed<T, Is>... ts) const
    {            
        // ts is a pack of std::tuple<int, char, double>
        return 1;
    }
};

template <typename T, std::size_t M, std::size_t... Is>
struct initializer<T, M, M, Is...>
{
    int operator()() const { return 0; }
};

static constexpr initializer<std::tuple<int, char, double>, 20> foo = {};
//                                        tuples limit+1 ~~~^

int main()
{    
    foo({1,'2',3.0});
    foo({1,'2',3.0}, {4,'5',6.0});
    foo({1,'2',3.0}, {4,'5',6.0}, {7,'8',9.0});
}

DEMO 2

---

Создание (или создание с макросами препроцессора) набора перегрузок, которые направляют аргументы в одинреализация:

#include <array>
#include <tuple>

using K = std::tuple<int, char, double>;

void foo(const std::array<K*, 5>& a)
{
    // a is an array of at most 5 non-null std::tuple<int, char, double>*
}

void foo(K p0) { foo({&p0}); }
void foo(K p0, K p1) { foo({&p0, &p1}); }
void foo(K p0, K p1, K p2) { foo({&p0, &p1, &p2}); }
void foo(K p0, K p1, K p2, K p3) { foo({&p0, &p1, &p2, &p3}); }
void foo(K p0, K p1, K p2, K p3, K p4) { foo({&p0, &p1, &p2, &p3, &p4}); }

int main()
{
    foo({1,'2',3.0});
    foo({1,'2',3.0}, {4,'5',6.0});
    foo({1,'2',3.0}, {4,'5',6.0}, {7,'8',9.0});
}

DEMO 3

---

Передать как массив и определить его размер (требуется дополнительная пара символов):

#include <tuple>
#include <cstddef>

template <std::size_t N>
void foo(const std::tuple<int, char, double> (&a)[N])
{
    // a is an array of exactly N std::tuple<int, char, double>
}

int main()
{
    foo({{1,'2',3.0}, {4,'5',6.0}});
 //     ^~~~~~ extra parens ~~~~~^
}

DEMO 4

---

Использовать std::initializer_list в качестве параметра конструктора (для пропуска лишних слов):

#include <tuple>
#include <initializer_list>

struct foo
{
    foo(std::initializer_list<std::tuple<int, char, double>> li)
    {
        // li is an initializer list of std::tuple<int, char, double>
    }
};

int main()
{
    foo{ {1,'2',3.0}, {4,'5',6.0} };
}

DEMO 5

Answer 2

Я не могу использовать C ++ 17 для этого.C ++ 11-совместимое решение гораздо предпочтительнее.

С C ++ 11 немного сложнее (нет std::index_sequence, нет std::make_index_sequence), но, если вы хотите сохранить вариативностьиспользование кортежей ... то есть ... если вы по существу хотите что-то как

foo (std::tuple<int, char, double> ... ts)

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

func ();
func (K t0);
func (K t0, K t1);
func (K t0, K t1, K t2);

, где K - ваш

using K = std::tuple<int, char, double>;

Ниже приведен пример полной компиляции C ++ 11

#include <tuple>
#include <iostream>

using K = std::tuple<int, char, double>;

template <typename T, std::size_t>
struct getTypeStruct
 { using type = T; };

template <typename T, std::size_t N>
using getType = typename getTypeStruct<T, N>::type;

template <int ...>
struct iList;

template <std::size_t = 50u, std::size_t = 0u, typename = iList<>>
struct foo;

template <std::size_t Top, std::size_t N, int ... Is>
struct foo<Top, N, iList<Is...>> : public foo<Top, N+1u, iList<0, Is...>>
 {
   using foo<Top, N+1u, iList<0, Is...>>::func;

   static void func (getType<K, Is> ... ts)
    { std::cout << sizeof...(ts) << std::endl; }
 };

template <std::size_t Top, int ... Is>
struct foo<Top, Top, iList<Is...>>
 {
   // fake func, for recursion ground case
   static void func ()
    { }
 };


int main()
 {
   foo<>::func({1,'2',3.0}); // print 1
   foo<>::func({1,'2',3.0}, {4,'5',6.0}); // print 2
   foo<>::func({1,'2',3.0}, {4,'5',6.0}, {7,'8',9.0});  // print 3
 }

Если вы можете использовать C ++ 14, вы можете использовать std::make_index_sequence и std::index_sequence, и код станет немного лучше, IMHO

#include <tuple>
#include <iostream>
#include <type_traits>

using K = std::tuple<int, char, double>;

template <std::size_t ... Is>
constexpr auto getIndexSequence (std::index_sequence<Is...> is)
   -> decltype(is);

template <std::size_t N>
using IndSeqFrom = decltype(getIndexSequence(std::make_index_sequence<N>{}));

template <typename T, std::size_t>
struct getTypeStruct
 { using type = T; };

template <typename T, std::size_t N>
using getType = typename getTypeStruct<T, N>::type;

template <std::size_t N = 50, typename = IndSeqFrom<N>>
struct foo;

template <std::size_t N, std::size_t ... Is>
struct foo<N, std::index_sequence<Is...>> : public foo<N-1u>
 {
   using foo<N-1u>::func;

   static void func (getType<K, Is> ... ts)
    { std::cout << sizeof...(ts) << std::endl; }
 };

template <>
struct foo<0, std::index_sequence<>>
 {
   static void func ()
    { std::cout << "0" << std::endl; }
 };

int main()
 {
   foo<>::func({1,'2',3.0});  // print 1
   foo<>::func({1,'2',3.0}, {4,'5',6.0});  // print 2
   foo<>::func({1,'2',3.0}, {4,'5',6.0}, {7,'8',9.0});  // print 3
 }

Жаль, что вы не можете использовать C ++ 17, потому чтовы можете использовать variadic unsing и вообще избегать рекурсивного наследования

#include <tuple>
#include <iostream>
#include <type_traits>

using K = std::tuple<int, char, double>;

template <std::size_t ... Is>
constexpr auto getIndexSequence (std::index_sequence<Is...> is)
   -> decltype(is);

template <std::size_t N>
using IndSeqFrom = decltype(getIndexSequence(std::make_index_sequence<N>{}));

template <typename T, std::size_t>
struct getTypeStruct
 { using type = T; };

template <typename T, std::size_t N>
using getType = typename getTypeStruct<T, N>::type;

template <std::size_t N, typename = IndSeqFrom<N>>
struct bar;

template <std::size_t N, std::size_t ... Is>
struct bar<N, std::index_sequence<Is...>>
 {
   static void func (getType<K, Is> ... ts)
    { std::cout << sizeof...(ts) << std::endl; }
 };

template <std::size_t N = 50, typename = IndSeqFrom<N>>
struct foo;

template <std::size_t N, std::size_t ... Is>
struct foo<N, std::index_sequence<Is...>> : public bar<Is>...
 { using bar<Is>::func...; };

int main()
 {
   foo<>::func({1,'2',3.0});  // print 1
   foo<>::func({1,'2',3.0}, {4,'5',6.0});  // print 2
   foo<>::func({1,'2',3.0}, {4,'5',6.0}, {7,'8',9.0});  // print 3
 }

Answer 3

{} не является выражением, следовательно, не имеет типа, вычитание аргумента касается типов, особое внимание уделяется, когда аргумент, используемый для выведения аргумента, является списком инициализатора параметром функции шаблонадолжен иметь специфические формы, в противном случае параметр представляет собой невнедренный контекст.Более упрощенный пример:

template <class T> struct A { T r; };
template <class T>
void foo (A<T> x);

using K = A<int>;
foo({1}); // fail
foo(K{1}); // compile

Это покрывается [temp.deduc.call] / 1

При удалении ссылок и cv-квалификаторы из P дают std::initializer_­list<P'> или P'[N] для некоторых P' и N, а аргумент является непустым списком инициализатора ([dcl.init.list]), затем вместо каждого элементасписок инициализатора, принимая P' в качестве типа параметра шаблона функции и элемент инициализатора в качестве аргумента, а в случае P'[N], если N является параметром шаблона нетипичного типа, N выводится из длинысписок инициализатора.В противном случае аргумент списка инициализатора приводит к тому, что параметр рассматривается как недетерминированный контекст

и [temp.deduct.type] / 5

Неведуемые контексты:

(5.6) Параметр функции, для которого связанный аргумент является списком инициализатора ([dcl.init.list]), но у параметра нет типа, для которого вычет изуказан список инициализатора ([temp.deduct.call]).

Когда вы:

• явно предоставляете аргументы шаблона, это работает ... ничего не выводить
• указать аргумент как K{1}, он работает ... аргумент больше не является список инициализаторов , это выражение с типом.