🎑 🔘 ♏️ C ++ में सेटर और गेट्टर के साथ नाम से सुलभ फ़ील्ड फ़ील्ड 💃 🕴🏾 🌠

जैसा कि आप जानते हैं, सी ++ में एक नियंत्रित पहुंच वाले वर्ग के क्षेत्रों का वर्णन करने का कोई साधन नहीं है, जैसे कि सी # में संपत्ति। आंशिक रूप से इस विषय पर एक लेख पहले से ही हब्राह्र पर चलाया जा रहा है, लेकिन मैं सिंटैक्स को दृढ़ता से नापसंद करता हूं। इसके अलावा, मैं वास्तव में नाम से खेतों को चलाने के समय तक पहुंचने में सक्षम होना चाहता था।

यदि आप किसी समस्या को हल करना चाहते हैं - तो पहले उत्तर का पता लगाने की कोशिश करें

आइए अनुमान लगाएं कि आपको आखिर में क्या चाहिए।
उदाहरण के लिए, एक इंट फील्ड जिसका नाम "x" है। हम इस रिकॉर्ड से काफी खुश हैं:

field(int,x);

और आगे कोड में हम इस क्षेत्र को संदर्भित करना चाहते हैं

 foo.x = 10; int t = foo.x; foo.setField("x", 15); int p = foo.getField("x");

फिर भी कभी-कभी हम इस क्षेत्र से संस्थापन और मूल्यों को नियंत्रित करना चाहते हैं, इसलिए हमें भी गेटर्स और सेटर लिखना होगा।
और खेतों को आरम्भ करने की संभावना के बारे में भी हमें नहीं भूलना चाहिए।

कहां से शुरू करें

रन टाइम में खेतों के बारे में आपको क्या जानने की जरूरत है? कम से कम उनके नाम और अर्थ। और प्रकार को जानना बुरा नहीं होगा।

टाइप

 class Type { public: const std::string name; const size_t size; template <typename T> static Type fromNativeType() { return Type(typeid(T).name(), sizeof(T)); } Type(const char * name, size_t size) : size(size), name(name) { } Type(const Type & another) : size(another.size), name(another.name) { } };

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

 class Bar { public: template <int val> Bar() { int var = val; printf("%d\n", var); } };

बार वर्ग स्वयं टेम्पलेट नहीं है, लेकिन इसमें एक डिफ़ॉल्ट टेम्पलेट निर्माता है। तो इस निर्माता को कॉल करने के लिए, आपको इसे तुरंत करने की आवश्यकता है। यह निम्नलिखित कोड भीख माँगता है:

 Bar bar = Bar<10>();

लेकिन इस तरह के रिकॉर्ड का मतलब है टेम्पलेट क्लास को इंस्टेंट करना, न कि टेम्पलेट कंस्ट्रक्टर।
कभी-कभी आप इसके आसपास हो सकते हैं, और फिर मैं दिखाऊंगा कि कैसे।
तो टाइप करें :: fromNativeType <> (), एक अर्थ में, एक कंस्ट्रक्टर भी है।

खेत का भंडारण

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

 class Basic { std::vector<FieldDeclaration> fields; public: template <typename FieldType> FieldType getField(const std::string & name, FieldType default) { for(int i = 0; i < fields.size(); ++i) { if (fields[i].name.compare(name)==0) { return static_cast< Field<FieldType>* >(fields[i].pointer)->getValue(); } } return default; } template <typename FieldType> void setField(const std::string & name, FieldType value) { for(int i = 0; i < fields.size(); ++i) { if (fields[i].name.compare(name)==0) { static_cast< Field<FieldType>* >(fields[i].pointer)->setValue(value); } } } };

संभवतः एसटीडी का उपयोग करना बेहतर है: भंडारण के लिए नक्शा, उदाहरण के लिए एसटीडी :: वेक्टर उपयुक्त है।
FieldDeclaration बस एक संरचना है जिसमें प्रकार की जानकारी होती है।

 struct FieldDeclaration { FieldDeclaration(const std::string & name, const Type & type, void * pointer = NULL) : name(name), type(type), pointer(pointer) { } const std::string name; const Type type; void * pointer; };

जादू का जादू

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

कुछ अवधारणाओं का इस्तेमाल किया

 #define __CONCAT__(a,b) a##b #define __STRINGIZE__(name) #name #define __CLASS_NAME__(name) __CONCAT__(__field_class__, name) #define __GETTER_NAME__(fieldname) __CONCAT__(getterof_, fieldname) #define __SETTER_NAME__(fieldname) __CONCAT__(setterof_, fieldname)

छद्म खोजशब्द

लेख की शुरुआत में, हम इस बात पर सहमत हुए कि हम फ़ील्ड विवरण वाक्यविन्यास का उपयोग करेंगे, जिसमें 2 तर्क हैं: फ़ील्ड का प्रकार और नाम। वास्तव में, मैंने दो प्रकार के क्षेत्रों को अलग किया:

स्मार्टफ़ील्ड - गेट्टर और सेटर का समर्थन करता है और रन टाइम से नाम से प्राप्त किया जा सकता है
फ़ील्ड - गेट्टर और सेटर का उपयोग नहीं करता है

 #define smartfield(type,name) \ type __stdcall __GETTER_NAME__(name)(); \ void __stdcall __SETTER_NAME__(name)(type value); \ __FIELD_CLASS_DECLARATION_SMART__(type,name) \ __CLASS_NAME__(name) name; #define field(type, name) \ __FIELD_CLASS_DECLARATION__(type,name) \ __CLASS_NAME__(name) name;

स्मार्टफ़ील्ड मैक्रो की पहली दो लाइनें संबंधित फ़ील्ड के गेटटर और सेटर को सीधे उस कक्षा में घोषित करती हैं जहां फ़ील्ड स्थित होगा। फिर आपको उनका कार्यान्वयन लिखना होगा। उन्हें क्रमशः getter_ <फ़ील्ड नाम> और सेटर_ <फ़ील्ड नाम> कहा जाएगा।
__Stdcall कॉलिंग कन्वेंशन संशोधक आपको पॉइंटर द्वारा क्लास विधि को कॉल करने की अनुमति देता है, यह स्पष्ट रूप से पहले पैरामीटर के रूप में पारित करता है (डिफ़ॉल्ट रूप से उपयोग किया जाने वाला Microsoft __thiscall कन्वेंशन इसे पारित करने के लिए ECX रजिस्टर का उपयोग करता है)।
__FIELD_CLASS_DECLARATION__ और __FIELD_CLASS_DECLARATION_SMART__ संबंधित फ़ील्ड ("इनर किचन क्लासेस" हम वापस आएंगे) की कक्षाओं का विवरण है।
__CLASS_NAME __ (नाम) नाम; यह वास्तव में "घरेलू व्यंजनों की कक्षाएं" की एक प्रति है।

क्लास फील्ड

यह ध्यान दिया जाना चाहिए कि "आंतरिक रसोई कक्षाएं" अधिक सामान्य फील्ड वर्ग के वंशज हैं

 #define NO_GETTER (TGetter)0 #define NO_SETTER (TSetter)0 template <typename FieldType> class Field { protected: typedef FieldType (*TGetter)(void *); typedef void (*TSetter)(void *, FieldType); TGetter getter; TSetter setter; void * that; public: const std::string name; const Type type; FieldType value; template< typename OwnerType > Field(OwnerType * _this, const char * nm) : name( nm ), type( Type::fromNativeType<FieldType>() ), getter(NO_GETTER), setter(NO_SETTER), that(_this) { _this->fields.push_back(FieldDeclaration(name, type, this)); } template< typename OwnerType > Field(OwnerType * _this, const char * nm, const FieldType & initvalue) : name( nm ), type( Type::fromNativeType<FieldType>() ), value(initvalue), getter(NO_GETTER), setter(NO_SETTER), that(_this) { _this->fields.push_back(FieldDeclaration(name, type, this)); } FieldType getValue() { if (getter) return getter(that); else return value; } void setValue(FieldType val) { if (setter) setter(that,val); else value = val; } Field<FieldType> & operator = (FieldType val) { setValue(val); return *this; } operator FieldType() { return getValue(); } };

तो, हमारे पास एक टेम्प्लेट क्लास फ़ील्ड है, जिसमें से टेम्प्लेट के लिए फ़ील्ड के प्रकार का संकेत आवश्यक है।
अपने आप में स्टोर करने के लिए क्लास:

क्षेत्र का नाम
फील्ड प्रकार की जानकारी
मूल्य
प्राप्त करनेवाला
बैठानेवाला
मालिक वर्ग में इसके बराबर इंगित करता है

ध्यान दें कि प्रकार TGetter और TSetter इस तरह से लिखे गए हैं कि वे जिन कार्यों का वर्णन करते हैं वे पहले पैरामीटर के रूप में शून्य * सूचक लेते हैं। यह वास्तव में एक सूचक है। यह काम करता है क्योंकि गेट्टर और सेटर को __stdcall संशोधक के साथ स्पष्ट रूप से चिह्नित किया गया है।

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

इसके बाद डिफॉल्ट गेट्टर और सेटर हैं। वे प्रोग्रामर द्वारा निर्दिष्ट एक गेटटर / सेटर की जांच करते हैं, और यदि वे सेट होते हैं, तो उन्हें पहले पैरामीटर के रूप में उस के स्पष्ट हस्तांतरण के साथ कॉल करें। अन्यथा, वे केवल एक मान लौटाते हैं / एक नया असाइन करते हैं।

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

इंडोर किचन क्लासेस

 #define __FIELD_CLASS_DECLARATION__(type, name) \ class __CLASS_NAME__(name) : public Field<type> \ { \ public: \ __FIELD_CLASS_CONSTRUCTOR_1__(type,name) \ __FIELD_CLASS_CONSTRUCTOR_2__(type,name) \ __CLASS_NAME__(name) & operator = (type val) \ { \ Field<type>::operator=(val); \ return *this; \ } \ }; #define __FIELD_CLASS_DECLARATION_SMART__(type, name) \ class __CLASS_NAME__(name) : public Field<type>\ { \ public: \ __FIELD_CLASS_CONSTRUCTOR_1_SMART__(type,name) \ __FIELD_CLASS_CONSTRUCTOR_2_SMART__(type,name) \ __CLASS_NAME__(name) & operator = (type val) \ { \ Field<type>::operator=(val); \ return *this; \ }\ };

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

इन वर्गों के निर्माणकर्ताओं के बारे में

 #define __FIELD_CLASS_CONSTRUCTOR_1_SMART__(type,name) \ template< class OwnerType > \ __CLASS_NAME__(name)(OwnerType * _this) \ : Field<type>(_this, __STRINGIZE__(name)) \ { \ auto get_ptr = &OwnerType::__GETTER_NAME__(name); \ auto set_ptr = &OwnerType::__SETTER_NAME__(name); \ this->getter = (TGetter)(void*)*(void**)(&get_ptr); \ this->setter = (TSetter)(void*)*(void**)(&set_ptr); \ } #define __FIELD_CLASS_CONSTRUCTOR_2_SMART__(type,name) \ template< class OwnerType > \ __CLASS_NAME__(name)(OwnerType * _this, type initvalue) \ : Field<type>(_this, __STRINGIZE__(name), initvalue) \ { \ auto get_ptr = &OwnerType::__GETTER_NAME__(name); \ auto set_ptr = &OwnerType::__SETTER_NAME__(name); \ this->getter = (TGetter)(void*)*(void**)(&get_ptr); \ this->setter = (TSetter)(void*)*(void**)(&set_ptr); \ } #define __FIELD_CLASS_CONSTRUCTOR_1__(type,name) \ template< class OwnerType > \ __CLASS_NAME__(name)(OwnerType * _this) \ : Field<type>(_this, __STRINGIZE__(name)) \ { \ } #define __FIELD_CLASS_CONSTRUCTOR_2__(type,name) \ template< class OwnerType > \ __CLASS_NAME__(name)(OwnerType * _this, type initvalue) \ : Field<type>(_this, __STRINGIZE__(name), initvalue) \ { \ }

