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

मेयर्स और अलेक्जेंड्रेस्कु ने लंबे समय से मल्टीमिथोड्स और उनके पुस्तकालय कार्यान्वयन के कुछ दृष्टिकोणों के बारे में लिखा है। लगभग 20 वर्षों के लिए, इन विचारों पर C ++ पर विभिन्न साहित्य में चर्चा की गई है, लेकिन अभी भी एक पूर्ण समाधान तक विकसित नहीं किया गया है जो वास्तविक परियोजनाओं में आसानी से उपयोग किया जा सकता है ...

मैंने इस समस्या के बारे में अपनी दृष्टि और इसे हल करने के तरीके की पेशकश करने के लिए, अपनी किस्मत आजमाने का फैसला किया। परिणाम अकेले हेडर पर एक टेम्पलेट लाइब्रेरी था।
यह C ++ 03 मानक के तहत एक कार्यान्वयन है, शुद्ध C ++ में: बिना किसी कोड जनरेटर या परिवर्धन के। लक्ष्य एक पुस्तकालय है जिसमें एक सरल और सहज ज्ञान युक्त अंतरफलक है जो रनटाइम के समय (और यहां तक कि मूल्य के अनुसार) कार्यों को ओवरलोड करने की क्षमता को महसूस करने के लिए है (यह एक न्यूनतम कार्यक्रम था, अंत में मुझे बहुत सारी अच्छाइयाँ मिलीं)।

परीक्षण ड्राइव के लिए, आपको स्रोतों को डाउनलोड करने की आवश्यकता है, और #include की एक जोड़ी बनाएं।

मैंने सरल से जटिल तक की प्रस्तुति को चुना। इसलिए, इस लेख में मैं पुस्तकालय का उपयोग करने के सबसे सरल तरीके के बारे में बात करूंगा और अब तक मैं कार्यान्वयन तकनीकों के बारे में बात नहीं करूंगा।

मल्टीमिथोड क्या है?

इसके कई पर्यायवाची हैं: एकाधिक प्रेषण, कई प्रकार के स्विचिंग, रनटाइम पर फ़ंक्शन अधिभार। इंटरनेट और साहित्य पर इस विषय पर बहुत सारी जानकारी है, इसलिए, मैं एक ही चीज़ को पार नहीं करूंगा, लेकिन मैं कुछ लिंक प्रदान करूंगा:
अंग्रेजी और रूसी विकिपीडिया।

C ++ में मल्टीमिथोड्स क्यों?

मैं इस मुद्दे का खुलासा नहीं करूंगा।
मैं आपको तुरंत सूचित कर दूंगा कि लक्ष्य मल्टीमिथोड को लागू करने का एक प्रयास था, और सी ++ में उनकी आवश्यकता के औचित्य के साथ अमूर्त तर्क नहीं है। किसी को जरूरत है, लेकिन किसी को नहीं। यदि कोई मुहावरा है, तो कार्यान्वयन का अधिकार मौजूद है, चाहे कोई इसे पसंद करे या नहीं। चूंकि अन्य भाषाओं में भाषा या पुस्तकालय की ओर से ऐसे कार्यान्वयन हैं, इसलिए C ++ बदतर है?
वैसे, सी ++ किसी दिन भाषा पक्ष से मल्टीमिथोड का समर्थन कर सकता है। यहाँ Björn Straustrup की पेशकश है । पहले, सभी को C ++ 0x संस्करण में अपनी उपस्थिति की उम्मीद थी, लेकिन अभी तक इस प्रस्ताव पर ठीक से काम नहीं किया गया है।

अपने आप से मैं जोड़ सकता हूँ। स्ट्रेंसेप की सिफारिश है कि, जब भी संभव हो, आंतरिक सदस्यों के तरीकों के बजाय, मुक्त कार्यों को वरीयता दी जाती है, यदि ऐसा फ़ंक्शन वर्ग के सार्वजनिक इंटरफ़ेस के लिए पर्याप्त है। लेकिन क्या होगा अगर फ़ंक्शन को बहुरूपी तर्क को संभालना चाहिए? हर बार आपको एक नया वर्चुअल तरीका जोड़ना होगा जो पूरे पदानुक्रम (या इसके भाग) को अनुमति देता है। यह डेटा और विधियों के तंग कनेक्शन की एक विशेषता है। मल्टीमिथोड इस निर्भरता से बचने की अनुमति देते हैं, वर्ग पदानुक्रम के साथ हस्तक्षेप किए बिना कार्यक्षमता का विस्तार करने की अनुमति देते हैं। यही है, आंतरिक आभासी तरीकों का उपयोग किए बिना, आप एक बाहरी आभासी विधि बना सकते हैं, और एक से नहीं, बल्कि कई बहुरूपी तर्कों से। सामान्य तौर पर, आवेदन का हिस्सा काफी विस्तृत होता है।

थोड़ा इतिहास

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

mml::make_multimethod(f1, f2,..., fn)

