C ++ 11个可变数量的参数,相同的特定types

问题很简单,我将如何实现一个采用可变数量参数的函数(类似于可变参数模板),但是所有参数都具有相同的types,比如int。

我在想这件事情,

void func(int... Arguments) 

或者不会对types工作recursion静态断言?

一个可能的解决scheme是使参数types成为一个容器,可以使用大括号初始值设定项列表(例如std::initializer_list<int>std::vector<int> std::initializer_list<int> 。 例如 :

 #include <iostream> #include <initializer_list> void func(std::initializer_list<int> a_args) { for (auto i: a_args) std::cout << i << '\n'; } int main() { func({4, 7}); func({4, 7, 12, 14}); } 

这里是一个从重载集合中删除函数的版本,而不是给出一个static_assert。 这可以让你在types不完全相同的时候提供可以使用的函数的其他重载,而不是一个无法避免的致命的static_assert。

 #include <type_traits> template<typename... T> struct all_same : std::false_type { }; template<> struct all_same<> : std::true_type { }; template<typename T> struct all_same<T> : std::true_type { }; template<typename T, typename... Ts> struct all_same<T, T, Ts...> : all_same<T, Ts...> { }; template<typename... T> typename std::enable_if<all_same<T...>::value, void>::type func(T...) { } 

如果你想支持完美的转发,你可能希望在检查types之前先衰减types,这样只要它们具有相同的types,函数就会接受左值和右值参数的混合:

 template<typename... T> typename std::enable_if<all_same<typename std::decay<T>::type...>::value, void>::type func(T&&...) { } 

另外,如果你有一个testing逻辑连接的通用特性,你可以使用std::is_same来代替编写自己的all_same

 template<typename T, typename... Ts> typename std::enable_if<and_<is_same<T, Ts>...>::value, void>::type func(T&&, Ts&&...) { } 

因为这需要至less一个参数,所以还需要另一个重载来支持零参数的情况:

 void func() { } 

and_ helper可以这样定义:

 template<typename...> struct and_; template<> struct and_<> : public std::true_type { }; template<typename B1> struct and_<B1> : public B1 { }; template<typename B1, typename B2> struct and_<B1, B2> : public std::conditional<B1::value, B2, B1>::type { }; template<typename B1, typename B2, typename B3, typename... Bn> struct and_<B1, B2, B3, Bn...> : public std::conditional<B1::value, and_<B2, B3, Bn...>, B1>::type { }; 

我认为你可以通过指定一个具体的types来咀嚼参数包的参数。 就像是:

 class MyClass{}; class MyOtherClass{}; void func() { // do something } template< typename... Arguments > void func( MyClass arg, Arguments ... args ) { // do something with arg func( args... ); // do something more with arg } void main() { MyClass a, b, c; MyOtherClass d; int i; float f; func( a, b, c ); // compiles fine func( i, f, d ); // cannot convert } 

在通用的情况下, void func( MyClass arg, Arguments ... args )将会变成void func( arg, Arguments ... args )和模板typesT.

@Skeen这个怎么样?

 template <typename T> void func_1(std::initializer_list<T>&& a) { // do something } template <typename... T> void func(T&&... a) { func_1({std::forward<T>(a)...}); } int main() { func(1, 2, 3); // func(1, 2, 3, 4.0); // OK doesn't compile } 

如果你不想使用基于大括号的initializer_list / vector并且想要将参数以参数包的forms分开,那么下面的解决scheme会在编译时使用recursionstatic_assert来检查它:

 #include<type_traits> template<typename T1, typename T2, typename... Error> struct is_same : std::false_type {}; template<typename T, typename... Checking> struct is_same<T, T, Checking...> : is_same<T, Checking...> {}; template<typename T> struct is_same<T,T> : std::true_type {}; template<typename... LeftMost> void func (LeftMost&&... args) { static_assert(is_same<typename std::decay<LeftMost>::type...>::value, "All types are not same as 'LeftMost'"); // ... } int main () { int var = 2; func(1,var,3,4,5); // ok func(1,2,3,4.0,5); // error due to `static_assert` failure } 

实际上,这个解决scheme将会检查所有关于第一个参数的参数。 假设它是double那么一切都将被检查对double

因为我不认为我看到这个解决scheme,所以你可以为每个types(在你的情况下,只是int )编写一个特定的函数,然后是一个采用可变参数types的转发函数。

写每个特定的情况:

那么对于每个特定的情况:

 // only int in your case void func(int i){ std::cout << "int i = " << i << std::endl; } 

那么你的转发function是这样的:

 template<typename Arg0, typename Arg1 typename ... Args> void func(Arg0 &&arg0, Arg1 &&arg1, Args &&... args){ func(std::forward<Arg0>(arg0)); func(std::forward<Arg1>(arg1), std::forward<Args>(args)...); } 

这很好,因为它可以扩展,当你想要接受也许另一种types。

像这样使用:

 int main(){ func(1, 2, 3, 4); // works fine func(1.0f, 2.0f, 3.0f, 4.0f); // compile error, no func(float) }