C++11

C++11, C++ प्रोग्रामिंग भाषा के लिए मानकीकरण के लिए अंतर्राष्ट्रीय संगठन/अंतर्राष्ट्रीय इंटरनेशनल इलेक्ट्रोटेक्नीकल कमीशन मानक का संस्करण है। C++ 11 ने C++ मानक के पूर्व संस्करण को परिवर्तित कर दिया हैं, जिसे C++ 03 कहा जाता है,^[1] और इस प्रकार बाद में इसे C++14 से परिवर्तित कर दिया हैं । इसका नाम विनिर्देन के प्रकाशन वर्ष के अनुसार भाषा संस्करणों के नामकरण की परंपरा का पालन करता है, चूंकि इसे पूर्व में C++0x नाम दिया गया था क्योंकि यह 2010 से पहले प्रकाशित होने का आशय था।^[2]

यद्यपि डिज़ाइन लक्ष्यों में से एक मुख्य भाषा में परिवर्तनों पर लाइब्रेरी में परिवर्तनों को प्राथमिकता देना था,^[3] इसलिए C++ 11 मूल भाषा में कई परिवर्तन करता है। कोर लैंग्वेज के जिन क्षेत्रों में अधिकतम सुधार हुआ हैं इस प्रकार उनमें मल्टीथ्रेडिंग सपोर्ट, सामान्य प्रोग्रामिंग सपोर्ट, यूनिफॉर्म इनिशियलाइज़ेशन और परफॉर्मेंस सम्मिलित हैं। गणितीय विशेष फंक्शन्स के लाइब्रेरी को छोड़कर, C++ मानक लाइब्रेरी में भी महत्वपूर्ण परिवर्तन किए गए थे, जिसमें अधिकांश C++ तकनीकी रिपोर्ट 1 (TR1) लाइब्रेरी (कंप्यूटर विज्ञान) सम्मिलित थे।^[4]

C++11 को ISO/IEC 14882:2011 के रूप में प्रकाशित किया गया था,^[5] इस प्रकार सितंबर 2011 में और शुल्क के लिए उपलब्ध है। प्रकाशित C++11 मानक के समान फंक्शन करने वाला प्रारूप N3337 है, जो दिनांक 16 जनवरी 2012 में बनकर तैयार किया गया था,^[6] इसमें C++11 मानक से केवल संपादकीय सुधार हुए हैं।^[7]

डिजाइन लक्ष्य

डिज़ाइन समिति ने C++11 को डिज़ाइन करने में कई लक्ष्यों पर टिके रहने का प्रयास किया:

ISO/IEC 14882|C++98 और संभवतः C (प्रोग्रामिंग भाषा) के साथ स्थिरता और अनुकूलता बनाए रखें
मूल भाषा का विस्तार करने के अतिरिक्त मानक लाइब्रेरी के माध्यम से नई सुविधाओं को प्रस्तुत करना पसंद करें
उन परिवर्तनों को प्राथमिकता दें जो प्रोग्रामिंग तकनीक को विकसित कर सकें
केवल विशिष्ट अनुप्रयोगों के लिए उपयोगी नई सुविधाओं को प्रस्तुत करने के अतिरिक्त सिस्टम और लाइब्रेरी डिज़ाइन को सुविधाजनक बनाने के लिए C++ में सुधार करें
पहले की असुरक्षित तकनीकों के सुरक्षित विकल्प प्रदान करके प्रकार की सुरक्षा बढ़ाएँ
प्रदर्शन और सीधे हार्डवेयर के साथ फंक्शन करने की क्षमता बढ़ाएँ
वास्तविक दुनिया की समस्याओं के लिए उचित समाधान प्रदान करता हैं
शून्य-ओवरहेड सिद्धांत लागू करें (कुछ उपयोगिताओं द्वारा आवश्यक अतिरिक्त समर्थन का उपयोग तभी किया जाना चाहिए जब उपयोगिता का उपयोग किया जाता है)
विशेषज्ञ प्रोग्रामरों द्वारा आवश्यक किसी भी उपयोगिता को हटाए बिना सी ++ को पढ़ाने और सीखने में सरल बनाएं

प्रारंभिक समय में लोगों पर ध्यान देना महत्वपूर्ण माना जाता है, क्योंकि अधिकांश कंप्यूटर प्रोग्रामर सदैव ऐसे ही होते हैं, और क्योंकि कई प्रारंभिक अपने ज्ञान को कभी भी विस्तृत नहीं करते हैं, स्वयं को उस भाषा के पहलुओं में फंक्शन करने के लिए सीमित करते हैं जिसमें वे विशेषज्ञ होते हैं।^[1]

C++ कोर भाषा के लिए एक्सटेंशन

