Lambda 函数作为类成员

Question

是否可以在不提前知道模板参数的情况下接受两种不同类型的 lambda 函数作为类成员？

struct two_functors {
    std::function<???> a;
    std::function<???> b;
    ...
};

这样的事情是可能的：

void main(){
    vector<two_functors> many_functors;

    int a = 2;
    int b = 3;
    double c = 4.7;
    double d = 8.4;

    two_functors add_and_subtract;
    add_and_subtract.a = [a, b](int x, int y){cout << x + y << endl;};
    add_and_subtract.b = [c, d](double x, double y){cout << x - y << endl;};

    two_functors multiply_and_divide;
    multiply_and_divide.a = [c, d](double x, double y){cout << x * y << endl;};
    multiply_and_divide.b = [a, b](int x, int y){cout << x / y << endl;};

    many_functors.push_back(add_and_subtract);
    many_functors.push_back(multiply_and_divide);

    for (auto functors : many_functors){
        functors.a();
        functors.b();
    }

}

Answer 1

如果你只是想在不同的时间构造two_functors，但稍后依次执行它们，你可以只使用捕获的数据。

struct two_functors
{
    function<void ()> a;
    function<void ()> b;
};

int main()
{
    vector<two_functors> many_functors;

    int a = 2;
    int b = 3;
    double c = 4.7;
    double d = 8.4;

    two_functors add_and_subtract {
        [a, b](){cout << a + b << endl;},
        [c, d](){cout << c - d << endl;}
    };

    two_functors multiply_and_divide {
        [c, d](){cout << c * d << endl;},
        [a, b](){cout << a / b << endl;}
    };

    many_functors.push_back(add_and_subtract);
    many_functors.push_back(multiply_and_divide);

    for (auto functors : many_functors){
        functors.a();
        functors.b();
    }
}

Answer 2

本质上是tuple。你可以看到这个接口是如何实现的。

template< class F0, class F1 >
struct two_functors {
   F0 func0;
   F1 func1;
};

template< class F0, class F1 >
two_functors<F0, F1> make_two_functor( F0&& f0, F1&& f1 )
{ 
   // Added [std::forward][2]
   return two_functors<F0,F1>( std::forward<F0>(f0), std::forward<F1>(f1) ); 
}

Answer 3

不是试图回答（我只需要格式化功能），只是 Steven 提议的变体

template<typename A, typename B> 
two_functors<A,B> make_two_functors(A&& a, B&& b) {
   return two_functors<A,B> {a, b};
}

与使用std::forward<T> 相比，这有什么缺点吗？

顺便说一句 - 我不知何故希望 C++11 不再需要这种“制造商”。

Answer 4

史蒂文的答案的替代方法是使用中间“伞”类。

编辑：刚刚在 g++ (GCC) 4.5.3 上编译了一个示例

 #include <functional>
 #include <iostream>

 using namespace std;

 class myfunction
 {

 };

 template <typename T>
 class specificFunction : public myfunction
 {
     public:
     function<T> f;

     specificFunction(function<T> pf)
     {
         f = pf;
     }
 };

 struct two_functors {
     myfunction* a;
     myfunction* b;
 };



int main()
{
     myfunction* f = new specificFunction<void(int,int)> ([](int a, int b) { cout << a << " - " << b << endl; });
     myfunction* f2 = new specificFunction<void(double,int)> ([](double a, int b) { cout << a << " - " << b << endl; });

     two_functors tf;
     tf.a = f;
     tf.b = f2;

     ((specificFunction<void(int,int)>*)(tf.a))->f(4,5);
     ((specificFunction<void(double,int)>*)(tf.b))->f(4.02,5);

 }