दिलचस्प पोस्ट
जावा में JSON को XML में परिवर्तित करना क्या सर्वर-साइड एपीआई के माध्यम से Google Analytics को इवेंट पोस्ट करने का कोई तरीका है? आईफोन निजी लाइब्रेरी के बिना एसएसआईडी मिलता है PHP सत्र आईडी कितना अनूठा है क्या टीसीएचआर अभी भी प्रासंगिक है? MySQL के लिए स्केलिंग समाधान (प्रतिकृति, क्लस्टरिंग) कैसे django टेम्पलेट्स में तार जोड़ने के लिए? कैसे प्रोग्रामैंक खाली ब्राउजर कैश करने के लिए? बहुस्तर पाठ के लिए एक एलीपिसिस लागू करना आईओएस के लिए इवेंट हैंडलिंग – कैसे hitTest: साथएवेंट: और प्वाइंटइनसाइड: साथएवेंट: संबंधित हैं? MySQL, MySQLi और PDO के बीच अंतर क्या है? ग्रहण त्रुटि, हाल ही के अपडेट के बाद आर.जेवा फाइल गायब है टंकिनर कैनवास कैसे गतिशील रूप से विंडो की चौड़ाई में बदलना है? बोवर और एनपीएम के बीच अंतर क्या है? एसक्यूएल के परिणामों को फ़िल्टर करने के तरीके में-कई-रिश्ते के बीच

C ++ टेम्पलेट कंस्ट्रक्टर

मैं बिना किसी तर्क के टेम्पलेट कंस्ट्रक्टर के साथ एक गैर-टेम्पलेट वर्ग रखना चाहता हूं।

जहाँ तक मैं समझता हूं, यह करना असंभव है (क्योंकि यह डिफ़ॉल्ट कन्स्ट्रक्टर के साथ विरोधाभास होगा – क्या मैं सही हूं? ), और समाधान निम्नलिखित है:

class A{ template <typename U> A(U* dummy) { // Do something } }; 

शायद इस (या एक बेहतर समाधान) के लिए एक बेहतर विकल्प है?

धन्यवाद।

वेब के समाधान से एकत्रित समाधान "C ++ टेम्पलेट कंस्ट्रक्टर"

कंस्ट्रक्टर टेम्पलेट को कॉल करते समय टेम्पलेट तर्क को स्पष्ट रूप से निर्दिष्ट करने का कोई तरीका नहीं है, इसलिए उन्हें तर्क कटौती के माध्यम से अनुमानित करना होगा। ऐसा इसलिए है क्योंकि यदि आप कहते हैं:

 Foo<int> f = Foo<int>(); 

<int> टेम्पलेट तर्क सूची Foo , इसके कंस्ट्रक्टर के लिए नहीं कंस्ट्रक्टर टेम्पलेट की तर्क सूची के लिए कहीं नहीं है

आपके समाधान के साथ भी आपको उस कंस्ट्रक्टर टेम्पलेट पर कॉल करने के लिए तर्क को पारित करना होगा। यह बिल्कुल स्पष्ट नहीं है कि आप क्या हासिल करने की कोशिश कर रहे हैं।

आप एक टेम्पलटेड फ़ैक्टरी फ़ंक्शन बना सकते हैं:

 class Foo { public: template <class T> static Foo* create() // could also return by value, or a smart pointer { return new Foo(...); } ... }; 

जहाँ तक मैं समझता हूँ, यह करना असंभव है (क्योंकि यह डिफ़ॉल्ट कन्स्ट्रक्टर के साथ विरोधाभास होगा – क्या मैं सही हूं?)

तुम गलत हो। यह किसी भी तरह से संघर्ष नहीं करता है। आप इसे कभी भी कॉल नहीं कर सकते

कुछ बिंदु:

  • अगर आप किसी भी निर्माता (एक templated एक सहित) घोषित, संकलक एक डिफ़ॉल्ट कन्स्ट्रक्टर घोषित करने से बचना होगा।
  • जब तक आप प्रति-कन्स्ट्रक्टर घोषित नहीं करते हैं (क्लास एक्स के लिए जो X या X& X const & लेता है) कंपाइलर डिफ़ॉल्ट प्रति कन्स्ट्रक्टर उत्पन्न करेगा।
  • यदि आप कक्षा एक्स के लिए एक टेम्पलेट कंस्ट्रक्टर प्रदान करते हैं जो T const & या T या T& लेता है तो कंपाइलर फिर भी एक डिफ़ॉल्ट गैर-टेम्पलेट वाली प्रति-कन्स्ट्रक्टर उत्पन्न करेगा, भले ही आप सोचें कि ऐसा नहीं होना चाहिए क्योंकि जब T = X घोषणा कॉपी कन्स्ट्रक्टर घोषणा से मेल खाता है
  • उत्तरार्द्ध मामले में आप टेम्पलेटेड एक के साथ एक गैर-टेम्पलएटेड कॉपी कन्स्ट्रक्टर प्रदान करना चाह सकते हैं। वे संघर्ष नहीं करेंगे जब एक्स पारित हो जाता है, तो नंट्मप्लेटेड को कहा जाएगा। अन्यथा templated

HTH

 template<class...>struct types{using type=types;}; template<class T>struct tag{using type=T;}; template<class Tag>using type_t=typename Tag::type; 

उपरोक्त सहायक आप मूल्यों के साथ काम करते हैं।

 class A { template<class T> A( tag<T> ); }; 

tag<T> प्रकार एक वेरिएबल है जिसमें कोई भी राज्य नहीं है, इसके अलावा यह कैरी प्रकार है आप इसे एक शुद्ध-प्रकार मान को एक टेम्पलेट फंक्शन में पास करने के लिए और टेम्पलेट फ़ंक्शन द्वारा टाइप किया जा सकता है, इसका उपयोग कर सकते हैं:

 auto a = A(tag<int>{}); 

आप एक से अधिक प्रकार में पारित कर सकते हैं:

 class A { template<class T, class U, class V> A( types<T,U,V> ); }; auto a = A(types<int,double,std::string>{}); 

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

 class C { public: template <typename T> C(T*); }; template <typename T> T* UseType() { static_cast<T*>(nullptr); } 

फिर कंसट्रक्टर के लिए टेम्प्लेट पैरामीटर के रूप में int का उपयोग करके टाइप C का ऑब्जेक्ट बनाने के लिए:

 C obj(UseType<int>()); 

चूंकि आप किसी कन्स्ट्रक्टर को टेम्प्लेट पैरामीटर नहीं दे सकते, इसलिए यह समाधान टेम्पलेट पैरामीटर को सामान्य पैरामीटर में रूपांतरित कर देता है। UseType<T>() को UseType<T>() करते समय UseType<T>() फ़ंक्शन का उपयोग करके कोड को देखकर किसी को स्पष्ट किया जाता है कि उस पैरामीटर का उद्देश्य निर्माता को किस प्रकार का उपयोग करना है यह बताता है।

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

ऐसा कुछ करने की कोशिश करो

 template<class T, int i> class A{ A(){ A(this) } A( A<int, 1>* a){ //do something } A( A<float, 1>* a){ //do something } . . . }; 

यहाँ एक वैकल्पिक हल है

ए के टेम्पलेट उप-वर्ग बी बनाएं। ए के कन्स्ट्रक्टर में निर्माण के टेम्पलेट-तर्क-स्वतंत्र हिस्सा लें। बी के निर्माता में टेम्पलेट-तर्क-निर्भर हिस्सा क्या है