C++ समिति का एक फंक्शन भाषा कोर का विकास है। कोर लैंग्वेज के जिन क्षेत्रों में ज्यादा सुधार हुआ उनमें थ्रेड (कंप्यूटर साइंस) सपोर्ट, जेनेरिक प्रोग्रामिंग सपोर्ट, यूनिफॉर्म इनिशियलाइज़ेशन और परफॉर्मेंस सम्मिलित हैं।

कोर लैंग्वेज रनटाइम परफॉरमेंस एन्हांसमेंट

ये भाषा सुविधाएँ मुख्य रूप से स्मृति या कम्प्यूटेशनल गति के किसी प्रकार के प्रदर्शन लाभ प्रदान करने के लिए सम्मिलित हैं।

आर वैल्यू रेफरेंस और मूव कंस्ट्रक्टर्स

C ++ 03 (और पहले) में, अस्थायी मान (कंप्यूटर विज्ञान) कहा जाता है, क्योंकि वे अधिकांशतः असाइनमेंट के दाहिने तरफ असत्य बोलते हैं) का उद्देश्य कभी भी परिवर्तनीय नहीं होना चाहिए - जैसा कि सी में - और इन्हें अलग-अलग माना जाता है, इस प्रकार इससे const T& प्रकार की कुछ स्थितियों में, टेम्परेरी मानक को संशोधित किया जा सकता था, यह ऐसा व्यवहार हैं जिसे किसी उपयोगी सुरक्षा का मार्ग भी माना जाता था।^[8] C++11 ऐसा नया गैर-कॉन्स्ट संदर्भ प्रकार (C++) जोड़ता है जिसे a कहा जाता है। इस प्रकार आर के प्रतिद्वंद्विता संदर्भ द्वारा T&& को पहचाना गया तथा इस प्रकार यह उन अस्थायी वस्तुओं को संदर्भित करता है जिन्हें चलाने वाले शब्दार्थों की अनुमति देने के उद्देश्य से आरंभिक होने के बाद संशोधित करने की अनुमति दी जाती है।

इस प्रकार सी ++ 03 के साथ ऐसी पुरानी प्रदर्शन करने वाली समस्या के लिए महंगी हैं और अनावश्यक डीप लैंग्वेज है जो वस्तुओं को मूल्य से पारित होने पर अंतर्निहित रूप से हो सकती है। इस मुद्दे को स्पष्ट करने के लिए, विचार करें कि a std::vector<T> आंतरिक रूप से, परिभाषित आकार के साथ सी-शैली सरणी के चारों ओर आवरण करती हैं। इस प्रकार यदि std::vector<T> अस्थायी बनाया जाता है या किसी फ़ंक्शन से लौटाया जाता है, इसे केवल एक नया बनाकर संग्रहीत किया जा सकता है, इस प्रकार std::vector<T> और इस प्रकार इसमें सभी आर वैल्यू के डेटा को कॉपी करना आवश्यक होता हैं। इस स्थिति में अस्थायी और उसकी सभी स्मृतियों को यह नष्ट कर देती हैं। (सरलता के लिए, यह वैरियेबल्चा वापसी मूल्य अनुकूलन की उपेक्षा करती है।)

C++11 में, ab:More C++ Idioms/Move Constructor या मूव कंस्ट्रक्टरका std::vector<T> जो इसके लिए प्रतिद्वंद्विता संदर्भ लेता है इस प्रकार std::vector<T> किसी नई आरवैल्यू से आंतरिक सी-शैली सरणी में पॉइंटर को कॉपी कर सकते हैं, इसके बाद std::vector<T> पुनः पॉइंटर को आर वैल्यू के अंदर शून्य पर सेट करते हैं। चूंकि अस्थायी रूप से ये उपयोग नहीं किया जाएगा, कोई भी कोड अशक्त सूचक तक पहुंचने का प्रयास नहीं करेगा, और क्योंकि सूचक शून्य है, जब यह सीमा से बाहर हो जाता है तो इस प्रकार इसकी मेमोरी को हटाया नहीं जाता है। इसलिए, ऑपरेशन न केवल एक गहरी प्रतिलिपि की कीमत चुकाता है, बल्कि सुरक्षित और अदृश्य रहता है।

इस प्रकार मानक लाइब्रेरी के बाहर किसी प्रकार का परिवर्तन करने की आवश्यकता के अतिरिक्त आर वैल्यू संदर्भ वर्तमान समय में कोड के प्रदर्शन द्वारा होने वाले लाभ को प्रदान कर सकता हैं। इस प्रकार लौटाने वाले फ़ंक्शन के दिए गए मान का प्रकार std::vector<T> अस्थायी को स्पष्ट रूप से परिवर्तन करने की आवश्यकता नहीं है। इस प्रकार std::vector<T> && मूव कंस्ट्रक्टर को काॅल करने के लिए किया जाता हैं, क्योंकि अस्थायी रूप से स्वचालित रूप से प्रतिद्वंद्विता माना जाता है। (चूंकि, यदि std::vector<T> किसी सी ++ 03 संस्करण है जिसमें चालक कन्स्ट्रक्टर नहीं है, तो इस प्रकार कॉपी कन्स्ट्रक्टर को साथ में काॅल करता है, इस प्रकार const std::vector<T>& ऐसी महत्वपूर्ण मेमोरी को आवंटन के कारण उत्पन्न होती हैं।)

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

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

