如何反转可变参数模板函数的参数顺序？

时间：2013-04-09 14:12:11

标签： c++ templates c++11 variadic-templates variadic-functions

我的模板功能带有 varargs模板参数，就像这样

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) );
}

6 个答案:

答案 0 :(得分：25)

总体方法和用法

总体方法包括将参数打包到{{1>} 引用中，利用std::tuple的完美转发机制。

这意味着，在运行时，您应该承担非常小的开销，并且不会进行不必要的复制/移动操作。此外，框架不使用递归（除了编译时递归，这对于生成索引是不可避免的），因此即使在编译器无法管理内联的情况下也没有运行时开销的风险递归函数调用（无论如何都不太可能，所以这更像是一个学术论点）。

此外，这个解决方案是通用的，因为您可以将它用作仅限标头的库，以反向参数调用您的函数，并且只需最少的工作量：std::forward_as_tuple()应该只是一个最小的瘦包装器< / strong> descending_print()左右。

以下是它的样子：

ascending_print()

以下是对实施的介绍。

第一步：恢复类型序列

这是一种恢复类型序列的简单方法：

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;
};

和live example。

第二步：恢复元组

下一步是恢复元组。鉴于通常的指数技巧机制：

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

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

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)>());
}

这是live example。

第三步：恢复函数的参数

最后一步是在调用目标函数时解压缩元组。这是另一个通用实用程序，为我们节省了几行：

#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
}

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

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)>());
}

当然是live example。

最后一步：简化

上述解决方案可能非常容易理解，但它可以使使用变得微不足道，并且非常灵活。给出了几个通用函数：

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

还有几个宏定义（我无法找到为函数模板创建重载集的方法，抱歉）：

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()

像往常一样结束live example。

答案 1 :(得分：18)

我认为你可以改变你的逻辑，而不是颠倒论点！例如，反转对参数的操作。

template <typename T>
void ascendingPrint(const T& x)
{
    cout << x << " ";
}

template<typename T, typename ... Args>
void ascendingPrint(const T& t, Args... args)
{
    ascendingPrint(t);                   // First print `t`
    ascendingPrint(args...);             // Then print others `args...`
}

template <typename T>
void descendingPrint(const T& x)
{
    cout << x << " ";
}

template<typename T, typename ... Args>
void descendingPrint(const T& t, Args... args)
{
    descendingPrint(args...);            // First print others `args...`
    descendingPrint(t);                  // Then print `t`
}

int main()
{
    ascendingPrint(1, 2, 3, 4);
    cout << endl;
    descendingPrint(1, 2, 3, 4);
}

输出

1 2 3 4 
4 3 2 1

答案 2 :(得分：12)

以下是专门revert<>的递归实现：

// forward decl
template<class ...Tn>
struct revert;

// recursion anchor
template<>
struct revert<>
{
    template<class ...Un>
    static void apply(Un const&... un)
    {
        ascendingPrint(un...);
    }
};

// recursion
template<class T, class ...Tn>
struct revert<T, Tn...> 
{
    template<class ...Un>
    static void apply(T const& t, Tn const&... tn, Un const&... un)
    {
        // bubble 1st parameter backwards
        revert<Tn...>::apply(tn..., t, un...);
    }
};

// using recursive function
template<class A, class ...An>
void descendingPrint(A const& a, An const&... an)
{
    revert<An...>::apply(an..., a);
}

适用于 gcc-4.6 / 7/8 和 clang ，可能符合标准 - 唯一困难的部分是通话revert<Tn...>::apply(tn..., t, un...)。

它有缺点（因为递归经常有），它会生成很多目标函数的模板实例化（代码膨胀），并且不使用完美转发，这可能是一个问题（但也许可以改进使用它）。

答案 3 :(得分：11)

以下是我在评论中提到的简单方法：反向生成索引并使用该方法解压缩元组。

// reversed indices...
template<unsigned... Is> struct seq{ using type = seq; };

template<unsigned I, unsigned... Is>
struct rgen_seq : rgen_seq<I-1, Is..., I-1>{};

template<unsigned... Is>
struct rgen_seq<0, Is...> : seq<Is...>{};

#include <tuple>

namespace aux{
template<class Tup, unsigned... Is>
void descending_print(Tup&& t, seq<Is...>)
{
    ascending_print(std::get<Is>(std::forward<Tup>(t))...);
}
} // aux::

template<class... Args>
void descending_print(Args&&... args)
{
    auto t = std::forward_as_tuple(std::forward<Args>(args)...);
    aux::descending_print(t, rgen_seq<sizeof...(Args)>{});
}

Live example.

答案 4 :(得分：3)

我的解决方案支持完美转发，不涉及递归：

#include <iostream>
#include <utility>
#include <tuple>

#include <cstdlib>

template< typename ...types >
void
ascendingPrint(types &&... _values)
{
    (std::cout << ... << std::forward< types >(_values)) << std::endl;
}

template< typename ...types, std::size_t ...indices >
void
descendingPrintHelper(std::tuple< types... > const & refs, std::index_sequence< indices... >)
{
    constexpr std::size_t back_index = sizeof...(indices) - 1;
    return ascendingPrint(std::forward< std::tuple_element_t< back_index - indices, std::tuple< types... > > >(std::get< back_index - indices >(refs))...);
}

template< typename ...types >
void
descendingPrint(types &&... _values)
{
    auto const refs = std::forward_as_tuple(std::forward< types >(_values)...);
    return descendingPrintHelper(refs, std::make_index_sequence< sizeof...(types) >{});
}

int
main()
{
    ascendingPrint(1, ' ', 2, ' ', 3);
    descendingPrint(1, ' ', 2, ' ', 3);
    return EXIT_SUCCESS;
}

Live example（or even simplier）。

现代编译器也可以完美地优化所有不必要的东西：https://godbolt.org/g/01Qf6w

答案 5 :(得分：1)

这可以使用 C++17 折叠表达式和从右到左顺序执行的小技巧来完成。

#include <iostream>

template< typename T> void print(T&& val) { std::cout << val; }

template< typename ... Types > void descendingPrint(Types&&... vals) {
    int tmps = 0;
    ((print(vals), tmps) = ...);
}

int main() {
    descendingPrint(1, ' ', 2, ' ', 3);
    return 0;
}
相关问题
最新问题