如何迭代参数包

Question

我需要用C ++ 14定义一个具有模板参数包的函数。

函数的呼叫者确保args ...的大小必须是偶数，例如2、4、6 ...，我的功能将传递两到两个函数。

template<typename F, typename F2, typename... Args>
void func(F f, F2 f2, Args&&... params) {
    using params_t = std::tuple<Args...>;
    auto tp = std::make_tuple(params...);
    for (std::size_t i = 0; i < sizeof...(Args); ++i) {
        f(std::get<i>(tp));
        f2(std::get<++i>(tp));
    }
}

// caller
func(f1, f2, "abc", 3, "def", "ppp");

这是不起作用的，因为i不是恒定的表达式。

我该怎么办？这是使用std :: tuple迭代参数包的正确和唯一方法？

Answer 1

要使用std :: tuple在参数包上迭代，通常您会使用 std :: index_sequence 引入一包新的索引，并使用折叠表达式进行实际迭代。类似的东西：

template<typename F, typename F2, typename... Args, std::size_t... I>
void func_impl(F& f, F2& f2, std::tuple<Args...> params, std::index_sequence<I...>) {
    // This would be a fold expression over a comma in C++17:
    /*
    (([&]{}(
        f(std::get<I*2>(params));
        f2(std::get<I*2+1>(params));
    )), ...);
    */
    // C++14 version
    using consume = int[];
    (void) consume{ 0, [&]{
        f(std::get<I*2>(params));
        f2(std::get<I*2+1>(params));
        return 0;
    }()... };
}

template<typename F, typename F2, typename... Args>
void func(F f, F2 f2, Args&&... args) {
    static_assert(sizeof...(args) % 2 == 0, "Must pass a multiple of 2 args to func");
    func_impl(
        f, f2,
        std::forward_as_tuple(std::forward<Args>(args)...),
        std::make_index_sequence<sizeof...(args) / 2>{}
    );
}

但是您也可以通过递归迭代，这在您的情况下可能更容易：

template<typename F, typename F2>
void func(F&& f, F2&& f2) {
    // base case: do nothing
}

template<typename F, typename F2, typename Arg1, typename Arg2, typename... Args>
void func(F&& f, F2&& f2, Arg1&& arg1, Arg2&& arg2, Args&&... args) {
    // recursive case
    f(arg1);
    f2(arg2);
    func(std::forward<F>(f), std::forward<F2>(f2), std::forward<Args>(args)...);
}

Answer 2

这是我在2011年有限的C ++的情况下做的类型的样本：
（没有 lambdas nor std :: tuple ）

#include <iostream>
using namespace std ;

static int count ()
    {
    return 0 ;
    }

template <class HEAD,class...TAIL> int count ( const HEAD & , const TAIL & ...tail )
    {
    return count( tail... )+1 ;
    }


template <class FONCTOR> int apply_fonctor ( const FONCTOR & )
    {
    return 0 ;
    }

template <class FONCTOR,class HEAD,class ...TAIL> int apply_fonctor ( const FONCTOR & f , const HEAD & head , const TAIL&...tail )
    {
    f( head ) ;
    return apply_fonctor( f,tail... )+1 ;
    }

struct Eggs 
    {
    int x ;
    Eggs ( int x )          : x(x)                                           {}
    Eggs ( const Eggs & e ) : x(e.x)                                         { cout << "### Eggs duplicated" ;}
    Eggs & operator= ( const Eggs & e )                                      { cout << "### Eggs copied" ; x = e.x ;}
    template<class OUT> friend OUT & operator<< ( OUT & o , const Eggs & e ) { o << "egg=" << e.x ; return o ;}
    };

struct Functor
    {
    void operator() ( int    p )       const { cout << " [" << p << "] " ;}
    void operator() ( bool   p )       const { cout << " [" << (p?"true":"false") << "] " ;}
    void operator() ( double p )       const { cout << " [" << p << "] " ;}
    void operator() ( const char * p ) const { cout << " [" << p << "] " ;}
    void operator() ( const Eggs & p ) const { cout << " [" << p << "] " ;}
    };

void main ()
    {       
    Eggs e(42) ;
    cout << "count = " << count() << endl ;
    cout << "count = " << count( "just one" ) << endl ;
    cout << "count = " << count( 42,"spam",3.14159,false,e,12345678901234567890ull ) << endl ;

    cout << "Calls of functor :" ;
    Functor f ;
    int nb = apply_fonctor( f,e,123,"bread",true,1.4142 ) ;
    cout << "\n applied to " << nb << endl ;
    //apply_fonctor( f,12345678901234567890ull ) ; // <--- won't commpile because Functor does not handle ULL
    }

有第一个示例执行参数的简单计数，
和第二个样本，演示了如何在每个参数上应用A fuctor 。

NB：最终eggs复制由 ### 在输出中显示。
- ＆gt;没有！

输出应为：

count = 1
count = 6
Calls of functor : [egg=42]  [123]  [bread]  [true]  [1.4142]
 applied to 5```