हम अपने एसटीडी :: फ़ंक्शन (बूस्ट :: फ़ंक्शन) लिखते हैं

एसटीडी :: फ़ंक्शन और बूस्ट :: फ़ंक्शन क्लास फ़ंक्शंस और फ़ंक्शन ऑब्जेक्ट्स पर उच्च-स्तरीय आवरण हैं। ऐसी कक्षाओं की वस्तुएं आपको दिए गए हस्ताक्षर के साथ फ़ंक्शन और फ़ंक्शंस को संग्रहीत करने और कॉल करने की अनुमति देती हैं, जो सुविधाजनक है, उदाहरण के लिए, कॉलबैक कॉल बनाते समय (उदाहरण के लिए, हम कई हैंडलर पंजीकृत कर सकते हैं, और यह या तो एक विशिष्ट ऑपरेटर के साथ सामान्य फ़ंक्शन या ऑब्जेक्ट हो सकते हैं =)

यदि आप रुचि रखते हैं कि यह कार्यक्षमता कैसे लागू की जाती है, तो कृपया

संक्षिप्त परिचय, उपयोग के उदाहरण

यदि आप बढ़ावा देने से परिचित नहीं हैं :: फ़ंक्शन और एसटीडी :: फ़ंक्शन, तो आप अपने आप को उनके साथ यहां और यहां परिचित कर सकते हैं
std :: फ़ंक्शन c ++ 11 भाषा मानक का हिस्सा है, और gcc-4.7 और msvc-2012 संकलक इसका समर्थन करते हैं (शायद पहले के संस्करणों में भी समर्थन है)। सिद्धांत रूप में, इस लेख के ढांचे में हम कार्यान्वयन को बढ़ावा देने और मानक एक पर पूरी तरह से समान होने पर विचार कर सकते हैं, इसलिए आप किसी भी कार्यान्वयन का उपयोग कर सकते हैं

वास्तव में उपयोग का एक उदाहरण:

int func1() { return 0; } struct callable { int operator() () { return 1; } }; ///... boost::function<int (void)> x; x = func1; int res = x(); //  0    callable c; x = c; res = x(); //  1    

हम कार्यान्वयन के लिए ही पास होते हैं

कार्यान्वयन स्वयं कई चरणों में किया जाएगा:

• सबसे सरल उपयोग-मामला एक फ़ंक्शन पॉइंटर या फ़ंक्शन ऑब्जेक्ट के साथ हमारी ऑब्जेक्ट को इनिशियलाइज़ करने के लिए है और ऑपरेटर को कॉल करता है ()
• असाइनमेंट ऑपरेटरों और कॉपी कंस्ट्रक्टर के लिए समर्थन
• सदस्य समारोह सूचक समर्थन

सरलतम कार्यान्वयन, टाइप इरेज़र की अवधारणा

इस वर्ग का कार्यान्वयन टाइप एरासुरे पैटर्न पर आधारित है। आप यहां और अधिक पढ़ सकते हैं । इसका उद्देश्य यह है कि हम एक ही इंटरफ़ेस के पीछे विभिन्न संस्थाओं (ऑब्जेक्ट्स, पॉइंटर्स, आदि) को "छुपा" सकते हैं जो समान क्षमताओं को प्रदान करते हैं (उदाहरण के लिए, कॉल करें तीन तर्कों के साथ कार्य करता है)। प्रकार के क्षरण को एक पुल के रूप में भी सोचा जा सकता है जो रनटाइम पॉलीमॉर्फिज्म और संकलन-टाइम पॉलीमॉर्फिज़्म को जोड़ता है।

इसलिए, हम कार्यान्वयन के लिए पास होते हैं।
हम C ++ 11 मानक से वैरेडिक टेम्प्लेट का उपयोग करेंगे। उदाहरण के लिए, gcc पहले ही संस्करण 4.3 से इस कार्यक्षमता का समर्थन करता है, इसलिए आप इसे सुरक्षित रूप से उपयोग कर सकते हैं।