f1, f2, ..., fn फ़ंक्शंस या कॉल करने योग्य ऑब्जेक्ट्स के नाम हैं जिन्हें गतिशील रूप से पुनः लोड करने की आवश्यकता है (यानी, उनसे मल्टीमिथोड इकट्ठा करें)। तर्कों के लिए कोई अतिरिक्त आवश्यकताएं नहीं हैं, make_multimethod एक फ़ंक्शन ऑब्जेक्ट देता है जो डिफ़ॉल्ट मापदंडों के साथ कॉन्फ़िगर किए गए मल्टीमिथोड (गतिशील रूप से अतिभारित फ़ंक्शन) का प्रतिनिधित्व करता है। यह एक पुस्तकालय उपयोगकर्ता में प्रवेश करने के लिए एक कम सीमा है, इसके लिए अतिरिक्त ज्ञान की आवश्यकता नहीं है।
नतीजतन, एक पुस्तकालय का गठन किया गया था, शायद और भी सभ्य, मैंने इसे ट्राइट कहा: एमएमएल - मल्टीमेथोड लाइब्रेरी । यह उसके लिए प्रकाश को देखने का समय है, सबसे अधिक संभावना है, वह किसी के लिए उपयोगी होगा। यह देखते हुए कि लगभग 3 वर्षों में C ++ में मल्टीमिथोड्स के साथ स्थिति कहीं भी स्थानांतरित नहीं हुई है (IMHO, शायद मुझे कुछ पता नहीं है)।

समस्या का बयान

एक मल्टीमिथोड को क्या करना चाहिए यह समझ में आता है। लेकिन उसे यह कैसे करना चाहिए, और, महत्वपूर्ण बात, यह कैसे दिखेगा? मैं मुख्य उद्देश्य पर निर्माण करूँगा - रन टाइम पर ओवरलोड । ऑब्जेक्ट-ओरिएंटेड ओवरलोडिंग क्या है? सामान्य तौर पर, C ++ में संकलन के दौरान फ़ंक्शन ओवरलोड कैसा दिखता है? आइए विश्लेषण करते हैं।
अधिभार नियमों के सभी विवरणों में जाने के बिना (वंशानुक्रम, उपयोग-घोषणाएँ, Koenig की खोज, आदि सहित), एक साधारण उदाहरण पर विचार करें:

 void f(int){} void f(double){} void f(char, void*){}

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

 auto of = f; //      f

भाषा के पास अतिभारित कार्यों के सेट को एक ही वस्तु में संयोजित करने का कोई साधन नहीं है। ओवरलोड के इस रूप को इंकार कर दिया जाता है।
एक वस्तु उन्मुख विकल्प पर विचार करें:

 struct f { void operator()(int) const {} void operator()(double) const {} void operator()(char, void*) const {} }; auto of = f(); //  , of  ,

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

तो, एक वस्तु-उन्मुख शैली में, एक अतिभारित फ़ंक्शन ऑपरेटर () के साथ एक फंक्शनल (उर्फ एक कार्यात्मक वस्तु) है। एमएमएल लाइब्रेरी में एक तैयार उपयोगी टेम्पलेट है जो कई अलग-अलग कॉल करने योग्य संस्थाओं को लपेटता है (ये फ़ंक्शनलर्स, लैम्ब्डा और साधारण कार्यों के लिए पॉइंटर्स हैं) और उनमें से प्रत्येक के लिए ओवरलोडेड ऑपरेटर () का प्रतिनिधित्व करता है। यह एक ऑब्जेक्ट overloaded_function <F1, ... Fn> और एक फ़ंक्शन make_overloaded_function (f1, ..., fn) है, जो अपने तर्कों के प्रकारों के माध्यम से अपने टेम्पलेट के मापदंडों को प्रदर्शित करके एक ऑब्जेक्ट बनाता है।

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

कुल। हमें समस्या का निम्नलिखित कथन मिलता है: एक कॉल करने योग्य इकाई को विकसित करने के लिए जिसमें स्टैटिकली (संकलित समय पर) ओवरलोड कार्यों का एक सेट शामिल होगा, एक कॉल करने योग्य इंटरफ़ेस प्रदान करेगा, जबकि रनटाइम के दौरान सेट से वांछित लक्ष्य स्थिर फ़ंक्शन के लिए आने वाली कॉलों को भेजना।

प्रस्तावित समाधान

