टेम्पलेट जादू CallWithType पैटर्न

शुभ दिन, प्रिय खाबरोवचियों!



इस लेख में, मैं इस बारे में बात करना चाहता हूं कि C ++ में आप संकलन-समय डेटा (प्रकार) को रन-टाइम डेटा (पूर्णांक मान) में कैसे बदल सकते हैं और इसके विपरीत ।



एक उदाहरण:

int nType = ... ;



अगर ( बढ़ावा :: is_base_of < ISettable, / * ... जादुई रूप से nType द्वारा छिपा हुआ प्रकार यहाँ हल करें ... * / > :: मूल्य )

{

// कुछ करो

}

अन्यथा

{

// कुछ और करो

}

यह पूरा विषय यह समझने के उद्देश्य से है कि "nType द्वारा यहां छिपे हुए जादुई प्रकार के समाधान" के बजाय क्या लिखा जाना चाहिए।



यदि आप केवल परिणाम में रुचि रखते हैं, तो अंतिम अनुभाग पर जाएं।

थोड़ा इतिहास

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

int nObjectType = ResolveObjectType ( ... ) ;



बढ़ावा देना :: share_ptr < IObject > pObject = CreateObject ( nObjectType ) ;

इस प्रणाली में तब तक सब कुछ ठीक था जब तक कि यह निश्चित नहीं हो जाता कि कुछ रनटाइम परिस्थितियों में, फॉर्म के रैपर को कुछ वस्तुओं पर लटकाए जाने की आवश्यकता है:

टेम्पलेट < वर्ग TObject >

वर्ग CFilter : सार्वजनिक Tobject

{

वर्चुअल बूल फ़िल्टरवैल्यू ( ... ) { ... } ;

} ;

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



इस प्रकार, रैपर को वैकल्पिक रूप से शामिल करना आवश्यक था। समस्याएँ तुरंत उत्पन्न हुई:

• एक एकल आवरण के अतिरिक्त के साथ, निर्मित वस्तुओं के प्रकार की संख्या लगभग 2 गुना बढ़ गई, क्योंकि आवरण एक प्रकार पर लागू नहीं होता, लेकिन एक निश्चित प्रकार के सेट पर।
• इन नए प्रकारों को जोड़ते समय, मुझे पूरे कोड के सभी स्विच मामलों की तलाश करनी थी

    (आखिरकार, यदि कोई कोड किसी प्रकार की वस्तु पर प्रतिक्रिया करता था, तो उसे अभी भी CFilter <A> का जवाब देना चाहिए, क्योंकि प्रकार अनिवार्य रूप से परिवर्तित नहीं हुआ है, बस नई सुविधाएँ जोड़ी गई हैं)। 

• GetObjectType (...) द्वारा लौटाए गए मूल्य से, मूल प्रकार (मैन्युअल रूप से लिखित स्विच के बिना) को पुनर्स्थापित करना पूरी तरह से असंभव था, जिसने अमूर्त कोड को लिखने की अनुमति नहीं दी, जो कि वस्तु, मानो, कुछ इंटरफ़ेस से विरासत में मिला है। इसलिए, उदाहरण के लिए, कुछ शर्तों के तहत, सीफिल्टर रैपर को ISETable से विरासत में मिली सभी वस्तुओं पर लागू किया जाना चाहिए।
• पहले से ही बनाई गई वस्तुएँ डायनेमिक_कास्ट (बहुत धीमी) का उपयोग किए बिना आमतौर पर उनके वास्तविक प्रकार को निर्धारित नहीं कर सकती थीं।

यह सब महसूस करते हुए, मैं बैठ गया और सोचा। यह पता चला कि मुझे जो कुछ भी करने की ज़रूरत थी, वह सीख गया था कि गेटओबजेक्टटाइप (...) द्वारा लौटाए गए मूल्य के पीछे छिपे हुए प्रकार को कैसे आकर्षित किया जाए, ताकि यह कंपाइलर के लिए स्पष्ट हो, अर्थात्। ताकि आप आत्मा में बातें लिख सकें:

