Tupleを可変長テンプレート関数の引数に展開するにはどうすればよいですか？

Question

可変引数テンプレート引数を使用したテンプレート関数の場合を考えてみましょう。

_template<typename Tret, typename... T> Tret func(const T&... t);
_

これで、値のタプルtができました。タプル値を引数として使用してfunc()を呼び出すにはどうすればよいですか？私はbind()関数を使ってcall()関数オブジェクトを読みました。また、いくつかの現在廃止されたドキュメントのapply()関数についても読みました。 GNU GCC 4.4実装にはcall()クラスにbind()関数があるようですが、この件に関するドキュメントはほとんどありません。

手書きの再帰的ハックを提案する人もいますが、可変引数テンプレート引数の真の価値は、上記のような場合にそれらを使用できるようにすることです。

誰もが解決策を持っていますか、それについてどこで読むべきかについてのヒントがありますか？

Answer 1

誰かが興味を持っているなら、ここに私のコードがあります

基本的に、コンパイル時に、コンパイラはさまざまな包括的関数呼び出し<N>->呼び出し<N-1>->呼び出し...->呼び出し<0>のすべての引数を再帰的に展開し、コンパイラは最適化されますfunc（arg1、arg2、arg3、...）に相当する最後の関数のみを保持するためのさまざまな中間関数呼び出し

オブジェクトで呼び出される関数用と静的関数用の2つのバージョンが提供されます。

#include <tr1/Tuple>

/**
 * Object Function Tuple Argument Unpacking
 *
 * This recursive template unpacks the Tuple parameters into
 * variadic template arguments until we reach the count of 0 where the function
 * is called with the correct parameters
 *
 * @tparam N Number of Tuple arguments to unroll
 *
 * @ingroup g_util_Tuple
 */
template < uint N >
struct apply_obj_func
{
  template < typename T, typename... ArgsF, typename... ArgsT, typename... Args >
  static void applyTuple( T* pObj,
                          void (T::*f)( ArgsF... ),
                          const std::tr1::Tuple<ArgsT...>& t,
                          Args... args )
  {
    apply_obj_func<N-1>::applyTuple( pObj, f, t, std::tr1::get<N-1>( t ), args... );
  }
};

//-----------------------------------------------------------------------------

/**
 * Object Function Tuple Argument Unpacking End Point
 *
 * This recursive template unpacks the Tuple parameters into
 * variadic template arguments until we reach the count of 0 where the function
 * is called with the correct parameters
 *
 * @ingroup g_util_Tuple
 */
template <>
struct apply_obj_func<0>
{
  template < typename T, typename... ArgsF, typename... ArgsT, typename... Args >
  static void applyTuple( T* pObj,
                          void (T::*f)( ArgsF... ),
                          const std::tr1::Tuple<ArgsT...>& /* t */,
                          Args... args )
  {
    (pObj->*f)( args... );
  }
};

//-----------------------------------------------------------------------------

/**
 * Object Function Call Forwarding Using Tuple Pack Parameters
 */
// Actual apply function
template < typename T, typename... ArgsF, typename... ArgsT >
void applyTuple( T* pObj,
                 void (T::*f)( ArgsF... ),
                 std::tr1::Tuple<ArgsT...> const& t )
{
   apply_obj_func<sizeof...(ArgsT)>::applyTuple( pObj, f, t );
}

//-----------------------------------------------------------------------------

/**
 * Static Function Tuple Argument Unpacking
 *
 * This recursive template unpacks the Tuple parameters into
 * variadic template arguments until we reach the count of 0 where the function
 * is called with the correct parameters
 *
 * @tparam N Number of Tuple arguments to unroll
 *
 * @ingroup g_util_Tuple
 */
template < uint N >
struct apply_func
{
  template < typename... ArgsF, typename... ArgsT, typename... Args >
  static void applyTuple( void (*f)( ArgsF... ),
                          const std::tr1::Tuple<ArgsT...>& t,
                          Args... args )
  {
    apply_func<N-1>::applyTuple( f, t, std::tr1::get<N-1>( t ), args... );
  }
};

//-----------------------------------------------------------------------------