मैं स्वयं मल्टीमिथोड के अलावा समस्या के सबसे सामान्य समाधान के लिए कक्षाओं, रणनीतियों, विशेषताओं के वर्गों, facades, एडेप्टर और अन्य उपयोगिताओं का एक सेट प्राप्त करने में कामयाब रहा। लेकिन, क्योंकि परिचयात्मक लेख, अभी के लिए मैं मल्टीमिथोड का उपयोग करने के सबसे आसान तरीके के बारे में बात करूँगा, तथाकथित कम सीमा। ऐसा करने के लिए, मैंने लक्ष्य कॉल करने योग्य संस्थाओं के सेट के आधार पर इसे बनाने के लिए मल्टीमिथोड मुखौटा और एक फ़ंक्शन तैयार किया make_multimethod । पुस्तकालय का मूल प्रेषणकर्ता वर्ग है, जिसकी चर्चा मैं निम्नलिखित लेखों में करूंगा क्योंकि मैं गहराई तक जाता हूं, यह अधिकतम रूप से सामान्यीकृत है और केवल मल्टीमिथोड के कार्यान्वयन तक सीमित नहीं है, मल्टीमिथोड डिस्पैचर के उपयोग को आसान बनाने के लिए एक मुखौटा है।

शायद पर्याप्त तर्क, यह समझने के लिए टिप्पणियों के साथ उदाहरणों का उपयोग करना बेहतर है कि यह कितना सरल है।

उदाहरण के लिए, हमें एक सरल पदानुक्रम की आवश्यकता है। मैं एक क्लासिक उदाहरण का उपयोग करूंगा: एक गेम जिसमें हम अंतरिक्ष यान, क्षुद्रग्रह और अंतरिक्ष स्टेशन टकराएंगे:

अनुक्रम

 struct game_object { virtual ~game_object() { } }; struct space_ship : game_object { }; struct space_station : game_object { }; struct asteroid : game_object { };

सुविधा के लिए, एक ऐसा कार्य जो गेम ऑब्जेक्ट्स में पॉलीमॉर्फिक पॉइंटर्स की एक सरणी लौटाता है:

get_obj_pointers ()

 vector<game_object*>& get_obj_pointers() { static space_ship ship; static asteroid ast; static space_station station; static vector<game_object*> objs; if (objs.empty()) { objs.push_back(&ship); objs.push_back(&ast); objs.push_back(&station); } return objs; }

स्टैटिकली ओवरलोड कार्यों के लक्ष्य का एक सेट:

 const char* collide_go_go(game_object*, game_object*) { return "Unsupported colliding!"; } const char* collide_sh_sh(space_ship*, space_ship*) { return "Space ship collides with space ship"; } const char* collide_sh_as(space_ship*, asteroid*) { return "Space ship collides with asteroid"; } const char* collide_as_sh(asteroid*, space_ship*) { return "Asteroid collides with space ship"; } const char* collide_as_as(asteroid*, asteroid*) { return "Asteroid collides with asteroid"; }

वे क्या अतिभारित हैं, आप पूछते हैं, उनके अलग-अलग नाम हैं। हां, पता लेने की सुविधा के लिए अलग, अलग। अगर किसी को वास्तव में इसकी आवश्यकता है, तो आप एक ही नाम दे सकते हैं, केवल आपको कार्यों का पता लेने पर अस्पष्टता को हल करना होगा।

पहला महत्वपूर्ण बिंदु। एक मल्टीमिथोड बनाएं (आपको हेडर कनेक्ट करने की आवश्यकता है <mml / generation / make_multimethod.hpp>):

 #include <mml/generation/make_multimethod.hpp> auto collide = make_multimethod( collide_go_go , collide_sh_sh , collide_sh_as , collide_as_sh , collide_as_as );

हो गया! टकराना - एक मल्टीमिथोड है। आप ऑटो के बिना कर सकते हैं, तुरंत एक टेम्पलेट फ़ंक्शन का परिणाम पास कर सकते हैं, बढ़ावा दे सकते हैं :: function <const char * (game_object *, game_object *)> टकराना = ... या स्पष्ट रूप से मल्टीमिथोड <...> निर्दिष्ट करें। स्पष्ट रूप से एक प्रकार निर्दिष्ट करना काफी कठिन है, स्वचालित कटौती का उपयोग करना सबसे अच्छा है। इनकैप्सुलेटिंग इन (बूस्ट | std | std :: tr1) :: फ़ंक्शन, आप कुछ विशिष्ट मामलों में कार्यक्षमता और प्रदर्शन में से कुछ खो देंगे (नीचे एक व्याख्यात्मक उदाहरण होगा), लेकिन, सामान्य तौर पर, ज्यादातर मामलों में व्यवहार समान होगा।

दूसरा महत्वपूर्ण बिंदु। हम एक मल्टीमिथोड का उपयोग करते हैं। हम जोड़े में सभी खेल वस्तुओं का सामना करते हैं:

 auto& objs = get_obj_pointers(); for (size_t i = 0; i < objs.size(); ++i) for (size_t j = 0; j < objs.size(); ++j) cout << '\t' << collide(objs[i], objs[j]) << endl;

निष्कर्ष

  Space ship collides with space ship Space ship collides with asteroid Asteroid collides with space ship Asteroid collides with asteroid

