C ++, क्या प्रकार परिभाषित किया गया है: आवश्यक वस्तुओं की प्रारंभिक घोषणा

पिछली बार , हमने यह पता लगाने के लिए SFINAE का उपयोग किया कि क्या किसी प्रकार की परिभाषा है, और हमने इसे if constexpr और जेनेरिक लैम्ब्डा अभिव्यक्तियों के साथ संयोजन में उपयोग किया है ताकि कोड टाइप का उपयोग कर सके यदि यह परिभाषित है, जबकि कंपाइलर द्वारा अभी भी स्वीकार किया जा रहा है (और त्याग किया गया) यदि प्रकार परिभाषित नहीं है।

हालाँकि, इस एप्लिकेशन के साथ कई समस्याएं हैं:

• हर बार आपको एक struct लिखने की आवश्यकता होती है।
• यदि प्रकार मौजूद नहीं है, तो जब आप इसे एक नाम निर्दिष्ट करते हैं, तो यह प्रकार वर्तमान नामस्थान में दर्ज किया जाता है, न कि उस नामस्थान में जिसमें आप टाइप करना चाहते थे।
• आपको एक अयोग्य नाम के साथ एक struct का उपयोग करने की आवश्यकता है। आप इसका उपयोग उस प्रकार की जांच के लिए नहीं कर सकते हैं जिसे आपने वर्तमान नामस्थान में आयात नहीं किया था।

हम एक समाधान के साथ सभी तीन समस्याओं को ठीक कर सकते हैं: पहले वांछित नाम स्थान में प्रकार की घोषणा करें।

 // awesome.h namespace awesome { //      struct special { ... }; } //   namespace awesome { //   ,    struct special; } 

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

 namespace app { void foo() { call_if_defined<awesome::special>([&](auto* p) { //      "awesome::special" // .     "special" //     . using special = std::decay_t<decltype(*p)>; //      "special"   //   "awesome::special". special::do_something(); }); } } 

जो लोग शुरुआत से ही लेखों की इस श्रृंखला का अनुसरण कर रहे हैं, उन्होंने देखा होगा कि call_if_defined पद्धति उस संस्करण से बिल्कुल मेल नहीं खाती है जो हमने पहले लिखा था। नया संस्करण कई प्रकार के मापदंडों का समर्थन करता है और सभी प्रकारों को परिभाषित करने पर ही लैम्बडा को कॉल करता है।

आइए करीब से देखें:

 template<typename... T, typename TLambda> void call_if_defined(TLambda&& lambda) { if constexpr ((... && is_complete_type_v<T>)) { lambda(static_cast<T*>(nullptr)...); } } 

यदि कोष्ठक (...) में डबल कोष्ठक अजीब लगते हैं, लेकिन उनकी आवश्यकता होती है। बाहरी कोष्ठकों की आवश्यकता if constexpr द्वारा होती है, और आन्तरिक कोष्ठक एक कनवल्शन एक्सप्रेशन द्वारा आवश्यक होते हैं। सजा अभिव्यक्ति का विस्तार है

  if constexpr ( (is_complete_type_v<T1> && is_complete_type_v<T2> && ... is_complete_type_v<Tn>)) 

लैम्ब्डा कॉल पैरामीटर पैकेज एक्सटेंशन का उपयोग करता है:

  lambda(static_cast<T*>(nullptr)...); 

इसका विस्तार होता है

  lambda(static_cast<T1*>(nullptr), static_cast<T2*>(nullptr), ..., static_cast<Tn*>(nullptr)); 

जहां static_cast<T*>(nullptr) प्रत्येक प्रकार के लिए एक बार दोहराया static_cast<T*>(nullptr) ।

जैसा कि मैंने पहले उल्लेख किया है, हम इस फ़ंक्शन का उपयोग लैम्बडा को कॉल करने के लिए कर सकते हैं यदि सभी प्रकार परिभाषित हैं:

 void foo(Source const& source) { call_if_defined<special, magic>( [&](auto* p1, auto* p2) { using special = std::decay_t<decltype(*p1)>; using magic = std::decay_t<decltype(*p2)>; auto s = source.try_get<special>(); if (s) magic::add_magic(s); }); } 

C ++ 20 आपको इसे इस तरह लिखने की अनुमति देता है:

 void foo(Source const& source) { call_if_defined<special, magic>( [&]<typename special, typename magic> (special*, magic*) { auto s = source.try_get<special>(); if (s) magic::add_magic(s); }); } 

जो आपको टेम्पलेट के प्रकार का नाम देने की अनुमति देता है, जिससे std::decay_t साथ खेलते हुए इसे फिर से निकालने की आवश्यकता समाप्त हो std::decay_t ।

अगले लेख में, हम इसे एक स्प्रिंगबोर्ड के रूप में उपयोग करेंगे और सर्किट का विस्तार करेंगे।

---

नोट : यह लेखों की मुख्य श्रृंखला का चौथा भाग है, लेकिन अभी भी अन्य भाग ( 1 , 2 , 3 , 5 ) हैं। अधीर के लिए: यहां आपको कॉपी और पेस्ट करने की आवश्यकता है:

 template<typename, typename = void> constexpr bool is_type_complete_v = false; template<typename T> constexpr bool is_type_complete_v <T, std::void_t<decltype(sizeof(T))>> = true; template<typename... T, typename TLambda> void call_if_defined(TLambda&& lambda) { if constexpr ((... && is_complete_type_v<T>)) { lambda(static_cast<T*>(nullptr)...); } } 

वैसे, हमारे पास एक अच्छा काम है

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

हॉक में नौकरियां:

• आप प्रतिभाशाली डेवलपर्स के साथ छोटी टीमों में काम करेंगे
• आपके पास विभिन्न प्रकार के हार्डवेयर प्लेटफार्मों और उपकरणों पर नई तकनीकों के साथ काम करने का अवसर होगा।
• आप बड़ी संभावनाओं के साथ जटिल तकनीकी समस्याओं को सुलझाने पर काम करेंगे
• आप दुनिया भर की शांत टीमों के साथ सहयोग करेंगे।

कर्तव्यों

• उच्च-गुणवत्ता, कुशल और स्वच्छ बहु-मंच C ++ कोड का डिजाइन, विकास और परीक्षण करें
• अच्छी तरह से स्केलेबल एज़्योर सेवाओं का विकास करें
• उत्पाद विकास को प्रोत्साहित करने के लिए आंतरिक और बाहरी ग्राहकों के साथ सीधे काम करें

योग्यता

• C ++ प्रोग्रामिंग और डीबगिंग कौशल
• एक कॉमन कोड वाली टीम में काम करने की क्षमता
• क्लाउड और वितरित सेवा प्रौद्योगिकियों के साथ अनुभव (उदा। Azure बैच, Azure Blob Storage, Docker, Telemetry)

एक प्लस होगा

• C #, ASP.Net, जावास्क्रिप्ट, टाइपस्क्रिप्ट, प्रतिक्रिया
• एकता, अवास्तविक या संबंधित खेल इंजन
• इंटरएक्टिव 3 डी, एआर या वीआर का अनुभव करें
• नेटवर्क और सर्वर सेवाएं
• प्रदर्शन अनुकूलन

आप अधिक जान सकते हैं और यहां या लिंक्डइन के माध्यम से अपना आवेदन जमा कर सकते हैं।