有人可以向我解释为什么C++，至少据我所知，没有实现强类型省略号函数，大意如下：
void foo(double ...) {
// Do Something
}
来说："用户可以将可变数量的项传递给foo函数，但是，所有项都必须是双精度">
有
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
}
但是非类型模板参数(UHM(的类型有一些限制：例如，它不能double。
从历史上看，省略号语法...来自 C。
这种复杂的野兽被用来为类似printf的功能提供动力，并与va_list、va_start等一起使用。
正如你所指出的，它不是类型安全的;但是 C 远非类型安全的，它对任何指针类型进行从void*到的隐式转换，它对积分/浮点值的隐式截断等等......
超集，所以它继承了 C 的省略号。
自成立以来，C++实践不断发展，并且一直在大力推动更强的类型。
在C++11中，这最终导致：
- 初始值设定项列表，给定类型的可变数量的值的简写语法：
foo({1, 2, 3, 4, 5}) - 可变参数模板，它们本身就是一头野兽，例如允许编写类型安全的
printf
可变参数模板实际上在其语法中重用省略号...，以表示类型或值的包，并作为解包运算符：
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...声明可变参数类型 -
Args const&...声明一组参数 -
args...在表达式中解压缩包装
使用可变参数模板和 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) {}
感谢哥伦布的好all_true把戏。您还可以在 C++17 中使用折叠表达式。
由于后来和即将推出的标准都专注于更简洁的语法(简洁的 for 循环、隐式函数模板......(，您提出的语法很可能有一天会进入标准;)
为什么没有提出(或被提出并拒绝(这样的事情，我不知道。这样的东西肯定会有用，但会增加语言的复杂性。正如昆汀所展示的那样，已经提出了一种C++11方法可以通过模板实现这种目标。
当概念画板被添加到标准中时，我们将有另一种更简洁的方式：
template <Convertible<double>... Args>
void foo(Args... doubles);
或
template <typename... Args>
requires Convertible<Args, double>()...
void foo(Args... doubles);
或者，正如@dyp指出的那样：
void foo(Convertible<double>... doubles);
就个人而言，在当前解决方案和我们将通过概念画板获得的解决方案之间，我认为这是解决问题的充分解决方案。特别是因为最后一个基本上是你最初要求的。
实现(某种程度上(您建议的方法是使用可变参数模板
template<typename... Arguments>
void foo(Arguments... parameters);
但是，您现在可以在参数包中传递任何类型。您提出的内容从未实现过，也许它可能是对语言的一个很好的补充，或者就目前的情况而言，它可能太难实现。您可以随时尝试撰写提案并将其提交给 isocpp.org
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)
{
}
基于马修的回答：
void foo () {}
template <typename... Rest>
void foo (double arg, Rest... rest)
{
/* do something with arg */
foo(rest...);
}
如果使用foo的代码进行编译，则知道所有参数都可以转换为double。
因为您可以使用
void foo(std::vector<T> values);