कंसोल को आउटपुट दिखाता है कि वास्तव में किसका सामना हुआ। जैसा कि आप देख सकते हैं, पदानुक्रम को किसी विशेष प्रेषण समर्थन की आवश्यकता नहीं है। मल्टीमिथोड किसी वस्तु के वास्तविक गतिशील प्रकार का पता लगाने के लिए डिफ़ॉल्ट रूप से डायनेमिक_का उपयोग करता है। इसलिए, आपको RTTI समर्थन सक्षम के साथ कोड संकलित करना होगा।
प्रभावशीलता का मूल्यांकन करने के लिए, मैं एक pseudocode देता हूं, जब संकलित किया जाता है, कॉल करने के लिए कॉल के समान मशीन कोड देगा (objs [i], objs [j]):

छद्म कोड

 inline const char* collide(game_object* obj1, game_object* obj2) { if (space_ship* sh1 = dynamic_cast<space_ship*>(obj1)) if (space_ship* sh2 = dynamic_cast<space_ship*>(obj2)) return collide_sh_sh(sh1, sh2); else if (asteroid* as2 = dynamic_cast<asteroid*>(obj2)) return collide_sh_as(sh1, as2); else return collide_go_go(sh1, obj2); else if (asteroid* as1 = dynamic_cast<asteroid*>(obj1)) if (space_ship* sh2 = dynamic_cast<space_ship*>(obj2)) return collide_as_sh(as1, sh2); else if (asteroid* as2 = dynamic_cast<asteroid*>(obj2)) return collide_as_as(as1, as2); else return collide_go_go(as1, obj2); else if (space_ship* sh2 = dynamic_cast<space_ship*>(obj2)) return collide_go_go(obj1, sh2); else if (asteroid* as2 = dynamic_cast<asteroid*>(obj2)) return collide_go_go(obj1, as2); else return collide_go_go(obj1, obj2); }

जैसा कि आप देख सकते हैं, रनटाइम पर ओवरहेड को सबसे अच्छे रूप से 2 डायनेमिक_कास्ट द्वारा दर्शाया गया है, सबसे खराब - 4 पर।

लाइब्रेरी पॉलीमॉर्फिक ऑब्जेक्ट्स के लिए पॉइंटर्स के साथ काम करती है: बिल्ट-इन और स्मार्ट और यहां तक कि उपयोगकर्ता-परिभाषित दोनों के साथ। लिंक्स के साथ काम करने के लिए, मैंने मुखौटा ref_multimethod (<mml / जनरेशन / make_ref_multimethod.hpp> में कार्यान्वित) लिखा:

पॉलीमॉर्फिक ऑब्जेक्ट्स के लिए लिंक की एक सरणी बनाने की सुविधा के लिए एक उपयोगिता फ़ंक्शन:

get_objs_refs ()

 boost::ptr_vector<game_object>& get_objs_refs() { static boost::ptr_vector<game_object> objs; if (objs.empty()) { objs.push_back(new space_ship); objs.push_back(new asteroid); objs.push_back(new space_station); } return objs; }

लिंक प्राप्त करने वाले लक्ष्य कार्य:

संकेत के साथ के रूप में एक ही सेट, केवल लिंक स्वीकार करते हैं

 const char* collide_ref_go_go(game_object&, game_object&) { return "Unsupported colliding!"; } const char* collide_ref_sh_sh(space_ship&, space_ship&) { return "Space ship collides with space ship"; } const char* collide_ref_sh_as(space_ship&, asteroid&) { return "Space ship collides with asteroid"; } const char* collide_ref_as_sh(asteroid&, space_ship&) { return "Asteroid collides with space ship"; } const char* collide_ref_as_as(asteroid&, asteroid&) { return "Asteroid collides with asteroid"; }

टकराने वाली वस्तुओं के एक ही चक्र को दोहराने के लिए नहीं, मैंने इसे एक टेम्पलेट फ़ंक्शन में लपेट दिया:

 template <typename F, typename Objs> void collide_tester(F collide, Objs& objs) { for (size_t i = 0; i < 2; ++i) for (size_t j = 0; j < 2; ++j) cout << '\t' << collide(objs[i], objs[j]) << endl; }

एक संदर्भ मल्टीमिथोड बनाएं और उसका उपयोग करें:

 #include <mml/generation/make_ref_multimethod.hpp> collide_tester( make_ref_multimethod( collide_ref_go_go , collide_ref_sh_sh , collide_ref_sh_as , collide_ref_as_sh , collide_ref_as_as ) , get_objs_refs() );

निष्कर्ष

  Space ship collides with space ship Space ship collides with asteroid Asteroid collides with space ship Asteroid collides with asteroid

समय के बराबर छद्म कोड बिंदुओं के साथ पिछले उदाहरण के समान होगा।

