std :: mem_fun

Question

का उपयोग करके तर्क कैसे गुजर रहा है मुझे पता चलेगा कि std :: mem_fun का उपयोग करके तर्क पारित करने का कोई तरीका है या नहीं? मैं सटीक बनाना चाहता हूं कि मेरे पास जितना संभव हो उतना तर्क हो सकता है और बहुत से सदस्य कार्य हो सकते हैं।
समस्या यह है कि मैं एक पुराने मानक पर हूं और मैं एक पूर्ण एसएलएल रास्ता तलाश रहा हूं इसलिए अगर मुझे पता है कि मैं इसे आसानी से कर सकता हूं तो भी बढ़ावा देने की अनुमति नहीं है =/

यहां थोड़ा सा है मैं कैसे करना चाहते हैं के चित्रण के लिए इसका इस्तेमाल:

#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

std::bind1st के माध्यम से उपयोग std::bind और std::bind2nd

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

दुर्भाग्य से, मानक दो तर्क संस्करण के लिए मदद नहीं करता है और आप अपने खुद के बारे में की जरूरत है:

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

std::bind1st और std::bind2nd देखें। वे उपयोग करने के लिए काफी बेवकूफ और बदसूरत हैं, लेकिन यदि आप केवल बिना किसी जोड़ के सी ++ 03 में मौजूद चीज़ों का उपयोग करने का आग्रह करते हैं, तो वे सब कुछ उपलब्ध हैं।

संपादित करें: कब/अगर मुझे ऐसा करने की ज़रूरत है, तो मैं आमतौर पर std::bind1st और/या std::bind2nd का उपयोग करने के बजाय इसे एक छोटे से मज़ेदार वर्ग के साथ करता हूं। यह अंततः उन उत्पन्न करने वालों से बहुत अलग नहीं है, लेकिन (आईएमओ) यह आम तौर पर अधिक पठनीय है।

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

मेरा स्वयं का लेना यह है कि ज्यादातर समय यह बैंड-एड्स की तरह है। यह लगातार for_each का उपयोग होता है। मुझे आमतौर पर लगता है कि कुछ विचारों के साथ, मुझे एक अधिक उपयुक्त एल्गोरिदम मिल सकता है, जो अक्सर इस आदेश पर किसी भी चीज की आवश्यकता को समाप्त करता है।

Answer 3

आप कर सकते हैं जुड़ कर:

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