Почему C++ не поддерживает сильно типизированный многоточие?

Question

Может кто-то пожалуйста, объясните мне, почему C++, по крайней мере, насколько мне известно, не реализует сильно типизированных функцию многоточием, что-то эффект:

void foo(double ...) { 
// Do Something 
} 

Это означает, что, в простом говорят: «The пользователя может передать переменное число слагаемых функции Foo, однако, все условия должны быть двойники

Answer 1

Исторически многоточие синтаксис ... происходит от С.

Этот сложный зверь был использован для питания printf -как функций и должен быть использован с va_list, va_start и т.д ...

Как вы отметили, он не является типичным; но тогда C далеко не является типичным, что с его неявными преобразованиями от и до void* для любых типов указателей, его неявное усечение интегралов/значений с плавающей запятой и т. д.

Поскольку C++ должен быть как можно ближе как надмножество C, он унаследовал многоточие от С.

---

с самого начала практики, C++ эволюционировал, и там был сильный толчок в сторону более сильной типизации.

В C++ 11, это завершилось:

• списков инициализатора, синтаксис стенографии для переменного числа значений данного типа: foo({1, 2, 3, 4, 5})
• VARIADIC шаблонов, которые животное свой собственные и разрешить запись типа а безопасный printf например

шаблонов VARIADIC фактически повторно многоточию ... в их синтаксисе для обозначения пакетов типов или значений и в качестве распаковки оператора:

void print(std::ostream&) {} 

template <typename T, typename... Args> 
void print(std::ostream& out, T const& t, Args const&... args) { 
    print(out << t, args...); // recursive, unless there are no args left 
           // (in that case, it calls the first overload 
           // instead of recursing.) 
} 

Обратите внимание на 3 различных формах использования ...:

• typename... объявить VARIADIC типа
• Args const&... объявить пакет аргументов
• args... для распаковки упаковки в выражении

Answer 2

Потому что вы можете использовать

void foo(std::vector<T> values); 

Answer 3

путь к достижению (своего рода), что вы предлагаете, чтобы использовать вариативные шаблоны

template<typename... Arguments> 
void foo(Arguments... parameters); 

однако вы можете передать любой тип в пакете параметров. То, что вы предлагаете, никогда не было реализовано, может быть, это может быть отличным дополнением к языку, или это может быть слишком сложно реализовать, когда все будет стоять. Вы всегда можете попробовать написать предложение и представить его на isocpp.org

Answer 4

Существует

void foo(std::initializer_list<double> values); 
// foo({1.5, 3.14, 2.7}); 

, который очень близок к этому.

Вы также можете использовать вариативные шаблоны, но он становится более дискурсивным. Что касается фактической причины, я бы сказал, что попытка привнести этот новый синтаксис, вероятно, не стоит того: как вы получаете доступ к отдельным элементам? Откуда вы знаете, когда остановиться? Что делает его лучше, чем, скажем, std::initializer_list?

У C++ есть что-то еще более близкое к этому: пакеты параметров не-типа.

template < non-type ... values> 

как в

template <int ... Ints> 
void foo() 
{ 
    for (int i : {Ints...}) 
     // do something with i 
} 

, но тип параметра шаблона не-типа (ммм) имеет некоторые ограничения: он не может быть double, например.

Answer 5

уже можно с переменным числом шаблонов и SFINAE:

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

template <class... Doubles, class = std::enable_if_t< 
    all_true<std::is_convertible<Doubles, double>{}...>{} 
>> 
void foo(Doubles... args) {} 

Благодаря Columbo за хороший all_true трюк. Вы также сможете использовать выражение fold в C++ 17.

Как позже и будущие стандарты сосредоточены на terser синтаксиса (немногословный для петель, неявных шаблонов функций ...) очень возможно, что предлагаемый вами синтаксис заканчивается в стандартном один день)

Answer 6

Для почему в частности, такая вещь не предлагалась (или была предложена и отвергнута), я не знаю. Такая вещь, безусловно, была бы полезна, но добавила бы больше сложности для языка. Как показывает Quentin, уже существует способ C++ 11 для достижения такой цели с помощью шаблонов.

Когда понятия добавляется к стандарту, мы будем иметь еще один, более краткий способ:

template <Convertible<double>... Args> 
void foo(Args... doubles); 

или

template <typename... Args> 
    requires Convertible<Args, double>()... 
void foo(Args... doubles); 

или, как @dyp points out:

void foo(Convertible<double>... doubles);  

Лично , между текущим решением и теми, которые мы получим с концепциями, я считаю, что это адекватно решение проблемы. Тем более, что последнее - это то, о чем вы вначале просили.

Answer 7

template<typename T, typename... Arguments> 
struct are_same; 

template <typename T, typename A1, typename... Args> 
struct are_same<T, A1, Args...>{ static const bool value = std::is_same<T, A1>::value && are_same<T, Args...>::value;}; 

template <typename T> 
struct are_same<T>{static const bool value = true;}; 

template<typename T, typename... Arguments> 
using requires_same = std::enable_if_t<are_same<T, Arguments...>::value>; 

template <typename... Arguments, typename = requires_same<double, Arguments...>> 
void foo(Arguments ... parameters) 
{ 
} 

Answer 8

на основе Matthew's answer:

void foo() {} 

template <typename... Rest> 
void foo (double arg, Rest... rest) 
{ 
    /* do something with arg */ 
    foo(rest...); 
} 

Если код с помощью foo компилирует, вы знаете, все аргументы могут быть конвертированы в double.