मैंने पहले ही कहा है कि कार्यात्मक वस्तुएं एक इनलाइन फ़ंक्शन के संकेत के साथ अनुकूलता की तुलना करती हैं ताकि वे एम्बेड करना आसान हो। इतना ही नहीं, इनमें से अधिकांश वस्तुओं में डेटा सदस्य नहीं होते हैं, इसलिए उन्हें ट्रिकी एम्टी बेस ऑप्टिमाइज़ेशन तकनीक का उपयोग करके कंटेनर की मेमोरी में संग्रहीत किया जा सकता है, जिसका उपयोग पुस्तकालय के आंतों में किया जाता है। यहाँ एक फ़नकार के साथ मल्टीमिथोड इंटरैक्शन का एक उदाहरण है:

 struct collider_sh_as { const char* operator()(space_ship*, asteroid*) const { return "Space ship collides with asteroid"; } }; collide_tester( make_multimethod( collide_go_go , collide_sh_sh , collider_sh_as() , collide_as_sh , collide_as_as ) , get_obj_pointers() );

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

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

एफ :: हस्ताक्षर के माध्यम से एक फंक्शनल प्रकार से एक कार्यात्मक प्रकार प्राप्त करने का प्रयास। इसे निम्नानुसार परिभाषित किया जाना चाहिए:
```
 struct collider_sh_as { typedef const char* signature(space_ship*, asteroid*); ... } 
```
यदि पिछला टाइपफ़ाइड गायब है, तो यह F :: result_type, F :: arg1_type, F :: arg2_type, ..., F :: arg n _type: के माध्यम से फ़ंक्टर के अंदर के प्रकारों को खोजने का प्रयास करता है।
```
 struct collider_sh_as { typedef const char* result_type; typedef space_ship* arg1_type; typedef asteroid* arg2_type; ... } 
```
इस प्रकार, बढ़ावा :: फ़ंक्शन, जो इस तरह के टाइडेफ़ को निर्यात करता है, स्वचालित रूप से समर्थित है।
यदि वे अनुपस्थित हैं, तो यह F :: result_type, F :: argument_type (एक unary function के लिए), F :: first_argument_type, F :: second_argument_type (एक बाइनरी फ़ंक्शन के लिए) के माध्यम से प्रकार खोजने की कोशिश करता है।
```
 struct collider_sh_as { typedef const char* result_type; typedef space_ship* first_argument_type; typedef asteroid* second_argument_type; ... } 
```
या, जो बहुत अधिक सुविधाजनक है:
```
 struct collider_sh_as : std::binary_function<space_ship*, asteroid*, result_type> { ... } 
```
इस प्रकार, std :: unary_function, std :: Binary_function स्वचालित रूप से समर्थित है।
यदि पिछले 3 चरण काम नहीं करते हैं, तो BOOST_TYPEOF का उपयोग किया जाता है। एक गैर-मानक ऑपरेटर () के साथ कोई भी फंक्शनल समर्थित है। इस प्रकार, std :: function और C ++ 11 lambdas समर्थित हैं। कुछ कंपाइलरों को कस्टम प्रकारों को पंजीकृत करना होगा। मुझे अभी भी समझ में नहीं आया कि BOOST_TYPEOF कैसे काम करता है, मैंने उपयोगकर्ता प्रकारों को पंजीकृत नहीं किया, और यह पूरी तरह से MSVC 7.1 और उच्चतर पर पैरामीटर प्रकार प्रदर्शित करता है।

पिछले उदाहरणों में, मल्टीमिथोड को एक ही धमनी के कार्यों से इकट्ठा किया गया था। यह एक पुस्तकालय सीमा नहीं है।
सामान्य तौर पर, लाइब्रेरी 0 से MML_MAX_ARITY तक की एरिटी का समर्थन करती है। MML_MAX_ARITY 5 के लिए डिफ़ॉल्ट। डिफ़ॉल्ट मान को बदला जा सकता है। ऐसा करने के लिए, हेडर को जोड़ने से पहले, आपको एक मैक्रो को परिभाषित करने की आवश्यकता है:

#define MML_MAX_ARITY n
n अधिकतम अरीति है।

उदाहरण के लिए nullary, unary और ternary फ़ंक्शन जोड़ें:

 //   , ,     const char* collide_void() { return "Nothing collides?!"; } //     ,   const char* collide_go(game_object*) { return "Unsupported colliding!"; } const char* collide_sh(space_ship*) { return "Space ship collides with what?!"; } const char* collide_as(asteroid*) { return "Asteroid collides with what?!"; } const char* collide_go_go_go(game_object*, game_object*, game_object*) { return "Unsupported colliding!"; } const char* collide_sh_as_as(space_ship*, asteroid*, asteroid*) { return "Space ship collides with two asteroids"; } const char* collide_sh_as_st(space_ship*, asteroid*, space_station*) { return "Space ship collides with asteroid and space_station"; }