constexpr - सामान्यीकृत स्थिर भाव

सी ++ में सदैव निरंतर अभिव्यक्ति की अवधारणा होती है। ये ऐसे भाव हैं जो 3+4 जैसे स्टेटमेंट के लिए संकलन समय और रन टाइम पर सदैव एक ही परिणाम देते हैं। इस प्रकार निरंतर अभिव्यक्तियाँ संकलक के लिए अनुकूलन के अवसर प्रदान करती हैं, और संकलक अधिकांशतः संकलन-समय फ़ंक्शन निष्पादन और फंक्शनक्रम में परिणामों को हार्डकोड करते हैं। इस प्रकार कई स्थानों पर, C++ विनिर्देशन के लिए निरंतर व्यंजकों का उपयोग करने की आवश्यकता होती है। इस प्रकार की सरणी को परिभाषित करने के लिए निरंतर अभिव्यक्ति की आवश्यकता होती है, और गणनाकर्ता मान निरंतर अभिव्यक्ति होना चाहिए।

चूंकि निरंतर अभिव्यक्ति को फ़ंक्शन कॉल या ऑब्जेक्ट कन्स्ट्रक्टर रखने की अनुमति नहीं दी गई है। तो कोड का एक भाग जितना सरल है उतना ही अमान्य भी होता है:

int get_five() {return 5;} int some_value[get_five() + 7]; // Create an array of 12 integers. Ill-formed C++

यह सी ++ 03 में मान्य नहीं था, क्योंकि get_five() + 7 स्थिर अभिव्यक्ति नहीं है। सी ++ 03 कंपाइलर के पास यह जानने का कोई तरीका नहीं है कि क्या get_five() वास्तव में रनटाइम पर स्थिर है। सैद्धांतिक रूप में यह फ़ंक्शन वैश्विक वैरिएबल को प्रभावित करता हैं, तथा अन्य गैर-रनटाइम स्थिर फंक्शन्स आदि को कॉल कर सकते हैं। C++11 ने constexpr कीवर्ड प्रस्तुत किया, जो इस प्रकार उपयोगकर्ता को यह गारंटी देने की अनुमति देता है कि कोई फ़ंक्शन या ऑब्जेक्ट कंस्ट्रक्टर संकलन-समय स्थिरांक है।^[9] उपरोक्त उदाहरण को निम्नानुसार फिर से लिखा जा सकता है:

constexpr int get_five() {return 5;} int some_value[get_five() + 7]; // Create an array of 12 integers. Valid C++11

यह संकलक को समझने और सत्यापित करने की अनुमति देता है कि get_five() संकलन-समय स्थिरांक है।

constexpr का उपयोग करते हुए किसी फ़ंक्शन पर कुछ सीमाएं लगाई जाती हैं कि वह फ़ंक्शन क्या कर सकता है। इस प्रकार सबसे पहले फ़ंक्शन में गैर-शून्य रिटर्न प्रकार होना चाहिए। दूसरा फ़ंक्शन बॉडी वैरियेबल घोषित नहीं कर सकती है या नए प्रकारों को परिभाषित नहीं कर सकती है। तीसरा, भौतिक में केवल घोषणाएँ, अशक्त कथन और एकल वापसी कथन हो सकते हैं। ऐसे तर्क मान सम्मिलित होने चाहिए, जो तर्क प्रतिस्थापन के पश्चात, रिटर्न स्टेटमेंट में अभिव्यक्ति एक निरंतर अभिव्यक्ति उत्पन्न करते हैं।

C++11 से पहले, वेरिएबल्स के मानों को निरंतर एक्सप्रेशंस में उपयोग किया जा सकता है, इस प्रकार यदि वेरिएबल्स को कॉन्स घोषित किया जाता है, इस प्रकार इनिशियलाइज़र का उपयोग भी होता हैं जिसके लिए कॉन्स्टेंट एक्सप्रेशन होता है, और यह इंटीग्रल या एन्यूमरेशन टाइप का होता है। सी ++ 11 प्रतिबंध को हटा देता है कि वेरिएबल्स अभिन्न या गणना प्रकार के होने चाहिए यदि उन्हें परिभाषित किया गया है, constexpr कीवर्ड:

constexpr double earth_gravitational_acceleration = 9.8; constexpr double moon_gravitational_acceleration = earth_gravitational_acceleration / 6.0;