int nType = ... ;



अगर ( बढ़ावा :: is_base_of < ISettable, / * ... जादुई रूप से nType द्वारा छिपा हुआ प्रकार यहाँ हल करें ... * / > :: मूल्य )

{

// कुछ करो

}

अन्यथा

{

// कुछ और करो

}

मेरा पहला विचार: "यह असंभव है!"

साँचा जादू, या असंभव संभव है!

थोड़ा और सोचने के बाद, मैं इस निष्कर्ष पर पहुंचा कि आपको निम्नलिखित दो कार्य लिखने की आवश्यकता है:

//! Tobject के लिए ऑब्जेक्ट ऑब्जेक्ट डिस्क्रिप्टर संवाददाता लौटाता है।

टेम्पलेट < वर्ग TObject >

इनलाइन इंट मेकडस्क्रिप्ट ( ) ;



//! कॉल ncptr के साथ rcFunctor nTypeDescriptor द्वारा छिपाए गए वास्तविक ऑब्जेक्ट प्रकार के लिए।

टेम्पलेट < वर्ग TFunctor >

इनलाइन टाइपनेम का नाम Impl :: ResolveReturnType < TFunctor > :: प्रकार CallWithType ( const TFunctor & rcFunctor, int nTypeDescriptor ) ;

सब कुछ यहाँ स्पष्ट है:

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

आप इसे इस तरह से उपयोग कर सकते हैं (इस उदाहरण में, हम यह निर्धारित करते हैं कि क्या किसी इंटरफ़ेस से विवरणकर्ता द्वारा एन्कोड किया गया प्रकार विरासत में मिला है):

टेम्पलेट < वर्ग TKind >

संरचना IsKindOfHelper

{

टाइप्डिफ बूल

आर ;



इनलाइन बूल ऑपरेटर ( ) ( ... ) कांस्टेबल

{

झूठे लौटना ;

}



इनलाइन बूल ऑपरेटर ( ) ( टीकेइंड * ) कास्ट

{

सच लौटना ;

}

} ;



टेम्पलेट < वर्ग TObject >

इनलाइन बूल IsKindOf ( int nTypeDescriptor )

{

वापसी CallWithType ( IsKindOfHelper < TObject > ( ) , nTypeDescriptor ) ;

}



...



int nType = ... ;



अगर ( IsKindOf < ISettable > ( nType ) )

{

// कुछ करो

}

अन्यथा

{

// कुछ और करो

}

सूची और विवरण लिखें।

तो, चलो कार्यान्वयन के लिए नीचे उतरें। सबसे पहले, हमें कुछ संकलन समय सारणी की आवश्यकता है जो कि प्रकार और प्रकार के विवरणकर्ताओं से मेल खाएगी। यहां सबसे सरल विकल्प लोकी :: टाइपिस्ट है, यह निम्नलिखित फॉर्म की एक संरचना है:

टेम्पलेट < वर्ग टी, कक्षा यू >

संरचना टाइपिस्ट

{

टाइम्डिफ टी हेड ;

टाइप्डिफ़ यू टेल ;

} ;

एक समय में इस संरचना के चिंतन ने मेरे दिमाग को C ++ के बारे में पूरी तरह उलट दिया। आइए देखें कि इसकी आवश्यकता क्यों है। सब कुछ बहुत सरल है: इसकी सहायता से मनमानी लंबाई के प्रकारों की सूची निर्धारित की जाती है:

टाइपिडिफ लोकी :: टाइपिस्ट < int , लोकी :: टाइपिस्ट < चार , लोकी :: टाइपिस्ट < शून्य , लोकी :: NullType >>>

TMyList ;

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

// int MyInt;

लोकी :: TypeAt < TMyList, 0 > :: परिणाम MyInt ;



// चार MyChar;

लोकी :: TypeAt < TMyList, 1 > :: परिणाम MyChar ;



int nIndexOfChar = Loki :: IndexOf < TMyList, char > :: value ;

