सी ++ 03 में कोई_एक कार्य करने के लिए सदस्य फ़ंक्शन पास करना (कोई बढ़ावा नहीं, कोई सी ++ 11)

Question

संकलन के नीचे "समाधान" संकलित करता है लेकिन यह वही नहीं है जो मैं चाहता हूं। मैं put सदस्य फ़ंक्शन को for_each और *this पर पास करना चाहता हूं। बूस्ट का उपयोग एक विकल्प नहीं है। क्या इसे सी ++ 03 के भीतर हल किया जा सकता है?

#include <algorithm> 
#include <functional> 
#include <vector> 
using namespace std; 

class Wheel { }; 

class Car { 

public: 

    void process(const vector<Wheel>& wheel) { 

     for_each(wheel.begin(), wheel.end(), *this); 
    } 

    void operator()(const Wheel& w) { put(w); } 

private: 

    void put(const Wheel& w) { } 
}; 

int main() { 

    vector<Wheel> w(4); 

    Car c; 

    c.process(w); 

    return 0; 
} 

Answer 1

हाँ, यह कर सकते हैं, mem_fun और bind1st टेम्पलेट्स के संयोजन का उपयोग:

void process(const vector<Wheel>& wheel) { 
    for_each(wheel.begin(), wheel.end(), bind1st(mem_fun(&Car::put), this)); 
} 

mem_fun करने के लिए कॉल एक नया कार्य उद्देश्य यह है कि दो तर्क में लेता है बनाता है - रिसीवर के रूप में कार्य करने के लिए एक Car* और Wheel, फिर put को रिसीवर के रूप में पहले पैरामीटर और तर्क के रूप में दूसरा पैरामीटर के साथ कॉल करता है। bind1st पर कॉल करने से फिर रिसीवर ऑब्जेक्ट को इस फ़ंक्शन के पहले पैरामीटर के रूप में लॉक कर दिया जाता है।

हालांकि, मुझे लगता है कि आपको इसे काम करने के लिए इस कोड में एक छोटा बदलाव करने की आवश्यकता होगी। bind1st एडेप्टर उन कार्यों के साथ अच्छी तरह से नहीं खेलता है जो कॉन्स्ट्र संदर्भ द्वारा उनके तर्क लेते हैं, इसलिए को put बदलने की आवश्यकता है ताकि संदर्भ के बजाय Wheel मूल्य से लिया जा सके।

Answer 2

निश्चित- आप बस अपना खुद का समकक्ष :: mem_func लिख सकते हैं। टीआर 1 में भी एक है। यदि आप तर्कों की संख्या बढ़ाना चाहते हैं, लेकिन अवधारणात्मक रूप से कठिन नहीं है तो यह थोड़ा दोहराया जा सकता है।

template<typename T, typename mem_func_type> struct mem_func_internal; 
template<typename T, typename Ret> struct mem_func_internal<T, Ret (T::*)()> { 
    typedef Ret(T::* functype)(); 
    T* obj; 
    functype func; 
    Ret operator()() { 
     return obj->*func(); 
    } 
}; 
template<typename T, typename Ret, typename ArgType1> struct mem_func_internal<T, Ret (T::*)(ArgType1) { 
    typedef Ret(T::* functype)(); 
    T* obj; 
    functype func; 
    Ret operator()(ArgType1 arg) { 
     return obj->*func(arg); 
    } 
} 
template<typename T, typename mem_func_type> struct mem_func : public mem_func_internal<T, mem_func_type> { 
    mem_func(T* object, mem_func_type mem_func) 
     : obj(object) 
     , func(mem_func) {} 
}; 
template<typename T, typename mem_func_type> mem_func<T, mem_func_type> bind_mem_func(T* object, mem_func_type func) { 
    return mem_func<T, mem_func_type>(object, func); 
} 
// Usage 
std::for_each(wheel.begin(), wheel.end(), bind_mem_func(this, &Car::put)); 

यह कुछ समय हो गया है क्योंकि मैंने इस तरह कोड लिखा था, इसलिए यह थोड़ा सा हो सकता है। लेकिन यह इसका सारांश है। केवल लैम्ब्डा का उपयोग किए बिना उपयोग उदाहरण लिखना मुश्किल है।

Answer 3

आप mem_fun_ref का उपयोग कर सकते हैं: here देखें।

mem_fun_ref अपने मामले में काम करना चाहिए जहां वस्तुओं की वेक्टर है:

for_each(wheel.begin(), wheel.end(), mem_fun_ref(&Wheel::put)); 

ध्यान दें कि ऊपर के उदाहरण में परिवर्तन put व्हील के एक सदस्य और न कार होने के लिए। यह आपको इस बारे में एक विचार देना चाहिए कि इसका उपयोग कैसे किया जाए।

उपयोग mem_fun यदि आप एक वस्तु की ओर इशारा का एक वेक्टर है