आंकड़े 1 और 2 क्षेत्र के मूल्य (2) और बिना (1) के आरंभीकरण के साथ निर्माणकर्ताओं द्वारा प्रतिष्ठित हैं। शब्द स्मार्ट एक गेटर और सेटर की उपस्थिति को इंगित करता है।
सभी कंस्ट्रक्टर बॉयलरप्लेट भी हैं (प्रकार को निर्माणकर्ता को सहेजा और पास किया जाना चाहिए) और उसी तरह से OwnerType स्वचालित प्रतिस्थापन का उपयोग करें। संबंधित फ़ील्ड निर्माता को कहा जाता है, और इसके अलावा और इनिशियलाइज़ेशन वैल्यू (यदि कोई हो), फ़ील्ड नाम भी इसे स्ट्रिंग कॉन्स्ट चार्ज [] __STRINGIZE__ मैक्रो द्वारा प्राप्त के साथ भेजा जाता है।
इसके बाद, SMART कंस्ट्रक्टर्स में, गेटर्स और सेटर्स के लिए पॉइंटर्स सेविंग और सेविंग किया जाता है। यह बहुत अजीब काम करता है। तथ्य यह है कि सी ++ कड़ाई से संकेत के प्रकारों को वर्ग विधियों में परिवर्तित करता है। यह इस तथ्य के कारण है कि, विरासत और आभासी तरीकों की संभावना को देखते हुए, हमेशा एक विधि के लिए एक पॉइंटर को एक फ़ंक्शन के लिए एक पॉइंटर के रूप में उसी तरह से व्यक्त नहीं किया जा सकता है। हालांकि, हम जानते हैं कि हमारे गेटटर और सेटर को इंगित किया जा सकता है, उदाहरण के लिए, प्रकार शून्य * द्वारा।
हम अस्थायी चर बनाते हैं जो पॉइंटर्स को सी ++ संकलक के तरीके के तरीकों को संग्रहीत करेंगे। मैंने प्रकार ऑटो लिखा था, वास्तव में, यह स्पष्ट रूप से लिखा जा सकता है, लेकिन यह अधिक सुविधाजनक है और इसके लिए C ++ 0x का धन्यवाद।
अगला, हमें इन अस्थायी चर के लिए संकेत मिलते हैं। इन बिंदुओं को शून्य करने के लिए डाली जाती है। फिर डेरेक्शन और शून्य हो जाओ *। खैर, अंत में, हम पहले से ही TGetter या TSetter प्रकारों को लाते हैं और सहेजते हैं।

अंतिम स्पर्श

चूँकि फ़ील्ड को सामान्य ऑपरेशन के लिए इस पॉइंटर की आवश्यकता होती है, इसलिए सभी फ़ील्ड को आरंभीकृत किया जाना चाहिए। इसलिए, छोटे मैक्रोज़ लिखना अच्छा होगा जो आपको आसानी से ऐसा करने की अनुमति देगा।

 #define initfieldval(name, value) name(this, value) #define initfield(name) name(this)

पहला मूल्य आरंभीकरण के लिए है, दूसरा सरल आरंभीकरण के लिए है।

वह सब है!

के उपयोग

 #include "basic.h" class Foo : public Basic { public: smartfield(int, i); field(float, f); Foo(); }; Foo::Foo() : initfield(i), initfieldval(f, 3.14) { } int Foo::getterof_i() { printf("Getting field i of class Foo\n"); return i.value; } void Foo::setterof_i(int value) { printf("Setting field i of class Foo\n"); i.value = value; } int main() { Foo foo; int j = foo.i; foo.setField("i", 10); int k = foo.getField("i", -1); float z = foo.f; return 0; }

निष्कर्ष

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

स्रोत कोड

पुनश्च
यहां लिखी गई हर चीज सी ++ के लिए पूरी तरह से प्यार से बाहर पैदा हुई थी।
बेशक, मैं कभी भी अपने काम में ऐसा नहीं लिखता हूं, और मैं इसे दूसरों को नहीं सुझाता, क्योंकि कोड को पढ़ना काफी मुश्किल है।

पीएस 2
मुझे बहुत गुस्सा है कि प्रीप्रोसेसर में मैक्रोज़ को अधिभारित करने की क्षमता नहीं है, कम से कम तर्कों की संख्या से, और मुझे लगता है कि कुछ भी इसे रोकता नहीं है।
यदि तर्कों की संख्या से मैक्रोज़ को अधिभारित करना संभव था, तो फ़ील्ड इनिशियलाइज़ेशन मैक्रोज़ और भी सुंदर दिखेंगे।

C ++ में सेटर और गेट्टर के साथ नाम से सुलभ फ़ील्ड फ़ील्ड