web-dev-qa-db-ja.com

可変個引数テンプレート関数の引数の順序を逆にする方法は？

私はテンプレート関数とvarargsテンプレート引数を持っています、このように

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

そして書きたい

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

どうすればよいですかparameter-packargsの順序を逆にして、渡す前に、つまり疑似で-コード：

template<typename Args...>
void descendingPrint(Args... args) {
  ascendingPrint( reverse(args) );
}
c++templatesc++11variadic-templatesvariadic-functions
36
towi

これが再帰的特殊な_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...)。

ただし、（再帰でよくあるように）ターゲット関数のテンプレートインスタンス化が多く生成され（コードの膨張）、完全な転送が使用されないという欠点があります。これは問題になる可能性があります（ただし、おそらくそれを使用するために改善される可能性があります）。

13
Alex

全体的なアプローチと使用法

全体的なアプローチは、引数を参照の_std::Tuple_にパックし、完全転送std::forward_as_Tuple()の機構。

これは、実行時に、非常に小さなオーバーヘッドが発生し、不要なコピー/移動操作が発生しないことを意味します。また、フレームワークは再帰を使用しないため（compile-timerecursionは別として、インデックスの生成には避けられません）、コンパイラーが使用する場合でも、実行時のオーバーヘッドのリスクはありません。再帰的な関数呼び出しをインライン化することができません（とにかくありそうもないので、これはより学術的な議論です）。

さらに、このソリューションは一般的であり、ヘッダーのみのライブラリとして使用して、逆の引数で最小限の労力で関数を呼び出すことができます。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;
};
_

小さなテストプログラム：

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

そして 実例 。

2番目のステップ：タプルを元に戻す

次のステップは、タプルを元に戻すことです。通常のインデックストリック機構を考えると：

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

これが 実例 です。

3番目のステップ：関数の引数を元に戻す

最後のステップは、ターゲット関数を呼び出すときにタプルを解凍することです。数行節約するためのもう1つの汎用ユーティリティは次のとおりです。

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

そしてもちろん 実例 。

最終ステップ：簡素化

上記の解決策は理解するのが簡単ではないかもしれませんが、useを簡単にすることができ、非常に柔軟です。いくつかの一般的な関数が与えられます：

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

結論として、いつものように、 実例 。

26
Andy Prowl

引数を逆にする代わりに、論理を逆にすることができると思います！たとえば、引数の操作を逆にします。

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
18
masoud

コメントで述べた簡単なアプローチは次のとおりです。逆にインデックスを生成し、それを使用してタプルを解凍します。

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

実例。

15
Xeo

私のソリューションは完全な転送をサポートしており、再帰は含まれていません。

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

実例 （ またはさらに単純 ）。

また、最新のコンパイラーは、不要なものをすべて完全に最適化できます。 https://godbolt.org/g/01Qf6w

3
Tomilov Anatoliy