सी ++ के मुहावरे। प्रकार मिटाना

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

प्रेरणा

एक कंटेनर में एक दूसरे से असंबंधित प्रकार की वस्तुओं को कैसे रखा जाए? उदाहरण के लिए, विकल्प कमांड लाइन से तुरंत अलग-अलग प्रकारों में "विघटित" हो जाते हैं और एक एकल कंटेनर में डाल दिए जाते हैं। या केवल एक प्रतिबंध के साथ एक वस्तु "कुछ" के अंदर एक वस्तु को स्टोर करने के लिए - संग्रहीत "कुछ" पर "()" ऑपरेटर की उपस्थिति? कैसे, सामान्य मामले में, किसी वस्तु के प्रकार को किसी अन्य वस्तु के पीछे छिपाकर, किसी वस्तु के प्रकार को "मिटाना"?

शून्य *

वास्तव में, C ++ में एक अंतर्निहित तंत्र है जो आपको एक सामान्य प्रकार के पीछे किसी भी वस्तु के प्रकार को छिपाने की अनुमति देता है। यह C पॉइंटर शून्य * से विरासत में मिला है।

उदाहरण के लिए, इसका उपयोग किया जा सकता है:

struct A{ void foo(); }; struct B{ int bar(double); }; A a; B b; std::vector<void*> v; v.push_back(&a); v.push_back(&b); static_cast<A*>(v[0])->foo(); static_cast<B*>(v[1])->bar(3.5); 

या तो:

 class void_any { public: void_any(const void* h, size_t size) : size_(size) { h_ = std::malloc(size); std::memcpy(h_, h, size); } void get(void*& h) { h = std::malloc(size_); std::memcpy(h, h_, size_); } ~void_any(){ std::free(h_); } private: size_t size_; void* h_; }; int some_int=675321; void_any va(&some_int, sizeof(int)); void* pi; va.get(pi); std::cout << *(int*)pi << std::endl; 

ऐसी योजना काम करेगी, लेकिन मुझे लगता है कि इसके नुकसान स्पष्ट हैं। कास्टिंग करते समय आप एक गलती कर सकते हैं, गलत आकार को कंस्ट्रक्टर को पास कर सकते हैं, आप इसका उपयोग rvalue अभिव्यक्तियों के साथ नहीं कर सकते। हम उपयोगकर्ता को यह याद दिलाते हैं कि पॉइंटर में किस प्रकार का ऑब्जेक्ट स्टोर किया गया है और "मैन्युअल रूप से" इसे इस प्रकार में डाला गया है। खैर, सबसे महत्वपूर्ण दोष, शायद यह है कि हम किसी भी तरह से जिस भाषा में लिख रहे हैं, उस प्रकार की प्रणाली का उपयोग नहीं करते हैं। यह एक पेचकश के साथ एक कील को हथौड़ा करने जैसा है। यह संभव है, लेकिन असुविधाजनक है। तो क्या करें?

पैटर्न और वंशानुक्रम

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

 template <typename T> struct some_t{}; some_t<int> s1; some_t<double> s2; 

ऊपर के टुकड़े में, s1 और s2 तात्कालिकता के बाद पूरी तरह से अलग, असंबंधित प्रकार की वस्तुएं हैं।
सौभाग्य से, C ++ सिर्फ टेम्पलेट्स तक सीमित नहीं है। और विरासत और गतिशील बहुरूपता हमारी सहायता के लिए आएगी। कैसे समझने के लिए अगला भाग पढ़ें।

कार्यान्वयन