हमें एक नए परीक्षक की आवश्यकता होती है, जो विभिन्न प्रकार की वस्तुओं को धक्का देगा:

 template <typename F, typename Objs> void collide_tester_var_arg(F collide, Objs& objs) { //   cout << '\t' << collide() << endl; // 1  cout << '\t' << collide(objs[0]) << endl; cout << '\t' << collide(objs[1]) << endl; // 2  cout << '\t' << collide(objs[0], objs[0]) << endl; cout << '\t' << collide(objs[0], objs[1]) << endl; // 3  cout << '\t' << collide(objs[0], objs[1], objs[1]) << endl; cout << '\t' << collide(objs[0], objs[1], objs[2]) << endl; }

हम एक मल्टीमिथोड बनाते हैं और उसका उपयोग करते हैं:

 collide_tester_var_arg( make_multimethod( collide_go_go , collide_sh_sh , collide_sh_as , collide_void , collide_go , collide_sh , collide_as , collide_go_go_go , collide_sh_as_as , collide_sh_as_st ) , get_obj_pointers() );

निष्कर्ष

  Nothing collides Space ship collides with what?! Asteroid collides with what?! Space ship collides with space ship Space ship collides with asteroid Space ship collides with two asteroids Space ship collides with asteroid and space_station

इस प्रकार, एक मल्टीमिथोड तर्कों की संख्या के संदर्भ में एक सांख्यिकीय रूप से अतिभारित फ़ंक्शन की तरह व्यवहार करता है।
छद्म कोड में किराया-समकक्ष यहां अधिक दिलचस्प होगा, यह दृढ़ता से तर्कों की संख्या पर निर्भर करता है:

छद्म कोड

 // collide() inline const char* collide() { return collide_void(); } //     ! // collide(objs[0]) // collide(objs[1]) inline const char* collide(game_object* obj) { if (space_ship* sh = dynamic_cast<space_ship*>(obj)) return collide_sh(sh); else if (asteroid* as = dynamic_cast<asteroid*>(obj)) return collide_as(as); else return collide_go(obj); } //    : // min 1 cast // max 2 casts // collide(objs[0], objs[0]) // collide(objs[0], objs[1]) //  ,      : inline const char* collide(game_object* obj1, game_object* obj2) {...} // collide(objs[0], objs[1], objs[1]) // collide(objs[0], objs[1], objs[2]) inline const char* collide(game_object* obj1, game_object* obj2, game_object* obj3) { if (space_ship* sh1 = dynamic_cast<space_ship*>(obj1)) if (space_ship* sh2 = dynamic_cast<space_ship*>(obj2)) if (asteroid* as3 = dynamic_cast<asteroid*>(obj3)) return collide_go_go_go(sh1, sh2, as3); else if (space_station* st3 = dynamic_cast<space_station*>(obj3)) return collide_go_go_go(sh1, sh2, st3); else return collide_go_go_go(sh1, sh2, obj3); else if (asteroid* as2 = dynamic_cast<asteroid*>(obj2)) if (asteroid* as3 = dynamic_cast<asteroid*>(obj3)) return collide_sh_as_as(sh1, as2, as3); else if (space_station* st3 = dynamic_cast<space_station*>(obj3)) return collide_sh_as_st(sh1, as2, st3); else return collide_go_go_go(sh1, as2, obj3); else if (asteroid* as3 = dynamic_cast<asteroid*>(obj3)) return collide_go_go_go(sh1, obj2, as3); else if (space_station* st3 = dynamic_cast<space_station*>(obj3)) return collide_go_go_go(sh1, obj2, st3); else return collide_go_go_go(sh1, obj2, obj3); else if (asteroid* as1 = dynamic_cast<asteroid*>(obj1)) if (space_ship* sh2 = dynamic_cast<space_ship*>(obj2)) if (asteroid* as3 = dynamic_cast<asteroid*>(obj3)) return collide_go_go_go(as1, sh2, as3); else if (space_station* st3 = dynamic_cast<space_station*>(obj3)) return collide_go_go_go(as1, sh2, st3); else return collide_go_go_go(as1, sh2, obj3); else if (asteroid* as2 = dynamic_cast<asteroid*>(obj2)) if (asteroid* as3 = dynamic_cast<asteroid*>(obj3)) return collide_go_go_go(as1, as2, as3); else if (space_station* st3 = dynamic_cast<space_station*>(obj3)) return collide_go_go_go(as1, as2, st3); else return collide_go_go_go(as1, as2, obj3); else if (asteroid* as3 = dynamic_cast<asteroid*>(obj3)) return collide_go_go_go(as1, obj2, as3); else if (space_station* st3 = dynamic_cast<space_station*>(obj3)) return collide_go_go_go(as1, obj2, st3); else return collide_go_go_go(as1, obj2, obj3); else if (space_ship* sh2 = dynamic_cast<space_ship*>(obj2)) if (asteroid* as3 = dynamic_cast<asteroid*>(obj3)) return collide_go_go_go(obj1, sh2, as3); else if (space_station* st3 = dynamic_cast<space_station*>(obj3)) return collide_go_go_go(obj1, sh2, st3); else return collide_go_go_go(obj1, sh2, obj3); else if (asteroid* as2 = dynamic_cast<asteroid*>(obj2)) if (asteroid* as3 = dynamic_cast<asteroid*>(obj3)) return collide_go_go_go(obj1, as2, as3); else if (space_station* st3 = dynamic_cast<space_station*>(obj3)) return collide_go_go_go(obj1, as2, st3); else return collide_go_go_go(obj1, as2, obj3); else if (asteroid* as3 = dynamic_cast<asteroid*>(obj3)) return collide_go_go_go(obj1, obj2, as3); else if (space_station* st3 = dynamic_cast<space_station*>(obj3)) return collide_go_go_go(obj1, obj2, st3); else return collide_go_go_go(obj1, obj2, obj3); } //    : // min 3 casts // max 6 casts

आप बहुरूपी प्रकार और मूल्य प्रकार मिला सकते हैं। मान प्रकार बस के रूप में पारित किया जाएगा।
हम कुछ अतिरिक्त वस्तुनिष्ठ कार्यों का परिचय देते हैं जो कि प्रकार int का तीसरा पैरामीटर ले सकते हैं:

 const char* collide_go_go_int(game_object*, game_object*, int) { return "Unsupported colliding with extra int parameter!"; } const char* collide_sh_as_int(space_ship*, asteroid*, int) { return "Space ship collides with asteroid with extra int parameter"; }

स्पष्टता के लिए, परीक्षक मल्टीमिथोड को प्रेषित करेगा:
2 बहुरूपी प्रकार;
3 बहुरूपी प्रकार;
एक गैर-बहुरूपी प्रकार के साथ 2 बहुरूपी:

 template <typename F, typename Objs> void collide_tester_non_polymorphic_arg(F collide, Objs& objs) { cout << '\t' << collide(objs[0], objs[1]) << endl; cout << '\t' << collide(objs[0], objs[1], objs[2]) << endl; cout << '\t' << collide(objs[0], objs[1], 1) << endl; }

हम पिछले और नए लक्ष्य कार्यों और उपयोग के आधार पर एक मल्टीमिथोड बनाते हैं:

 collide_tester_non_polymorphic_arg( make_multimethod( collide_go_go , collide_sh_sh , collide_sh_as , collide_as_sh , collide_as_as , collide_go_go_go , collide_sh_as_st , collide_sh_as_as , collide_go_go_int , collide_sh_as_int ) , get_obj_pointers() );

निष्कर्ष

  Space ship collides with asteroid Space ship collides with asteroid and space_station Space ship collides with asteroid with extra int parameter

मैंने पहली और दूसरी कॉल के लिए रणथाइम को बराबर दिया, तीसरे पर विचार करें:

छद्म कोड

 // collide(objs[0], objs[1], 1) inline const char* collide(game_object* obj1, game_object* obj2, int n) { if (space_ship* sh1 = dynamic_cast<space_ship*>(obj1)) if (space_ship* sh2 = dynamic_cast<space_ship*>(obj2)) return collide_go_go_int(sh1, sh2, n); else if (asteroid* as2 = dynamic_cast<asteroid*>(obj2)) return collide_sh_as_int(sh1, as2, n); else return collide_go_go_int(sh1, obj2, n); else if (asteroid* as1 = dynamic_cast<asteroid*>(obj1)) if (space_ship* sh2 = dynamic_cast<space_ship*>(obj2)) return collide_go_go_int(as1, sh2, n); else if (asteroid* as2 = dynamic_cast<asteroid*>(obj2)) return collide_go_go_int(as1, as2, n); else return collide_go_go_int(as1, obj2, n); else if (space_ship* sh2 = dynamic_cast<space_ship*>(obj2)) return collide_go_go_int(obj1, sh2, n); else if (asteroid* as2 = dynamic_cast<asteroid*>(obj2)) return collide_go_go_int(obj1, as2, n); else return collide_go_go_int(obj1, obj2, n); } //    : // min 2 casts // max 4 casts

जैसा कि आप देख सकते हैं, गैर-बहुरूपी तर्क अतिरिक्त उपरि का नेतृत्व नहीं करते हैं।

कांस्टेबल और अस्थिर क्वालिफायर पर ओवरलोडिंग भी समर्थित है:

 const char* collide_go_cvgo(game_object*, const volatile game_object*) { return "Unsupported colliding!"; } const char* collide_sh_cas(space_ship*, const asteroid*) { return "Space ship collides with const asteroid"; } const char* collide_sh_vas(space_ship*, volatile asteroid*) { return "Space ship collides with volatile asteroid"; } const char* collide_sh_cvas(space_ship*, const volatile asteroid*) { return "Space ship collides with const volatile asteroid"; } template <typename F, typename Objs> void collide_tester_cv(F collide, Objs& objs) { game_object* object = objs[1]; const game_object* c_object = objs[1]; const volatile game_object* cv_object = objs[1]; cout << '\t' << collide(objs[0], object) << endl; cout << '\t' << collide(objs[0], c_object) << endl; cout << '\t' << collide(objs[0], cv_object) << endl; } collide_tester_cv( make_multimethod( collide_sh_as , collide_go_cvgo , collide_sh_cas , collide_sh_vas , collide_sh_cvas ) , get_obj_pointers() ); }