/**
 * Static Function Tuple Argument Unpacking End Point
 *
 * This recursive template unpacks the Tuple parameters into
 * variadic template arguments until we reach the count of 0 where the function
 * is called with the correct parameters
 *
 * @ingroup g_util_Tuple
 */
template <>
struct apply_func<0>
{
  template < typename... ArgsF, typename... ArgsT, typename... Args >
  static void applyTuple( void (*f)( ArgsF... ),
                          const std::tr1::Tuple<ArgsT...>& /* t */,
                          Args... args )
  {
    f( args... );
  }
};

//-----------------------------------------------------------------------------

/**
 * Static Function Call Forwarding Using Tuple Pack Parameters
 */
// Actual apply function
template < typename... ArgsF, typename... ArgsT >
void applyTuple( void (*f)(ArgsF...),
                 std::tr1::Tuple<ArgsT...> const& t )
{
   apply_func<sizeof...(ArgsT)>::applyTuple( f, t );
}

// ***************************************
// Usage
// ***************************************

template < typename T, typename... Args >
class Message : public iMessage
{

  typedef void (T::*F)( Args... args );

public:

  Message( const std::string& name,
           T& obj,
           F pFunc,
           Args... args );

private:

  virtual void doDispatch( );

  T*  pObj_;
  F   pFunc_;
  std::tr1::Tuple<Args...> args_;
};

//-----------------------------------------------------------------------------

template < typename T, typename... Args >
Message<T, Args...>::Message( const std::string& name,
                              T& obj,
                              F pFunc,
                              Args... args )
: iMessage( name ),
  pObj_( &obj ),
  pFunc_( pFunc ),
  args_( std::forward<Args>(args)... )
{

}

//-----------------------------------------------------------------------------

template < typename T, typename... Args >
void Message<T, Args...>::doDispatch( )
{
  try
  {
    applyTuple( pObj_, pFunc_, args_ );
  }
  catch ( std::exception& e )
  {

  }
}

Answer 2

C++では、Tupleを展開/展開して、それらのTuple要素を可変長テンプレート関数に適用する多くの方法があります。これは、インデックス配列を作成する小さなヘルパークラスです。テンプレートのメタプログラミングでよく使用されます。

// ------------- UTILITY---------------
template<int...> struct index_Tuple{}; 

template<int I, typename IndexTuple, typename... Types> 
struct make_indexes_impl; 

template<int I, int... Indexes, typename T, typename ... Types> 
struct make_indexes_impl<I, index_Tuple<Indexes...>, T, Types...> 
{ 
    typedef typename make_indexes_impl<I + 1, index_Tuple<Indexes..., I>, Types...>::type type; 
}; 

template<int I, int... Indexes> 
struct make_indexes_impl<I, index_Tuple<Indexes...> > 
{ 
    typedef index_Tuple<Indexes...> type; 
}; 

template<typename ... Types> 
struct make_indexes : make_indexes_impl<0, index_Tuple<>, Types...> 
{}; 

今、仕事をするコードはそれほど大きくありません：

 // ----------UNPACK Tuple AND APPLY TO FUNCTION ---------
#include <Tuple>
#include <iostream> 

using namespace std;

template<class Ret, class... Args, int... Indexes > 
Ret apply_helper( Ret (*pf)(Args...), index_Tuple< Indexes... >, Tuple<Args...>&& tup) 
{ 
    return pf( forward<Args>( get<Indexes>(tup))... ); 
} 

template<class Ret, class ... Args> 
Ret apply(Ret (*pf)(Args...), const Tuple<Args...>&  tup)
{
    return apply_helper(pf, typename make_indexes<Args...>::type(), Tuple<Args...>(tup));
}

template<class Ret, class ... Args> 
Ret apply(Ret (*pf)(Args...), Tuple<Args...>&&  tup)
{
    return apply_helper(pf, typename make_indexes<Args...>::type(), forward<Tuple<Args...>>(tup));
}

テストは以下のとおりです。

// --------------------- TEST ------------------
void one(int i, double d)
{
    std::cout << "function one(" << i << ", " << d << ");\n";
}
int two(int i)
{
    std::cout << "function two(" << i << ");\n";
    return i;
}

int main()
{
    std::Tuple<int, double> tup(23, 4.5);
    apply(one, tup);

    int d = apply(two, std::make_Tuple(2));    

    return 0;
}