तो, शब्दों से कार्रवाई तक। यह हमारे लिए पहले से ही स्पष्ट है कि हमारा "आवरण" एक टेम्पलेट नहीं होना चाहिए, लेकिन यह निर्माणकर्ता में किसी भी प्रकार की वस्तु को स्वीकार करने में सक्षम होना चाहिए। यह कैसे संभव है? यह सही है, टेम्पलेट कंस्ट्रक्टर का उपयोग करना।

 class any { public: template<typename T> any(const T& t); //… }; 

लेकिन अब यह कैसे बचा जाए कि हमें कंस्ट्रक्टर में क्या पारित किया गया था? हमारी कक्षा को टी टाइप करने वाले कंस्ट्रक्टर के बारे में कुछ भी पता नहीं है, इसलिए हम इस तरह नहीं लिख सकते हैं:

 class any { //... private: T t_; }; 

इस समस्या को हल करने के लिए, हम एक सूचक को एक सार सहायक संरचना में संग्रहीत करेंगे, और इसे हमें कन्स्ट्रक्टर टी में दे देंगे, हम इसे टेम्पलेट संरचना को दे देंगे जो सार सहायक आधार से विरासत में मिली है।

 class any { public: any(const T& t) : held_(new holder<T>(t)){} //… private: struct base_holder { virtual ~base_holder(){} }; template<typename T> struct holder : base_holder { holder(const T& t) : t_(t){} T t_; }; private: base_holder* held_; }; 

बहुत बढ़िया! अब हम कक्षा "किसी भी" में किसी भी प्रकार की एक वस्तु को बचा सकते हैं। मामला छोटा है, अब बचाई गई वस्तु को, यदि आवश्यक हो, तो किसी तरह से हमारे रैपर के आंत्र से "निकाल" लिया जाए। इसके लिए, दुर्भाग्य से, हमें RTTI का उपयोग करना होगा। हम एक फ़ंक्शन जोड़ते हैं जो हमारे सहायक संरचनाओं में संग्रहीत मूल्य के प्रकार के बारे में जानकारी देता है।

 struct base_holder { //... virtual const std::type_info& type_info() const = 0; }; template<typename T> struct holder : base_holder { //... const std::type_info& type_info() const { return typeid(t_); } }; 

अब मूल वस्तु को वापस करने के लिए एक फ़ंक्शन लिखना मुश्किल नहीं है।

 template<typename U> U cast() const { if(typeid(U) != held_->type_info()) throw std::runtime_error("Bad any cast"); return static_cast<holder<U>* >(held_)->t_; } 

दुर्भाग्य से RTTI का उपयोग क्यों किया जाना चाहिए? क्योंकि, मैं समय संकलन करने के लिए टाइप जाँच को स्थानांतरित करने के लिए कुछ इस तरह लिखना चाहूंगा:

 U cast(typename std::enable_if<std::is_same<U, decltype( static_cast<holder<U>* >(held_)->t_)>::value>::type* = 0) const { return static_cast<holder<U>* >(held_)->t_; } 

यह समाधान उपयुक्त क्यों नहीं है? तथ्य यह है कि

 std::is_same<U, decltype(static_cast<holder<U>* >(held_)->t_)>::value 

वास्तव में हमेशा सही रहेगा, भले ही धारक में वास्तव में किस प्रकार की वस्तु संग्रहीत हो। ऐसा कोड संकलन करेगा और यहां तक ​​कि क्रैश के बिना भी निष्पादित करेगा (यदि आप भाग्यशाली हैं)

 any a(2); a.cast<std::string>(); 

लेकिन परिणाम पूरी तरह से अलग होंगे जो प्रोग्रामर को उम्मीद है।

बूस्ट :: फंक्शन क्लास टाइप इरेज़र के एक ही सिद्धांत का उपयोग करता है। कॉस्मेटिक अंतर यह है कि फ़ंक्शन रिटर्न प्रकारों और तर्कों द्वारा एक टेम्पलेट पैरामीटर है, और एक फ़ंक्शन सहायक संरचनाओं में दिखाई देता है

 virtual return_type operator()(arg_type1, .., arg_typeN); 

लिस्टिंग

 class any { public: template<typename T> any(const T& t) : held_(new holder<T>(t)){} ~any(){ delete held_; } template<typename U> U cast() const { if(typeid(U) != held_->type_info()) throw std::runtime_error("Bad any cast"); return static_cast<holder<U>* >(held_)->t_; } private: struct base_holder { virtual ~base_holder(){} virtual const std::type_info& type_info() const = 0; }; template<typename T> struct holder : base_holder { holder(const T& t) : t_(t){} const std::type_info& type_info() const { return typeid(t_); } T t_; }; private: base_holder* held_; }; int main() { any a(2); std::cout << a.cast<int>() << std::endl; any b(std::string("abcd")); try { std::cout << b.cast<double>() << std::endl; } catch(const std::exception& e) { std::cout << e.what() << std::endl; } return 0; }