💮 ✏️ 🌱 C ++ में संरचना तुलना ऑपरेटरों की स्वचालित पीढ़ी 🏇🏼 🧖🏻 💎

सभी उपयोगकर्ता कक्षाओं और संरचनाओं के लिए C ++ भाषा डिफ़ॉल्ट रूप से एक कॉपी कंस्ट्रक्टर और एक कॉपी असाइनमेंट ऑपरेटर बनाती है। इस प्रकार, मामलों की एक महत्वपूर्ण श्रृंखला के लिए, प्रोग्रामर को इन कार्यों को मैन्युअल रूप से लिखने से मुक्त किया जाता है। उदाहरण के लिए, डिफ़ॉल्ट स्टेटमेंट उन संरचनाओं के लिए अच्छी तरह से काम करते हैं जिनमें डेटा होता है। इसके अलावा, डेटा को सरल प्रकारों में और जटिल कंटेनरों में संग्रहीत किया जा सकता है, जैसे कि std :: वेक्टर या std :: string।

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

संरचनाओं की शब्द-दर-शब्द तुलना के लिए एक ऑपरेटर लिखना मुश्किल नहीं है, लेकिन कार्यक्रम का ऐसा संगठन त्रुटियों के दृष्टिकोण से असुविधाजनक और खतरनाक है। कहते हैं, यदि प्रोग्रामर संरचना में एक नया सदस्य जोड़ता है, लेकिन उपयोगकर्ता तुलना ऑपरेटर में संबंधित तुलना जोड़ना भूल जाता है, तो प्रोग्राम में एक कठिन निदान त्रुटि उत्पन्न होती है। इसके अलावा, संरचना की घोषणा और इसकी तुलना के उपयोगकर्ता ऑपरेटर आमतौर पर एक-दूसरे से अलग होते हैं, क्योंकि वे अलग-अलग फाइलों (* .h और * .cpp) में होते हैं।

C ++ में शब्द-दर-शब्द तुलना ऑपरेटरों को स्वचालित करना आसान नहीं है, क्योंकि इस भाषा में कोई उपकरण नहीं हैं जो आपको यह पता लगाने की अनुमति देते हैं कि प्रोग्राम ऑपरेशन के दौरान संरचना में कितने और कौन से सदस्य शामिल हैं।

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

अन्य मौजूदा समाधान

फिलहाल, मैं वर्णित समस्या के निम्नलिखित वैकल्पिक समाधानों को जानता हूं:

गतिशील संरचनाओं का उपयोग। सामान्य सी ++ संरचना के बजाय, विषम तत्वों का एक कंटेनर लगाया जाता है, जो एक प्रकार के लिए डाली जाती हैं। उदाहरण के लिए, Windows OLE से VARIANT टाइप करें। सदस्य नामों को संग्रहीत करने के लिए एक स्ट्रिंग कंटेनर का भी उपयोग किया जाता है। इस प्रकार, सदस्यों के नाम, उनके प्रकार और संख्या को कार्यक्रम के लिए उपलब्ध समय पर उपलब्ध कराया जाता है। हालांकि, इस तरह की संरचना के सदस्यों के लिए कार्यक्रम के निष्पादन के दौरान यह दृष्टिकोण लागतों की ओर जाता है। प्रपत्र का एक्सेस सिंटैक्स object.member_name या pObject-> सदस्य_नाम अनुपलब्ध हो जाता है, इसे ऑब्जेक्ट की तरह कुछ में बदलना होगा। (“सदस्य_नाम”)। इसके अलावा, मेमोरी की खपत में एक रैखिक वृद्धि होती है: संरचना का प्रत्येक उदाहरण एक नियमित (स्थिर) संरचना की तुलना में स्मृति में अधिक स्थान लेता है।
बूस्ट लाइब्रेरी का उपयोग कर, अर्थात् बढ़ावा :: फ्यूजन :: मैप कंटेनर। यहां, सभी लागतों को कंपाइलर के कंधों पर रखना संभव था, लेकिन सदस्यों तक पहुंचने के लिए पारंपरिक वाक्यविन्यास को बचाया नहीं जा सका। आपको फॉर्म के कंस्ट्रक्शन का उपयोग करना होगा: at_key <सदस्य_नेमी> (ऑब्जेक्ट)।
C ++ कोड जनरेशन। C ++ में संरचना का वर्णन और इसकी तुलना के ऑपरेटर प्रोग्रामर द्वारा मैन्युअल रूप से नहीं लिखे गए हैं, लेकिन कुछ अन्य इनपुट भाषा में संरचना के विवरण के आधार पर एक स्क्रिप्ट द्वारा उत्पन्न होता है। यह दृष्टिकोण, मेरे दृष्टिकोण से, आदर्श है, लेकिन मैंने अभी तक इसे लागू नहीं किया है, इसलिए लेख उसके बारे में नहीं है।

मैक्रो सॉल्यूशन

मैक्रोज़ का उपयोग करने के लिए मैं जिस समाधान को लागू करने में कामयाब रहा, उसके निम्नलिखित फायदे हैं:

संरचना के सदस्यों तक पहुंच के लिए रन टाइम पर कोई लोड नहीं है।
प्रपत्र object.member_name या pObject-> Member_name के संरचना सदस्यों तक पहुँचने के लिए मानक सिंटैक्स को सहेजना संभव था।
फॉर्म ओ (1) का मेमोरी लोड। दूसरे शब्दों में, ऑटो-तुलना के साथ एक संरचना का प्रत्येक उदाहरण एक नियमित संरचना के रूप में अधिक मेमोरी स्थान लेता है। इस तरह की संरचनाओं के प्रत्येक घोषित प्रकार के लिए केवल निरंतर (छोटी) मेमोरी लागत होती है।

नुकसान में से, निम्नलिखित पर ध्यान दिया जा सकता है:

अतिरिक्त सेवा के सदस्यों की संरचना में उपस्थिति, जो कि इन्टेलिसेंस या डॉक्सीजेन जैसे विश्लेषण उपकरणों की सुविधा को कम करती है।
उपयोगकर्ता नाम के साथ सेवा सदस्यों के नामों के संघर्ष की संभावना।
प्रपत्र संरचना के प्रारंभकों की सूची के साथ प्रारंभ करने में असमर्थता a = {1,2,3}।

उदाहरण का उपयोग करें

मान लें कि हमें उन लोगों के बारे में डेटा संग्रहीत करने के लिए एक संरचना बनाने की आवश्यकता है जो निम्न साधारण संरचना के बराबर हैं:

struct MANPARAMS { std::string name; int age; std::vector<std::string> friend_names; double karma; };

मेरी लाइब्रेरी के आधार पर, स्वचालित टर्म ऑपरेशन वाली एक संरचना इस प्रकार घोषित की गई है:

 class AUTO_MANPARAMS { PARAMSTRUCT_DECLARE_BEGIN(AUTO_MANPARAMS); public: DECLARE_MEMBER_PARAMSTRUCT(std::string, name); DECLARE_MEMBER_PARAMSTRUCT(int, age); DECLARE_MEMBER_PARAMSTRUCT(std::vector<std::string>, friend_names); DECLARE_MEMBER_PARAMSTRUCT(double, karma); };

उसके बाद, पूरे कार्यक्रम के लिए, आपको * .cpp फ़ाइलों में से एक में निम्नलिखित मैक्रो कॉल संकलित करने की आवश्यकता है:

 PARAMFIELD_IMPL(AUTO_MANPARAMS);

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

 void men(void) { AUTO_MANPARAMS man1, man2; man1.name = “John Smith”; man1.age = 18; man1.karma = 0; man2.name = “John Doe”; man2.age = 36; man2.karma = 1; man2.friends.push_back(“Sergud Smith”); if(man1 == man2) printf(“Ku-ku!\n”); }

कार्यान्वयन

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

मुख्य कार्यान्वयन विचार:

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

1. प्रत्येक सदस्य के लिए तुलनात्मक कार्यों की ऑटो-पीढ़ी

ऐसा प्रत्येक फ़ंक्शन संरचना का एक सदस्य है और "इसके" डेटा सदस्य की तुलना करता है। यह मैक्रो DECLARE_MEMBER_PARAMSTRUCT (प्रकार, नाम) में निम्नानुसार उत्पन्न होता है:

 bool comp##name(const ThisParamFieldClass& a) const \ { \ return name == a.name; \ } \

जहाँ ThisParamFieldClass हमारी संरचना का प्रकार है, जिसे हेड मैक्रो में टाइपडिफ के माध्यम से घोषित किया जाता है - नीचे देखें।

2. कार्यों की तुलना करने के लिए संकेत के साथ सरणी

हेड मैक्रो PARAMSTRUCT_DECLARE_BEGIN (x) एक स्टैटिक ऐरे की घोषणा करता है जिसमें प्रत्येक सदस्य तुलनात्मक फ़ंक्शन के लिए संकेत संग्रहीत होते हैं। ऐसा करने के लिए, पहले उनके प्रकार का निर्धारण करें:

 #define PARAMSTRUCT_DECLARE_BEGIN(x) \ private: \ typedef x ThisParamFieldClass; \ typedef bool (ThisParamFieldClass::*ComFun)(const ThisParamFieldClass& a) const; \ struct MEM_STAT_DATA \ { \ std::string member_name; \ ComFun comfun; \ }; \