इन सभी रूपकों को संकलन चरण में "ऊपर" कहा जाता है और निष्पादन के समय ओवरहेड की आवश्यकता नहीं होती है। लोकी के बारे में अधिक जानकारी विकिपीडिया पर पाई जा सकती है, इसमें पुस्तकालय स्रोतों का लिंक भी है। "मॉडर्न डिज़ाइन इन सी ++" (अलेक्जेंड्रेस्कु) पुस्तक में आप यह पता लगा सकते हैं कि यह सब कैसे काम करता है।



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

टाइप सूचियों के माध्यम से एक पैटर्न को लागू करना।

विचार:

  एक निश्चित प्रकार की सूची में सभी ज्ञात ऑब्जेक्ट प्रकारों को सूचीबद्ध करें।  फिर, एक विशेष प्रकार का इंडेक्स एक प्रकार का डिस्क्रिप्टर होगा, लेकिन टाइप डिस्क्रिप्टर को जानने के बाद, आप इसे सूची में देखकर स्वयं ही प्रदर्शित कर सकते हैं।  एकमात्र समस्या निम्नलिखित है: सूचकांक द्वारा प्रकार के अनुमान के लिए, सूचकांक को एक स्थिर (संकलन-समय मान) के रूप में दर्शाया जाना चाहिए, अर्थात।  हमें यह जानने की आवश्यकता है कि संख्यात्मक चर के मानों को उनके संबंधित प्रकार mpl :: int_ <# value #> में कैसे परिवर्तित किया जाए। 

नाम स्थान को बढ़ावा देने का उपयोग करना ;



नामस्थान Impl

{

//! ज्ञात वस्तु प्रकारों की एक सूची।

/ ** वास्तविक दुनिया में यह संरचना टेम्पलेट्स द्वारा निर्मित है। * /

typedef mpl :: सूची < TObjectType1, TObjectType2, TObjectType3 >

TKnownObjectTypes ;



//! ज्ञात वस्तु प्रकारों की गणना।

typedef mpl :: आकार < TKnownAtomTypes > :: प्रकार

TKnownObjectTypesCount ;

}



नामस्थान Impl

{

//! यह मेटाफ़ंक्शन TKnownObjects से TObject का एक सूचकांक देता है।

/ ** अगर टोबेक्ट TKnownObjects में अनुपस्थित है, तो रिटर्न -1 * /

टेम्पलेट < वर्ग TObject >

संरचना MakeDescriptorImpl

: / * यदि * / mpl :: eval_if <

/ * खोजें (TOBject) == अंत * /

is_same <

टाइपनेम mpl :: खोजें < TKnownObjectTypes, Tobject > :: प्रकार ,

mpl :: end < TKnownObjectTypes > :: प्रकार > ,

/ * फिर वापसी -1 * /

mpl :: पहचान < mpl :: int_ < - 1 >> ,

/ * और वापसी दूरी (शुरू, खोजें (TOBject)) * /

mpl :: लागू करें <

mpl :: दूरी <

mpl :: start < TKnownObjectTypes > :: प्रकार ,

mpl :: खोजें < TKnownObjectTypes, _ >> ,

Tobject >> :: प्रकार

{

} ;



//! TFunctor को TobjectType के साथ कॉल करने में मदद करता है *

टेम्पलेट < वर्ग TFunctor >

संरचना CallWithObjectTypeHelperPointerBased

{



जनता :



// typename ResolveReturnType <TFunctor> :: टाइप करने के लिए TFunctor :: R if

// TFunctor :: R typedef मौजूद है, अन्यथा, यह खाली करने के लिए विकसित होता है।

typedef typename ResolveReturnType < TFunctor > :: प्रकार

आर ;



संरक्षित :



कास्ट TFunctor और

m_rcFunctor ;



जनता :



CallWithObjectTypeHelperPointerBased ( const TFunctor & rcFunctor )

: m_rcFunctor ( rcFunctor )

{

}



//! इस फ़ंक्शन को CallWithInt (...) द्वारा कहा जाता है।

टेम्पलेट < वर्ग TIndex >

आर ऑपरेटर ( ) ( TIndex ) कांस्टेबल

{

// इंडेक्स द्वारा ऑब्जेक्ट प्रकार का पता लगाएं

typedef typename mpl :: पर < TKnownObjectTypes, TIndex > :: प्रकार

Tobject ;



// पॉइंटर को पॉइंटर के साथ वास्तविक ऑब्जेक्ट प्रकार के लिए

वापसी m_rcFunctor ( ( TObject * ) NULL ) ;

}



//! इस फ़ंक्शन को CallWithInt (...) द्वारा कहा जाता है।

आर ऑपरेटर ( ) ( mpl :: void_ ) कास्ट

{

// विवरणक टूट गया है, विशेष मूल्य के साथ कॉल फ़नकार

वापसी m_rcFunctor ( mpl :: void_ ( ) ) ;

}

} ;



}



//! रिटर्न टू ऑब्जेक्ट टाइप डिस्क्रिप्टर संवाददाता टूबजेक्ट।

टेम्पलेट < वर्ग TObject >

इनलाइन इंट मेकडस्क्रिप्ट ( )

{

// अज्ञात वस्तु प्रकार के लिए ऑब्जेक्ट प्रकार का विवरण बनाने का प्रयास!

BOOST_STATIC_ASSERT ( Impl :: MakeDescriptorImpl < Tobject > :: value ! = - 1 ) ;



// रिटर्न डिस्क्रिप्टर, यह वास्तव में संकलित समय लगातार उत्पन्न होता है।

वापसी Impl :: MakeDescriptorImpl < TObject > :: मूल्य ;

}



//! TOBject के साथ rcFunctor कॉल करें * nObjectTypeDescriptor के संवाददाता।

टेम्पलेट < वर्ग TFunctor >

इनलाइन टाइपनेम का नाम Impl :: ResolveReturnType < TFunctor > :: प्रकार CallWithType ( const TFunctor & rcFunctor, int nObjectTypeDescriptor )

{

// int के साथ कॉल करेगा

// Impl :: CallWithObjectTypeHelperPointerBased <TFunctor> (rcFunctor)

// functor with mpl :: int_ <N> () तर्क, जहां N संकलन समय स्थिर है

// nObjectTypeDescriptor के मान के अनुरूप।

// अगर nObjectTypeDescriptor <0 || nObjectTypeDescriptor> = TKnownObjectTypesCount

// functor को mpl :: void_ () के साथ बुलाया जाएगा, यह दर्शाता है कि प्रकार का विवरण टूट गया है।

वापसी Impl :: CallWithInt < mpl :: int_ < 0 > , TKnownObjectTypesCount (-

Impl :: CallWithObjectTypeHelperPointerBased < TFunctor > ( rcFunctor ) ,

nObjectTypeDescriptor ) ;

}

मैंने पूरे कोड पर विस्तार से टिप्पणी करने की कोशिश की, हालांकि यह अभी भी काफी जटिल है, इसलिए कुछ टिप्पणियां हैं:



1।

typename ResolveReturnType :: टाइप को कंपाइलर द्वारा TFunctor :: R. के रूप में समझा जाता है। यदि TFunctor :: R एक अमान्य अभिव्यक्ति है (उदाहरण के लिए, यदि प्रकार R की परिभाषा TFunctor में नहीं है), तो ResolveReturnType :: प्रकार की व्याख्या शून्य के रूप में की जाती है। हाँ यह संभव है। नहीं, मैं झूठ नहीं बोल रहा हूँ । कार्यान्वयन को नीचे देखा जा सकता है, जो लिंक कॉलविथआईंट के कार्यान्वयन का वर्णन करता है।



2।

MakeDescriptorImpl सक्रिय रूप से बढ़ावा देने के साथ काम करता है :: mpl और भयभीत दिखता है। स्पष्टता के लिए, टिप्पणियों में stl में समान भाव होते हैं (जो, निश्चित रूप से, संकलन चरण पर लागू नहीं होते हैं)। स्कीम से इंडेंटेशन स्टाइल फटा हुआ है । उन लोगों के लिए जो कार्यात्मक प्रोग्रामिंग भाषाओं से परिचित हैं, आपको बस यह समझने की आवश्यकता है कि C ++ में मेटाप्रोग्रामिंग (टेम्पलेट मैजिक) एक कार्यात्मक भाषा है।



3।

CallWithInt रन-टाइम पूर्णांक मानों को विशिष्ट मानों के विशिष्ट क्षेत्र से संकलन-समय पूर्णांक मानों में परिवर्तित करता है। हम इस फ़ंक्शन को थोड़ी देर बाद कार्यान्वित करेंगे।

  उदाहरण: 42 को mpl में कनवर्ट किया जाता है :: int_ <42> 

4।

यदि कार्यान्वयन mpl :: सूची का उपयोग करने के बजाय, बाइनरी ट्री का उपयोग करने के बजाय अधिक कुशल (संकलन गति के संदर्भ में) होगा। दुर्भाग्य से, मुझे ऐसी संरचनाएं नहीं मिलीं, लेकिन मैंने खुद लंबे समय तक लिखा था। हमारी परियोजना के लिए, यह महत्वपूर्ण नहीं था, 500 से कम प्रकारों की संख्या के साथ यह उस तरह काम करता है।



5।

रनटाइम प्रदर्शन के संदर्भ में, यह कोड बहुत तेज है। CallWithInt, जैसा कि हम नीचे देखेंगे, नेस्टेड स्विच मामलों पर काम करता है, इसलिए, संख्या को एक प्रकार में बदलने के लिए, आपको ऑफसेट के साथ केवल कुछ बिना शर्त कूद की आवश्यकता होती है। उलटा परिवर्तन के लिए, कुछ भी ज़रूरत नहीं है, क्योंकि MakeDescriptor एक स्थिर में inlines।



6।

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

• वस्तुओं की एक मूल सूची सेट की जाती है (उदाहरण में उसी तरह)
• यदि संभव हो तो प्रत्येक आवरण प्रकार की वर्तमान सूची से प्रत्येक प्रकार के बदले में लागू होता है। रैपर खुद निर्धारित करता है कि वह किसी विशेष प्रकार के साथ कैसे संवाद करेगा। बाइंडिंग परिणाम (नया प्रकार) को वर्तमान प्रकार सूची में जोड़ा जाता है।

यह क्रिया संकलन चरण में टेम्प्लेट का उपयोग करके की जाती है, इसमें लगभग 200 लाइनें होती हैं। एक नया आवरण जोड़ने के लिए (और सभी नए प्रकार जो आवरण लाएगा), आपको केवल 10 पंक्तियों को लिखने की आवश्यकता है, जबकि नए प्रकार स्वचालित रूप से मौजूदा कोड द्वारा उठाए जाएंगे।



7।

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

CallWithInt रिलीज़

  यह हमारे लिए अंतिम (सबसे कठिन) कदम उठाने के लिए बना रहता है: एक फ़ंक्शन लिखें जो कि प्रकार mpl के एक फ़ंक्शनल को बुलाएगा :: int_ <N> (), जहां एन रन-टाइम चर के अंदर संग्रहीत मूल्य से मेल खाती है।  यह शायद सबसे कठिन हिस्सा है, क्योंकि  यह वह है जो रनटाइम वैल्यू को टाइप में ट्रांसलेट करता है। 

विचार बहुत सरल है:

  हम स्विच के साथ एक फ़ंक्शन बनाते हैं, एक सौ तत्वों का कहना है, इस फ़ंक्शन को किसी भी फ़नकार को वैल्यू mpl :: int <N> के साथ कॉल करना चाहिए, जहां एन फ़ंक्शन के लिए पारित चर के मूल्य से मेल खाती है।  यदि हमें एक और अंतराल बदलने के लिए कहा जाता है, तो हम बस अतिरिक्त धोखाधड़ी करते हैं: ऑफसेट और डिब्बे में विभाजित।  इसलिए, उदाहरण के लिए, अगर हमें किसी संख्या को अंतराल 56 ... 156 में एक प्रकार में परिवर्तित करने के लिए कहा जाता है, तो आपको बस हर बार उस चर से घटाना होगा, जो हमें 56 में दिया गया था, और फिर, एक प्रकार में परिवर्तित करने के बाद, 56 जोड़ें (लेकिन प्रकार!)  अगर हमें किसी संख्या को अंतराल 200..400 से बदलने के लिए कहा जाता है, तो हमें पहले इसे "100" खंडों में विभाजित करना चाहिए, फिर अनुभाग की संख्या और अनुभाग के भीतर ऑफसेट की गणना करें। 