私は他の言語の専門家ではありませんが、これらの言語のメニューにそのような機能がない場合、それを行う方法はないと思います。少なくともC++ではできますが、それほど複雑ではないと思います...

Answer 3

私はこれが最もエレガントなソリューションであることがわかりました（そして最適に転送されます）：

#include <cstddef>
#include <Tuple>
#include <type_traits>
#include <utility>

template<size_t N>
struct Apply {
    template<typename F, typename T, typename... A>
    static inline auto apply(F && f, T && t, A &&... a)
        -> decltype(Apply<N-1>::apply(
            ::std::forward<F>(f), ::std::forward<T>(t),
            ::std::get<N-1>(::std::forward<T>(t)), ::std::forward<A>(a)...
        ))
    {
        return Apply<N-1>::apply(::std::forward<F>(f), ::std::forward<T>(t),
            ::std::get<N-1>(::std::forward<T>(t)), ::std::forward<A>(a)...
        );
    }
};

template<>
struct Apply<0> {
    template<typename F, typename T, typename... A>
    static inline auto apply(F && f, T &&, A &&... a)
        -> decltype(::std::forward<F>(f)(::std::forward<A>(a)...))
    {
        return ::std::forward<F>(f)(::std::forward<A>(a)...);
    }
};

template<typename F, typename T>
inline auto apply(F && f, T && t)
    -> decltype(Apply< ::std::Tuple_size<
        typename ::std::decay<T>::type
    >::value>::apply(::std::forward<F>(f), ::std::forward<T>(t)))
{
    return Apply< ::std::Tuple_size<
        typename ::std::decay<T>::type
    >::value>::apply(::std::forward<F>(f), ::std::forward<T>(t));
}

使用例：

void foo(int i, bool b);

std::Tuple<int, bool> t = make_Tuple(20, false);

void m()
{
    apply(&foo, t);
}

残念ながら、GCC（少なくとも4.6）は「申し訳ありませんが未実装：mangling overload」（これは単にコンパイラがまだC++ 11仕様を完全に実装していないことを意味します）でこれをコンパイルできず、可変テンプレートを使用するため、 MSVCで動作するため、多かれ少なかれ役に立たない。ただし、仕様をサポートするコンパイラがあれば、それが私見の最良のアプローチになります。 （注：GCCの欠陥を回避したり、Boost Preprocessorで実装したりするためにこれを変更するのはそれほど難しくありませんが、優雅さを損なうため、これが私が投稿しているバージョンです。）

GCC 4.7は現在、このコードを問題なくサポートしています。

編集：実際の関数呼び出しを前方に追加して、右辺値参照フォームをサポートします*これはclangを使用している場合（または他の誰かが実際に追加する場合）。

編集：非メンバー適用関数の本体の関数オブジェクトの周りに前方に欠落が追加されました。不足していると指摘してくれたpheedbaqに感謝します。

編集：そして、これは非常に優れているという理由だけでC++ 14バージョンです（実際にはまだコンパイルされていません）：

#include <cstddef>
#include <Tuple>
#include <type_traits>
#include <utility>

template<size_t N>
struct Apply {
    template<typename F, typename T, typename... A>
    static inline auto apply(F && f, T && t, A &&... a) {
        return Apply<N-1>::apply(::std::forward<F>(f), ::std::forward<T>(t),
            ::std::get<N-1>(::std::forward<T>(t)), ::std::forward<A>(a)...
        );
    }
};

template<>
struct Apply<0> {
    template<typename F, typename T, typename... A>
    static inline auto apply(F && f, T &&, A &&... a) {
        return ::std::forward<F>(f)(::std::forward<A>(a)...);
    }
};

template<typename F, typename T>
inline auto apply(F && f, T && t) {
    return Apply< ::std::Tuple_size< ::std::decay_t<T>
      >::value>::apply(::std::forward<F>(f), ::std::forward<T>(t));
}

以下はメンバー関数のバージョンです（あまりテストされていません！）：

using std::forward; // You can change this if you like unreadable code or care hugely about namespace pollution.

