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

史蒂文答案的另一种选择是使用中级“伞”类。

编辑：刚编译了一个关于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);

 }

Answer 4

不是尝试回答（我只需要格式化专长），只是史蒂文提案的变体

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而消失。

Lambda用作类成员

4 个答案: