Làm thế nào để vượt qua các đối số bằng cách sử dụng std :: mem_fun

Question

Tôi sẽ biết nếu có một cách để vượt qua đối số bằng cách sử dụng std :: mem_fun? Tôi muốn chính xác rằng tôi có thể có nhiều đối số nhất có thể và rất nhiều chức năng của thành viên.
Vấn đề là tôi đang ở trên một tiêu chuẩn cũ và tôi đang tìm kiếm một cách thức đầy đủ để không được phép trả lời ngay cả khi tôi biết tôi có thể làm điều đó dễ dàng =/

Đây là một chút minh họa làm thế nào tôi muốn sử dụng nó:

#include <list> 
#include <algorithm> 

// Class declaration 
// 
struct Interface { 
    virtual void run() = 0; 
    virtual void do_something(int) = 0; 
    virtual void do_func(int, int) = 0; 
}; 

struct A : public Interface { 
    void run() { cout << "Class A : run" << endl; } 
    void do_something(int foo) { cout << "Class A : " << foo << endl; } 
    void do_func(int foo, int bar) { cout << "Class A : " << foo << " " << bar << endl; } 
}; 

struct B : public Interface { 
    void run() { cout << "Class B : run" << endl; } 
    void do_something(int foo) { cout << "Class B : " << foo << endl; } 
    void do_func(int foo, int bar) { cout << "Class B : " << foo << " " << bar << endl; } 
}; 

// Main 
// 
int main() { 
    // Create A and B 
    A a; 
    B b; 

    // Insert it inside a list 
    std::list<Interface *> list; 
    list.push_back(&a); 
    list.push_back(&b); 

    // This works 
    std::for_each(list.begin(), list.end(), std::mem_fun(&Interface::run)); 

    // But how to give arguments for those member funcs ? 
    std::for_each(list.begin(), list.end(), std::mem_fun(&Interface::do_something)); 
    std::for_each(list.begin(), list.end(), std::mem_fun(&Interface::do_func)); 
    return 0; 
} 

Answer 1

Sử dụng std::bind qua std::bind1st và std::bind2nd

std::for_each(list.begin(), list.end(), 
       std::bind2nd(std::mem_fun(&Interface::do_something),1) // because 1st is this 
      ); 

Thật không may, tiêu chuẩn không giúp cho phiên bản hai đối số và bạn cần phải viết riêng của bạn:

struct MyFunctor 
{ 
    void (Interface::*func)(int,int); 
    int   a; 
    int   b; 

    MyFunctor(void (Interface::*f)(int,int), int a, int b): func(f), a(a), b(b) {} 

    void operator()(Interface* i){ (i->*func)(a,b);} 
}; 

std::for_each(list.begin(), list.end(), 
       MyFunctor(&Interface::do_func, 1, 2) 
      ); 

Answer 2

Xem std::bind1st và std::bind2nd. Chúng khá vụng về và xấu xí để sử dụng, nhưng nếu bạn khăng khăng chỉ sử dụng những gì có mặt trong C++ 03 mà không có bất kỳ bổ sung nào, chúng có khá nhiều thứ sẵn có.

Chỉnh sửa: khi/nếu tôi cần làm điều này, tôi thường làm điều đó với một lớp nhỏ functor thay vì sử dụng std::bind1st và/hoặc std::bind2nd. Điều này không phải là cuối cùng nhiều khác với những gì tạo ra, nhưng (IMO) nó thường dễ đọc hơn.

template<class T> 
class invoke_do_something { 
    int value; 
public: 
    adder(int x) : value(x) {} 
    void operator()(T &t) { 
     t.do_something(value); 
    } 
}; 

std::for_each(list.begin(), list.end(), invoke_do_something(1)); 

Theo tôi, phần lớn thời gian này là loại trợ giúp. Nó xảy ra liên tục sử dụng for_each. Tôi thường thấy rằng với một số suy nghĩ, tôi có thể tìm thấy một thuật toán phù hợp hơn, mà thường xuyên loại bỏ sự cần thiết cho bất cứ điều gì về thứ tự này cả.

Answer 3

Bạn có thể bằng cách liên kết:

using std::placeholders::_1 
int a; 
std::for_each(list.begin(), list.end(), std::bind(&Interface::do_something, _1, a));