template<size_t N>
struct ApplyMember
{
    template<typename C, typename F, typename T, typename... A>
    static inline auto apply(C&& c, F&& f, T&& t, A&&... a) ->
        decltype(ApplyMember<N-1>::apply(forward<C>(c), forward<F>(f), forward<T>(t), std::get<N-1>(forward<T>(t)), forward<A>(a)...))
    {
        return ApplyMember<N-1>::apply(forward<C>(c), forward<F>(f), forward<T>(t), std::get<N-1>(forward<T>(t)), forward<A>(a)...);
    }
};

template<>
struct ApplyMember<0>
{
    template<typename C, typename F, typename T, typename... A>
    static inline auto apply(C&& c, F&& f, T&&, A&&... a) ->
        decltype((forward<C>(c)->*forward<F>(f))(forward<A>(a)...))
    {
        return (forward<C>(c)->*forward<F>(f))(forward<A>(a)...);
    }
};

// C is the class, F is the member function, T is the Tuple.
template<typename C, typename F, typename T>
inline auto apply(C&& c, F&& f, T&& t) ->
    decltype(ApplyMember<std::Tuple_size<typename std::decay<T>::type>::value>::apply(forward<C>(c), forward<F>(f), forward<T>(t)))
{
    return ApplyMember<std::Tuple_size<typename std::decay<T>::type>::value>::apply(forward<C>(c), forward<F>(f), forward<T>(t));
}

// Example:

class MyClass
{
public:
    void foo(int i, bool b);
};

MyClass mc;

std::Tuple<int, bool> t = make_Tuple(20, false);

void m()
{
    apply(&mc, &MyClass::foo, t);
}

Answer 4

C++ 17では、これを行うことができます。

std::apply(the_function, the_Tuple);

これは、std :: experimental :: applyを使用して、すでにClang ++ 3.9で機能します。

the_functionがテンプレート化されている場合、これは機能しないというコメントに応答して、次の回避策があります。

#include <Tuple>

template <typename T, typename U> void my_func(T &&t, U &&u) {}

int main(int argc, char *argv[argc]) {

  std::Tuple<int, float> my_Tuple;

  std::apply([](auto &&... args) { my_func(args...); }, my_Tuple);

  return 0;
}

この回避策は、関数が期待される場所にオーバーロードセットと関数テンプレートを渡すという一般的な問題に対する単純化されたソリューションです。一般的なソリューション（完全転送、constexpr-ness、およびnoexcept-nessを処理するソリューション）をここに示します： https://blog.tartanllama.xyz/passing-overload-sets/ 。

Answer 5

template<typename F, typename Tuple, std::size_t ... I>
auto apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>) {
    return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
}
template<typename F, typename Tuple>
auto apply(F&& f, Tuple&& t) {
    using Indices = std::make_index_sequence<std::Tuple_size<std::decay_t<Tuple>>::value>;
    return apply_impl(std::forward<F>(f), std::forward<Tuple>(t), Indices());
}

これは、index_sequenceを使用してC++ 14ドラフトから適応されます。将来の標準（TS）に適用することを提案するかもしれません。

Answer 6

1）関数の引数として既製のparameter_pack構造体がある場合、次のようにstd :: tieを使用できます。

template <class... Args>
void tie_func(std::Tuple<Args...> t, Args&... args)
{
 std::tie<Args...>(args...) = t;
}

int main()
{
 std::Tuple<int, double, std::string> t(2, 3.3, "abc");

 int i;
 double d;
 std::string s;

 tie_func(t, i, d, s);

 std::cout << i << " " << d << " " << s << std::endl;
}

2）既製のparampack引数がない場合は、このようにタプルを解く必要があります

#include <Tuple>
#include <functional>
#include <iostream>



template<int N>
struct apply_wrap {
    template<typename R, typename... TupleArgs, typename... UnpackedArgs>
    static R applyTuple( std::function<R(TupleArgs...)>& f, const std::Tuple<TupleArgs...>& t, UnpackedArgs... args )
    {
        return apply_wrap<N-1>::applyTuple( f, t, std::get<N-1>( t ), args... );
    }
};


template<>
struct apply_wrap<0>
{
    template<typename R, typename... TupleArgs, typename... UnpackedArgs>
    static R applyTuple( std::function<R(TupleArgs...)>& f, const std::Tuple<TupleArgs...>&, UnpackedArgs... args )
    {
        return f( args... );
    }
};



