是否可以使用元组中传递的所有可能的K组合参数(重复)来调用方法? [英] Is it possible to invoke a method with all possible K-combinations (with repetition) of arguments passed in a tuple?
本文介绍了是否可以使用元组中传递的所有可能的K组合参数(重复)来调用方法?的处理方法,对大家解决问题具有一定的参考价值,需要的朋友们下面随着小编来一起学习吧!
问题描述
所需的行为可以说明如下:
The desired behaviour can be illustrated as follows:
void foo(int x, int y) {
std::cout << x << " " << y << std::endl;
}
int main() {
all_combinations<2>(foo, std::make_tuple(1, 2)); // K = 2
// to run:
// foo(1, 1)
// foo(1, 2)
// foo(2, 1)
// foo(2, 2)
}
推荐答案
c ++ 14版本可能如下所示:
The c++14 version could look as follows:
#include <tuple>
#include <utility>
#include <iostream>
#include <initializer_list>
template <class Foo, class Tuple, size_t... Is, size_t... Is2>
int all_combinations_impl(Foo foo, Tuple t, std::index_sequence<Is...> , std::integral_constant<size_t, 0>, std::index_sequence<Is2...>) {
foo(std::get<Is>(t)...);
std::cout << std::endl;
return 0;
}
template <class Foo, class Tuple, size_t... Is, size_t K, size_t... Is2>
int all_combinations_impl(Foo foo, Tuple t, std::index_sequence<Is...>, std::integral_constant<size_t, K>, std::index_sequence<Is2...> is) {
std::initializer_list<int> all = {all_combinations_impl(foo, t, std::index_sequence<Is..., Is2>{}, std::integral_constant<size_t, K-1>{}, is)...};
(void)all;
}
template <size_t K, class Foo, class Tuple>
void all_combinations(Foo foo, Tuple t) {
all_combinations_impl(foo, t, std::index_sequence<>{}, std::integral_constant<size_t, K>{}, std::make_index_sequence<std::tuple_size<Tuple>::value>{});
}
int main() {
all_combinations<2>([](auto... args) { std::forward_as_tuple((std::cout << args)...); }, std::make_tuple("1 ", "2 ", "3 "));
}
不幸的是,c ++ 11不附带 std :: integer_sequence
,因此我们需要执行其他实现:
Unfortunately c++11 does not come with std::integer_sequence
, so we need to do additional implementation:
#include <tuple>
#include <utility>
#include <iostream>
#include <initializer_list>
template <class T, T... Vs>
struct integer_sequence { };
template <class T, class, class, class = integer_sequence<T>, class = integer_sequence<T, 0>, class = void>
struct make_integer_sequence_impl;
template <class T, T ICV1, T... Res, T... Pow>
struct make_integer_sequence_impl<T, std::integral_constant<T, ICV1>, std::integral_constant<T, 0>, integer_sequence<T, Res...>, integer_sequence<T, Pow...>, typename std::enable_if<(ICV1 > 0)>::type>: make_integer_sequence_impl<T, std::integral_constant<T, ICV1/2>, std::integral_constant<T, ICV1%2>, integer_sequence<T, Res...>, integer_sequence<T, Pow..., (Pow + sizeof...(Pow))...>> { };
template <class T, T ICV1, T... Res, T... Pow>
struct make_integer_sequence_impl<T, std::integral_constant<T, ICV1>, std::integral_constant<T, 1>, integer_sequence<T, Res...>, integer_sequence<T, Pow...>, void>: make_integer_sequence_impl<T, std::integral_constant<T, ICV1/2>, std::integral_constant<T, ICV1%2>, integer_sequence<T, Pow..., (Res + sizeof...(Pow))...>, integer_sequence<T, Pow..., (Pow + sizeof...(Pow))...>> { };
template <class T, class Res, class Pow>
struct make_integer_sequence_impl<T, std::integral_constant<T, 0>, std::integral_constant<T, 0>, Res, Pow, void> {
using type = Res;
};
template <class T, T V>
using make_integer_sequence = typename make_integer_sequence_impl<T, std::integral_constant<T, V/2>, std::integral_constant<T, V%2>>::type;
template <size_t V>
using make_index_sequence = make_integer_sequence<size_t, V>;
template <size_t... V>
using index_sequence = integer_sequence<size_t, V...>;
template <class Foo, class Tuple, size_t... Is, size_t... Is2>
int all_combinations_impl(Foo foo, Tuple t, index_sequence<Is...> , std::integral_constant<size_t, 0>, index_sequence<Is2...>) {
foo(std::get<Is>(t)...);
std::cout << std::endl;
return 0;
}
template <class Foo, class Tuple, size_t... Is, size_t K, size_t... Is2>
int all_combinations_impl(Foo foo, Tuple t, index_sequence<Is...>, std::integral_constant<size_t, K>, index_sequence<Is2...> is) {
std::initializer_list<int> all = {all_combinations_impl(foo, t, index_sequence<Is..., Is2>{}, std::integral_constant<size_t, K-1>{}, is)...};
(void)all;
}
template <size_t K, class Foo, class Tuple>
void all_combinations(Foo foo, Tuple t) {
all_combinations_impl(foo, t, index_sequence<>{}, std::integral_constant<size_t, K>{}, make_index_sequence<std::tuple_size<Tuple>::value>{});
}
struct s {
template <class... Args>
void operator()(Args... args) const {
std::forward_as_tuple((std::cout << args)...);
}
};
int main() {
all_combinations<3>(s{}, std::make_tuple("1 ", "2 ", "3 "));
}
这篇关于是否可以使用元组中传递的所有可能的K组合参数(重复)来调用方法?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!
查看全文