सामान्य रूप से दृश्यों के पीछे कैसे काम को बढ़ावा देता है?

Question

बूस्ट सोर्स कोड की समीक्षा करने में काफी समय व्यतीत किए बिना, क्या कोई मुझे एक त्वरित रैंड डाउन दे सकता है कि कैसे बढ़ावा देने के लिए बाध्य किया जाता है?

Answer 1

मैं bind स्रोत के इस टुकड़े की तरह।

bind_template शीर्षलेख operator() परिभाषाओं की सूची में विस्तारित है। उदाहरण के लिए, सबसे सरल:

result_type operator()() 
{ 
    list0 a; 
    BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); 
} 

हम return करने के लिए BOOST_BIND_RETURN मैक्रो फैलता है इस बिंदु पर देख सकते हैं लाइन अधिक return l_(type...) की तरह है।

एक पैरामीटर संस्करण यहाँ है:

template<class A1> result_type operator()(A1 & a1) 
{ 
    list1<A1 &> a(a1); 
    BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0); 
} 

यह बहुत समान है।

listN कक्षा पैरामीटर सूचियों के लिए रैपर हैं। यहां बहुत गहरा जादू चल रहा है कि मैं वास्तव में बहुत ज्यादा समझ में नहीं आता हूं। उन्होंने operator() को अधिभारित किया है जो रहस्यमय unwrap फ़ंक्शन को कॉल करता है। कुछ संकलक विशिष्ट भार के उपेक्षा कर, यह एक बहुत कुछ कर नहीं करता है:

// unwrap 

template<class F> inline F & unwrap(F * f, long) 
{ 
    return *f; 
} 

template<class F> inline F & unwrap(reference_wrapper<F> * f, int) 
{ 
    return f->get(); 
} 

template<class F> inline F & unwrap(reference_wrapper<F> const * f, int) 
{ 
    return f->get(); 
} 

नामकरण परंपरा हो रहा है: Fbind को समारोह पैरामीटर का प्रकार है। R रिटर्न प्रकार है। L पैरामीटर प्रकारों की एक सूची बनता है। कई जटिलताओं भी हैं क्योंकि विभिन्न मानकों के लिए नौ से अधिक अधिभार नहीं हैं। उस पर ज्यादा ध्यान न दें।

Answer 2

मुझे लगता है कि यह एक टेम्प्लेट क्लास है जो तर्क के लिए एक सदस्य चर घोषित करता है जिसे आप बाध्य करना चाहते हैं और शेष तर्कों के लिए ओवरलोड()।

template<class R, class F, class L> class bind_t 
{ 
public: 

    typedef bind_t this_type; 

    bind_t(F f, L const & l): f_(f), l_(l) {} 

#define BOOST_BIND_RETURN return 
#include <boost/bind/bind_template.hpp> 
#undef BOOST_BIND_RETURN 

}; 

आपको बताता है लगभग सभी आप जानना चाहते हैं, वास्तव में:

Answer 3

वैसे, अगर bind_t ढह और boost/bind/bind_template.hpp शामिल करके सरल है, यह आसान की तरह समझने के लिए हो जाता है निम्नलिखित:

template<class R, class F, class L> 
class bind_t 
{ 
    public: 

     typedef bind_t this_type; 

     bind_t(F f, L const & l): f_(f), l_(l) {} 

     typedef typename result_traits<R, F>::type result_type; 
     ... 
     template<class A1> 
      result_type operator()(A1 & a1) 
      { 
       list1<A1 &> a(a1); 
       return l_(type<result_type>(), f_, a, 0); 
      } 
    private: 
     F f_; 
     L l_; 

};