पिछली बार , हमने यह पता लगाने के लिए SFINAE का उपयोग किया था कि क्या एक प्रकार की परिभाषा थी, और हमने इसका उपयोग
if constexpr
और जेनेरिक लैम्ब्डा के संयोजन में किया ताकि कोड प्रकार का उपयोग कर सके यदि यह परिभाषित किया गया है, जबकि अभी भी संकलक द्वारा स्वीकार किया जा रहा है और खारिज किया जा रहा है ) यदि प्रकार परिभाषित नहीं है।
हालाँकि, हमारे उपयोग में कुछ समस्याएँ थीं, कुछ छोटी झुंझलाहट, कुछ अधिक निराशा।
- आपको हर समय
struct
को कहना था। - यदि प्रकार मौजूद नहीं था, तो इसका नामकरण करने का कार्य वर्तमान नामस्थान में इंजेक्ट होने का कारण बनता है, न कि आपके द्वारा टाइप किए जाने वाले नामस्थान से।
- आपको अयोग्य नाम के साथ
struct
तकनीक का उपयोग करना चाहिए। आप इसका उपयोग उस प्रकार की जांच के लिए नहीं कर सकते हैं जिसे आपने वर्तमान नामस्थान में आयात नहीं किया था।
हम एक ही समाधान के साथ सभी तीन समस्याओं को ठीक कर सकते हैं: इच्छित नाम स्थान में प्रकार की भविष्यवाणी करें।

एक बार जब आप ऐसा कर लेते हैं, तो आपको
struct
कहने की आवश्यकता नहीं है क्योंकि संरचना निश्चित रूप से घोषित की गई है।
call_if_defined
में टेम्प्लेट टाइप पैरामीटर के रूप में इसका उपयोग करने से नई घोषणा नहीं होगी, क्योंकि यह पहले ही घोषित की जा चुकी है। और जब से यह घोषित किया गया है, आप इसे इसके अयोग्य नाम, इसके पूर्ण नाम स्थान या बीच में कुछ भी के माध्यम से एक्सेस कर सकते हैं। इसके अलावा एक अन्य उपनाम या आश्रित प्रकार। (क्षमा करें, वे बीच में नहीं हैं।)
namespace app { void foo() { call_if_defined<awesome::special>([&](auto* p) {
उन लोगों के लिए जो शुरू से ही श्रृंखला का पालन करते रहे हैं, आपने देखा होगा कि
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)
को प्रत्येक प्रकार के लिए एक बार दोहराया जाता है।
जैसा कि मैंने पहले उल्लेख किया है, हम इस फ़ंक्शन का उपयोग लंबोदा को कॉल करने के लिए कर सकते हैं यदि
सभी प्रकार परिभाषित किए गए हैं:
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
गेम खेलकर इसे फिर से प्राप्त करने की परेशानी से बचा जाता है।
अगली बार , हम इसे एक स्प्रिंगबोर्ड के रूप में उपयोग करेंगे और पैटर्न का विस्तार करेंगे।
खोज इंजन के माध्यम से यहां आने वालों को ध्यान दें : यह श्रृंखला के मुख्य भाग का अंतिम भाग है, लेकिन अभी भी कुछ हिस्से आने बाकी हैं। अधीर के लिए, यहाँ कॉपी-पेस्ट करने के लिए सामान है:
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 क्लाउड की शक्ति के साथ उस विशेषज्ञता को मिला रहे हैं, जो हाल ही में घोषित Azure रिमोट रेंडरिंग सेवा जैसे मिश्रित वास्तविकता अनुभव वाले कई नए रोमांचक सेवाओं को विकसित करने के लिए है। हम ग्राउंड-ब्रेकिंग मिक्स्ड रियलिटी अनुभवों के निर्माण को सक्षम करने के लिए एआर, वीआर और क्लाउड प्रौद्योगिकियों के अभिसरण के बारे में भावुक हैं।
हॉक में काम करना:- आप प्रतिभाशाली डेवलपर्स के साथ छोटी केंद्रित टीमों में काम करेंगे
- आपके पास अत्याधुनिक हार्डवेयर प्लेटफार्मों और उपकरणों की एक विविध श्रेणी पर नई तकनीकों के साथ काम करने का अवसर होगा
- आप व्यापक दायरे के साथ चुनौतीपूर्ण तकनीकी समस्याओं को हल करने पर काम करेंगे
- आप दुनिया भर की प्रतिभाशाली टीमों के साथ सहयोग करेंगे
जिम्मेदारियों
- डिजाइन, विकास, परीक्षण और उच्च गुणवत्ता, कुशल और स्वच्छ मल्टीप्लेयर C ++ कोड वितरित करें
- अत्यधिक स्केलेबल एज़्योर सेवाओं का विकास करें
- उत्पाद विकास को चलाने के लिए आंतरिक और बाहरी ग्राहकों के साथ सीधे काम करें
योग्यता
- सी ++ कोडिंग और डिबगिंग कौशल
- साझा कोड आधार पर टीम के वातावरण में काम करने की क्षमता
- क्लाउड और वितरित सेवा तकनीकों के साथ अनुभव (जैसे एज़्योर बैच, एज़्योर ब्लॉब स्टोरेज, डॉकर, टेलीमेट्री)
बोनस अंक
अन्य बहुत सारे कौशल हैं जिनकी आवश्यकता नहीं है, लेकिन यह टीम भर में मूल्यवान हैं और इनमें शामिल हैं:
- C #, ASP.Net, जावास्क्रिप्ट, टाइपस्क्रिप्ट, प्रतिक्रिया
- एकता, अवास्तविक या संबंधित खेल इंजन
- इंटरैक्टिव 3 डी, एआर या वीआर में अनुभव
- नेटवर्किंग और बैकएंड सेवाएं
- प्रदर्शन अनुकूलन
आप अधिक जानकारी प्राप्त कर सकते हैं और अपना सीवी
यहां जमा कर सकते
हैं ।