टर्नरी ऑपरेटर का राज

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

कसौटी

निम्नलिखित कोड संकलित करेगा? क्यों समझाएं।
1।

int i; int j; (false ? i: j) = 45; 

2।

 int i; int j; (true ? i: j) = 45; 

3।

 short i; int j; (true ? i: j) = 45; 

4।

 return true ? 0 : 1; 

5।

 true ? return 0 : return 1; 

अगले टुकड़े का निष्कर्ष क्या होगा? क्यों?
6।

 std::cout << (false ? 9 : '9') << " " << (true ? 9 : '9'); 

निम्नलिखित कोड के परिणामस्वरूप चर ए, बी और सी के मूल्य क्या हैं? क्यों?
7।

 int a = 1; int b = 1; int c = 1; a = true ? ++b : ++c; 

8. ऐसी स्थिति क्या है जहां आप {...} और {...} का उपयोग नहीं कर सकते हैं, लेकिन आप टर्नरी ऑपरेटर का उपयोग कर सकते हैं।
9. टर्नरी ऑपरेटर के उपयोग में संभावित खतरे क्या हैं? उनका कारण क्या है?
10. टर्नरी ऑपरेटर के अप्रत्याशित उपयोग आपके दिमाग में क्या आते हैं?

व्याख्या

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

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

 struct A{ operator int(){ return 1; } }; struct B{ operator int(){ return 3; } }; 

यानी सबसे आम प्रकार वह प्रकार है जिसके लिए दोनों ऑपरेंड डाले जा सकते हैं। ऐसी परिस्थितियाँ हो सकती हैं जहाँ कोई सामान्य प्रकार न हो। उदाहरण के लिए,

 struct C{}; struct D{}; 

कोई सामान्य प्रकार नहीं है, और अगला टुकड़ा बिल्कुल संकलन नहीं करता है

 (true ? C() : D()); 

So. हमने टर्नरी ऑपरेटर के प्रकार को थोड़ा हल किया। यह मूल्य श्रेणी के साथ समस्या को हल करने के लिए बनी हुई है। यहाँ निम्न नियम लागू होता है: यदि प्रकार को टर्नरी ऑपरेटर में सबसे आम में परिवर्तित किया जाता है, तो टर्नेरी ऑपरेटर को प्रचलित किया जाता है। यदि नहीं, तो lvalue । अब जब हम जानते हैं कि हम क्या जानते हैं, हम पहले 7 प्रश्नों का उत्तर आसानी से दे सकते हैं।

उत्तर

1. और 2. - हाँ। प्रकार रूपांतरण नहीं होता है, और मान प्रदान करने के लिए lvalue काफी संभव है।
3. - कोई नहीं। टाइप रूपांतरण यहाँ होता है। तो "=" चिह्न के बाईं ओर अभिव्यक्ति का मूल्य वर्ग व्याप्त है । और प्रतिद्वंद्विता , जैसा कि आप जानते हैं, असाइन नहीं किया जा सकता है।
4. - हाँ। हमने यह सब एक से अधिक बार किया है।
5. - नहीं। यहाँ पूरी बात यह है कि C ++ स्टेटमेंट में एक्सप्रेशन नहीं टूट सकता।
6. कार्यक्रम "57 9" प्रदर्शित करता है। इस खंड में, इस तथ्य के कारण कि 2 और 3 के ऑपरेंड के विभिन्न प्रकार हैं, सबसे सामान्य प्रकार में रूपांतरण होता है। इस मामले में, इंट । एक '9', जैसा कि आप जानते हैं, ASCII कोड 57 है।
7. इस प्रश्न में टर्नरी ऑपरेटर की एक और विशेषता निहित है। अर्थात्, केवल उस ऑपरेंड से दूसरे और तीसरे, जिसमें निष्पादन का धागा पहुंचता है, की गणना की जाती है। हालाँकि, एक ही व्यवहार को अगर {...} और {...} के साथ देखा जा सकता है। तदनुसार, चर a, b और c का मान 2, 2, 1 होगा।

यदि मैं {...} और {{}} का उपयोग नहीं कर सकता हूं, लेकिन क्या मैं टर्नरी ऑपरेटर का उपयोग कर सकता हूं?

उदाहरण के लिए, कंस्ट्रक्टर आरंभीकरण सूची में। आप इस तरह नहीं लिख सकते:

 struct S { S() : if(true) i_(1) else i_(0){} int i_; }; 

लेकिन यह इस तरह से संभव है:

 struct S { S() : i_(some_condition ? 0 : 1){} int i_; }; 

लिंक को इनिशियलाइज़ करते समय, कंडीशन के आधार पर। जैसा कि आप जानते हैं, आप एक गैर-लिंक किए गए लिंक की घोषणा नहीं कर सकते हैं, इसलिए निम्न टुकड़ा संकलन नहीं करता है:

 int a = 3; int b = 4; int& i; if(some_condition) i = a; else i = b; 

लेकिन निम्नलिखित संकलन सफलतापूर्वक:

 int& i = (some_condition ? a : b); 

C ++ 11 में, टर्नरी ऑपरेटर का अधिक बार उपयोग किया जाता है। यह इस तथ्य के कारण है कि कॉन्स्टैक्स के कार्यों में `अभिव्यक्ति` के अलावा कुछ भी नहीं होना चाहिए। और `अभिव्यक्ति` अच्छी तरह से एक टर्नरी ऑपरेटर हो सकता है।
एक उदाहरण के रूप में, मैं एक संख्या की सादगी का निर्धारण करने के लिए एक शास्त्रीय एल्गोरिथ्म दूंगा

 constexpr bool check_if_prime_impl(unsigned int num, unsigned int d) { return (d * d > num) ? true : (num % d == 0) ? false : check_if_prime_impl(num, d + 1); } constexpr bool check_if_prime(unsigned int num) { return (num <= 1) ? false : check_if_prime_impl(num, 2); } 

उसी उदाहरण में, वैसे, आप कैस्केडिंग टर्नरी ऑपरेटरों के उपयोग को देख सकते हैं, जो असीमित घोंसले के शिकार हो सकते हैं और यदि {...} और {{}} को बदल सकते हैं।

टर्नरी ऑपरेटर के खतरे

मान लीजिए कि हमारे पास एक वर्ग स्ट्रिंग है

 class String { public: operator const char*(); }; 

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

 const char* s = some_condition ? "abcd" : String("dcba"); 

जैसा कि हम पहले से ही जानते हैं, टर्नरी ऑपरेटर का दूसरा और तीसरा ऑपरेंड सबसे सामान्य प्रकार तक कम हो जाता है। इस मामले में, यह कास्ट चार * है । लेकिन स्ट्रिंग ऑब्जेक्ट ("dcba") अभिव्यक्ति के अंत में नष्ट हो जाता है और s अमान्य मेमोरी को इंगित करेगा। सबसे अच्छा मामले में, जब आप बाद में एस का उपयोग करने का प्रयास करते हैं तो प्रोग्राम क्रैश हो जाएगा। सबसे खराब रूप से, यह गलत परिणाम देगा, जिससे ग्राहक में असंतोष होगा और प्रोग्रामर के लिए सिरदर्द होगा।

टर्नरी ऑपरेटर का असामान्य उपयोग

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

 template <typename T, typename U> struct common_type { typedef decltype(true ? std::declval<T>() : std::declval<U>()) type; }; template<typename T, typename U> struct is_same{ enum { value = false; } }; template<typename T> struct is_same<T, T>{ enum { value = true; } }; int main() { std::cout << is_same<int, common_type<A, B>::type>::value <<std::endl; } 

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