निष्कर्ष

  Space ship collides with asteroid Space ship collides with const asteroid Space ship collides with const volatile asteroid

, . , , . … :

 template <typename F, typename Objs> void collide_tester_compile_time_optim(F collide, Objs& objs) { space_ship ship; asteroid ast; cout << '\t' << collide(objs[0], &ast) << endl; cout << '\t' << collide(&ship, &ast) << endl; } collide_tester_compile_time_optim( make_multimethod( collide_go_go , collide_sh_sh , collide_sh_as , collide_as_sh , collide_as_as ) , get_obj_pointers() );

निष्कर्ष

  Space ship collides with asteroid Space ship collides with asteroid

 // collide(objs[0], &ast) inline const char* collide(game_object* obj1, asteroid* as2) { if (space_ship* sh1 = dynamic_cast<space_ship*>(obj1)) return collide_sh_as(sh1, as2); else if (asteroid* as1 = dynamic_cast<asteroid*>(obj1)) return collide_as_as(as1, as2); else return collide_go_go(obj1, as2); } //    : // min 1 cast // max 2 casts // collide(&ship, &ast) inline const char* collide(space_ship* sh1, asteroid* as2) { return collide_sh_as(sh1, as2); } //   !

, , .. .
, .
, , , boost::function /*std::function*/. — collide((game_object*)&ship, (game_object*)&ast) — .