template<typename R, typename... TupleArgs>
R applyTuple( std::function<R(TupleArgs...)>& f, std::Tuple<TupleArgs...> const& t )
{
    return apply_wrap<sizeof...(TupleArgs)>::applyTuple( f, t );
}



int fac(int n)
{
    int r=1;
    for(int i=2; i<=n; ++i)
        r *= i;
    return r;
}



int main()
{
    auto t = std::make_Tuple(5);
    auto f = std::function<decltype(fac)>(&fac);
    cout << applyTuple(f, t);
}

Answer 7

ニュースは良く見えません。

ちょうどリリースされたドラフト標準 を読み終えたが、これに対する組み込みのソリューションは見当たらないが、奇妙に思える。

そのようなことについて尋ねるのに最適な場所は（まだお持ちでない場合）comp.lang.c ++。moderatedです。これは、定期的に標準の投稿を作成している人もいるからです。

このスレッド をチェックすると、誰かが同じ質問をしているのかもしれません（この場合、この答え全体が少しイライラするでしょう！）提案された。

変換が簡単なため、関数がTupleを受け入れるようにする方が簡単かどうか疑問に思いました。しかし、これは、すべての関数が最大の柔軟性を得るために引数としてタプルを受け入れる必要があることを意味します。したがって、タプルの組み込み拡張を関数引数パックに提供しないという奇妙さを示しています。

更新：上記のリンクは機能しません-これを貼り付けてください：

http://groups.google.com/group/comp.lang.c++.moderated/browse_thread/thread/750fa3815cdaac45/d8dc09e34bbb9661?lnk=gst&q=Tuple+variadic#d8dc09e34bbb9661

Answer 8

この実装はすべて優れています。しかし、メンバー関数コンパイラへのポインタを使用するため、ターゲット関数呼び出しをインライン化できないことがよくあります（少なくともgcc 4.8は、何があってもインライン化できません なぜgccは、決定可能な関数ポインタをインライン化できないのですか？ ）

しかし、関数パラメーターとしてではなく、テンプレート引数としてメンバー関数へのポインターを送信すると、状況が変わります。

/// from https://stackoverflow.com/a/9288547/1559666
template<int ...> struct seq {};
template<int N, int ...S> struct gens : gens<N-1, N-1, S...> {};
template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };

template<typename TT>
using makeSeq = typename gens< std::Tuple_size< typename std::decay<TT>::type >::value >::type;


// deduce function return type
template<class ...Args>
struct fn_type;

template<class ...Args>
struct fn_type< std::Tuple<Args...> >{

    // will not be called
    template<class Self, class Fn>
    static auto type_helper(Self &self, Fn f) -> decltype((self.*f)(declval<Args>()...)){
        //return (self.*f)(Args()...);
        return NULL;
    }
};

template<class Self, class ...Args>
struct APPLY_Tuple{};

template<class Self, class ...Args>
struct APPLY_Tuple<Self, std::Tuple<Args...>>{
    Self &self;
    APPLY_Tuple(Self &self): self(self){}

    template<class T, T (Self::* f)(Args...),  class Tuple>
    void delayed_call(Tuple &&list){
        caller<T, f, Tuple >(forward<Tuple>(list), makeSeq<Tuple>() );
    }

    template<class T, T (Self::* f)(Args...), class Tuple, int ...S>
    void caller(Tuple &&list, const seq<S...>){
        (self.*f)( std::get<S>(forward<Tuple>(list))... );
    }
};

#define type_of(val) typename decay<decltype(val)>::type

#define apply_Tuple(obj, fname, Tuple) \
    APPLY_Tuple<typename decay<decltype(obj)>::type, typename decay<decltype(Tuple)>::type >(obj).delayed_call< \
            decltype( fn_type< type_of(Tuple) >::type_helper(obj, &decay<decltype(obj)>::type::fname) ), \
            &decay<decltype(obj)>::type::fname \
            > \
            (Tuple);

そして使用法：

struct DelayedCall
{  
    void call_me(int a, int b, int c){
        std::cout << a+b+c;
    }

