람다가 클래스 멤버로 기능 함

Question

람다 함수의 두 가지 다른 유형을 미리 템플릿 인수를 모른 채로 클래스 멤버로 받아 들일 수 있습니까? 이 같은 것을 할 수 있다는 것을

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

같은 :

본질적으로 tuple의

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

. 인터페이스가 어떻게 구현되는지 볼 수 있습니다.

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의 대답에 대한 대안은 중간 "우산"클래스를 사용하는 것입니다.

편집 : 그냥 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>과 비교하면 단점이 있습니까?

Btw - 어떻게 든 그런 "제조사"에 대한 필요성이 C++ 11에서 사라 졌으면 좋겠다.