How to reverse the order of arguments of a variadic template function?

by

Overall approach and usage

The overal approach consists in packing the arguments into an std::tuple of references, exploiting the perfect forwarding machinery of std::forward_as_tuple().

This means that, at run-time, you should incur in very small overhead and no unnecessary copy/move operations. Also, the framework does not use recursion (apart from compile-time recursion, which is unavoidable for generating indices), so no risk of run-time overhead even in case the compiler would not manage to inline the recursive function calls (which is unlikely anyway, so this is more of an academic argument).

Moreover, this solution is general, in that you can use it as a header-only library to invoke your functions with reversed arguments and with minimum effort: descending_print() should be just a minimal thin wrapper around ascending_print().

Here is how it should look like:

MAKE_REVERT_CALLABLE(ascending_print)

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

What follows is a presentation of the implementation.

First step: reverting a type sequence

Here is a simple way to revert a type sequence:

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

A small test program:

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

And a live example.

Second step: reverting a tuple

The next step consists in reverting a tuple. Given the usual indices trick machinery:

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;

Together with the functions defined above, a tuple can easily be reverted this way:

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

Here is a simple test program:

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

Here is a live example.

Third step: reverting a function’s arguments

The final step consists in unpacking the tuple when calling our target function. Here is another generic utility to save us a couple of lines:

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

The above function creates a tuple whose elements are the arguments provided, but in reverse order. We are not ready to define our target:

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

The above function(s) prints all the arguments provided. And here is how we could write 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)>());
}

A simple test case again:

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

And of course a live example.

Final step: simplification

The above solution may be non-trivial to understand, but it can be made trivial to use, and quite flexible. Given a couple of generic functions:

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

And a couple of macro definitions (I couldn’t find a way to create an overload set for a function template, sorry):

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

It becomes really easy to adapt any function for being called with arguments in reverse order:

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

To conclude, as usual, a live example.

More Related Contents:

  1. Variadic template pack expansion
  2. trailing return type using decltype with a variadic template function
  3. Specifying one type for all arguments passed to variadic function or variadic template function w/out using array, vector, structs, etc?
  4. C++11: I can go from multiple args to tuple, but can I go from tuple to multiple args? [duplicate]
  5. Calling a function for each variadic template argument and an array
  6. What is the meaning of “… …” token? i.e. double ellipsis operator on parameter pack
  7. Is it possible to “store” a template parameter pack without expanding it?
  8. Parameter pack must be at the end of the parameter list… When and why?
  9. What does this variadic template code do?
  10. Expansion with variadic templates [duplicate]
  11. C++ parameter pack, constrained to have instances of a single type?
  12. Variadic templates
  13. What is the easiest way to print a variadic parameter pack using std::ostream?
  14. Variadic function template with pack expansion not in last parameter
  15. How can I expand call to variadic template base classes?
  16. C++11: Number of Variadic Template Function Parameters?
  17. How to make a variadic is_same?
  18. Is there a way to write make_unique() in VS2012?
  19. How to combine std::bind(), variadic templates, and perfect forwarding?
  20. “unpacking” a tuple to call a matching function pointer
  21. std::function vs template
  22. initializer_list and template type deduction
  23. What are the rules for the “…” token in the context of variadic templates?
  24. Matching alias template as template argument
  25. How do compilers treat variable length arrays
  26. C++11 “overloaded lambda” with variadic template and variable capture
  27. Is there a compiler bug exposed by my implementation of an is_complete type trait?
  28. generic member function pointer as a template parameter
  29. Returning a void?
  30. How does std::forward receive the correct argument?

Leave a Comment