    void fire(){
        Tuple<int,int,int> list = make_Tuple(1,2,3);
        apply_Tuple(*this, call_me, list); // even simpler than previous implementations
    }
};

Linlinableの証明 http://goo.gl/5UqVnC

---

小さな変更で、apply_Tupleを「オーバーロード」できます：

#define VA_NARGS_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, N, ...) N
#define VA_NARGS(...) VA_NARGS_IMPL(X,##__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0)
#define VARARG_IMPL_(base, count, ...) base##count(__VA_ARGS__)
#define VARARG_IMPL(base, count, ...) VARARG_IMPL_(base, count, __VA_ARGS__)
#define VARARG(base, ...) VARARG_IMPL(base, VA_NARGS(__VA_ARGS__), __VA_ARGS__)

#define apply_Tuple2(fname, Tuple) apply_Tuple3(*this, fname, Tuple)
#define apply_Tuple3(obj, fname, Tuple) \
    APPLY_Tuple<typename decay<decltype(obj)>::type, typename decay<decltype(Tuple)>::type >(obj).delayed_call< \
            decltype( fn_type< type_of(Tuple) >::type_helper(obj, &decay<decltype(obj)>::type::fname) ), \
            &decay<decltype(obj)>::type::fname \
            /* ,decltype(Tuple) */> \
            (Tuple);
#define apply_Tuple(...) VARARG(apply_Tuple, __VA_ARGS__)

...

apply_Tuple(obj, call_me, list);
apply_Tuple(call_me, list);       // call this->call_me(list....)

---

さらに、これはテンプレート化された関数で機能する唯一のソリューションです。

Answer 9

私はMSVS 2013RCを評価していますが、場合によってはここで提案された以前のソリューションの一部をコンパイルできませんでした。たとえば、MSVSは、ネームスペースのインブリケーションの制限のために、関数パラメーターが多すぎると「auto」リターンのコンパイルに失敗します（Microsoftに情報を送信して修正しました）。それ以外の場合、関数の戻り値にアクセスする必要がありますが、これはラムダでも実行できます。次の2つの例では同じ結果が得られます。

apply_Tuple([&ret1](double a){ret1 = cos(a); }, std::make_Tuple<double>(.2));
ret2 = apply_Tuple((double(*)(double))cos, std::make_Tuple<double>(.2));

そして、私の前に答えをここに投稿してくれた人たちに感謝します。

template<size_t N>
struct apply_impl {
    template<typename F, typename T, typename... A>
    static inline auto apply_Tuple(F&& f, T&& t, A&&... a)
    -> decltype(apply_impl<N-1>::apply_Tuple(std::forward<F>(f), std::forward<T>(t),
                          std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...)) {
         return apply_impl<N-1>::apply_Tuple(std::forward<F>(f), std::forward<T>(t),
                          std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...);
    }
    template<typename C, typename F, typename T, typename... A>
    static inline auto apply_Tuple(C*const o, F&& f, T&& t, A&&... a)
    -> decltype(apply_impl<N-1>::apply_Tuple(o, std::forward<F>(f), std::forward<T>(t),
                          std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...)) {
         return apply_impl<N-1>::apply_Tuple(o, std::forward<F>(f), std::forward<T>(t),
                          std::get<N-1>(std::forward<T>(t)), std::forward<A>(a)...);
    }
};