इस प्रकार के डेटा वेरिएबल्स निहित रूप से होते हैं, और इनकों इनिशियलाइज़र होना चाहिए जिसके लिए निरंतर अभिव्यक्ति का उपयोग होना चाहिए।

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

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

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

constexpr से consteval मेंमतभेद होना , सी ++ 20 में प्रस्तुत किया गया हैं, इस प्रकार जिसमें बाद वाले संस्करणों को सदैव संकलन समय स्थिरांक द्वारा उत्पन्न करना चाहिए, जबकि constexpr का इस पर प्रतिबंध नहीं है।

पुराने डेटा की परिभाषा में होने वाले सरल संशोधन

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

सी ++ 11 ने पीओडी अवधारणा को दो अलग-अलग अवधारणाओं तुच्छ और मानक-लेआउट में विभाजित करके कई पीओडी नियमों को आराम दिया गया हैं।

इस प्रकार जो तुच्छ है, उसे स्टैटिकली इनिशियलाइज़ किया जा सकता है। इस प्रकार इसका अर्थ यह भी है कि इसके माध्यम से डेटा को कॉपी करना मान्य है। इस प्रकार memcpyकॉपी कन्स्ट्रक्टर का उपयोग करने के अतिरिक्त तुच्छ प्रकार के जीवनकाल तब प्रारंभ होता है जब इसका भंडारण परिभाषित किया जाता है, न कि जब कोई निर्माणकर्ता पूरा हो जाता है।

किसी तुच्छ वर्ग या संरचना को एक के रूप में परिभाषित किया गया है:

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

कंस्ट्रक्टर केवल तभी तुच्छ होते हैं जब class का कोई आभासी सदस्य फंक्शन न हो और कोई आभासी आधार वर्ग न हो इस बात का ध्यान रखा जाता हैं। इस प्रकार कॉपी/मूव ऑपरेशंस के लिए भी सभी गैर-स्थैतिक डेटा सदस्यों को तुच्छ होने की आवश्यकता होती है।

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

इसका कोई आभासी फंक्शन नहीं है
इसका कोई वर्चुअल बेस क्लास नहीं है
इसके सभी गैर-स्थैतिक डेटा सदस्यों का अभिगम नियंत्रण (सार्वजनिक, निजी, संरक्षित) है
इसके सभी गैर-स्थैतिक डेटा सदस्य, इसके आधार वर्ग में कोई भी सम्मिलित है, पदानुक्रम में ही वर्ग में हैं
उपरोक्त नियम सभी आधार वर्गों और वर्ग पदानुक्रम में सभी गैर-स्थैतिक डेटा सदस्यों पर भी लागू होते हैं
इसमें पहले परिभाषित गैर-स्थैतिक डेटा सदस्य के समान प्रकार का कोई आधार वर्ग नहीं है

एक वर्ग / संरचना / संघ को POD माना जाता है, इस प्रकार यदि यह तुच्छ, मानक-लेआउट है, और इसके सभी गैर-स्थैतिक डेटा सदस्य और आधार वर्ग POD हैं।

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

कोर लैंग्वेज बिल्ड-टाइम परफॉर्मेंस एन्हांसमेंट

बाहरी टेम्पलेट

सी ++ 03 में, जब भी अनुवाद इकाई में पूर्ण रूप से निर्दिष्ट टेम्पलेट का सामना करना पड़ता है तो संकलक को टेम्पलेट को तुरंत चालू करना चाहिए। इस प्रकार यदि टेम्पलेट को कई अनुवाद इकाइयों में कई प्रकारों के साथ तत्काल किया जाता है, तो यह नाटकीय रूप से संकलन समय बढ़ा सकता है। C++ 03 में इसे रोकने का कोई तरीका नहीं है, इसलिए C++11 ने बाहरी डेटा घोषणाओं के अनुरूप बाहरी टेम्पलेट घोषणाएं प्रस्तुत कीं जाती हैं।

सी ++ 03 में यह वाक्यविन्यास है कि संकलक को टेम्पलेट को तुरंत चालू करने के लिए बाध्य किया जाए:

template class std::vector<MyClass>;

C++11 अब यह सिंटैक्स प्रदान करता है:

extern template class std::vector<MyClass>;

जो संकलक को इस अनुवाद इकाई में टेम्पलेट को तत्काल नहीं करने के लिए कहता है।

कोर भाषा प्रयोज्य संवर्द्धन

भाषा को उपयोग में सरल बनाने के प्राथमिक उद्देश्य के लिए ये सुविधाएं सम्मिलित हैं। ये इस प्रकार की सुरक्षा में सुधार कर सकते हैं, कोड पुनरावृत्ति को कम कर सकते हैं, गलत कोड की संभावना कम कर सकते हैं, आदि।

प्रारंभकर्ता सूचियां