मुझे लगता है कि मैं इसे बेवजह समझा रहा हूं, इसलिए यहां बहुत अधिक हत्यारा कोड है ।



टिप्पणी:



0।

बहुत सारे मधुमक्खी :(



1।

वास्तविक दुनिया में, स्विच में 100 मामले हैं (मूल्य का प्रयोगात्मक रूप से चयन किया गया था, कोड किसी भी मूल्य के लिए परिचालन है> = 2)।



2।

वास्तविक दुनिया में, मैक्रो द्वारा स्विच मामले उत्पन्न होते हैं।



3।

यह तेजी से काम करता है। बहुत तेज है। आपको इस तरह के क्रूर भावों के लिए भुगतान करना होगा। संकलक स्विच करने के लिए पूंछ पुनरावृत्ति के माध्यम से एक सरल कार्यान्वयन का अनुकूलन नहीं कर सका :(

आवेदन

अब आप यह कर सकते हैं:



1. किसी भी वस्तु को बनाना, वस्तु के प्रकार को ज्ञात प्रकारों की सूची में जोड़ना। पहले, जब नए प्रकार की वस्तुओं को जोड़ते हैं, तो सभी स्विच मामलों को प्रकारों के लिए खोजना आवश्यक था, अब कोई स्विच केस नहीं है, जिसका अर्थ है कि सभी नए प्रकार की वस्तुओं को "बॉक्स से बाहर" का समर्थन किया जाता है। यह उदाहरण एक स्विच केस के गायब होने को दिखाता है।



यह था:

int nObjectType = ResolveObjectType ( ... ) ;



स्विच ( nObjectType )

{

केस 1 :

नया tobject1 ( ) लौटें ;

मामला 2 :

नया TObject2 लौटाएँ ( ) ;

केस 3 :

नई TObject3 लौटें ( ) ;

मामला 4 :

नया TObject4 ( ) लौटें ;

/ * ... 100+ अधिक मामले यहाँ जाते हैं * /

डिफ़ॉल्ट :

वापसी NULL ;

} ;

यह बन गया:

//! यह आवरण वास्तविक वस्तु प्रकार निर्धारित करने की अनुमति देता है।

टेम्पलेट < वर्ग TBase, वर्ग Tobject = TBase >

संरचना CTypeWrapper

: पब्लिक टीबीज़

{

//! रिटर्न इस उदाहरण के लिए डिस्क्रिप्टर संवाददाता टाइप करें।

वर्चुअल इंट टाइपसीस्क्रिप्ट ( ) कांस्टेबल

{

वापसी MakeDescriptor < Tobject > ( ) ;

}

} ;



//! वस्तुओं को बनाने में मदद करता है। दरअसल यह फनकार है, जिसे ऑब्जेक्ट प्रकार के साथ बुलाया जाता है।

वर्ग CreateObjectHelper

{



जनता :



// वापसी प्रकार

टाइपराइफ IObject *

आर ;



निजी :



टेम्पलेट < वर्ग TBase, वर्ग Tobject >

इनलाइन TBase * MakeObject ( ) कास्ट

{

नया CObjectTypeWrapper < TBase, TObject > ( ) लौटें ;

}



जनता :



//! सामान्य मामला

टेम्पलेट < वर्ग TObject >

इनलाइन tobject * ऑपरेटर ( ) ( Tobject * , ... ) const

{

वापसी करें MakeObject < Tobject, TObject > ( ) ;

}



इनलाइन IObject * ऑपरेटर ( ) ( बूस्ट :: mpl :: void_ ) कास्ट

{

मुखर ( "टाइप डिस्क्रिप्टर टूटा हुआ है! यहाँ नहीं होना चाहिए!" )



वापसी NULL ;

}



जनता :



// वस्तुओं के लिए विशेष मामला, IObjectType1 से प्राप्त किया गया

टेम्पलेट < वर्ग TObject >

IObject * ऑपरेटर ( ) ( Tobject * , IObjectType1 * ) कास्ट

{

// ...

}



// IObjectType2 से प्राप्त वस्तुओं के लिए विशेष मामला

टेम्पलेट < वर्ग TObject >

IObject * ऑपरेटर ( ) ( Tobject * , IObjectType2 * ) कास्ट

{

// ...

}

} ;



...



int nObjectType = ResolveObjectType ( ... ) ;



वापसी ऑब्जेक्टटैट्स :: CallDoublePointerBasedFunctorWithObjectType (

CreateObjectHelper ( ) ,

nObjectType ) ;

2. वंशानुक्रम वृक्ष के मध्य स्थित कक्षाओं के व्यवहार को बदलना, वस्तु के वास्तविक प्रकार के आधार पर, बिना डायनेमिक_कास्ट का उपयोग किए बिना (कॉलविटाइप के साथ दृष्टिकोण हमारे वर्ग पदानुक्रम पर लगभग 50 गुना तेज है):

टेम्पलेट < वर्ग TKind >

संरचना IsKindOfHelper

{

टाइप्डफेल बूल

आर ;



इनलाइन बूल ऑपरेटर ( ) ( ... ) कांस्टेबल

{

झूठे लौटना ;

}



इनलाइन बूल ऑपरेटर ( ) ( टीकेइंड * ) कास्ट

{

सच लौटना ;

}

} ;



टेम्पलेट < वर्ग TObject >

इनलाइन बूल IsKindOf ( int nTypeDescriptor )

{

वापसी CallWithType ( IsKindOfHelper < TObject > ( ) , nTypeDescriptor ) ;

}



...



// TypeDescriptor वर्चुअल func है, जो वास्तविक ऑब्जेक्ट प्रकार के डिस्क्रिप्टर को लौटाता है।

// पिछले उदाहरण में दिखाया गया कार्यान्वयन (आपको इस फ़ंक्शन को हाथों से लिखने की आवश्यकता नहीं है)

अगर ( IsKindOf < ISettable > ( यह - > TypeDescriptor ( ) ) )

{

// कुछ करो

}

अन्यथा

{

// कुछ और करो

}

3. एक वेरिएबल पर काम करने की क्षमता जिसमें टाइप डिस्क्रिप्टर होता है सीधे टाइप का। यह निर्धारित करने के लिए प्रक्रिया के दौरान बहुत मदद करता है कि किस प्रकार के ऑब्जेक्ट को बनाने के लिए (यदि प्रकार कई बाहरी कारकों पर निर्भर करता है):

int ApplySomeWrapper ( int nType )

{

bool bShouldBeWrapperApplied = ... ;



अगर ( bhouldBeWrapperApplied )

{

// IsWrapperApplicable CallWithType का उपयोग करके वास्तविक प्रकार के tobject में nType को कनवर्ट करता है

// और कॉल WrapperTraits :: CSomeWrapper :: IsApplicable <TObject> :: मान मेटाफ़ंक्शन

अगर ( IsWrapperApplicable < WrapperTraits :: CSomeWrapper > ( nType ) )

{

// IsWrapperApplicable वास्तविक प्रकार को कॉलविटाइप, कॉल का उपयोग करके Tobject में कनवर्ट करता है,

// कॉल WrapperTraits :: CSomeWrapper :: MakeWrappedType <TObject> :: प्रकार मेटाफ़ंक्शन

// लिपटे हुए प्रकार को हल करने के लिए, फिर इस प्रकार के लिए MakeDescriptor को कॉल करें।

वापसी करें MakeWrappedType < WrapperTraits :: CSomeWrapper > ( nType ) ;

}

}



वापसी nType ;

}