// This is a work-around for MSVS 2013RC that is required in some cases
#if _MSC_VER <= 1800 /* update this when bug is corrected */
template<>
struct apply_impl<6> {
    template<typename F, typename T, typename... A>
    static inline auto apply_Tuple(F&& f, T&& t, A&&... a)
    -> decltype(std::forward<F>(f)(std::get<0>(std::forward<T>(t)), std::get<1>(std::forward<T>(t)), std::get<2>(std::forward<T>(t)),
           std::get<3>(std::forward<T>(t)), std::get<4>(std::forward<T>(t)), std::get<5>(std::forward<T>(t)), std::forward<A>(a)...)) {
         return std::forward<F>(f)(std::get<0>(std::forward<T>(t)), std::get<1>(std::forward<T>(t)), std::get<2>(std::forward<T>(t)),
           std::get<3>(std::forward<T>(t)), std::get<4>(std::forward<T>(t)), std::get<5>(std::forward<T>(t)), std::forward<A>(a)...);
    }
    template<typename C, typename F, typename T, typename... A>
    static inline auto apply_Tuple(C*const o, F&& f, T&& t, A&&... a)
    -> decltype((o->*std::forward<F>(f))(std::get<0>(std::forward<T>(t)), std::get<1>(std::forward<T>(t)), std::get<2>(std::forward<T>(t)),
           std::get<3>(std::forward<T>(t)), std::get<4>(std::forward<T>(t)), std::get<5>(std::forward<T>(t)), std::forward<A>(a)...)) {
         return (o->*std::forward<F>(f))(std::get<0>(std::forward<T>(t)), std::get<1>(std::forward<T>(t)), std::get<2>(std::forward<T>(t)),
           std::get<3>(std::forward<T>(t)), std::get<4>(std::forward<T>(t)), std::get<5>(std::forward<T>(t)), std::forward<A>(a)...);
    }
};
#endif

template<>
struct apply_impl<0> {
    template<typename F, typename T, typename... A>
    static inline auto apply_Tuple(F&& f, T&&, A&&... a)
    -> decltype(std::forward<F>(f)(std::forward<A>(a)...)) {
         return std::forward<F>(f)(std::forward<A>(a)...);
    }
    template<typename C, typename F, typename T, typename... A>
    static inline auto apply_Tuple(C*const o, F&& f, T&&, A&&... a)
    -> decltype((o->*std::forward<F>(f))(std::forward<A>(a)...)) {
         return (o->*std::forward<F>(f))(std::forward<A>(a)...);
    }
};

// Apply Tuple parameters on a non-member or static-member function by perfect forwarding
template<typename F, typename T>
inline auto apply_Tuple(F&& f, T&& t)
-> decltype(apply_impl<std::Tuple_size<typename std::decay<T>::type>::value>::apply_Tuple(std::forward<F>(f), std::forward<T>(t))) {
     return apply_impl<std::Tuple_size<typename std::decay<T>::type>::value>::apply_Tuple(std::forward<F>(f), std::forward<T>(t));
}

// Apply Tuple parameters on a member function
template<typename C, typename F, typename T>
inline auto apply_Tuple(C*const o, F&& f, T&& t)
-> decltype(apply_impl<std::Tuple_size<typename std::decay<T>::type>::value>::apply_Tuple(o, std::forward<F>(f), std::forward<T>(t))) {
     return apply_impl<std::Tuple_size<typename std::decay<T>::type>::value>::apply_Tuple(o, std::forward<F>(f), std::forward<T>(t));
}

Answer 10

@Davidのソリューションを拡張して、次のような再帰的なテンプレートを作成できます。

1. （過度に冗長な、imo）integer_sequenceセマンティクスを使用しない
2. 余分な一時テンプレートパラメータint Nを使用して再帰的な繰り返しをカウントしない
3. （静的/グローバルファンクターのオプション）コンパイル時最適化のテンプレートパラメーターとしてファンクターを使用します

例えば。：

template <class F, F func>
struct static_functor {
    template <class... T, class... Args_tmp>
    static inline auto apply(const std::Tuple<T...>& t, Args_tmp... args)
            -> decltype(func(std::declval<T>()...)) {
        return static_functor<F,func>::apply(t, args...,
                std::get<sizeof...(Args_tmp)>(t));
    }
    template <class... T>
    static inline auto apply(const std::Tuple<T...>& t, T... args)
            -> decltype(func(args...)) {
        return func(args...);
    }
};

static_functor<decltype(&myFunc), &myFunc>::apply(my_Tuple);

あるいは、ファンクターがコンパイル時に定義されていない場合（たとえば、_constexprファンクターインスタンス、またはラムダ式）、クラステンプレートパラメーターの代わりに関数パラメーターとして使用し、実際に包含クラスを完全に削除できます。 ：

template <class F, class... T, class... Args_tmp>
inline auto apply_functor(F&& func, const std::Tuple<T...>& t,
        Args_tmp... args) -> decltype(func(std::declval<T>()...)) {
    return apply_functor(func, t, args..., std::get<sizeof...(Args_tmp)>(t));
}
template <class F, class... T>
inline auto apply_functor(F&& func, const std::Tuple<T...>& t,
        T... args) -> decltype(func(args...)) {
    return func(args...);
}