सी ++ 03 ने सी से प्रारंभकर्ता-सूची सुविधा को विरासत में मिला है। इस प्रकार इसकी संरचना में सदस्यों की परिभाषाओं के क्रम में संरचना या सरणी को ब्रेसिज़ में तर्कों की सूची दी जाती है। ये इनिशियलाइज़र-सूचियाँ पुनरावर्ती हैं, इसलिए अन्य स्ट्रक्वैरियेबल वाले स्ट्रक्वैरियेबल या स्ट्रक्वैरियेबल की सरणी द्वारा इनका उपयोग कर सकता है।

{

struct Object
{
float first;
int second;
};
Object scalar = {0.43f, 10}; //One Object, with first=0.43f and second=10
Object anArray[] = {{13.4f, 3}, {43.28f, 29}, {5.934f, 17}}; //An array of three Objects

यह स्थैतिक सूचियों के लिए बहुत उपयोगी है, या किसी संरचना को कुछ मूल्य के लिए आरंभ करना है। सी ++ किसी ऑब्जेक्ट को प्रारंभ करने के लिए कन्स्ट्रक्टर भी प्रदान करता है, लेकिन वे अधिकांशतः प्रारंभिक सूची के रूप में सुविधाजनक नहीं होते हैं। चूंकि इस प्रकार सी ++ 03 प्रारंभिक-सूचियों को केवल उन संरचनाओं और class पर अनुमति देता है जो सरल पुराने डेटा (पीओडी) परिभाषा के अनुरूप हैं; सी ++ 11 प्रारंभकर्ता-सूचियों को बढ़ाता है, इसलिए इन्हें मानक कंटेनर समेत सभी वर्गों के लिए std::vector का उपयोग किया जा सकता है।

C++11 अवधारणा को टेम्प्लेट से बांधता है, जिसे std::initializer_list कहा जाता है। यह कंस्ट्रक्टर्स और अन्य फ़ंक्शंस को इनिशियलाइज़र सूचियों को पैरामीटर के रूप में लेने की अनुमति देता है। उदाहरण के लिए:

class SequenceClass
{
public:
    SequenceClass(std::initializer_list<int> list);

यह अनुमति देता है इस प्रकार SequenceClass पूर्णांकों के अनुक्रम से निर्मित होता हैं, जैसे:

SequenceClass some_var = {1, 4, 5, 6};

यह कंस्ट्रक्टर विशेष प्रकार का कंस्ट्रक्टर है, जिसे इनिशियलाइज़र लिस्ट कन्स्ट्रक्टर कहा जाता है। ऐसे कन्स्ट्रक्टर वाले वर्गों को विशेष रूप से युनिफार्म लोकेटर के समय माना जाता है।

टेम्पलेट वर्ग std::initializer_list<> प्रथम श्रेणी का नागरिक है | इस प्रकार प्रथम श्रेणी का C++11 मानक लाइब्रेरी प्रकार। वे C++11 कंपाइलर के उपयोग के माध्यम से स्थिर रूप से निर्मित किए जा सकते हैं, {} ऐसे संदर्भों में एक प्रकार के नाम के बिना सिंटैक्स जहां ऐसे ब्रेसिज़ a को घटाता हैं। इस प्रकार std::initializer_list, या जैसे प्रकार को स्पष्ट रूप से निर्दिष्ट करके std::initializer_list<SomeType>{args} (और इसी प्रकार डवलेपमेंट सिंटैक्स के अन्य भागों में उपयोग किया जाता हैं)।

सूची को एक बार बनाने के पश्चात कॉपी किया जा सकता है, जो सरल होता है और कॉपी करने के उपरांत इसके रूप में फंक्शन का उपयोग करता हैं। (वर्ग सामान्यतः प्रारंभ/अंत पॉइंटर्स की एक जोड़ी के रूप में फंक्शनान्वित किया जाता है)। इस प्रकार std::initializer_list स्थिर है, इस प्रकार इसके सदस्यों को बनाया जाने के पश्चात परिवर्तित नहीं किया जा सकता है, और न ही उन सदस्यों में डेटा परिवर्तित किया जा सकता है (जो उनसे आगे बढ़ने से नियम बनाते हैं, इस प्रकार class के सदस्यों में प्रतियों की आवश्यकता होती है जिनका उपयोग किया जाता हैं)।

यद्यपि इसका निर्माण विशेष रूप से संकलक द्वारा किया जाता है, a std::initializer_list ऐसा वास्तविक प्रकार है, और इस प्रकार इसलिए इसका उपयोग क्लास कंस्ट्रक्टर के अतिरिक्त अन्य स्थानों पर भी किया जा सकता है। नियमित फंक्शन टाइप किए जा सकते हैं std::initializer_list तर्क के रूप में किया जाता हैं। उदाहरण के लिए:

void function_name(std::initializer_list<float> list); // Copying is cheap; see above function_name({1.0f, -3.45f, -0.4f});

मानक लाइब्रेरी में इसके उदाहरणों में सम्मिलित हैं std::min() और std::max() टेम्पलेट्स ले रहा है std::initializer_listसंख्यात्मक प्रकार हैं। मानक कंटेनरों को इन तरीकों से भी आरंभ किया जा सकता है:

std::vector<std::string> v = { "xyzzy", "plugh", "abracadabra" };
std::vector<std::string> v({ "xyzzy", "plugh", "abracadabra" });
std::vector<std::string> v{ "xyzzy", "plugh", "abracadabra" }; // see "Uniform initialization" below

यूनिफ़ॉर्म इनिशियलाइज़ेशन

सी ++ 03 में प्रारंभिक प्रकारों के साथ कई समस्याएं रहती हैं। इस प्रकार ऐसा करने के कई तरीके सम्मिलित रहते हैं, और कुछ परस्पर विनिमय करने पर अलग अलग परिणाम देते हैं। उदाहरण के लिए, पारंपरिक कन्स्ट्रक्टर सिंटैक्स, फ़ंक्शन घोषणा की तरह दिख सकता है, और इस प्रकार यह सुनिश्चित करने के लिए कुछ कदम उठाए जाने चाहिए जैसे इस प्रकार के संकलक का उपयोग सबसे अधिक रूप से पार्स नियम के द्वारा किया जाता हैं। जो कि इस प्रकार की गलतियाँ नहीं करेगा। इस प्रकार यह केवल समुच्चय और POD प्रकारों को कुल प्रारंभकर्ताओं के साथ प्रारंभ किया जा सकता है (जिसका उपयोग SomeType var = {/*stuff*/}; के लिए किया जाता हैं।)

C++11 एक सिंटैक्स प्रदान करता है जो किसी भी वस्तु पर फंक्शन करने वाले पूर्ण रूप से समान प्रकार के इनिशियलाइज़ेशन की अनुमति देता है। यह प्रारंभकर्ता सूची सिंटैक्स पर प्रसारित होता है:

  struct BasicStruct

{
    int x;
    double y;
};

struct AltStruct
{
    AltStruct(int x, double y)
        : x_{x}
        , y_{y}
    {}

private:
    int x_;
    double y_;
};

BasicStruct var1{5, 3.2};

AltStruct var2{2, 4.3};

इस प्रकार var1 को इनिशियलाईज करने के लिए किया जाता हैं जैसे कि यह कुल प्रारंभिकरण था। इसका अर्थ यह हैं कि यह किसी ऑब्जेक्ट के प्रत्येक डेटा मेम्बर के परिवर्तन में प्रारंभकर्ता सूची से संबंधित मान के साथ प्रतिलिपि के आधार पर प्रारंभ किया जाता हैं। जहां आवश्यक हो वहां निहित प्रकार के रूपांतरण का उपयोग किया जाता हैं। इस प्रकार यदि कोई रूपांतरण सम्मिलित नहीं होता हैं, या केवल संकुचित रूपांतरण सम्मिलित होता है, तो प्रोग्राम बुरी तरह कार्य करने लगते है। जिसका फिर इनिशियलाईजेशन करके var2 द्वारा कंस्ट्रक्टर को काॅल किया जाता हैं।

इस प्रकार इस पर आधारित एक प्रोग्राम दिया गया है:

struct IdString
{
    std::string name;
    int identifier;
};

IdString get_string()
{
    return {"foo", 42}; //Note the lack of explicit type.

यूनिफ़ॉर्म इनिशियलाइज़ेशन कंस्ट्रक्टर सिंटैक्स को प्रतिस्थापित नहीं करता है, जिसकी अभी भी कई बार आवश्यकता होती है। यदि किसी वर्ग में प्रारंभकर्ता सूची कन्स्ट्रक्टर रहता है तो (TypeName(initializer_list<SomeType>);) का निर्माण इसके अन्य रूपों पर प्राथमिकता के लिए किया जाता है, इस प्रकार प्रारंभकर्ता सूची अनुक्रम कन्स्ट्रक्टर के प्रकार के अनुरूप होता हैं। सी ++ 11 का संस्करण std::vector इसके टेम्पलेट प्रकार के लिए प्रारंभकर्ता सूची के रूप में कन्स्ट्रक्टर पर आधारित होता है। इस प्रकार यह कोड:

std::vector<int> the_vec{4};

इनिशियलाइज़र लिस्ट कंस्ट्रक्टर को कॉल करती हैं, न कि कंस्ट्रक्टर को, इस प्रकार std::vector एक आकार का पैरामीटर उपयोग करता है और उस आकार के साथ वैक्टर बनाता है। इसके बाद वाले कंस्ट्रक्टर तक पहुंचने के लिए उपयोगकर्ता को सीधे मानक कंस्ट्रक्टर सिंटैक्स का उपयोग करने की आवश्यकता होती हैं।

टाइप अनुमान

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

सी ++ 11 इसकी दो विधियों से कम करने की अनुमति देता है। इस प्रकार सबसे पहले यह स्पष्ट रूप से प्रारंभ होने के साथ वैरियेबल की उचित परिभाषा का उपयोग करता हैं। इस प्रकार auto कीवर्ड को उपयोग किया जाता हैं।^[10]^[11] यह विशिष्ट प्रकार के प्रारंभकर्ता का मुख्य वैरियेबल बनाता है:

auto some_strange_callable_type = std::bind(&some_function, _2, _1, some_object);

auto other_variable = 5;

इसके जैसा एक और उदाहरण some_strange_callable_type है जो विशेष टेम्प्लेट फ़ंक्शन को ओवरराइड करता है। इस प्रकार std::bind उन विशेष तर्कों के लिए रिटर्न मान को संकलक द्वारा अपने सिमेंटिक विश्लेषण कर्तव्यों के भाग के रूप में सरलीकृत करके निर्धारित किया जाता है, लेकिन उपयोगकर्ता के लिए निरीक्षण पर निर्धारित करना सरल नहीं है।

जैसे other_variable भी अच्छी तरह से परिभाषित किया जाता है, लेकिन उपयोगकर्ता के लिए यह निर्धारित करना सरल है। इस प्रकार यह int पूर्णांक शाब्दिक मानों के समान प्रकार का मान संग्रहित करता हैं।

इस कीवर्ड का उपयोग auto सी ++ में कीवर्ड के शब्दार्थ को पुन: उपयोग करने के लिए किया जाता है, जो मूल रूप से टाइपलेस पूर्ववर्ती भाषा बी (प्रोग्रामिंग लैंग्वेज) में उपयोग किया गया था, एक अनपेक्षित स्वचालित वैरियेबल परिभाषा को दर्शाने की संबंधित भूमिका के लिए उचित उदाहरण हैं।

इसके पश्चात कीवर्ड decltype संकलन-समय पर अभिव्यक्ति करने के प्रकार को निर्धारित करने के लिए उपयोग किया जाता हैं। उदाहरण के लिए:

int some_int; decltype(some_int) other_integer_variable = 5;

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

for (std::vector<int>::const_iterator itr = myvec.cbegin(); itr != myvec.cend(); ++itr)

प्रोग्रामर इस प्रकार के छोटे-छोटे स्टेटमेंट का उपयोग करता है।

for (auto itr = myvec.cbegin(); itr != myvec.cend(); ++itr)

जिसे और अधिक संकुचित किया जा सकता है क्योंकि myvec पुनरावृत्तियों को प्रारंभ या समाप्त करता है:

for (const auto& x : myvec)

यह अंतर बढ़ता है क्योंकि प्रोग्रामर नेस्ट कंटेनरों को प्रारंभ करता है, चूंकि इस प्रकार ऐसी स्थितियों में typedefकोड की मात्रा कम करने का अच्छा तरीका है। द्वारा दर्शाया गया प्रकार decltype द्वारा निकाले गए autoप्रकार से भिन्न हो सकते हैं

#include <vector>
int main()
{
const std::vector<int> v(1);
auto a = v[0]; // a has type int
decltype(v[0]) b = 1; // b has type const int&, the return type of
// std::vector<int>::operator[](size_type) const
auto c = 0; // c has type int
auto d = c; // d has type int
decltype(c) e; // e has type int, the type of the entity named by c
decltype((c)) f = c; // f has type int&, because (c) is an lvalue
decltype(0) g; // g has type int, because 0 is an rvalue
}

लूप के लिए रेंज आधारित

for C++11 के सिंटैक्स का विस्तार करता है, तथा तत्वों की इस श्रृंखला पर सरल पुनरावृत्ति की अनुमति देने के लिए कथन का उपयोग किया जाता हैं जो इस प्रकार हैं:

int my_array[5] = {1, 2, 3, 4, 5};
// double the value of each element in my_array:
for (int& x : my_array)
x *= 2;
// similar but also using type inference for array elements
for (auto& x : my_array)
x *= 2;

for का यह रूप जिसे "नेस्टेड लूप" भी कहा जाता है, इस सूची में प्रत्येक तत्व पर पुनरावृति करता हैं। यह सी स्टाइल सारणियों के लिए इनिशियलाइज़र सूचियों और किसी भी प्रकार के लिए फंक्शन का उपोग करेगा इस प्रकार begin() और end() के लिए परिभाषित फंक्शन जो पुनरावृत्तियों को लौटाते हैं। इस प्रकार आरंभ/समाप्त संयोजन वाले सभी मानक लाइब्रेरी कंटेनर श्रेणी-आधारित के लिए कथन के साथ फंक्शन का उपयोग करेंगे।

लैम्ब्डा फ़ंक्शंस और एक्सप्रेशन

C++11 एनामिनस फंक्शन्स को बनाने की क्षमता प्रदान करता है, जिसे लैम्ब्डा फ़ंक्शन कहा जाता है।^[12]

इन्हें निम्नानुसार परिभाषित किया गया है:

[](int x, int y) -> int { return x + y; }

इस प्रकार रिटर्न फंक्शन के द्वारा (-> int इस उदाहरण में) इन सभी को छोड़ा जा सकता है। return फंक्शन एक ही मान लौटाता हैं।

यह लैम्ब्डा वैकल्पिक रूप से क्लोजर (कंप्यूटर साइंस) हो सकता है।

वैकल्पिक फ़ंक्शन सिंटैक्स

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

template<class Lhs, class Rhs> Ret adding_func(const Lhs &lhs, const Rhs &rhs) {return lhs + rhs;} //Ret must be the type of lhs+rhs

प्रारूप Ret जो भी प्रकार का जोड़ है, जिसके द्वारा Lhs और Rhs उत्पादन करते हैं। उपरोक्त C++11 की फंक्शन क्षमता के साथ भी decltype का भी उपयोग किया जाता हैं। जिसके लिए ऐसा नहीं हो सकता:

 template<class Lhs, class Rhs>

  decltype(lhs+rhs) adding_func(const Lhs &lhs, const Rhs &rhs) {return lhs + rhs;} //Not valid C++11

यह सी ++ नहीं है क्योंकि lhs और rhs अभी तक परिभाषित नहीं किया गया है, वे तब तक पहचानकर्ता नहीं होंगे जब तक कि पार्सर ने बचे हुए फ़ंक्शन प्रोटोटाइप को पार्स नहीं करते हैं।

इसके आसपास फंक्शन करने के लिए, सी ++ 11 ने अनुगामी-रिटर्न-प्रकार के साथ नये फ़ंक्शन डिक्लेरेशन सिंटैक्स द्वारा प्रस्तुत किया जाता हैं:^[13]

template<class Lhs, class Rhs> auto adding_func(const Lhs &lhs, const Rhs &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}

इस सिंटैक्स का उपयोग अधिक सांसारिक फंक्शन घोषणाओं और परिभाषाओं के लिए किया जा सकता है:

struct SomeStruct
{
auto func_name(int x, int y) -> int;
};
auto SomeStruct::func_name(int x, int y) -> int
{
return x + y;
}

इस स्थिति में "ऑटो" कीवर्ड का उपयोग सिंटैक्स का भाग है और सी ++ 11 में स्वचालित प्रकार की कमी नहीं करता है। चूंकि, C ++ 14 से प्रारंभ होकर, अनुगामी रिटर्न प्रकार को पूर्ण रूप से हटाया जा सकता है और कंपाइलर रिटर्न प्रकार को स्वचालित रूप से घटा देता हैं।^[14]

वस्तु निर्माण में सुधार

सी ++ 03 में, class के रचनाकारों को उस वर्ग की प्रारंभिक सूची में अन्य कन्स्ट्रक्टरों को कॉल करने की अनुमति नहीं है। इस प्रकार प्रत्येक कंस्ट्रक्टर को अपने सभी वर्ग सदस्यों का निर्माण स्वयं करना चाहिए या निम्नानुसार एक सामान्य सदस्य फ़ंक्शन को कॉल करना चाहिए:

class SomeType
{
public:
    SomeType(int new_number)
    {
        Construct(new_number);
    }

    SomeType()
    {
        Construct(42);
    }

private:
    void Construct(int new_number)
    {
        number = new_number;
    }

    int number;

};

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

C++11 इन सभी समस्याओं का समाधान प्रदान करता है।

सी ++ 11 कंस्ट्रक्टर्स को अन्य पीयर कंस्ट्रक्टर्स (जिसे प्रतिनिधिमंडल (प्रोग्रामिंग) कहा जाता है) को कॉल करने की अनुमति देता है। इस प्रकार यह कंस्ट्रक्टरों को कम से कम जोड़े गए कोड के साथ दूसरे कंस्ट्रक्टर के व्यवहार का उपयोग करने की अनुमति देता है। डेलिगेशन का उपयोग अन्य भाषाओं में किया गया है, उदाहरण के लिए, जावा (प्रोग्रामिंग भाषा) और स्टेटमेंट सी इत्यादि।

यह सिंटैक्स इस प्रकार है:

class SomeType
{
int number;
public:
SomeType(int new_number) : number(new_number) {}
SomeType() : SomeType(42) {}
};

ध्यान दें कि, इस स्थिति में इसके प्रभाव को से इसे प्राप्त किया जा सकता था, new_number डिफ़ॉल्ट पैरामीटर के रूप में प्रयोग किया जाता हैं। इसका सिंटैक्स इंटरफ़ेस के अतिरिक्त फंक्शन में डिफ़ॉल्ट मान (42) को व्यक्त करने की अनुमत�

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[1]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

Anonymous

Search