, boost::shared_ptr, ( ). boost::shared_ptr <mml/casting/sp_dynamic_caster.hpp>.
एक उदाहरण:

 #include <mml/casting/sp_dynamic_caster.hpp> const char* sp_collide_go_go(game_object*, boost::shared_ptr<game_object>) { return "Unsupported colliding!"; } const char* sp_collide_sh_sh(space_ship*, boost::shared_ptr<space_ship>) { return "Space ship collides with smart_ptr space ship"; } struct sp_collider_sh_as { const char* operator()(space_ship*, boost::shared_ptr<asteroid>) const { return "Space ship collides with smart_ptr asteroid"; } }; template <typename F, typename Objs> void sp_collide_tester(F collide, Objs& objs) { boost::shared_ptr<game_object> obj1(new space_ship); boost::shared_ptr<game_object> obj2(new asteroid); cout << '\t' << collide(objs[0], obj1) << endl; cout << '\t' << collide(objs[0], obj2) << endl; } sp_collide_tester( make_multimethod( sp_collide_go_go , sp_collide_sh_sh , sp_collider_sh_as() ) , get_obj_pointers() );

निष्कर्ष

  Space ship collides with smart_ptr space ship Space ship collides with smart_ptr asteroid

छद्म कोड

 // collide(objs[0], obj1) // collide(objs[0], obj2) inline const char* collide(game_object* obj1, const boost::shared_ptr<game_object>& sp_obj2) { if (space_ship* sh1 = dynamic_cast<space_ship*>(obj1)) if (boost::shared_ptr<space_ship> sp_sh2 = boost::shared_dynamic_cast<space_ship>(sp_obj2)) return sp_collide_sh_sh(sh1, sp_sh2); else if (boost::shared_ptr<asteroid> sp_as2 = boost::shared_dynamic_cast<asteroid>(sp_obj2)) return sp_collider_sh_as()(sh1, sp_as2); else return sp_collide_go_go(obj1, sp_obj2); else if (boost::shared_ptr<space_ship> sp_sh2 = boost::shared_dynamic_cast<space_ship>(sp_obj2)) return sp_collide_go_go(obj1, sp_sh2); else if (boost::shared_ptr<asteroid> sp_as2 = boost::shared_dynamic_cast<asteroid>(sp_obj2)) return sp_collide_go_go(obj1, sp_as2); else return sp_collide_go_go(obj1, sp_obj2); } //    : // min 2 casts // max 3 casts

लाभ

. . , , . . . , .
( 0).
— compile time, .

कमियों

( ). , .. . - . , . , .
, .

उत्पादकता

— dynamic_cast. dynamic_cast . , - . , «fast_cast», dynamic_cast . , . , ?
GUI . (inlining) .
, . Acyclyc Visitor , . dynamic_cast.
, , . ( , ) — .

पर निर्भर करता है

C++ 03 BOOST (headers only) 1.45.0 .

महत्वपूर्ण! «boost» «mml» include- . «boost» «mml» include directories, , .

( Windows):
GCC 3.4.2;
Visual C++ 7.1, 8.0, 9.0, 10.0.

UPD: , , . , . , ( 57 ~190 ). , . , , if-else, .

UPD 2: : , C++ . , . , . mejedi .

. , .

C ++ में मल्टीमिथोड्स। पुस्तकालय कार्यान्वयन। एमएमएल का परिचय

मल्टीमिथोड क्या है?

C ++ में मल्टीमिथोड्स क्यों?

थोड़ा इतिहास

समस्या का बयान

प्रस्तावित समाधान

लाभ

कमियों

उत्पादकता

पर निर्भर करता है

More articles: