सी ++ में ऑपरेटर में कार्यान्वयन

नमस्ते! आज मैं आपको कुछ जादू दिखाने की उम्मीद करता हूं। मेरा शौक C ++ में सभी प्रकार के असंभव प्रतीत होने वाले टुकड़ों का आविष्कार कर रहा है, जो मुझे भाषा के सभी प्रकार की सूक्ष्मताएं सीखने में मदद करता है, अच्छी तरह से, या बस मज़े करना। ऑपरेटर कई भाषाओं में है, उदाहरण के लिए पायथन, जेएस। लेकिन वे इसे C ++ में नहीं लाए, लेकिन कभी-कभी मैं चाहता हूं कि यह लागू हो, इसलिए इसे लागू नहीं किया जाए।

std::unordered_map<std::string, std::string> some_map = { { "black", "white" }, { "cat", "dog" }, { "day", "night" } }; if (auto res = "cat" in some_map) { res->second = "fish"; } 

ऑपरेटर को कैसे काम करना चाहिए, मुझे लगता है कि यह स्पष्ट है। वह बाईं वस्तु को लेता है और जाँचता है कि क्या दाईं ओर इंगित की गई वस्तु में इस वस्तु की घटना है, जिसका संग्रह नहीं होना है। अपने आप में कोई सार्वभौमिक समाधान नहीं है, जिस तरह अन्य ऑपरेटरों के लिए कोई सार्वभौमिक समाधान नहीं है, इसलिए, उन्हें ओवरलोड करने की संभावना का आविष्कार किया गया था। इसलिए, ऑपरेटर के लिए, आपको एक समान तंत्र को लागू करने की आवश्यकता है।

ओवरलोड इस तरह दिखेगा।

 bool operator_in(const string& key, const unordered_map<string, string>& data) { return data.find(key) != data.end(); } 

मुझे लगता है कि विचार स्पष्ट है, प्रजातियों की अभिव्यक्ति।

  "some string" in some_map 

इसे एक फंक्शन कॉल में बदलना चाहिए।

  operator_in("some string", some_map) 

ऑपरेटर की ओवरलोडिंग के लिए मौजूदा क्षमताओं का उपयोग करते हुए, इस तंत्र को लागू करना काफी सरल है। ऑपरेटर खुद अनिवार्य रूप से एक मैक्रो है जो गुणा करता है।

  #define in *OP_IN_HELP{}* 

इस मामले में, OP_IN_HELP एक खाली वर्ग है और हमें केवल सही अधिभार का चयन करने के लिए कार्य करता है।

  class OP_IN_HELP {}; template<class TIn> OP_IN_LVAL<TIn> operator*(const TIn& data, const OP_IN_HELP&) { return OP_IN_LVAL<TIn>(data); } 

ऑपरेटर बॉयलरप्लेट है, जो आपको पहले तर्क के रूप में किसी भी प्रकार को स्वीकार करने की अनुमति देता है। अब हमें किसी तरह से सही वस्तु प्राप्त करने की आवश्यकता है, बिना किसी को खोए। ऐसा करने के लिए, हम क्लास OP_IN_LVAL को लागू करते हैं जो हमारी बाईं वस्तु को संग्रहित करेगा।

  template<class TIn> struct OP_IN_LVAL { const TIn& m_in; OP_IN_LVAL(const TIn& val) : m_in(val) {}; }; 

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

  template<class TIn> struct OP_IN_LVAL { const TIn& m_in; OP_IN_LVAL(const TIn& val) : m_in(val) {}; template<class TWhat> bool operator*(const TWhat& what) const { return operator_in(m_in, what); } }; 

वास्तव में यह समाधान पहले से ही काम करेगा, लेकिन यह सीमित है और हमें इस तरह से लिखने की अनुमति नहीं देगा।

  if (auto res = "true" in some_map) { res->second = "false"; } 

हमें ऐसा अवसर मिले, इसके लिए हमें ओवरलोडेड ऑपरेटर के रिटर्न वैल्यू को फेंकना होगा। ऐसा करने के दो संस्करण हैं, एक C ++ 14 की क्षमताओं का उपयोग करता है, दूसरा C ++ 11 के भाग के रूप में काम करता है।

  template<class TIn> struct OP_IN_LVAL { const TIn& m_in; OP_IN_LVAL(const TIn& val) :m_in(val) {}; //   C++14 template<class TWhat> auto operator*(const TWhat& what) const { return operator_in(m_in, what); } //   C++11 template<class TWhat> auto operator*(const TWhat& what) const -> decltype(operator_in(m_in, what)) { return operator_in(m_in, what); } //       //       template<class TWhat> auto operator*(TWhat& what) const -> decltype(operator_in(m_in, what)) { return operator_in(m_in, what); } }; 

चूंकि मैं मुख्य रूप से विजुअल स्टूडियो 2013 में काम करता हूं, मैं सी ++ 11 के ढांचे तक सीमित हूं और सी ++ 11 के भीतर समाधान सी ++ 14 में सफलतापूर्वक काम करेगा, इसलिए मैं आपको इसे चुनने की सलाह देता हूं।

Unordered_map के लिए ऑपरेटर में जेनेरिक का एक उदाहरण कार्यान्वयन।

 template<class TIterator> class OpInResult { bool m_result; TIterator m_iter; public: OpInResult(bool result, TIterator& iter) : m_result(result), m_iter(iter) {} operator bool() { return m_result; } TIterator& operator->() { return m_iter; } TIterator& data() { return m_iter; } }; template<class TKey, class TVal> auto operator_in(const TKey& key, std::unordered_map<TKey, TVal>& data) -> OpInResult<typename std::unordered_map<TKey, TVal>::iterator> { auto iter = data.find(key); return OpInResult<typename std::unordered_map<TKey, TVal>::iterator>(iter != data.end(), iter); } template<class TKey, class TVal> auto operator_in(const char* key, std::unordered_map<TKey, TVal>& data) -> OpInResult<typename std::unordered_map<TKey, TVal>::iterator> { auto iter = data.find(key); return OpInResult<typename std::unordered_map<TKey, TVal>::iterator>(iter != data.end(), iter); } 

OpInResult वर्ग आपको कास्ट ऑपरेटर को ओवरराइड करने की अनुमति देता है, जो हमें इसमें उपयोग करने की अनुमति देता है। यह तीर ऑपरेटर को भी ओवरराइड करता है, जिससे आप अपने आप को एक पुनरावृत्त के रूप में मुखौटा लगा सकते हैं जो unordered_map.find () लौटाता है।

एक उदाहरण यहाँ पाया जा सकता है cpp.sh/7rfdw

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

सी ++ 17 में, इस तरह लिखना संभव हो गया।

  if (auto res = some_map.find("true"); res != some_map.end()) { res->second = "false"; } 

लेकिन यह मुझे दृश्य का डिजाइन लगता है

  if (auto res = "true" in some_map) { res->second = "false"; } 

यह अच्छा लग रहा है।

ओवरलोड के अधिक उदाहरण यहाँ देखे जा सकते हैं github.com/ChaosOptima/operator_in

इस ऑपरेटर के कार्यान्वयन के सिद्धांत के आधार पर, लागू करने में कोई समस्या नहीं होगी
और अन्य ऑपरेटरों और अभिव्यक्ति, उदाहरण के लिए।

  negative = FROM some_vector WHERE [](int x){return x < 0;};