हम मूल नहीं होंगे और हमारे क्लास फ़ंक्शन को कॉल करेंगे। जाहिर है, वर्ग टेम्पलेट होगा, यह भी स्पष्ट है कि इसमें एक टेम्पलेट पैरामीटर होगा - जिसे तथाकथित फ़ंक्शन का हस्ताक्षर (प्रकार) कहा जाएगा। टेम्पलेट का कोई सामान्य कार्यान्वयन नहीं है, सभी कार्य टेम्पलेट के आंशिक विशेषज्ञता में होंगे। आंशिक विशेषज्ञता की आवश्यकता है ताकि हम अपने हस्ताक्षर से तर्कों और वापसी मूल्य का उपयोग कर सकें।
कार्यान्वयन खुद:

 template <typename UnusedType> class function; template <typename ReturnType, typename ... ArgumentTypes> class function <ReturnType (ArgumentTypes ...)> { public: function() : mInvoker() {} template <typename FunctionT> function(FunctionT f) : mInvoker(new free_function_holder<FunctionT>(f)) {} ReturnType operator ()(ArgumentTypes ... args) { return mInvoker->invoke(args ...); } private: class function_holder_base { public: function_holder_base() {} virtual ~function_holder_base() {} virtual ReturnType invoke(ArgumentTypes ... args) = 0; }; typedef std::auto_ptr<function_holder_base> invoker_t; template <typename FunctionT> class free_function_holder : public function_holder_base { public: free_function_holder(FunctionT func) : function_holder_base(), mFunction(func) {} virtual ReturnType invoke(ArgumentTypes ... args) { return mFunction(args ...); } private: FunctionT mFunction; }; invoker_t mInvoker; }; 

फ़ंक्शन क्लास फ़ंक्शन हस्ताक्षर के अनुसार ऑपरेटर () को परिभाषित करता है और फ़ंक्शन_होल्डर_बेस क्लास के इनवोक विधि में नियंत्रण स्थानांतरित करता है। इस वर्ग में एक वर्चुअल इनवोक फ़ंक्शन है, जो निर्दिष्ट हस्ताक्षर (इस पैरामीटर के निहितार्थ के अपवाद के साथ) से भी मेल खाता है।
फंक्शन क्लास में एक टेम्प्लेट कंस्ट्रक्टर भी होता है, जो एक तर्क लेता है; इस कंस्ट्रक्टर में, function_holder_base क्लास का वंशज free_function_holder बनता है। यह वंश एक टेम्पलेट वर्ग है - यह पारित तर्क (आमतौर पर एक फ़ंक्शन के लिए एक फ़ाइटर या पॉइंटर) को संग्रहीत करता है। यह इनवोक विधि को भी परिभाषित करता है, जो दिए गए तर्कों के साथ संग्रहित फ़नकार को बुलाता है।

यहाँ C ++ में टेम्प्लेट की कई विशेषताओं पर ध्यान देना आवश्यक है:

• वापसी मूल्य का प्रकार कोई भी हो सकता है (शून्य सहित), अर्थात, निर्माण वापसी mFunction (args ...); रिटर्न वैल्यू शून्य होने पर भी वैध। यह खासतौर पर टेम्प्लेट मेटाप्रोग्रामिंग के लिए किया जाता है, ताकि शून्य प्रकार के लिए विशेषज्ञता का उत्पादन न हो।
• इसी तरह, अगर इनपुट तर्कों की संख्या 0 है (तो पैरामीटर के बिना फ़ंक्शन)।
• हम एक टेम्प्लेट क्लास लिख सकते हैं जो कुछ बेस क्लास का इनहेरिटर्स है (और जरूरी नहीं कि एक टेम्प्लेट एक हो) - यह पूरे टाइप इरेस पैटर्न है

सिद्धांत रूप में, हमें std :: function और boost :: function का एक काम करने योग्य एनालॉग मिला है, हम निम्नलिखित कोड लिख सकते हैं:

 int func2(const int * x, int y) { return (*x) + y; } ///... typedef function<int (const int * , int)> int_function_with_two_args_t; int_function_with_two_args_t f2(func2); int x = 10; cout << "calling function with signature int (const int * , int): " << f2(&x, 20) << endl; 

