Лямбда-функции как члены класса

можно ли принять два разных типа лямбда-функции в качестве членов класса не зная своих аргументов шаблона раньше времени? 

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();
    }

}
7
c++ c++11 functor lambda

4 ответов

Если вы просто хотите построить 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();
    }
}
3

Это по существу кортежа!--3-->. Вы можете видеть, как интерфейс реализован для этого.

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) ); 
}
2

не попытка ответить (мне просто нужен подвиг форматирования), просто вариация предложения Стивена

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.

0

альтернативой ответу Стивена было бы использование промежуточного "зонтичного" класса.

EDIT: просто скомпилировал пример на 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);

 }
0