और फिर एक सरणी घोषित की जाती है:

 static std::vector<MEM_STAT_DATA> stat_data; \

तुलना ऑपरेटरों को भी यहां घोषित किया जाता है:

 public: \ bool operator==(const ThisParamFieldClass& a) const; \ bool operator!=(const ThisParamFieldClass& a) const { return !operator==(a); } \

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

3. संरचना के सदस्यों पर डेटा में भरना

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

 class cl##name \ { \ public: \ cl##name(void) \ { \ if(populate_statdata) \ { \ MEM_STAT_DATA msd = \ { \ #name, \ &ThisParamFieldClass::comp##name \ }; \ stat_data.push_back(msd); \ } \ } \ }; \ cl##name ob##name;

जहाँ populate_statdata एक स्थैतिक ध्वज है जिसे हेड मैक्रो और संकेतों में घोषित किया गया है कि क्या stat_data सरणी संरचना सदस्यों के नाम और उनके तुलनात्मक कार्यों से भरी जानी चाहिए। जब प्रोग्राम शुरू होता है, तो नीचे वर्णित आरंभीकरण तंत्र populate_statdata = true सेट करता है और संरचना का एक उदाहरण बनाता है। इसी समय, संरचना के प्रत्येक सदस्य से जुड़े सेवा ऑब्जेक्ट निर्माता सदस्य डेटा के साथ सरणी को भरते हैं। उसके बाद, populate_statdata = false सेट किया गया है, और सदस्य जानकारी के साथ स्थिर सरणी अब नहीं बदलता है। यह समाधान हर बार कुछ समय के नुकसान की ओर जाता है जब उपयोगकर्ता प्रोग्राम populate_statdata ध्वज की जांच करने के लिए एक संरचना बनाता है। हालाँकि, मेमोरी की खपत नहीं बढ़ती है: सेवा ऑब्जेक्ट में डेटा सदस्य नहीं हैं, केवल एक निर्माता है।

अंत में, populate_statdata: फ्लैग कंट्रोल तंत्र को एक कंस्ट्रक्टर के साथ एक स्थिर सेवा ऑब्जेक्ट का उपयोग करके लागू किया जाता है, पूरे ढांचे के लिए। इस ऑब्जेक्ट को हेड मैक्रो में घोषित किया गया है:

 class VcfInitializer \ { \ public: \ VcfInitializer(void); \ }; \ static VcfInitializer vcinit;

निर्माता का कार्यान्वयन PARAMFIELD_IMPL (x) मैक्रो में है:

 x::VcfInitializer::VcfInitializer(void) \ { \ x::populate_statdata = true; \ ThisParamFieldClass dummy; \ x::populate_statdata = false; \ } \

पूर्ण स्थूल पाठ

 #define PARAMSTRUCT_DECLARE_BEGIN(x) \ private: \ typedef x ThisParamFieldClass; \ typedef bool (ThisParamFieldClass::*ComFun)(const ThisParamFieldClass& a) const; \ struct MEM_STAT_DATA \ { \ std::string member_name; \ ComFun comfun; \ }; \ static std::vector<MEM_STAT_DATA> stat_data; \ static bool populate_statdata; \ public: \ bool operator==(const ThisParamFieldClass& a) const; \ bool operator!=(const ThisParamFieldClass& a) const { return !operator==(a); } \ private: \ class VcfInitializer \ { \ public: \ VcfInitializer(void); \ }; \ static VcfInitializer vcinit; #define DECLARE_MEMBER_PARAMSTRUCT(type,name) \ public: \ type name; \ private: \ bool comp##name(const ThisParamFieldClass& a) const \ { \ return name == a.name; \ } \ class cl##name \ { \ public: \ cl##name(void) \ { \ if(populate_statdata) \ { \ MEM_STAT_DATA msd = \ { \ #name, \ &ThisParamFieldClass::comp##name, \ }; \ stat_data.push_back(msd); \ } \ } \ }; \ cl##name ob##name; #define PARAMFIELD_IMPL(x) \ std::vector<x::MEM_STAT_DATA> x::stat_data; \ bool x::populate_statdata = false; \ x::VcfInitializer x::vcinit; \ x::VcfInitializer::VcfInitializer(void) \ { \ x::populate_statdata = true; \ ThisParamFieldClass dummy; \ x::populate_statdata = false; \ } \ bool x::operator==(const x& a) const \ { \ bool r = true; \ for(size_t i=0; r && i<stat_data.size(); i++) \ { \ r = (this->*stat_data[i].comfun)(a); \ } \ return r; \ }

निष्कर्ष

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

C ++ में संरचना तुलना ऑपरेटरों की स्वचालित पीढ़ी