हम अपनी कक्षा में सुधार करते हैं:

एक नियमित फ़ंक्शन पॉइंटर के व्यवहार को कॉपी करें - असाइनमेंट ऑपरेटर और कॉपी कंस्ट्रक्टर

किसी ऑब्जेक्ट को कॉपी या असाइन करने के लिए, हमें आधार क्लास फ़ंक्शन_होल्डर_बेस में एक पॉइंटर को कॉपी (क्लोन) करने में सक्षम होना चाहिए। ऐसा करने के लिए, हम निम्नानुसार इस वर्ग के इंटरफ़ेस का विस्तार करते हैं:

  class function_holder_base { public: function_holder_base() {} virtual ~function_holder_base(){} virtual ReturnType invoke(ArgumentTypes ... args) = 0; virtual std::auto_ptr<function_holder_base> clone() = 0; private: function_holder_base(const function_holder_base & ); void operator = (const function_holder_base &); }; 

हम अपनी कक्षा को अनुपयोगी बनाते हैं (हम संबंधित ऑपरेटर और कंस्ट्रक्टर को निजी अनुभाग में घोषित करते हैं), और हम क्लोन विधि जोड़ते हैं ताकि वारिस स्वयं सही क्लोनिंग रणनीति का निर्धारण करें।

इसके अलावा, असाइनमेंट ऑपरेटरों और एक कॉपी कंस्ट्रक्टर को फंक्शन क्लास में जोड़ा जाता है:

  function(const function & other) : mInvoker(other.mInvoker->clone()) {} function & operator = (const function & other) { mInvoker = other.mInvoker->clone(); } 

यहां हम auto_ptr और इसके विनाशकारी असाइनमेंट का उपयोग करते हैं।

यह उत्तराधिकारी में क्लोन पद्धति के कार्यान्वयन को लिखने के लिए बना हुआ है - free_function_holder:

  typedef free_function_holder<FunctionT> self_type; virtual invoker_t clone() { return invoker_t(new self_type(mFunction)); } 

बस इतना ही, अब हमारी कक्षा एक नियमित फंक्शन पॉइंटर की तरह व्यवहार करती है, और हम यह कर सकते हैं:

 int func1() { return 0; } ///... typedef function<int (void)> int_function_t; int_function_t f1(func1); cout << "calling function with signature int (void): " << f1() << endl; int_function_t f2; f2 = f1; cout << "calling function after assignment operator with signature int (void): " << f2() << endl; int_function_t f3(f2); cout << "calling function after copying ctor with signature int (void): " << f3() << endl; 

हम अंतिम भाग को पास करते हैं:

सदस्य फ़ंक्शन बिंदुओं के लिए समर्थन जोड़ें