apply_functor(&myFunc, my_Tuple);

メンバー関数呼び出し可能オブジェクトの場合、上記のコードのいずれかを@Davidの回答と同様に調整できます。

説明

2番目のコードを参照すると、2つのテンプレート関数があります。最初のテンプレート関数は、ファンクターfunc、タイプT...のタプルt、およびタイプArgs_tmp...のパラメーターパックargsを取ります。呼び出されると、tのオブジェクトをパラメーターパックの先頭（0）から末尾まで1つずつ再帰的に追加し、新しいインクリメントされたパラメーターパックで関数を再度呼び出します。

2番目の関数のシグネチャは、パラメータパックargsにT...型を使用することを除いて、最初の関数とほぼ同じです。したがって、最初の関数のargsがtからの値で完全に満たされると、その型はT...（psuedo-code、typeid(T...) == typeid(Args_tmp...)）になり、コンパイラは代わりに2番目のオーバーロードを呼び出します関数。次にfunc(args...)を呼び出します。

静的ファンクターの例のコードは同様に機能し、代わりにファンクターがクラステンプレート引数として使用されます。

Answer 11

これはどう：

// Warning: NOT tested!
#include <cstddef>
#include <Tuple>
#include <type_traits>
#include <utility>

using std::declval;
using std::forward;
using std::get;
using std::integral_constant;
using std::size_t;
using std::Tuple;

namespace detail
{
    template < typename Func, typename ...T, typename ...Args >
    auto  explode_Tuple( integral_constant<size_t, 0u>, Tuple<T...> const &t,
     Func &&f, Args &&...a )
     -> decltype( forward<Func>(f)(declval<T const>()...) )
    { return forward<Func>( f )( forward<Args>(a)... ); }

    template < size_t Index, typename Func, typename ...T, typename ...Args >
    auto  explode_Tuple( integral_constant<size_t, Index>, Tuple<T...> const&t,
     Func &&f, Args &&...a )
     -> decltype( forward<Func>(f)(declval<T const>()...) )
    {
        return explode_Tuple( integral_constant<size_t, Index - 1u>{}, t,
         forward<Func>(f), get<Index - 1u>(t), forward<Args>(a)... );
    }
}

template < typename Func, typename ...T >
auto  run_Tuple( Func &&f, Tuple<T...> const &t )
 -> decltype( forward<Func>(f)(declval<T const>()...) )
{
    return detail::explode_Tuple( integral_constant<size_t, sizeof...(T)>{}, t,
     forward<Func>(f) );
}

template < typename Tret, typename ...T >
Tret  func_T( Tuple<T...> const &t )
{ return run_Tuple( &func<Tret, T...>, t ); }

run_Tuple関数テンプレートは、指定されたTupleを受け取り、その要素を指定された関数に個別に渡します。ヘルパー関数テンプレートexplode_Tupleを再帰的に呼び出すことにより、作業を実行します。 run_TupleがTupleのサイズをexplode_Tupleに渡すことが重要です。その数は、抽出する要素の数のカウンターとして機能します。

タプルが空の場合、run_Tupleは、他の唯一の引数としてリモート関数を使用してexplode_Tupleの最初のバージョンを呼び出します。リモート関数は引数なしで呼び出され、完了です。タプルが空でない場合、リモート関数とともに、explode_Tupleの2番目のバージョンに大きい数値が渡されます。同じ引数を使用して、explode_Tupleの再帰呼び出しが行われます。ただし、カウンター番号が1つ減り、最後のTuple要素がリモート関数の後に引数として追加されます。再帰呼び出しでは、カウンターがゼロではなく、カウンターが再び減少して別の呼び出しが行われ、次の参照されない要素がリモート関数の後、ただし他の挿入された引数の前に引数リストに挿入されるか、カウンターが到達しますゼロで、リモート関数がallで呼び出され、その後に累積された引数。

関数テンプレートの特定のバージョンを適切に強制する構文があるかどうかはわかりません。関数へのポインタを関数オブジェクトとして使用できると思います。コンパイラが自動的に修正します。