gpt4 book ai didi

c++ - 如何反转可变参数模板函数的参数顺序?

转载 作者:IT老高 更新时间:2023-10-28 12:38:41 26 4
gpt4 key购买 nike

我有一个带有可变参数模板参数模板函数,像这样

template<typename Args...>
void ascendingPrint(Args... args) { /* ... */ }

我想写

template<typename Args...>
void descendingPrint(Args... args) {
/* implementation using ascendingPrint()? */
}

在传递它之前,我如何颠倒 parameter-pack args 的顺序,即在伪代码中:

template<typename Args...>
void descendingPrint(Args... args) {
ascendingPrint( reverse(args) );
}

最佳答案

总体方法和用法


总体方法包括将参数打包到 referencesstd::tuple 中,利用 完美转发 机制std::forward_as_tuple().

这意味着,在运行时,您应该产生非常小的开销,并且没有不必要的复制/移动操作。此外,该框架不使用递归(除了 compile-time 递归,这对于生成索引是不可避免的),因此即使编译器无法内联递归函数调用(无论如何这不太可能,所以这更像是一个学术论点)。

此外,此解决方案是通用的,因为您可以将其用作仅头文件的库,以使用反向参数和最小的努力来调用您的函数:descending_print() 应该只是一个 ascending_print() 周围的 >minimal thin wrapper

它应该是这样的:

MAKE_REVERT_CALLABLE(ascending_print)

template<typename... Args>
void descending_print(Args&&... args)
{
revert_call(REVERT_ADAPTER(ascending_print), std::forward<Args>(args)...);
}

下面是实现的介绍。


第一步:恢复类型序列


这里有一个简单的恢复类型序列的方法:

#include <tuple>
#include <type_traits>

template<typename, typename>
struct append_to_type_seq { };

template<typename T, typename... Ts>
struct append_to_type_seq<T, std::tuple<Ts...>>
{
using type = std::tuple<Ts..., T>;
};

template<typename... Ts>
struct revert_type_seq
{
using type = std::tuple<>;
};

template<typename T, typename... Ts>
struct revert_type_seq<T, Ts...>
{
using type = typename append_to_type_seq<
T,
typename revert_type_seq<Ts...>::type
>::type;
};

一个小测试程序:

int main()
{
static_assert(
std::is_same<
revert_type_seq<char, int, bool>::type,
std::tuple<bool, int, char>
>::value,
"Error"
);
}

还有一个 live example .


第二步:还原元组


下一步是还原一个元组。鉴于通常的索引欺骗机制:

template <int... Is>
struct index_list { };

namespace detail
{
template <int MIN, int N, int... Is>
struct range_builder;

template <int MIN, int... Is>
struct range_builder<MIN, MIN, Is...>
{
typedef index_list<Is...> type;
};

template <int MIN, int N, int... Is>
struct range_builder : public range_builder<MIN, N - 1, N - 1, Is...>
{ };
}

template<int MIN, int MAX>
using index_range = typename detail::range_builder<MIN, MAX>::type;

与上面定义的函数一起,元组可以通过这种方式轻松恢复:

template<typename... Args, int... Is>
typename revert_type_seq<Args...>::type
revert_tuple(std::tuple<Args...> t, index_list<Is...>)
{
using reverted_tuple = typename revert_type_seq<Args...>::type;

// Forwarding machinery that handles both lvalues and rvalues...
auto rt = std::forward_as_tuple(
std::forward<
typename std::conditional<
std::is_lvalue_reference<
typename std::tuple_element<Is, reverted_tuple>::type
>::value,
typename std::tuple_element<Is, reverted_tuple>::type,
typename std::remove_reference<
typename std::tuple_element<Is, reverted_tuple>::type
>::type
>::type
>(std::get<sizeof...(Args) - Is - 1>(t))...
);

return rt;
}

template<typename... Args>
typename revert_type_seq<Args...>::type
revert_tuple(std::tuple<Args...> t)
{
return revert_tuple(t, index_range<0, sizeof...(Args)>());
}

这是一个简单的测试程序:

#include <iostream>

int main()
{
std::tuple<int, int, char> t(42, 1729, 'c');
auto rt = revert_tuple(t);

std::cout << std::get<0>(rt) << " "; // Prints c
std::cout << std::get<1>(rt) << " "; // Prints 1729
std::cout << std::get<2>(rt) << " "; // Prints 42
}

这里是 live example .


第三步:恢复函数的参数


最后一步是在调用目标函数时解包元组。这是另一个通用实用程序,可以为我们节省几行代码:

template<typename... Args>
typename revert_type_seq<Args...>::type
make_revert(Args&&... args)
{
auto t = std::forward_as_tuple(std::forward<Args>(args)...);
return revert_tuple(t);
}

上面的函数创建了一个元组,其元素是提供的参数,但顺序相反。我们还没有准备好定义我们的目标:

template<typename T>
void ascending_print(T&& t)
{
std::cout << std::forward<T>(t) << " ";
}

template<typename T, typename... Args>
void ascending_print(T&& t, Args&&... args)
{
ascending_print(std::forward<T>(t));
ascending_print(std::forward<Args>(args)...);
}

上述函数打印所有提供的参数。下面是我们如何编写 descending_print():

template<typename T, int... Is>
void call_ascending_print(T&& t, index_list<Is...>)
{
ascending_print(std::get<Is>(std::forward<T>(t))...);
}

template<typename... Args>
void descending_print(Args&&... args) {
call_ascending_print(make_revert(std::forward<Args>(args)...),
index_range<0, sizeof...(Args)>());
}

又是一个简单的测试用例:

int main()
{
ascending_print(42, 3.14, "Hello, World!");
std::cout << std::endl;
descending_print(42, 3.14, "Hello, World!");
}

当然还有 live example .


最后一步:简化


上面的解决方案可能理解起来并不简单,但是使用可以变得简单,而且非常灵活。给定几个通用函数:

template<typename F, typename... Args, int... Is>
void revert_call(F&& f, index_list<Is...>, Args&&... args)
{
auto rt = make_revert(std::forward<Args>(args)...);
f(std::get<Is>(rt)...);
}

template<typename F, typename... Args>
void revert_call(F&& f, Args&&... args)
{
revert_call(f, index_range<0, sizeof...(Args)>(),
std::forward<Args>(args)...);
}

还有几个宏定义(我找不到为函数模板创建重载集的方法,抱歉):

#define MAKE_REVERT_CALLABLE(func) \
struct revert_caller_ ## func \
{ \
template<typename... Args> void operator () (Args&&... args) \
{ func(std::forward<Args>(args)...); } \
};

#define REVERT_ADAPTER(func) \
revert_caller_ ## func()

调整 any 函数以用相反的顺序调用参数变得非常容易:

MAKE_REVERT_CALLABLE(ascending_print)

template<typename... Args>
void descending_print(Args&&... args)
{
revert_call(REVERT_ADAPTER(ascending_print), std::forward<Args>(args)...);
}

int main()
{
ascending_print(42, 3.14, "Hello, World!");
std::cout << std::endl;
descending_print(42, 3.14, "Hello, World!");
}

和往常一样,总结一下 live example .

关于c++ - 如何反转可变参数模板函数的参数顺序?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/15904288/

26 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com