前提：
与可变参数模板玩弄一点后，我意识到，实现任何事情去稍微超出琐碎的元编程任务很快变得相当繁琐。 特别是，我发现自己希望的进行了一个多参数包的通用操作 ，如迭代 ， 拆分 ， 循环的一种方式std::for_each样时尚，等等。
在观看了由安德烈Alexandrescu的本次讲座由C ++和超越2012年的可取static if为C ++（从借来构建d编程语言 ），我隐隐觉得某种static for会来得心应手，以及-我觉得更这些的static结构可能带来的好处。
于是我开始想知道如果有一种方法来实现这样的一个可变参数模板函数（ 伪代码 ）的说法包：
template<typename... Ts>
void my_function(Ts&&... args)
{
static for (int i = 0; i < sizeof...(args); i++) // PSEUDO-CODE!
{
foo(nth_value_of<i>(args));
}
}
这将得到翻译在编译的时候弄成这个样子：
template<typename... Ts>
void my_function(Ts&&... args)
{
foo(nth_value_of<0>(args));
foo(nth_value_of<1>(args));
// ...
foo(nth_value_of<sizeof...(args) - 1>(args));
}
原则上， static_for将允许更精细的处理：
template<typename... Ts>
void foo(Ts&&... args)
{
constexpr s = sizeof...(args);
static for (int i = 0; i < s / 2; i++)
{
// Do something
foo(nth_value_of<i>(args));
}
static for (int i = s / 2; i < s; i++)
{
// Do something different
bar(nth_value_of<i>(args));
}
}
或者这样一个更具表现力的成语：
template<typename... Ts>
void foo(Ts&&... args)
{
static for_each (auto&& x : args)
{
foo(x);
}
}
相关工作：
我没有在网络上的一些搜索和发现的东西确实存在：
- 此链接介绍如何将参数包转换成Boost.MPL载体，但只做了一半的方式（如果不是更小）朝着目标;
- 在SO这个问题似乎需要一个类似并稍微相关的元编程功能（分裂的参数包了两半） -实际上，上有SO几个问题，这似乎与此有关的问题，但没有回答我已经阅读解决它令人满意恕我直言;
- Boost.Fusion定义算法的参数包转换成一个元组 ，但我宁愿：
- 不产生不必要的临时变量来保存参数，可以（也应该）完全转发到一些通用的算法;
- 有一个小的，独立的图书馆要做到这一点，而Boost.Fusion可能包括除为解决这一问题，需要的方式更多的东西。
题：
有没有比较简单的方法，可能通过一些模板元编程，实现什么我没有在现有方法的局限性招致找？
由于我没有高兴我找到了什么，我试图找出一个解决方案自己，最后写一个小库 ，它允许在参数组制定通用操作。 我的解决方案具有以下特点：
- 允许迭代在所有或参数组中，有可能通过计算它们对包索引指定的一些元件;
- 允许参数包到可变参数函子的转发计算部分;
- 仅需要包括一个相对短的头文件;
- 大量使用完美转发允许重内联和避免了不必要的复制/移动允许最小的性能损失;
- 内部实现的迭代算法依赖于空基类优化用于最小化存储器消耗;
- 这是很容易（相对，考虑到它的模板元编程）扩展和适应。
我首先会显示什么可以与库完成 ， 然后发布实施 。
用例
此处是如何的示例for_each_in_arg_pack()函数可以被用于通过一个包的所有参数进行迭代并且在输入每一个参数传递给一些客户端提供的函子（当然，在仿函数必须有如果参数的通用呼叫操作员包中包含异质类型的值）：
// Simple functor with a generic call operator that prints its input. This is used by the
// following functors and by some demonstrative test cases in the main() routine.
struct print
{
template<typename T>
void operator () (T&& t)
{
cout << t << endl;
}
};
// This shows how a for_each_*** helper can be used inside a variadic template function
template<typename... Ts>
void print_all(Ts&&... args)
{
for_each_in_arg_pack(print(), forward<Ts>(args)...);
}
在print上述仿函数也可以在更复杂的计算中使用。 特别是，这里是怎么一会重复上一个子集 （在这种情况下， 子范围 ）的一组参数：
// Shows how to select portions of an argument pack and
// invoke a functor for each of the selected elements
template<typename... Ts>
void split_and_print(Ts&&... args)
{
constexpr size_t packSize = sizeof...(args);
constexpr size_t halfSize = packSize / 2;
cout << "Printing first half:" << endl;
for_each_in_arg_pack_subset(
print(), // The functor to invoke for each element
index_range<0, halfSize>(), // The indices to select
forward<Ts>(args)... // The argument pack
);
cout << "Printing second half:" << endl;
for_each_in_arg_pack_subset(
print(), // The functor to invoke for each element
index_range<halfSize, packSize>(), // The indices to select
forward<Ts>(args)... // The argument pack
);
}
有时，一个可能只是想一个参数包的一部分转发到其他一些可变参数的函子，而不是通过它的元素进行迭代，并分别通过它们中的每一个非可变参数函子。 这就是forward_subpack()算法允许这样做：
// Functor with variadic call operator that shows the usage of for_each_***
// to print all the arguments of a heterogeneous pack
struct my_func
{
template<typename... Ts>
void operator ()(Ts&&... args)
{
print_all(forward<Ts>(args)...);
}
};
// Shows how to forward only a portion of an argument pack
// to another variadic functor
template<typename... Ts>
void split_and_print(Ts&&... args)
{
constexpr size_t packSize = sizeof...(args);
constexpr size_t halfSize = packSize / 2;
cout << "Printing first half:" << endl;
forward_subpack(my_func(), index_range<0, halfSize>(), forward<Ts>(args)...);
cout << "Printing second half:" << endl;
forward_subpack(my_func(), index_range<halfSize, packSize>(), forward<Ts>(args)...);
}
对于更具体的任务，它当然也可以通过索引他们检索一个包具体参数。 这就是nth_value_of()函数允许这样做，其助手一起first_value_of()和last_value_of()
// Shows that arguments in a pack can be indexed
template<unsigned I, typename... Ts>
void print_first_last_and_indexed(Ts&&... args)
{
cout << "First argument: " << first_value_of(forward<Ts>(args)...) << endl;
cout << "Last argument: " << last_value_of(forward<Ts>(args)...) << endl;
cout << "Argument #" << I << ": " << nth_value_of<I>(forward<Ts>(args)...) << endl;
}
如果参数组是在另一方面均匀 （即，所有的参数具有相同的类型），制剂如下面的一个可能是优选的。 所述is_homogeneous_pack<>元功能允许确定在参数包的所有类型是否是同质的，并且主要是指在使用static_assert()语句：
// Shows the use of range-based for loops to iterate over a
// homogeneous argument pack
template<typename... Ts>
void print_all(Ts&&... args)
{
static_assert(
is_homogeneous_pack<Ts...>::value,
"Template parameter pack not homogeneous!"
);
for (auto&& x : { args... })
{
// Do something with x...
}
cout << endl;
}
最后，由于lambda表达式是用于仿函数只是语法糖 ，它们可以在与上面的算法结合使用，以及; 然而，直到通用的lambda将由C ++的支持，这是唯一可能均相参数包。 以下示例还示出了的使用homogeneous-type<>元函数，它返回的在均相包的所有参数的类型：
// ...
static_assert(
is_homogeneous_pack<Ts...>::value,
"Template parameter pack not homogeneous!"
);
using type = homogeneous_type<Ts...>::type;
for_each_in_arg_pack([] (type const& x) { cout << x << endl; }, forward<Ts>(args)...);
这基本上就是图书馆允许这样做，但我相信它甚至可以被扩展到执行更复杂的任务。
实施
现在到了实现，这本身就是一个有点棘手，所以我会靠注释来解释代码，并避免使这个帖子太长（也许它已经是）：
#include <type_traits>
#include <utility>
//===============================================================================
// META-FUNCTIONS FOR EXTRACTING THE n-th TYPE OF A PARAMETER PACK
// Declare primary template
template<int I, typename... Ts>
struct nth_type_of
{
};
// Base step
template<typename T, typename... Ts>
struct nth_type_of<0, T, Ts...>
{
using type = T;
};
// Induction step
template<int I, typename T, typename... Ts>
struct nth_type_of<I, T, Ts...>
{
using type = typename nth_type_of<I - 1, Ts...>::type;
};
// Helper meta-function for retrieving the first type in a parameter pack
template<typename... Ts>
struct first_type_of
{
using type = typename nth_type_of<0, Ts...>::type;
};
// Helper meta-function for retrieving the last type in a parameter pack
template<typename... Ts>
struct last_type_of
{
using type = typename nth_type_of<sizeof...(Ts) - 1, Ts...>::type;
};
//===============================================================================
// FUNCTIONS FOR EXTRACTING THE n-th VALUE OF AN ARGUMENT PACK
// Base step
template<int I, typename T, typename... Ts>
auto nth_value_of(T&& t, Ts&&... args) ->
typename std::enable_if<(I == 0), decltype(std::forward<T>(t))>::type
{
return std::forward<T>(t);
}
// Induction step
template<int I, typename T, typename... Ts>
auto nth_value_of(T&& t, Ts&&... args) ->
typename std::enable_if<(I > 0), decltype(
std::forward<typename nth_type_of<I, T, Ts...>::type>(
std::declval<typename nth_type_of<I, T, Ts...>::type>()
)
)>::type
{
using return_type = typename nth_type_of<I, T, Ts...>::type;
return std::forward<return_type>(nth_value_of<I - 1>((std::forward<Ts>(args))...));
}
// Helper function for retrieving the first value of an argument pack
template<typename... Ts>
auto first_value_of(Ts&&... args) ->
decltype(
std::forward<typename first_type_of<Ts...>::type>(
std::declval<typename first_type_of<Ts...>::type>()
)
)
{
using return_type = typename first_type_of<Ts...>::type;
return std::forward<return_type>(nth_value_of<0>((std::forward<Ts>(args))...));
}
// Helper function for retrieving the last value of an argument pack
template<typename... Ts>
auto last_value_of(Ts&&... args) ->
decltype(
std::forward<typename last_type_of<Ts...>::type>(
std::declval<typename last_type_of<Ts...>::type>()
)
)
{
using return_type = typename last_type_of<Ts...>::type;
return std::forward<return_type>(nth_value_of<sizeof...(Ts) - 1>((std::forward<Ts>(args))...));
}
//===============================================================================
// METAFUNCTION FOR COMPUTING THE UNDERLYING TYPE OF HOMOGENEOUS PARAMETER PACKS
// Used as the underlying type of non-homogeneous parameter packs
struct null_type
{
};
// Declare primary template
template<typename... Ts>
struct homogeneous_type;
// Base step
template<typename T>
struct homogeneous_type<T>
{
using type = T;
static const bool isHomogeneous = true;
};
// Induction step
template<typename T, typename... Ts>
struct homogeneous_type<T, Ts...>
{
// The underlying type of the tail of the parameter pack
using type_of_remaining_parameters = typename homogeneous_type<Ts...>::type;
// True if each parameter in the pack has the same type
static const bool isHomogeneous = std::is_same<T, type_of_remaining_parameters>::value;
// If isHomogeneous is "false", the underlying type is the fictitious null_type
using type = typename std::conditional<isHomogeneous, T, null_type>::type;
};
// Meta-function to determine if a parameter pack is homogeneous
template<typename... Ts>
struct is_homogeneous_pack
{
static const bool value = homogeneous_type<Ts...>::isHomogeneous;
};
//===============================================================================
// META-FUNCTIONS FOR CREATING INDEX LISTS
// The structure that encapsulates index lists
template <unsigned... Is>
struct index_list
{
};
// Collects internal details for generating index ranges [MIN, MAX)
namespace detail
{
// Declare primary template for index range builder
template <unsigned MIN, unsigned N, unsigned... Is>
struct range_builder;
// Base step
template <unsigned MIN, unsigned... Is>
struct range_builder<MIN, MIN, Is...>
{
typedef index_list<Is...> type;
};
// Induction step
template <unsigned MIN, unsigned N, unsigned... Is>
struct range_builder : public range_builder<MIN, N - 1, N - 1, Is...>
{
};
}
// Meta-function that returns a [MIN, MAX) index range
template<unsigned MIN, unsigned MAX>
using index_range = typename detail::range_builder<MIN, MAX>::type;
//===============================================================================
// CLASSES AND FUNCTIONS FOR REALIZING LOOPS ON ARGUMENT PACKS
// Implementation inspired by @jogojapan's answer to this question:
// http://stackoverflow.com/questions/14089637/return-several-arguments-for-another-function-by-a-single-function
// Collects internal details for implementing functor invocation
namespace detail
{
// Functor invocation is realized through variadic inheritance.
// The constructor of each base class invokes an input functor.
// An functor invoker for an argument pack has one base class
// for each argument in the pack
// Realizes the invocation of the functor for one parameter
template<unsigned I, typename T>
struct invoker_base
{
template<typename F, typename U>
invoker_base(F&& f, U&& u) { f(u); }
};
// Necessary because a class cannot inherit the same class twice
template<unsigned I, typename T>
struct indexed_type
{
static const unsigned int index = I;
using type = T;
};
// The functor invoker: inherits from a list of base classes.
// The constructor of each of these classes invokes the input
// functor with one of the arguments in the pack.
template<typename... Ts>
struct invoker : public invoker_base<Ts::index, typename Ts::type>...
{
template<typename F, typename... Us>
invoker(F&& f, Us&&... args)
:
invoker_base<Ts::index, typename Ts::type>(std::forward<F>(f), std::forward<Us>(args))...
{
}
};
}
// The functor provided in the first argument is invoked for each
// argument in the pack whose index is contained in the index list
// specified in the second argument
template<typename F, unsigned... Is, typename... Ts>
void for_each_in_arg_pack_subset(F&& f, index_list<Is...> const& i, Ts&&... args)
{
// Constructors of invoker's sub-objects will invoke the functor.
// Note that argument types must be paired with numbers because the
// implementation is based on inheritance, and one class cannot
// inherit the same base class twice.
detail::invoker<detail::indexed_type<Is, typename nth_type_of<Is, Ts...>::type>...> invoker(
f,
(nth_value_of<Is>(std::forward<Ts>(args)...))...
);
}
// The functor provided in the first argument is invoked for each
// argument in the pack
template<typename F, typename... Ts>
void for_each_in_arg_pack(F&& f, Ts&&... args)
{
for_each_in_arg_pack_subset(f, index_range<0, sizeof...(Ts)>(), std::forward<Ts>(args)...);
}
// The functor provided in the first argument is given in input the
// arguments in whose index is contained in the index list specified
// as the second argument.
template<typename F, unsigned... Is, typename... Ts>
void forward_subpack(F&& f, index_list<Is...> const& i, Ts&&... args)
{
f((nth_value_of<Is>(std::forward<Ts>(args)...))...);
}
// The functor provided in the first argument is given in input all the
// arguments in the pack.
template<typename F, typename... Ts>
void forward_pack(F&& f, Ts&&... args)
{
f(std::forward<Ts>(args)...);
}
结论
当然，即使我提供我自己回答这个问题（实际上是因为这个事实），我很好奇听到的话，替代或更好的解决办法是存在，我已经错过了-除了“相关工作”一节中提到的那些的问题。
让我张贴此代码的基础上，讨论：
#include <initializer_list>
#define EXPAND(EXPR) std::initializer_list<int>{((EXPR),0)...}
// Example of use:
#include <iostream>
#include <utility>
void print(int i){std::cout << "int: " << i << '\n';}
int print(double d){std::cout << "double: " << d << '\n';return 2;}
template<class...T> void f(T&&...args){
EXPAND(print(std::forward<T>(args)));
}
int main(){
f();
f(1,2.,3);
}
我检查所生成的代码以g++ -std=c++11 -O1和main只包含3调用print ，没有膨胀的助手的痕迹。
使用枚举溶液（ALA的Python）。
用法：
void fun(int i, size_t index, size_t size) {
if (index != 0) {
std::cout << ", ";
}
std::cout << i;
if (index == size - 1) {
std::cout << "\n";
}
} // fun
enumerate(fun, 2, 3, 4);
// Expected output: "2, 3, 4\n"
// check it at: http://liveworkspace.org/code/1cydbw$4
码：
// Fun: expects a callable of 3 parameters: Arg, size_t, size_t
// Arg: forwarded argument
// size_t: index of current argument
// size_t: number of arguments
template <typename Fun, typename... Args, size_t... Is>
void enumerate_impl(Fun&& fun, index_list<Is...>, Args&&... args) {
std::initializer_list<int> _{
(fun(std::forward<Args>(args), Is, sizeof...(Is)), 0)...
};
(void)_; // placate compiler, only the side-effects interest us
}
template <typename Fun, typename... Args>
void enumerate(Fun&& fun, Args&&... args) {
enumerate_impl(fun,
index_range<0, sizeof...(args)>(),
std::forward<Args>(args)...);
}
范围生成器（从您的解决方案pilferred）：
// The structure that encapsulates index lists
template <size_t... Is>
struct index_list
{
};
// Collects internal details for generating index ranges [MIN, MAX)
namespace detail
{
// Declare primary template for index range builder
template <size_t MIN, size_t N, size_t... Is>
struct range_builder;
// Base step
template <size_t MIN, size_t... Is>
struct range_builder<MIN, MIN, Is...>
{
typedef index_list<Is...> type;
};
// Induction step
template <size_t MIN, size_t N, size_t... Is>
struct range_builder : public range_builder<MIN, N - 1, N - 1, Is...>
{
};
}
// Meta-function that returns a [MIN, MAX) index range
template<size_t MIN, size_t MAX>
using index_range = typename detail::range_builder<MIN, MAX>::type;
阅读一些其他职位和摆弄了一阵后，我想出了以下（有点类似于上述情况，但执行是一个有点不同）。 我写这个使用Visual Studio 2013编译器。
使用lambda表达式使用 -
static_for_each()(
[](std::string const& str)
{
std::cout << str << std::endl;
}, "Hello, ", "Lambda!");
使用Lambda时，不足的是参数必须在拉姆达的参数列表中声明的同一类型。 这意味着它只会用一种类型的工作。 如果你想用一个模板功能，可以使用下面的例子。
使用结构包装仿函数的用法 -
struct print_wrapper
{
template <typename T>
void operator()(T&& str)
{
std::cout << str << " ";
}
};
//
// A little test object we can use.
struct test_object
{
test_object() : str("I'm a test object!") {}
std::string str;
};
std::ostream& operator<<(std::ostream& os, test_object t)
{
os << t.str;
return os;
}
//
// prints: "Hello, Functor! 1 2 I'm a test object!"
static_for_each()(print_wrapper(), "Hello,", "Functor!", 1, 2.0f, test_object());
这使您可以在您想要使用的仿函数对它们进行操作的任何类型的通过。 我发现这很干净，很好地工作了我想要的东西。 你也可以用一个函数参数包这样使用它 -
template <typename T, typename... Args>
void call(T f, Args... args)
{
static_for_each()(f, args...);
}
call(print_wrapper(), "Hello", "Call", "Wrapper!");
这里是实现 -
//
// Statically iterate over a parameter pack
// and call a functor passing each argument.
struct static_for_each
{
private:
//
// Get the parameter pack argument at index i.
template <size_t i, typename... Args>
static auto get_arg(Args&&... as)
-> decltype(std::get<i>(std::forward_as_tuple(std::forward<Args>(as)...)))
{
return std::get<i>(std::forward_as_tuple(std::forward<Args>(as)...));
}
//
// Recursive template for iterating over
// parameter pack and calling the functor.
template <size_t Start, size_t End>
struct internal_static_for
{
template <typename Functor, typename... Ts>
void operator()(Functor f, Ts&&... args)
{
f(get_arg<Start>(args...));
internal_static_for<Start + 1, End>()(f, args...);
}
};
//
// Specialize the template to end the recursion.
template <size_t End>
struct internal_static_for<End, End>
{
template <typename Functor, typename... Ts>
void operator()(Functor f, Ts&&... args){}
};
public:
//
// Publically exposed operator()().
// Handles template recursion over parameter pack.
// Takes the functor to be executed and a parameter
// pack of arguments to pass to the functor, one at a time.
template<typename Functor, typename... Ts>
void operator()(Functor f, Ts&&... args)
{
//
// Statically iterate over parameter
// pack from the first argument to the
// last, calling functor f with each
// argument in the parameter pack.
internal_static_for<0u, sizeof...(Ts)>()(f, args...);
}
};
希望人们发现这很有用:-)
文章来源: How to make generic computations over heterogeneous argument packs of a variadic template function?