विधि बिंदुओं के लिए समर्थन काफी सीमित था: मैं एक ऑब्जेक्ट पास कर सकता हूं, जिसमें एक विधि सूचक केवल मूल्य द्वारा लागू किया जाता है (मैं भी संदर्भ (कॉन्स्ट और कॉन्स्ट नहीं) और पॉइंटर (कॉस्ट और कॉस्ट नहीं) द्वारा पसंद करूंगा, लेकिन मूल रूप से के लिए इसका एक उदाहरण पर्याप्त होगा।

बूस्ट (एसटीडी) और फ़ंक्शन के हमारे कार्यान्वयन का उपयोग करते समय, हम इस नियम का पालन करते हैं कि पहला तर्क ऑब्जेक्ट होना चाहिए, जिस पर विधि के लिए सूचक लागू किया जाता है, क्रमशः, तर्क अब दो प्रकारों में विभाजित हैं: ऑब्जेक्ट ही और विधि के फैसले। तदनुसार, हमारे पास गारंटी है कि तर्कों की संख्या सख्ती से 0 से अधिक है, और हम इसका आगे उपयोग करेंगे:

  template <typename FunctionType, typename ClassType, typename ... RestArgumentTypes> class member_function_holder : public function_holder_base { public: typedef FunctionType ClassType::* member_function_signature_t; member_function_holder(member_function_signature_t f) : mFunction(f){} virtual ReturnType invoke(ClassType obj, RestArgumentTypes ... restArgs) { return (obj.*mFunction)(restArgs ...); } virtual invoker_t clone() { return invoker_t(new member_function_holder(mFunction)); } private: member_function_signature_t mFunction; }; 

एक निर्माता का एक कार्यान्वयन जो एक संकेतक को एक विधि में ले जाता है, तुच्छ है:

  template <typename FunctionType, typename ClassType> function(FunctionType ClassType::* f) : mInvoker(new member_function_holder<FunctionType, ArgumentTypes ...>(f)) {} 

हमने फंक्शन_होल्डर_बेस के एक और वंशज को विशेष रूप से तरीकों की ओर संकेत किया। वेरिएडिक टेम्प्लेट सुविधा का उपयोग यहां किया जाता है: प्रकारों की एक परिवर्तनीय संख्या (जो एक दीर्घवृत्त द्वारा निर्दिष्ट की जाती है) को एक निश्चित भाग में विभाजित किया जा सकता है, और शेष एक चर लंबाई (जिसमें प्रकार की संख्या निश्चित भाग के आकार से कम है)। कंस्ट्रक्टर में, हम टेम्प्लेट मापदंडों को पास करते हैं, जिसमें एक प्रकार का एक निश्चित भाग होता है - फ़ंक्शन के हस्ताक्षर, और एक मनमाना हिस्सा - बाकी (ये सभी तर्कों के प्रकार हैं), और सदस्य_फंक्शन_होल्डर के कार्यान्वयन में हम कहते हैं कि निश्चित भाग में दो तत्व शामिल हैं - फ़ंक्शन, वर्ग, के हस्ताक्षर। जहां हमारा तरीका स्थित है, और कॉल के लिए सीधे तर्क (यहां हम सिर्फ उपरोक्त गारंटी का उपयोग करते हैं कि सभी तर्कों की संख्या सख्ती से 0 से अधिक है)। इस प्रकार, हम पॉइंटर को निर्माता को विधि में सहेजते हैं, और इसे आह्वान विधि के कार्यान्वयन में कहते हैं।

मैं एक प्रकार के "पॉइंटर को एक विधि" घोषित करने के अत्यंत असुविधाजनक और गैर-सहज तरीके के बारे में और इस तरह की कॉल करने के तरीके के बारे में अलग से कहना चाहूंगा। इस अवसर पर, सी ++ एफएक्यू में चेतावनी दी गई है कि बिंदुओं के साथ काम करने के दौरान सिरदर्द की मात्रा को कैसे कम किया जाए (मैं इस अभिव्यक्ति को सही तरीके से लिखने के लिए आधे घंटे तक गुगली करता हूं)

यहाँ एक उदाहरण है:

 struct Foo { int smth(int x) { return x + 1; } }; ///... typedef function<int (Foo, int)> member_function_t; member_function_t f1 = &Foo::smth; Foo foo; cout << "calling member function with signature int (int): " << f1(foo, 5) << endl; 

निष्कर्ष

वैरेडिक टेम्प्लेट के समर्थन के लिए धन्यवाद, फ़ंक्शन का कार्यान्वयन संक्षिप्त हो गया है, उसी बूस्ट में पुराने कंपाइलरों (जिसमें वैरेडिक टेम्प्लेट नहीं है) का समर्थन करने की आवश्यकता के कारण इस कार्यक्षमता को बूस्टर.प्रोसेसर का उपयोग करके लागू किया गया है (और तर्कों की संख्या की सीमा है - डिफ़ॉल्ट रूप से 10, आप बदल सकते हैं उपयुक्त परिभाषित परिभाषित करके: BOOST_FUNCTION_MAX_ARGS)। मोटे तौर पर, एक तर्क के साथ कार्यों के लिए कार्यान्वयन किया गया था, और फिर प्रीप्रोसेसिंग जादू का उपयोग करके बड़ी संख्या में तर्कों को "क्लोन" किया गया।

एक पूरा उदाहरण यहाँ है।