C++11

Not to be confused with C11 (C standard revision).

C++11, C++ प्रोग्रामिंग भाषा के लिए मानकीकरण के लिए अंतर्राष्ट्रीय संगठन/अंतर्राष्ट्रीय इंटरनेशनल इलेक्ट्रोटेक्नीकल कमीशन मानक का एक संस्करण है। C++ 11 ने C++ मानक के पूर्व संस्करण को बदल दिया, जिसे C++ 03 कहा जाता है, और बाद में इसे C++14 से बदल दिया गया। नाम विनिर्देश के प्रकाशन वर्ष द्वारा भाषा संस्करणों के नामकरण की परंपरा का पालन करता है, हालांकि इसे पूर्व में C++0x नाम दिया गया था क्योंकि यह 2010 से पहले प्रकाशित होने की उम्मीद थी। यद्यपि डिज़ाइन लक्ष्यों में से एक मुख्य भाषा में परिवर्तनों पर पुस्तकालयों में परिवर्तनों को प्राथमिकता देना था, C++ 11 मूल भाषा में कई बदलाव करता है। कोर लैंग्वेज के जिन क्षेत्रों में काफी सुधार हुआ उनमें मल्टीथ्रेडिंग सपोर्ट, सामान्य प्रोग्रामिंग सपोर्ट, यूनिफॉर्म इनिशियलाइज़ेशन और परफॉर्मेंस शामिल हैं। गणितीय विशेष कार्यों के पुस्तकालय को छोड़कर, C++ मानक पुस्तकालय में भी महत्वपूर्ण परिवर्तन किए गए, जिसमें अधिकांश C++ तकनीकी रिपोर्ट 1 (TR1) पुस्तकालय (कंप्यूटर विज्ञान) शामिल थे। C++11 को ISO/IEC 14882:2011 के रूप में प्रकाशित किया गया था सितंबर 2011 में और शुल्क के लिए उपलब्ध है। प्रकाशित C++11 मानक के समान काम करने वाला मसौदा N3337 है, दिनांक 16 जनवरी 2012; इसमें C++11 मानक से केवल संपादकीय सुधार हैं।

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

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

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

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

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

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

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

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

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

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

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

C++11 में, ab:More C++ Idioms/Move Constructor|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() इस्तेमाल किया जाना चाहिए। रावल्यू संदर्भों को केवल कुछ परिस्थितियों में ही संशोधित किया जा सकता है, जिसका मुख्य रूप से मूव कंस्ट्रक्टर के साथ उपयोग करने का इरादा है।

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

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

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

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

int get_five() {वापसी 5;}

int some_value [get_five() + 7]; // 12 पूर्णांकों की एक सरणी बनाएँ। खराब गठित सी ++

यह सी ++ 03 में मान्य नहीं था, क्योंकि get_five() + 7 स्थिर अभिव्यक्ति नहीं है। सी ++ 03 कंपाइलर के पास यह जानने का कोई तरीका नहीं है कि क्या get_five() वास्तव में रनटाइम पर स्थिर है। सिद्धांत रूप में, यह फ़ंक्शन वैश्विक चर को प्रभावित कर सकता है, अन्य गैर-रनटाइम स्थिर कार्यों आदि को कॉल कर सकता है।

C++11 ने कीवर्ड पेश किया constexpr, जो उपयोगकर्ता को यह गारंटी देने की अनुमति देता है कि एक फ़ंक्शन या ऑब्जेक्ट कंस्ट्रक्टर एक संकलन-समय स्थिरांक है। उपरोक्त उदाहरण को निम्नानुसार फिर से लिखा जा सकता है:

constexpr int get_five () {वापसी 5;}

int some_value [get_five() + 7]; // 12 पूर्णांकों की एक सरणी बनाएँ। वैध सी ++ 11

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

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

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

constexpr डबल अर्थ_गुरुत्वाकर्षण_त्वरण = 9.8; constexpr दोहरा चाँद_गुरुत्वाकर्षण_त्वरण = पृथ्वी_गुरुत्वाकर्षण_त्वरण / 6.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

टेम्पलेट वर्ग एसटीडी:: वेक्टर

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

बाहरी टेम्पलेट वर्ग एसटीडी:: वेक्टर

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

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

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

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

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

संरचना वस्तु {

   पहले तैरना;
   इंट सेकंड;

};

वस्तु अदिश = {0.43f, 10}; // एक वस्तु, पहले = 0.43f और दूसरी = 10 के साथ ऑब्जेक्ट ऐरे [] = {{13.4f, 3}, {43.28f, 29}, {5.934f, 17}}; // तीन वस्तुओं की एक सरणी

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

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

क्लास सीक्वेंस क्लास { जनता:

   अनुक्रम क्लास (एसटीडी :: प्रारंभकर्ता_सूची <int> सूची);

};

यह अनुमति देता है 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 स्थिर है: एक बार इसके सदस्यों को बनाया जाने के बाद बदला नहीं जा सकता है, और न ही उन सदस्यों में डेटा बदला जा सकता है (जो उनसे आगे बढ़ने से नियम बनाते हैं, कक्षा के सदस्यों में प्रतियों की आवश्यकता होती है, आदि)।

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

शून्य function_name (एसटीडी :: प्रारंभकर्ता_सूची <फ्लोट> सूची); // नकल करना सस्ता है; ऊपर देखें

function_name ({1.0f, -3.45f, -0.4f});

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

मानक कंटेनरों को इन तरीकों से भी आरंभ किया जा सकता है:

एसटीडी :: वेक्टर <एसटीडी :: स्ट्रिंग> वी = {xyzzy, प्लग, abracadabra}; एसटीडी :: वेक्टर <एसटीडी :: स्ट्रिंग> वी ({xyzzy, प्लग, abracadabra}); एसटीडी :: वेक्टर <एसटीडी :: स्ट्रिंग> वी {xyzzy, प्लग, abracadabra}; // नीचे यूनिफ़ॉर्म इनिशियलाइज़ेशन देखें

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

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

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

स्ट्रक्चर बेसिकस्ट्रक्चर {

   इंट एक्स;
   डबल वाई;

};

संरचना AltStruct {

   AltStruct(int x, डबल y)
       : x_{x}
       , Y y}
   {}

निजी:

   इंट x_;
   डबल वाई_;

};

बेसिक स्ट्रक्चर var1{5, 3.2}; AltStruct var2{2, 4.3};

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

कोई यह भी कर सकता है:

संरचना IdString {

   एसटीडी :: स्ट्रिंग नाम;
   इंट पहचानकर्ता;

};

आईडीस्ट्रिंग get_string () {

   वापसी {फू, 42}; // स्पष्ट प्रकार की कमी पर ध्यान दें।

}

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

एसटीडी :: वेक्टर <int> the_vec {4};

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

टाइप अनुमान

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

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

ऑटो some_strange_callable_type = std::bind(&some_function, _2, _1, some_object); ऑटो अन्य_वैरिएबल = 5;

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

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

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

int some_int; decltype (some_int) अन्य_इंटीजर_वेरिएबल = 5;

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

auto कोड की वाचालता को कम करने के लिए भी उपयोगी है। उदाहरण के लिए, लिखने के बजाय

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

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

के लिए (ऑटो आईटीआर = myvec.cbegin (); आईटीआर! = myvec.cend (); ++ आईटीआर)

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

के लिए (स्थिरांक ऑटो और x: myvec)

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

द्वारा दर्शाया गया प्रकार decltype द्वारा निकाले गए प्रकार से भिन्न हो सकते हैं auto.

1. शामिल <वेक्टर>

मुख्य प्रवेश बिंदु() {

   स्थिरांक एसटीडी :: वेक्टर वी (1);
   ऑटो ए = वी [0]; // a का प्रकार int है
   डिक्लेटाइप (वी [0]) बी = 1; // b का प्रकार const int& है, जिसका रिटर्न प्रकार है
                         // एसटीडी :: वेक्टर <int> :: ऑपरेटर [] (size_type) स्थिरांक
   ऑटो सी = 0; // c का प्रकार int है
   ऑटो डी = सी; // डी में टाइप इंट है
   डिक्लेटाइप (सी) ई; // ई में टाइप इंट है, सी द्वारा नामित इकाई का प्रकार
   decltype ((सी)) एफ = सी; // f का प्रकार int& है, क्योंकि (c) एक लवल्यू है
   डिक्लेटाइप (0) जी; // g का प्रकार int है, क्योंकि 0 एक प्रतिद्वंद्विता है

}

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

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

int my_array [5] = {1, 2, 3, 4, 5}; // my_array में प्रत्येक तत्व का मान दोगुना करें: के लिए (int और x: my_array)

   एक्स * = 2;

// समान लेकिन सरणी तत्वों के लिए प्रकार अनुमान का भी उपयोग करना के लिए (ऑटो और एक्स: my_array)

   एक्स * = 2;

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

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

Main article: Anonymous function § C++ (since C++11)

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

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

[](int x, int y) -> int {वापसी x + y; }

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

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

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

टेम्पलेट <कक्षा एलएचएस, कक्षा आरएचएस>

 Ret Add_func(const Lhs &lhs, const Rhs &rhs) {return lhs + rhs;} //Ret को lhs+rhs का प्रकार होना चाहिए

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

टेम्पलेट <कक्षा एलएचएस, कक्षा आरएचएस>

 decltype(lhs+rhs) Add_func(const Lhs &lhs, const Rhs &rhs) {वापसी lhs + rhs;} // C++11 मान्य नहीं है

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

इसके आसपास काम करने के लिए, सी ++ 11 ने अनुगामी-रिटर्न-प्रकार के साथ एक नया फ़ंक्शन डिक्लेरेशन सिंटैक्स पेश किया:

टेम्पलेट

 ऑटो एडिंग_फंक (स्थिरांक एलएचएस और एलएचएस, स्थिरांक आरएचएस और आरएचएस) -> decltype (एलएचएस + आरएचएस) {वापसी एलएचएस + आरएचएस;}

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

स्ट्रक्चर समस्ट्रक्चर{

   ऑटो func_name (int x, int y) -> int;

};

ऑटो कुछ संरचना :: func_name (int x, int y) -> int {

   वापसी एक्स + वाई;

}

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

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

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

क्लास समटाइप { जनता:

   कुछ प्रकार (int new_number)
   {
       निर्माण (नया_नंबर);
   }

   कुछ प्रकार ()
   {
       निर्माण (42);
   }

निजी:

   शून्य निर्माण (int new_number)
   {
       संख्या = नया_नंबर;
   }

   इंट संख्या;

};

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

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

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

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

क्लास समटाइप {

   इंट संख्या;

जनता:

   कुछ प्रकार (int new_number): संख्या (new_number) {}
   कुछ प्रकार (): कुछ प्रकार (42) {}

};

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

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

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

वाक्य रचना इस प्रकार है:

क्लास बेस क्लास { जनता:

   बेसक्लास (इंट वैल्यू);

};

वर्ग व्युत्पन्न वर्ग: सार्वजनिक आधार वर्ग { जनता:

   बेस क्लास का उपयोग :: बेस क्लास;

};

सदस्य आरंभीकरण के लिए, C++11 इस सिंटैक्स की अनुमति देता है:

क्लास समक्लास { जनता:

   कुछ क्लास () {}
   स्पष्ट कुछ क्लास (int new_value): मान (new_value) {}

निजी:

   इंट वैल्यू = 5;

};

क्लास का कोई भी कंस्ट्रक्टर इनिशियलाइज़ होगा value 5 के साथ, यदि कंस्ट्रक्टर अपने स्वयं के आरंभीकरण को ओवरराइड नहीं करता है। तो उपरोक्त खाली कंस्ट्रक्टर इनिशियलाइज़ हो जाएगा value जैसा कि क्लास की परिभाषा बताती है, लेकिन एक इंट लेने वाला कंस्ट्रक्टर इसे दिए गए पैरामीटर के लिए इनिशियलाइज़ करेगा।

यह ऊपर दिखाए गए असाइनमेंट इनिशियलाइज़ेशन के बजाय कंस्ट्रक्टर या यूनिफ़ॉर्म इनिशियलाइज़ेशन का भी उपयोग कर सकता है।

स्पष्ट ओवरराइड और अंतिम

सी ++ 03 में, गलती से एक नया वर्चुअल फ़ंक्शन बनाना संभव है, जब कोई बेस क्लास फ़ंक्शन को ओवरराइड करने का इरादा रखता है। उदाहरण के लिए:

संरचना आधार {

   वर्चुअल शून्य some_func (फ्लोट);

};

संरचना व्युत्पन्न: आधार {

   आभासी शून्य some_func (int);

};

मान लीजिए Derived::some_func बेस क्लास संस्करण को बदलने का इरादा है। लेकिन इसके बजाय, क्योंकि इसमें एक अलग प्रकार का हस्ताक्षर है, यह दूसरा वर्चुअल फ़ंक्शन बनाता है। यह एक आम समस्या है, खासकर जब कोई उपयोगकर्ता बेस क्लास को संशोधित करने जाता है।

C++11 इस समस्या को हल करने के लिए सिंटैक्स प्रदान करता है।

संरचना आधार {

   वर्चुअल शून्य some_func (फ्लोट);

};

संरचना व्युत्पन्न: आधार {

   वर्चुअल शून्य some_func (int) ओवरराइड; // खराब गठित - बेस क्लास विधि को ओवरराइड नहीं करता है

}; override e> विशेष पहचानकर्ता का अर्थ है कि संकलक यह देखने के लिए आधार वर्ग (तों) की जाँच करेगा कि क्या इस सटीक हस्ताक्षर के साथ कोई आभासी कार्य है। और अगर वहाँ नहीं है, तो संकलक एक त्रुटि का संकेत देगा।

सी ++ 11 कक्षाओं से विरासत को रोकने या व्युत्पन्न कक्षाओं में ओवरराइडिंग विधियों को रोकने की क्षमता भी जोड़ता है। यह विशेष पहचानकर्ता के साथ किया जाता है final. उदाहरण के लिए:

स्ट्रक्चर बेस1 फाइनल { };

संरचना व्युत्पन्न 1: बेस 1 {}; // गलत तरीके से बनाया गया है क्योंकि वर्ग बेस 1 को अंतिम रूप से चिह्नित किया गया है

संरचना आधार2 {

   आभासी शून्य च () अंतिम;

};

संरचना व्युत्पन्न 2: बेस 2 {

   शून्य च (); // गलत तरीके से बनाया गया है क्योंकि वर्चुअल फ़ंक्शन Base2::f को अंतिम रूप से चिह्नित किया गया है

};

इस उदाहरण में, virtual void f() final; बयान एक नया वर्चुअल फ़ंक्शन घोषित करता है, लेकिन यह व्युत्पन्न कक्षाओं को इसे ओवरराइड करने से भी रोकता है। यह व्युत्पन्न कक्षाओं को उस विशेष फ़ंक्शन नाम और पैरामीटर संयोजन का उपयोग करने से रोकने का प्रभाव भी रखता है।

ध्यान दें कि न तो override और न final भाषा कीवर्ड हैं। वे घोषणाकर्ता विशेषताओं के लिए तकनीकी रूप से पहचानकर्ता हैं:

• वे केवल उन विशिष्ट अनुगामी संदर्भों में उपयोग किए जाने पर विशेषताओं के रूप में विशेष अर्थ प्राप्त करते हैं (सभी प्रकार के विनिर्देशक, एक्सेस विनिर्देशक, सदस्य घोषणाएँ (संरचना, वर्ग और एनम प्रकार के लिए) और घोषणाकर्ता विनिर्देशक, लेकिन प्रत्येक घोषणाकर्ता के आरंभीकरण या कोड कार्यान्वयन से पहले घोषणाकर्ताओं की अल्पविराम से अलग की गई सूची);
• वे घोषित प्रकार के हस्ताक्षर में परिवर्तन नहीं करते हैं और किसी भी दायरे में किसी भी नए पहचानकर्ता को घोषित या ओवरराइड नहीं करते हैं;
• मान्यता प्राप्त और स्वीकृत घोषणाकर्ता विशेषताओं को सी ++ के भविष्य के संस्करणों में विस्तारित किया जा सकता है (कुछ संकलक-विशिष्ट एक्सटेंशन पहले से ही जोड़े गए घोषणाकर्ता विशेषताओं को पहचानते हैं, कोड जनरेशन विकल्प या संकलक को अनुकूलन संकेत प्रदान करने के लिए, या संकलित कोड में अतिरिक्त डेटा उत्पन्न करने के लिए, इरादा डिबगर्स, लिंकर्स, और संकलित कोड की तैनाती के लिए, या अतिरिक्त सिस्टम-विशिष्ट सुरक्षा विशेषताएँ प्रदान करने के लिए, या रनटाइम पर प्रतिबिंब (कंप्यूटर विज्ञान) क्षमताओं को बढ़ाने के लिए, या अन्य प्रोग्रामिंग भाषाओं और रनटाइम सिस्टम के साथ इंटरऑपरेबिलिटी के लिए अतिरिक्त बाध्यकारी जानकारी प्रदान करने के लिए; घोषणाकर्ता विशेषता पहचानकर्ता के बाद ये एक्सटेंशन कोष्ठक के बीच पैरामीटर ले सकते हैं; एएनएसआई अनुरूपता के लिए, इन कंपाइलर-विशिष्ट एक्सटेंशन को डबल अंडरस्कोर उपसर्ग सम्मेलन का उपयोग करना चाहिए)।
• किसी अन्य स्थान पर, वे नई घोषणाओं के लिए मान्य पहचानकर्ता हो सकते हैं (और बाद में उपयोग करें यदि वे सुलभ हैं)।

अशक्त सूचक स्थिरांक

इस खंड और अकेले इस खंड के प्रयोजनों के लिए, प्रत्येक घटना "0" का अर्थ है "एक स्थिर अभिव्यक्ति जो इसका मूल्यांकन करती है 0, जो int प्रकार का है"। वास्तव में, निरंतर अभिव्यक्ति किसी भी अभिन्न प्रकार की हो सकती है।

1972 में सी की सुबह के बाद से, निरंतर 0 निरंतर पूर्णांक और अशक्त सूचक स्थिरांक की दोहरी भूमिका रही है। के दोहरे अर्थ में निहित अस्पष्टता 0 सी में प्रीप्रोसेसर मैक्रो का उपयोग करके निपटाया गया था NULL, जो आमतौर पर या तो तक फैलता है ((void*)0) या 0. सी ++ से निहित रूपांतरण को रोकता है void * अन्य सूचक प्रकारों के लिए, इस प्रकार कास्टिंग के लाभ को दूर करना 0 को void *. परिणामस्वरूप, केवल 0 शून्य सूचक स्थिरांक के रूप में अनुमत है। यह समारोह अधिभार के साथ खराब तरीके से इंटरैक्ट करता है:

शून्य फू (चार *); शून्य फू (इंट);

अगर NULL परिभाषित किया जाता है 0 (जो आमतौर पर C++ में होता है), कथन foo(NULL); कॉल करेंगे foo(int), जो लगभग निश्चित रूप से वह नहीं है जो प्रोग्रामर का इरादा था, और न कि कोड के सतही पढ़ने से क्या पता चलता है।

सी ++ 11 एक विशिष्ट शून्य सूचक स्थिरांक के रूप में कार्य करने के लिए एक नया कीवर्ड पेश करके इसे ठीक करता है: nullptr. यह प्रकार का है nullptr_t, जो निहित रूप से परिवर्तनीय है और किसी भी सूचक प्रकार या सूचक-से-सदस्य प्रकार से तुलनीय है। इसके अलावा, यह अंतर्निहित रूप से परिवर्तनीय या अभिन्न प्रकारों से तुलनीय नहीं है bool. जबकि मूल प्रस्ताव में निर्दिष्ट किया गया था कि प्रकार का एक प्रतिद्वंद्विता nullptr_t में परिवर्तनीय नहीं होना चाहिए bool, कोर लैंग्वेज वर्किंग ग्रुप ने तय किया कि इस तरह का रूपांतरण नियमित पॉइंटर प्रकारों के साथ संगति के लिए वांछनीय होगा। जून 2008 में प्रस्तावित शब्द परिवर्तन को सर्वसम्मति से वर्किंग पेपर में वोट दिया गया था। इसी तरह का प्रस्ताव सी स्टैंडर्ड वर्किंग ग्रुप के लिए भी लाया गया है। पश्चगामी संगतता कारणों के लिए, 0 एक वैध शून्य सूचक स्थिर रहता है।

चार * पीसी = नलप्टर; // ठीक int *pi = nullptr; // ठीक बूल बी = नलप्टर; // ठीक है। ख झूठा है। int i = नलप्टर; // गलती

फू (नलप्टर); // कॉल फू (nullptr_t), फू नहीं (int); /*

 ध्यान दें कि ऊपर दिए गए उदाहरण में foo(nullptr_t) वास्तव में foo(char *) को अंतर्निहित रूपांतरण का उपयोग करके कॉल करेगा,
 केवल तभी जब संगत पॉइंटर प्रकारों के दायरे में कोई अन्य फ़ंक्शन ओवरलोडिंग नहीं कर रहा हो।
 यदि एकाधिक ओवरलोडिंग मौजूद हैं, तो संकल्प विफल हो जाएगा क्योंकि यह अस्पष्ट है,
 जब तक कि फू (nullptr_t) की स्पष्ट घोषणा न हो।

 सी ++ 11 के लिए मानक प्रकार के शीर्षलेखों में, nullptr_t प्रकार को इस प्रकार घोषित किया जाना चाहिए:
     टाइपपीफ डिक्लटाइप (नलप्टर) नलप्टर_टी;
 लेकिन नहीं के रूप में:
     टाइपपीफ int nullptr_t; // सी ++ के पूर्व संस्करण जिन्हें NULL को 0 के रूप में परिभाषित करने की आवश्यकता है
     टाइपपीफ शून्य *nullptr_t; // एएनएसआई सी जो न्यूल को ((शून्य *) 0) के रूप में परिभाषित करता है

• /

जोरदार ढंग से टाइप की गई गणनाएं

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

C++11 गणना के एक विशेष वर्गीकरण की अनुमति देता है जिसमें इनमें से कोई भी समस्या नहीं है। इसका उपयोग करके व्यक्त किया जाता है enum class (enum struct पर्यायवाची के रूप में भी स्वीकार किया जाता है) घोषणा:

एनम वर्ग गणना {

   Val1,
   Val2,
   वैल3 = 100,
   वैल4 // = 101

};

यह गणना प्रकार-सुरक्षित है। Enum वर्ग मान पूर्ण रूप से पूर्णांक में परिवर्तित नहीं होते हैं। इस प्रकार, उनकी तुलना पूर्णांकों से भी नहीं की जा सकती (अभिव्यक्ति Enumeration::Val4 == 101 संकलन त्रुटि देता है)।

अंतर्निहित प्रकार के एनम वर्ग हमेशा ज्ञात होते हैं। डिफ़ॉल्ट प्रकार है int; इसे एक अलग अभिन्न प्रकार से ओवरराइड किया जा सकता है जैसा कि इस उदाहरण में देखा जा सकता है:

एनम वर्ग Enum2: अहस्ताक्षरित int {Val1, Val2};

पुरानी शैली की गणनाओं के साथ मूल्यों को बाहरी दायरे में रखा जाता है। नई शैली की गणनाओं के साथ उन्हें एनम वर्ग के नाम के दायरे में रखा गया है। तो उपरोक्त उदाहरण में, Val1 अपरिभाषित है, लेकिन Enum2::Val1 परिभाषित किया गया।

पुरानी शैली की गणनाओं को स्पष्ट स्कूपिंग प्रदान करने और अंतर्निहित प्रकार की परिभाषा प्रदान करने के लिए एक संक्रमणकालीन वाक्यविन्यास भी है:

एनम Enum3: अहस्ताक्षरित लंबा {Val1 = 1, Val2};

इस मामले में गणनाकर्ता के नाम गणना के दायरे में परिभाषित किए गए हैं (Enum3::Val1), लेकिन पश्चगामी अनुकूलता के लिए उन्हें संलग्न दायरे में भी रखा गया है।

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

एनम एनम 1; // सी ++ 03 और सी ++ 11 में अमान्य; अंतर्निहित प्रकार निर्धारित नहीं किया जा सकता है। एनम Enum2 : अहस्ताक्षरित int; // सी ++ 11 में मान्य, अंतर्निहित प्रकार स्पष्ट रूप से निर्दिष्ट है। एनम वर्ग Enum3; // सी ++ 11 में मान्य, अंतर्निहित प्रकार int है। एनम वर्ग Enum4 : अहस्ताक्षरित int; // सी ++ 11 में मान्य। एनम Enum2 : अहस्ताक्षरित छोटा; // C++11 में अमान्य, क्योंकि Enum2 को पहले एक अलग अंतर्निहित प्रकार के साथ घोषित किया गया था।

समकोण कोष्ठक

सी ++ 03 का पार्सर परिभाषित करता है ">>” सभी मामलों में राइट शिफ्ट ऑपरेटर या स्ट्रीम एक्सट्रैक्शन ऑपरेटर के रूप में। हालाँकि, नेस्टेड टेम्प्लेट घोषणाओं के साथ, प्रोग्रामर के लिए दो समकोण कोष्ठकों के बीच एक स्थान रखने की उपेक्षा करने की प्रवृत्ति होती है, इस प्रकार एक कंपाइलर सिंटैक्स त्रुटि होती है।

सी ++ 11 पार्सर के विनिर्देश में सुधार करता है ताकि कई समकोण कोष्ठकों को टेम्पलेट तर्क सूची को बंद करने के रूप में समझा जा सके जहां यह उचित है। पैरामीटर एक्सप्रेशन के चारों ओर कोष्ठक का उपयोग करके इसे ओवरराइड किया जा सकता है ">”, “>=" या ">>"बाइनरी ऑपरेटर्स:

टेम्प्लेट <बूल टेस्ट> क्लास समटाइप; एसटीडी :: वेक्टर <कुछ टाइप <1> 2>> एक्स 1; // एक एसटीडी के रूप में व्याख्या :: SomeType <true> के वेक्टर,

   // इसके बाद 2 >> X1 है, जो घोषणाकर्ता के लिए मान्य सिंटैक्स नहीं है। 1 सत्य है।

एसटीडी :: वेक्टर <कुछ टाइप <(1> 2) >> एक्स 1; // एसटीडी के रूप में व्याख्या :: कुछ प्रकार के वेक्टर <गलत>,

   // इसके बाद डिक्लेरेटर x1 आता है, जो वैध C++11 सिंटैक्स है। (1>2) असत्य है।

स्पष्ट रूपांतरण ऑपरेटर

सी ++ 98 जोड़ा गया explicit कीवर्ड को कंस्ट्रक्टर पर एक संशोधक के रूप में इस्तेमाल किया जा सकता है ताकि सिंगल-तर्क कंस्ट्रक्टर को अंतर्निहित प्रकार के रूपांतरण ऑपरेटर के रूप में उपयोग करने से रोका जा सके। हालाँकि, यह वास्तविक रूपांतरण ऑपरेटरों के लिए कुछ नहीं करता है। उदाहरण के लिए, एक स्मार्ट पॉइंटर क्लास में a operator bool() इसे एक आदिम सूचक की तरह अधिक कार्य करने की अनुमति देने के लिए: यदि इसमें यह रूपांतरण शामिल है, तो इसका परीक्षण किया जा सकता है if (smart_ptr_variable) (जो सच होगा यदि सूचक गैर-शून्य और अन्यथा झूठा था)। हालाँकि, यह अन्य, अनपेक्षित रूपांतरणों को भी अनुमति देता है। क्योंकि सी ++ bool एक अंकगणितीय प्रकार के रूप में परिभाषित किया गया है, इसे अंतर्निहित रूप से अभिन्न या फ़्लोटिंग-पॉइंट प्रकारों में परिवर्तित किया जा सकता है, जो गणितीय संचालन की अनुमति देता है जो उपयोगकर्ता द्वारा अभिप्रेत नहीं है।

सी ++ 11 में, explicit कीवर्ड अब रूपांतरण ऑपरेटरों पर लागू किया जा सकता है। कन्स्ट्रक्टर के साथ, यह उन रूपांतरण कार्यों को अंतर्निहित रूपांतरणों में उपयोग करने से रोकता है। हालाँकि, भाषा के संदर्भ जिन्हें विशेष रूप से एक बूलियन मान की आवश्यकता होती है (if-स्टेटमेंट और लूप की स्थिति, और तार्किक ऑपरेटरों के लिए संचालन) को स्पष्ट रूपांतरण के रूप में गिना जाता है और इस प्रकार एक बूल रूपांतरण ऑपरेटर का उपयोग कर सकता है।

उदाहरण के लिए, यह फीचर b:More C++ Idioms/Safe bool इश्यू को सफाई से हल करता है।

टेम्पलेट उपनाम

सी ++ 03 में, एक टाइपपीफ को केवल अन्य प्रकार के समानार्थी के रूप में परिभाषित करना संभव है, जिसमें निर्दिष्ट सभी वास्तविक टेम्पलेट तर्कों के साथ टेम्पलेट विशेषज्ञता के समानार्थी शामिल हैं। टाइपपीफ टेम्पलेट बनाना संभव नहीं है। उदाहरण के लिए:

टेम्प्लेट <टाइपनेम फर्स्ट, टाइपनेम सेकेंड, इंट थर्ड>

वर्ग कुछ प्रकार;

टेम्पलेट <टाइपनाम दूसरा> टाइपपीफ कुछ प्रकार <अन्य प्रकार, दूसरा, 5> टाइपपीफनाम; // सी ++ 03 में अमान्य

यह संकलित नहीं होगा।

सी ++ 11 इस सिंटैक्स के साथ इस क्षमता को जोड़ता है:

टेम्प्लेट <टाइपनेम फर्स्ट, टाइपनेम सेकेंड, इंट थर्ड> वर्ग कुछ प्रकार;

टेम्पलेट <टाइपनाम दूसरा> TypedefName = SomeType<OtherType, Second, 5>; using e> सिंटैक्स का उपयोग C++ 11 में टाइप अलियासिंग के रूप में भी किया जा सकता है:

टाइपपीफ शून्य (* फंक्शन टाइप) (डबल); // पुराना तरीका फंक्शनटाइप = शून्य (*) (डबल) का उपयोग करना; // नया पेश किया गया सिंटैक्स

अप्रतिबंधित संघ

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

यह C++11 में अनुमत यूनियन का एक सरल उदाहरण है:

1. शामिल <नया> // नियुक्ति के लिए आवश्यक 'नया'।

संरचना बिंदु {

   बिंदु() {}
   बिंदु (int x, int y): x_(x), y_(y) {}
   इंट x_, y_;

};

संघ यू {

   इंट जेड;
   डबल डब्ल्यू;
   प्वाइंट पी; // सी ++ 03 में अमान्य; सी ++ 11 में मान्य।
   यू() {} // प्वाइंट सदस्य के कारण, अब एक कन्स्ट्रक्टर परिभाषा की आवश्यकता है।
   यू (स्थिरांक बिंदु और पीटी): पी (पीटी) {} // प्रारंभकर्ता सूची का उपयोग करके प्वाइंट ऑब्जेक्ट का निर्माण करें।
   यू एंड ऑपरेटर = (स्थिरांक प्वाइंट और पीटी) {नया (& पी) प्वाइंट (पीटी); वापसी * ​​यह; } // प्लेसमेंट 'नया' का उपयोग करके पॉइंट ऑब्जेक्ट असाइन करें।

};

परिवर्तन किसी भी मौजूदा कोड को नहीं तोड़ेंगे क्योंकि वे केवल मौजूदा नियमों को शिथिल करते हैं।

कोर भाषा कार्यक्षमता में सुधार

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

वैराडिक टेम्प्लेट

Main article: Variadic template

सी ++ 11 में, टेम्पलेट टेम्पलेट पैरामीटर के परिवर्तनीय संख्या ले सकते हैं। यह प्रकार-सुरक्षित वैरिएडिक कार्यों की परिभाषा की भी अनुमति देता है।

नया स्ट्रिंग शाब्दिक

C++ 03 दो प्रकार के स्ट्रिंग लिटरल प्रदान करता है। डबल कोट्स के भीतर निहित पहली तरह, प्रकार की एक शून्य-समाप्त सरणी उत्पन्न करती है const char. दूसरी तरह, के रूप में परिभाषित किया गया L"", प्रकार की एक अशक्त-समाप्त सरणी उत्पन्न करता है const wchar_t, कहाँ wchar_t अपरिभाषित आकार और शब्दार्थ का एक विस्तृत-चरित्र है। कोई भी शाब्दिक प्रकार UTF-8, UTF-16, या यूनिकोड एन्कोडिंग की किसी अन्य प्रकार की यूनिकोड तुलना के साथ स्ट्रिंग शाब्दिक के लिए समर्थन प्रदान नहीं करता है।

C++11 तीन यूनिकोड एनकोडिंग का समर्थन करता है: UTF-8, UTF-16 और UTF-32। प्रकार की परिभाषा char स्पष्ट रूप से व्यक्त करने के लिए संशोधित किया गया है कि यह कम से कम UTF-8 के आठ-बिट कोडिंग को संग्रहीत करने के लिए आवश्यक आकार है, और संकलक के मूल निष्पादन वर्ण सेट के किसी भी सदस्य को शामिल करने के लिए पर्याप्त बड़ा है। इसे पूर्व में सी ++ मानक में केवल बाद वाले के रूप में परिभाषित किया गया था, फिर कम से कम 8 बिट्स की गारंटी के लिए सी मानक पर निर्भर था। इसके अलावा, सी ++ 11 दो नए चरित्र प्रकार जोड़ता है: char16_t और char32_t. ये क्रमशः UTF-16 और UTF-32 को स्टोर करने के लिए डिज़ाइन किए गए हैं।

प्रत्येक समर्थित एनकोडिंग के लिए स्ट्रिंग शाब्दिक बनाना इस प्रकार किया जा सकता है:

u8 मैं एक UTF-8 स्ट्रिंग हूँ। u यह एक UTF-16 स्ट्रिंग है। U यह एक UTF-32 स्ट्रिंग है।

पहली स्ट्रिंग का प्रकार सामान्य है const char[]. दूसरी कड़ी का प्रकार है const char16_t[] (नोट लोअर केस 'यू' उपसर्ग)। तीसरे तार का प्रकार है const char32_t[] (अपर केस 'यू' उपसर्ग)।

यूनिकोड स्ट्रिंग शाब्दिक का निर्माण करते समय, यूनिकोड कोड बिंदुओं को सीधे स्ट्रिंग में सम्मिलित करना अक्सर उपयोगी होता है। ऐसा करने के लिए, C++11 इस सिंटैक्स की अनुमति देता है:

u8 यह एक यूनिकोड कैरेक्टर है: \u2018। u यह एक बड़ा यूनिकोड कैरेक्टर है: \u2018। यू यह एक यूनिकोड वर्ण है: \U00002018।

के बाद की संख्या \u एक हेक्साडेसिमल संख्या है; इसे सामान्य की आवश्यकता नहीं है 0x उपसर्ग। पहचानकर्ता \u 16-बिट यूनिकोड कोड बिंदु का प्रतिनिधित्व करता है; 32-बिट कोड बिंदु दर्ज करने के लिए, उपयोग करें \U और एक 32-बिट हेक्साडेसिमल संख्या। केवल मान्य यूनिकोड कोड अंक दर्ज किए जा सकते हैं। उदाहरण के लिए, U+D800–U+DFFF श्रेणी पर कोड बिंदु निषिद्ध हैं, क्योंकि वे UTF-16 एन्कोडिंग में सरोगेट जोड़े के लिए आरक्षित हैं।

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

R (स्ट्रिंग डेटा \ Stuff )
आर सीमांकक (स्ट्रिंग डेटा \ सामग्री) सीमांकक
</पूर्व>

पहले मामले में, के बीच सब कुछ "( और यह )" कड़ी का हिस्सा है। " ई> और \ पात्रों को भागने की जरूरत नहीं है। दूसरे मामले में, "delimiter( स्ट्रिंग शुरू करता है, और यह तभी समाप्त होता है जब )delimiter" पहुंच गया। डोर delimiter रिक्त स्ट्रिंग सहित लंबाई में 16 वर्णों तक कोई भी स्ट्रिंग हो सकती है। इस स्ट्रिंग में रिक्त स्थान, नियंत्रण वर्ण नहीं हो सकते, (, ), या \ चरित्र। इस सीमांकक स्ट्रिंग का उपयोग करके, उपयोगकर्ता के पास हो सकता है ) कच्चे स्ट्रिंग शाब्दिक के भीतर वर्ण। उदाहरण के लिए, R"delimiter((a-z))delimiter" के बराबर है "(a-z)".
रॉ स्ट्रिंग लिटरल को वाइड लिटरल या यूनिकोड लिटरल प्रीफिक्स में से किसी के साथ जोड़ा जा सकता है:

u8R XXX(मैं एक कच्चा UTF-8 स्ट्रिंग हूं।)XXX
uR *(यह एक कच्ची UTF-16 स्ट्रिंग है।)*
यूआर (यह एक कच्चा यूटीएफ -32 स्ट्रिंग है।)
</पूर्व>

उपयोगकर्ता परिभाषित शाब्दिक
सी ++ 03 कई अक्षर प्रदान करता है। पात्र 12.5 एक शाब्दिक है जिसे संकलक द्वारा एक प्रकार के रूप में हल किया जाता है double 12.5 के मान के साथ। हालाँकि, प्रत्यय का जोड़ f, के रूप में 12.5f, प्रकार का मान बनाता है float जिसमें मान 12.5 है। शाब्दिक के लिए प्रत्यय संशोधक C ++ विनिर्देशन द्वारा तय किए गए हैं, और C ++ 03 कोड नए शाब्दिक संशोधक नहीं बना सकते हैं।

इसके विपरीत, सी ++ 11 उपयोगकर्ता को नए प्रकार के शाब्दिक संशोधक को परिभाषित करने में सक्षम बनाता है जो शाब्दिक संशोधित वर्णों की स्ट्रिंग के आधार पर वस्तुओं का निर्माण करेगा।

शाब्दिक परिवर्तन को दो अलग-अलग चरणों में परिभाषित किया गया है: कच्चा और पका हुआ। एक कच्चा शाब्दिक कुछ विशिष्ट प्रकार के वर्णों का एक क्रम है, जबकि पका हुआ शाब्दिक एक अलग प्रकार का होता है। सी ++ शाब्दिक 1234, कच्चे शाब्दिक के रूप में, वर्णों का यह क्रम है '1', '2', '3', '4'. पके हुए शाब्दिक के रूप में, यह पूर्णांक 1234 है। C++ शाब्दिक 0xA कच्चे रूप में है '0', 'x', 'A', जबकि पके हुए रूप में यह पूर्णांक 10 है।

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

सभी उपयोक्ता परिभाषित शाब्दिक प्रत्यय हैं; उपसर्ग शाब्दिक को परिभाषित करना संभव नहीं है। अंडरस्कोर को छोड़कर किसी भी वर्ण से शुरू होने वाले सभी प्रत्यय (_) मानक द्वारा आरक्षित हैं। इस प्रकार, सभी उपयोक्ता-परिभाषित शाब्दिकों में एक अंडरस्कोर से शुरू होने वाले प्रत्यय होने चाहिए (_).
शाब्दिक के कच्चे रूप को संसाधित करने वाले उपयोगकर्ता-परिभाषित शाब्दिक को एक शाब्दिक ऑपरेटर के माध्यम से परिभाषित किया जाता है, जिसे लिखा जाता है operator "". एक उदाहरण इस प्रकार है:

<वाक्यविन्यास लैंग = सीपीपी>
आउटपुट टाइप ऑपरेटर _mysuffix (स्थिरांक चार * शाब्दिक_स्ट्रिंग)
{
    // मानता है कि OutputType में एक कंस्ट्रक्टर है जो एक const char * लेता है
    आउटपुट टाइप रिट (शाब्दिक_स्ट्रिंग);
    वापसी रिट;
}

आउटपुट टाइप some_variable = 1234_mysuffix;
// मानता है कि OutputType में get_value() विधि है जो एक डबल रिटर्न देती है
जोर दें (some_variable.get_value () == 1234.0)
</वाक्यविन्यास हाइलाइट>

असाइनमेंट स्टेटमेंट OutputType some_variable = 1234_mysuffix; उपयोगकर्ता परिभाषित शाब्दिक फ़ंक्शन द्वारा परिभाषित कोड निष्पादित करता है। यह समारोह पारित हो गया है "1234" सी-स्टाइल स्ट्रिंग के रूप में, इसलिए इसमें एक शून्य टर्मिनेटर है।

पूर्णांक और फ्लोटिंग पॉइंट रॉ लिटरल को संसाधित करने के लिए एक वैकल्पिक तंत्र एक विविध टेम्पलेट के माध्यम से है:

<वाक्यविन्यास लैंग = सीपीपी>
टेम्पलेट<char...> OutputType ऑपरेटर _tuffix();

आउटपुट टाइप some_variable = 1234_tuffix;
आउटपुट टाइप अन्य_वैरिएबल = 2.17_टफिक्स;
</वाक्यविन्यास हाइलाइट>

यह लिटरल प्रोसेसिंग फंक्शन को इस रूप में इंस्टेंट करता है operator "" _tuffix<'1', '2', '3', '4'>(). इस रूप में, स्ट्रिंग को समाप्त करने वाला कोई अशक्त वर्ण नहीं है। ऐसा करने का मुख्य उद्देश्य C++ 11's का उपयोग करना है constexpr कीवर्ड यह सुनिश्चित करने के लिए कि संकलक पूरी तरह से संकलित समय पर शाब्दिक रूप से परिवर्तित हो जाएगा OutputType एक constexpr-constructible और copyable टाइप है, और लिटरल प्रोसेसिंग फंक्शन a है constexpr समारोह।

न्यूमेरिक लिटरल के लिए, पके हुए लिटरल का प्रकार या तो है unsigned long long अभिन्न शाब्दिक के लिए या long double फ़्लोटिंग पॉइंट शाब्दिक के लिए। (ध्यान दें: हस्ताक्षरित इंटीग्रल प्रकारों की कोई आवश्यकता नहीं है क्योंकि साइन-उपसर्ग शाब्दिक को एक अभिव्यक्ति के रूप में पार्स किया जाता है जिसमें साइन एक यूनरी प्रीफ़िक्स ऑपरेटर और अहस्ताक्षरित संख्या के रूप में होता है।) कोई वैकल्पिक टेम्पलेट फॉर्म नहीं है:

<वाक्यविन्यास लैंग = सीपीपी>
OutputType ऑपरेटर _प्रत्यय (अहस्ताक्षरित लंबा लंबा);
आउटपुट टाइप ऑपरेटर _प्रत्यय (लंबा डबल);

आउटपुट टाइप some_variable = 1234_suffix; // 'अहस्ताक्षरित लंबे लंबे' अधिभार का उपयोग करता है।
आउटपुट टाइप अन्य_वैरिएबल = 3.1416_प्रत्यय; // 'लॉन्ग डबल' ओवरलोड का उपयोग करता है।
</वाक्यविन्यास हाइलाइट>

स्ट्रिंग अक्षर के लिए पूर्व में उल्लिखित नए स्ट्रिंग उपसर्गों के अनुसार, इनका उपयोग किया जाता है:

<वाक्यविन्यास लैंग = सीपीपी>
OutputType ऑपरेटर _ssuffix (स्थिरांक चार * string_values, size_t num_chars);
आउटपुट टाइप ऑपरेटर _ssuffix (स्थिरांक wchar_t * string_values, size_t num_chars);
OutputType ऑपरेटर _ssuffix (const char16_t * string_values, size_t num_chars);
OutputType ऑपरेटर _ssuffix (स्थिरांक char32_t * string_values, size_t num_chars);

आउटपुट टाइप some_variable = 1234 _ssuffix; // 'कॉन्स्ट चार *' ओवरलोड का उपयोग करता है।
आउटपुट टाइप some_variable = u8 1234 _ssuffix; // 'कॉन्स्ट चार *' ओवरलोड का उपयोग करता है।
आउटपुट टाइप some_variable = L 1234 _ssuffix; // 'const wchar_t *' ओवरलोड का उपयोग करता है।
आउटपुट टाइप some_variable = u 1234 _ssuffix; // 'const char16_t *' ओवरलोड का उपयोग करता है।
आउटपुट टाइप some_variable = U 1234 _ssuffix; // 'const char32_t *' ओवरलोड का उपयोग करता है।
</वाक्यविन्यास हाइलाइट>

कोई वैकल्पिक टेम्पलेट प्रपत्र नहीं है। वर्ण शाब्दिक इसी तरह परिभाषित किए गए हैं।

मल्टीथ्रेडिंग मेमोरी मॉडल
See also: Memory model (computing)
C++11 थ्रेड (कंप्यूटर विज्ञान) के लिए समर्थन का मानकीकरण करता है।

इसमें दो भाग शामिल हैं: एक मेमोरी मॉडल जो एक प्रोग्राम में कई थ्रेड्स को सह-अस्तित्व की अनुमति देता है और थ्रेड्स के बीच बातचीत के लिए लाइब्रेरी सपोर्ट करता है। (#Threading सुविधाओं पर इस लेख का अनुभाग देखें।)

मेमोरी मॉडल परिभाषित करता है कि कब कई थ्रेड्स एक ही मेमोरी लोकेशन तक पहुंच सकते हैं, और निर्दिष्ट करता है कि कब एक थ्रेड द्वारा अपडेट अन्य थ्रेड्स के लिए दृश्यमान हो जाते हैं।

थ्रेड-लोकल स्टोरेज
बहु-थ्रेडेड वातावरण में, प्रत्येक थ्रेड के लिए कुछ अद्वितीय चर (प्रोग्रामिंग) होना आम बात है। यह पहले से ही किसी फ़ंक्शन के स्थानीय चर के लिए होता है, लेकिन यह वैश्विक और स्थैतिक चर के लिए नहीं होता है।

एक नया थ्रेड-लोकल स्टोरेज | थ्रेड-लोकल स्टोरेज अवधि (मौजूदा स्थिर, गतिशील और स्वचालित के अलावा) स्टोरेज स्पेसियर द्वारा इंगित की जाती है thread_local.

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

स्पष्ट रूप से डिफॉल्ट विशेष सदस्य कार्य
सी ++ 03 में, कंपाइलर उन कक्षाओं के लिए प्रदान करता है जो उन्हें स्वयं के लिए प्रदान नहीं करते हैं, एक डिफ़ॉल्ट कन्स्ट्रक्टर, एक कॉपी कन्स्ट्रक्टर, एक कॉपी असाइनमेंट ऑपरेटर (operator=), और एक विध्वंसक। प्रोग्रामर कस्टम संस्करणों को परिभाषित करके इन डिफॉल्ट्स को ओवरराइड कर सकता है। C++ कई वैश्विक ऑपरेटरों को भी परिभाषित करता है (जैसे operator new) जो सभी वर्गों पर काम करता है, जिसे प्रोग्रामर ओवरराइड कर सकता है।

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

डिफॉल्ट कंस्ट्रक्टर के मामले में, कंपाइलर डिफॉल्ट कंस्ट्रक्टर उत्पन्न नहीं करेगा यदि किसी क्लास को किसी कंस्ट्रक्टर के साथ परिभाषित किया गया है। यह कई मामलों में उपयोगी है, लेकिन यह विशेष कंस्ट्रक्टर और कंपाइलर-जेनरेट किए गए डिफ़ॉल्ट दोनों के लिए भी उपयोगी है।

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

<वाक्यविन्यास लैंग = सीपीपी>
क्लास समटाइप
{
    कुछ प्रकार () = डिफ़ॉल्ट; // डिफॉल्ट कंस्ट्रक्टर स्पष्ट रूप से कहा गया है।
    कुछ प्रकार (अन्य प्रकार का मान);
};
</वाक्यविन्यास हाइलाइट>

स्पष्ट रूप से हटाए गए कार्य
एक फ़ंक्शन को स्पष्ट रूप से अक्षम किया जा सकता है। यह अंतर्निहित प्रकार के रूपांतरणों को रोकने के लिए उपयोगी है। = delete e> विनिर्देशक का उपयोग विशेष प्रकार के पैरामीटर वाले फ़ंक्शन को कॉल करने से रोकने के लिए किया जा सकता है।उदाहरण के लिए:
<वाक्यविन्यास लैंग = सीपीपी>
शून्य नहीं (डबल i);
शून्य नहीं (int) = हटाएं;
</वाक्यविन्यास हाइलाइट>

कॉल करने का प्रयास noInt() एक साथ int साइलेंट रूपांतरण करने के बजाय, पैरामीटर को कंपाइलर द्वारा अस्वीकार कर दिया जाएगा double. कॉलिंग noInt() के साथ float अभी भी काम करता है।

इसके अलावा किसी अन्य प्रकार से फ़ंक्शन को कॉल करने पर रोक लगाना संभव है double एक टेम्पलेट का उपयोग करके:
<वाक्यविन्यास लैंग = सीपीपी>
डबल केवल डबल (डबल डी) {वापसी डी;}
टेम्पलेट <टाइपनेम टी> केवल डबल डबल (टी) = हटाएं;
</वाक्यविन्यास हाइलाइट>

कॉलिंग onlyDouble(1.0) काम करेगा, जबकि onlyDouble(1.0f) एक संकलक त्रुटि उत्पन्न करेगा।

क्लास मेंबर फ़ंक्शंस और कंस्ट्रक्टर्स को भी डिलीट किया जा सकता है। उदाहरण के लिए, कॉपी कंस्ट्रक्टर और को हटाकर क्लास ऑब्जेक्ट्स को कॉपी करने से रोकना संभव है operator =:

<वाक्यविन्यास लैंग = सीपीपी>
गैर कॉपी करने योग्य वर्ग
{
    कॉपी न करने योग्य ();
    NonCopyable(const NonCopyable&) = हटाएं;
    NonCopyable& ऑपरेटर = (स्थिरांक NonCopyable&) = हटाएं;
};
</वाक्यविन्यास हाइलाइट>

टाइप करें long long int
C++ 03 में, सबसे बड़ा पूर्णांक प्रकार है long int. कम से कम उतने उपयोग योग्य बिट होने की गारंटी है int. इसका परिणाम हुआ long int कुछ लोकप्रिय कार्यान्वयनों पर 64 बिट्स का आकार और अन्य पर 32 बिट्स। सी ++ 11 एक नया पूर्णांक प्रकार जोड़ता है long long int इस मुद्दे का समाधान करने के लिए। यह कम से कम एक जितना बड़ा होने की गारंटी है long int, और 64 बिट्स से कम नहीं है। प्रकार मूल रूप से सी 99 द्वारा मानक सी में पेश किया गया था, और अधिकांश सी ++ कंपाइलर्स ने इसे पहले से ही एक एक्सटेंशन के रूप में समर्थन दिया था।


स्थिर अभिकथन
C++ 03 अभिकथन (कंप्यूटिंग) का परीक्षण करने के लिए दो विधियाँ प्रदान करता है: मैक्रो assert और प्रीप्रोसेसर निर्देश #error. हालांकि, इनमें से कोई भी टेम्प्लेट में उपयोग के लिए उपयुक्त नहीं है: मैक्रो निष्पादन-समय पर अभिकथन का परीक्षण करता है, जबकि प्रीप्रोसेसर निर्देश प्रीप्रोसेसिंग के दौरान अभिकथन का परीक्षण करता है, जो कि टेम्प्लेट के इन्स्टेन्शियशन से पहले होता है। इनमें से कोई भी उन गुणों के परीक्षण के लिए उपयुक्त नहीं है जो टेम्प्लेट पैरामीटर पर निर्भर हैं।

नई उपयोगिता नए कीवर्ड का उपयोग करते हुए संकलन-समय पर अभिकथन का परीक्षण करने का एक नया तरीका पेश करती है static_assert.
घोषणा इस रूप को मानती है:
 static_assert (निरंतर-अभिव्यक्ति, त्रुटि-संदेश);

यहां कुछ उदाहरण दिए गए हैं कि कैसे static_assert इस्तेमाल किया जा सकता है:
<वाक्यविन्यास लैंग = सीपीपी>
static_assert((ग्रीकपीआई > 3.14) && (ग्रीकपीआई <3.15), ग्रीकपीआई गलत है! );
</वाक्यविन्यास हाइलाइट>
<वाक्यविन्यास लैंग = सीपीपी>
टेम्पलेट <कक्षा टी>
स्ट्रक्चर चेक
{
    static_assert(sizeof(int) <= sizeof(T), T काफी बड़ा नहीं है! );
};
</वाक्यविन्यास हाइलाइट>
<वाक्यविन्यास लैंग = सीपीपी>
टेम्प्लेट <क्लास इंटीग्रल>
इंटीग्रल फू (इंटीग्रल एक्स, इंटीग्रल वाई)
{
    static_assert(std::is_integral<Integral>::value, foo() पैरामीटर एक अभिन्न प्रकार होना चाहिए।);
}
</वाक्यविन्यास हाइलाइट>

जब निरंतर अभिव्यक्ति है false संकलक एक त्रुटि संदेश उत्पन्न करता है। पहला उदाहरण प्रीप्रोसेसर निर्देश के समान है #error, हालांकि प्रीप्रोसेसर केवल अभिन्न प्रकारों का समर्थन करता है। इसके विपरीत, दूसरे उदाहरण में टेम्पलेट वर्ग के प्रत्येक इन्स्टेन्शियशन पर अभिकथन की जाँच की जाती है Check.

स्टैटिक अभिकथन टेम्प्लेट के बाहर भी उपयोगी होते हैं। उदाहरण के लिए, एक एल्गोरिथम का दिया गया कार्यान्वयन a के आकार पर निर्भर हो सकता है long long एक से बड़ा होना int, कुछ ऐसा जो मानक गारंटी नहीं देता है। ऐसी धारणा अधिकांश प्रणालियों और संकलकों पर मान्य है, लेकिन सभी पर नहीं।

अनुमति दें sizeof स्पष्ट वस्तु के बिना कक्षाओं के सदस्यों पर काम करने के लिए
सी ++ 03 में, sizeof ऑपरेटर का उपयोग प्रकार और वस्तुओं पर किया जा सकता है। लेकिन ऐसा करने के लिए इसका इस्तेमाल नहीं किया जा सकता है:

<वाक्यविन्यास लैंग = सीपीपी>
संरचना कुछ प्रकार {अन्य प्रकार के सदस्य; };

आकार (कुछ प्रकार :: सदस्य); // सी ++ 03 के साथ काम नहीं करता है। सी ++ 11 के साथ ठीक है
</वाक्यविन्यास हाइलाइट>

इसका आकार वापस करना चाहिए OtherType. सी ++ 03 इसे अस्वीकार करता है, इसलिए यह एक संकलन त्रुटि है। सी ++ 11 इसे अनुमति देता है। इसके लिए भी अनुमति है alignof ऑपरेटर सी ++ 11 में पेश किया गया।

नियंत्रण और क्वेरी वस्तु संरेखण
सी ++ 11 परिवर्तनीय संरेखण को पूछताछ और नियंत्रित करने की अनुमति देता है alignof और alignas. alignof e> ऑपरेटर प्रकार लेता है और 2 बाइट सीमा की शक्ति देता है जिस पर प्रकार के उदाहरण आवंटित किए जाने चाहिए (a std::size_t). जब एक संदर्भ प्रकार दिया जाता है alignof संदर्भित प्रकार का संरेखण लौटाता है; सरणियों के लिए यह तत्व प्रकार के संरेखण को लौटाता है। alignas e> निर्दिष्टकर्ता एक चर के लिए स्मृति संरेखण को नियंत्रित करता है। निर्दिष्टकर्ता स्थिर या एक प्रकार लेता है; जब एक प्रकार की आपूर्ति की alignas(T) के लिए आशुलिपि है alignas(alignof(T)). उदाहरण के लिए, यह निर्दिष्ट करने के लिए कि एक फ्लोट रखने के लिए एक चार सरणी को ठीक से गठबंधन किया जाना चाहिए:
<वाक्यविन्यास लैंग = सीपीपी>
संरेखण (फ्लोट) अहस्ताक्षरित चार सी [आकार (फ्लोट)]
</वाक्यविन्यास हाइलाइट>

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

गुण
C++11 भाषा के लिए कंपाइलर/टूल एक्सटेंशन के लिए एक मानकीकृत सिंटैक्स प्रदान करता है। इस तरह के एक्सटेंशन पारंपरिक रूप से उपयोग करके निर्दिष्ट किए गए थे #pragma निर्देश या विक्रेता-विशिष्ट कीवर्ड (जैसे __attribute__ जीएनयू के लिए और __declspec माइक्रोसॉफ्ट के लिए)। नए सिंटैक्स के साथ, अतिरिक्त जानकारी को दोहरे वर्ग कोष्ठक में संलग्न विशेषता के रूप में निर्दिष्ट किया जा सकता है। स्रोत कोड के विभिन्न तत्वों पर एक विशेषता लागू की जा सकती है:
<वाक्यविन्यास लैंग = सीपीपी>
int attr1 और attr2, attr3;

attr4(arg1, arg2) अगर (cond)
{
    विक्रेता :: attr5 वापसी i;
}
</वाक्यविन्यास हाइलाइट>
उपरोक्त उदाहरण में, विशेषता attr1 चर के प्रकार पर लागू होता है i, attr2 और attr3 चर पर ही लागू करें, attr4 पर लागू होता है if बयान और vendor::attr5 रिटर्न स्टेटमेंट पर लागू होता है। सामान्य तौर पर (लेकिन कुछ अपवादों के साथ), एक नामित इकाई के लिए निर्दिष्ट एक विशेषता नाम के बाद और इकाई से पहले रखी जाती है, अन्यथा, जैसा कि ऊपर दिखाया गया है, कई विशेषताओं को डबल स्क्वायर ब्रैकेट की एक जोड़ी के अंदर सूचीबद्ध किया जा सकता है, अतिरिक्त तर्क प्रदान किए जा सकते हैं एक विशेषता के लिए, और विशेषताएँ विक्रेता-विशिष्ट विशेषता नामस्थानों द्वारा स्कोप की जा सकती हैं।

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

C++11 स्वयं दो मानक विशेषताएँ प्रदान करता है: noreturn यह निर्दिष्ट करने के लिए कि कोई फ़ंक्शन वापस नहीं आता है, और carries_dependency बहु-थ्रेडेड कोड को अनुकूलित करने में मदद करने के लिए यह इंगित करके कि फ़ंक्शन तर्क या वापसी मूल्य एक निर्भरता रखता है।


सी ++ मानक पुस्तकालय परिवर्तन
C++11 मानक पुस्तकालय में कई नई सुविधाएँ पेश की गईं। इनमें से कई को पुराने मानक के तहत लागू किया जा सकता था, लेकिन कुछ नए C++11 कोर सुविधाओं पर भरोसा करते हैं (अधिक या कम हद तक)।

नई लाइब्रेरी (कंप्यूटर साइंस) का एक बड़ा हिस्सा दस्तावेज़ तकनीकी रिपोर्ट 1|C++ मानक समिति की लाइब्रेरी तकनीकी रिपोर्ट (जिसे TR1 कहा जाता है) में परिभाषित किया गया था, जिसे 2005 में प्रकाशित किया गया था। TR1 के विभिन्न पूर्ण और आंशिक कार्यान्वयन वर्तमान में नाम स्थान का उपयोग करके उपलब्ध हैं। std::tr1. सी ++ 11 के लिए उन्हें नेमस्पेस में ले जाया गया std. हालाँकि, जैसा कि TR1 सुविधाओं को C++11 मानक पुस्तकालय में लाया गया था, उन्हें C++11 भाषा सुविधाओं के साथ जहां उपयुक्त हो, उन्नत किया गया था जो प्रारंभिक TR1 संस्करण में उपलब्ध नहीं थे। इसके अलावा, उन्हें उन सुविधाओं के साथ बढ़ाया जा सकता है जो सी ++ 03 के तहत संभव थे, लेकिन मूल टीआर 1 विनिर्देश का हिस्सा नहीं थे।

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

* रावल्यू संदर्भ और संबंधित चाल समर्थन
* UTF-16 एन्कोडिंग इकाई और UTF-32 एन्कोडिंग इकाई यूनिकोड वर्ण प्रकारों के लिए समर्थन
* वैराडिक टेम्प्लेट (सही अग्रेषण के लिए अनुमति देने के लिए Rvalue संदर्भों के साथ युग्मित)
* संकलन-समय निरंतर भाव
* decltype
* explicit रूपांतरण ऑपरेटरों
* कार्यों को डिफॉल्ट घोषित या हटा दिया गया

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

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

थ्रेड क्लास (std::thread) प्रदान किया जाता है, जो नए थ्रेड में चलने के लिए एक समारोह वस्तु (और इसे पारित करने के लिए तर्कों की एक वैकल्पिक श्रृंखला) लेता है। एक थ्रेड को तब तक रोकना संभव है जब तक कि एक और निष्पादन थ्रेड पूरा न हो जाए, थ्रेड जॉइनिंग सपोर्ट प्रदान करता है std::thread::join() सदस्य समारोह। प्लेटफ़ॉर्म (कंप्यूटिंग)-विशिष्ट संचालन के लिए अंतर्निहित नेटिव थ्रेड ऑब्जेक्ट (ओं) तक पहुँच प्रदान की जाती है, जहाँ संभव हो std::thread::native_handle() सदस्य समारोह।

थ्रेड्स के बीच तुल्यकालन के लिए, उचित आपसी बहिष्कार (std::mutex, std::recursive_mutex, आदि) और मॉनिटर (सिंक्रनाइज़ेशन) (std::condition_variable और std::condition_variable_any) पुस्तकालय में जोड़े जाते हैं। ये संसाधन अधिग्रहण प्रारंभ है (RAII) लॉक्स (std::lock_guard और std::unique_lock) और आसान उपयोग के लिए लॉकिंग एल्गोरिदम।

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

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

नई std::async सुविधा कार्यों को चलाने और उन्हें a से बांधने का एक सुविधाजनक तरीका प्रदान करती है std::future. उपयोगकर्ता यह चुन सकता है कि कार्य को एसिंक्रोनस रूप से एक अलग थ्रेड पर या सिंक्रोनस रूप से उस थ्रेड पर चलाना है जो मूल्य की प्रतीक्षा करता है। डिफ़ॉल्ट रूप से, कार्यान्वयन चुन सकता है, जो ओवरसब्सक्रिप्शन के बिना हार्डवेयर समवर्ती का लाभ उठाने का एक आसान तरीका प्रदान करता है, और सरल उपयोगों के लिए थ्रेड पूल के कुछ फायदे प्रदान करता है।

टपल प्रकार
टुपल्स पूर्व-व्यवस्थित आयामों के विषम वस्तुओं से बने संग्रह हैं। एक टपल को संरचना के सदस्य चर का सामान्यीकरण माना जा सकता है।

TR1 टपल प्रकार का C++ 11 संस्करण C++ 11 सुविधाओं जैसे #Variadic टेम्प्लेट से लाभान्वित हुआ। यथोचित रूप से लागू करने के लिए, TR1 संस्करण को कार्यान्वयन-परिभाषित अधिकतम संख्या में समाहित प्रकार और पर्याप्त मैक्रो प्रवंचना की आवश्यकता होती है। इसके विपरीत, सी ++ 11 संस्करण के कार्यान्वयन के लिए किसी स्पष्ट कार्यान्वयन-परिभाषित प्रकार की अधिकतम संख्या की आवश्यकता नहीं है। हालांकि कंपाइलर्स के पास टेम्पलेट इंस्टेंटेशन (जो सामान्य है) के लिए आंतरिक अधिकतम रिकर्सन गहराई होगी, ट्यूपल्स का सी ++ 11 संस्करण उपयोगकर्ता को इस मान का खुलासा नहीं करेगा।

वैरेडिक टेम्प्लेट का उपयोग करते हुए, टपल वर्ग की घोषणा निम्नानुसार दिखती है:
<वाक्यविन्यास लैंग = सीपीपी>
टेम्पलेट <कक्षा ... प्रकार> वर्ग टपल;
</वाक्यविन्यास हाइलाइट>

टपल प्रकार की परिभाषा और उपयोग का एक उदाहरण:
<वाक्यविन्यास लैंग = सीपीपी>
typedef std::tuple <int, double, long &, const char *> test_tuple;
लंबा लंबा = 12;
test_tuple प्रूफ (18, 6.5, लंबा, सियाओ!);

लंबा = एसटीडी :: प्राप्त <0> ​​(प्रमाण); // मान 18 को 'लंबा' असाइन करें।
एसटीडी :: प्राप्त <3> (प्रमाण) = सुंदर! ; // टपल के चौथे तत्व को संशोधित करें।
</वाक्यविन्यास हाइलाइट>

टपल बनाना संभव है proof इसकी सामग्री को परिभाषित किए बिना, लेकिन केवल तभी जब टपल तत्वों के प्रकार में डिफ़ॉल्ट कन्स्ट्रक्टर होते हैं। इसके अलावा, एक टपल को दूसरे टपल को असाइन करना संभव है: यदि दो टुपल्स के प्रकार समान हैं, तो प्रत्येक तत्व प्रकार में एक कॉपी कंस्ट्रक्टर होना चाहिए; अन्यथा, दाईं ओर के टपल का प्रत्येक तत्व प्रकार बाईं ओर के टपल के संबंधित तत्व प्रकार के लिए परिवर्तनीय होना चाहिए या बाईं ओर के टपल के संबंधित तत्व प्रकार के पास एक उपयुक्त कंस्ट्रक्टर है।
<वाक्यविन्यास लैंग = सीपीपी>
typedef std::tuple <int, डबल, स्ट्रिंग> tuple_1 t1;
typedef std::tuple <char, short , const char * > tuple_2 t2 ('X', 2, Hola! );
टी 1 = टी 2; // ठीक है, पहले दो तत्वों को परिवर्तित किया जा सकता है,
         // तीसरे का निर्माण 'कॉन्स्ट चार *' से किया जा सकता है।
</वाक्यविन्यास हाइलाइट>

ठीक वैसा std::make_pair के लिए std::pair, वहां मौजूद std::make_tuple स्वचालित रूप से बनाने के लिए std::tupleप्रकार कटौती का उपयोग करना और auto ऐसे टपल को घोषित करने में मदद करता है। std::tie टुपल्स को अनपैक करने में मदद करने के लिए लैवल्यू संदर्भों के टुपल्स बनाता है। std::ignore यहाँ भी मदद करता है। उदाहरण देखें:

<वाक्यविन्यास लैंग = सीपीपी>
ऑटो रिकॉर्ड = एसटीडी :: मेक_टुपल (हरि राम, नई दिल्ली, 3.5, 'ए');
एसटीडी :: स्ट्रिंग नाम; फ्लोट जीपीए; चार ग्रेड;
एसटीडी :: टाई (नाम, एसटीडी :: अनदेखा, जीपीए, ग्रेड) = रिकॉर्ड; // std::ignore जगह का नाम छोड़ने में मदद करता है
एसटीडी :: अदालत << नाम <<   << जीपीए <<   << ग्रेड << एसटीडी :: एंडल;
</वाक्यविन्यास हाइलाइट>

संबंधपरक ऑपरेटर उपलब्ध हैं (तत्वों की समान संख्या वाले ट्यूपल्स के बीच), और ट्यूपल की विशेषताओं की जांच के लिए दो भाव उपलब्ध हैं (केवल संकलन के दौरान):
*std::tuple_size<T>::value टपल में तत्वों की संख्या लौटाता है T,
*std::tuple_element<I, T>::type वस्तु संख्या का प्रकार लौटाता है I टपल का T.

हैश टेबल
सी ++ मानक लाइब्रेरी में हैश टेबल (अनऑर्डर किए गए सहयोगी कंटेनर) शामिल करना सबसे आवर्ती अनुरोधों में से एक है। केवल समय की कमी के कारण इसे C++ 03 में नहीं अपनाया गया था। हालांकि हैश टेबल सबसे खराब स्थिति (कई टकरावों की उपस्थिति में) में एक संतुलित पेड़ की तुलना में कम कुशल हैं, वे कई वास्तविक अनुप्रयोगों में बेहतर प्रदर्शन करते हैं।

टक्करों को केवल हैश टेबल#अलग श्रंखला के माध्यम से प्रबंधित किया जाता है क्योंकि समिति ने खुले पते के समाधान को मानकीकृत करने के लिए उपयुक्त नहीं माना है जो बहुत सारी आंतरिक समस्याओं का परिचय देता है (सबसे ऊपर जब तत्वों को मिटाना स्वीकार किया जाता है)। अपने स्वयं के हैश तालिका कार्यान्वयन विकसित करने वाले गैर-मानक पुस्तकालयों के साथ नाम के टकराव से बचने के लिए, "हैश" के बजाय उपसर्ग "अनऑर्डर" का उपयोग किया गया था।

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



Type of hash table
Associated values
Equivalent keys


std::unordered_set
No
No


std::unordered_multiset
No
Yes


std::unordered_map
Yes
No


std::unordered_multimap
Yes
Yes

नई कक्षाएं एक मानक टेम्पलेट लाइब्रेरी#कंटेनर की सभी आवश्यकताओं को पूरा करती हैं, और तत्वों तक पहुँचने के लिए आवश्यक सभी विधियाँ हैं: insert, erase, begin, end.

इस नई सुविधा के लिए किसी C++ भाषा कोर एक्सटेंशन की आवश्यकता नहीं थी (हालांकि कार्यान्वयन विभिन्न C++11 भाषा सुविधाओं का लाभ उठाएगा), हेडर का केवल एक छोटा सा विस्तार <functional> और हेडर का परिचय <unordered_set> और <unordered_map>. किसी भी मौजूदा मानक वर्ग में किसी अन्य परिवर्तन की आवश्यकता नहीं थी, और यह मानक पुस्तकालय के किसी अन्य विस्तार पर निर्भर नहीं करता है।

 नियमित अभिव्यक्ति
नई लाइब्रेरी, नए हेडर में परिभाषित <regex>, कुछ नई कक्षाओं से बना है:
* नियमित अभिव्यक्ति को टेम्प्लेट क्लास के उदाहरण द्वारा दर्शाया जाता है std::regex;
*घटनाओं को टेम्पलेट वर्ग के उदाहरण द्वारा दर्शाया जाता है std::match_results,
*std::regex_iterator का उपयोग रेगेक्स के सभी मैचों पर पुनरावृति करने के लिए किया जाता है

कार्यक्रम std::regex_search खोज के लिए प्रयोग किया जाता है, जबकि 'खोजें और बदलें' फ़ंक्शन के लिए std::regex_replace प्रयोग किया जाता है जो एक नई स्ट्रिंग देता है।
यहाँ के उपयोग का एक उदाहरण है std::regex_iterator:
<वाक्यविन्यास लैंग = सीपीपी>
  #शामिल <रेगेक्स>
  const char *pattern = R ([^ ,.\t\n]+); // स्पेस, कॉमा, पीरियड टैब न्यूलाइन द्वारा अलग किए गए शब्दों को खोजें

  एसटीडी :: रेगेक्स आरजीएक्स (पैटर्न); // अमान्य पैटर्न पर अपवाद फेंकता है

  const char *target = अनसीन यूनिवर्सिटी - अंख-मोरपार्क;

  // 'पैटर्न' के वर्णों से अलग 'लक्ष्य' के सभी शब्दों की पहचान करने के लिए एक regex_iterator का प्रयोग करें।
  ऑटो इटर =
      एसटीडी :: cregex_iterator (लक्ष्य, लक्ष्य + strlen (लक्ष्य), rgx);

  // अनुक्रम इटरेटर का अंत करें
  ऑटो अंत =
      एसटीडी :: cregex_iterator ();

  for (; iter != end; ++iter)
  {
    एसटीडी :: स्ट्रिंग match_str = iter-> str ();
    एसटीडी :: अदालत << match_str << '\n';
  }
</वाक्यविन्यास हाइलाइट>

पुस्तकालय <regex> किसी भी मौजूदा शीर्षलेख में कोई बदलाव की आवश्यकता नहीं है (हालांकि यह जहां उचित होगा वहां उनका उपयोग करेगा) और न ही मूल भाषा का विस्तार। POSIX C में, नियमित अभिव्यक्तियाँ C POSIX लाइब्रेरी#regex.h के माध्यम से भी उपलब्ध हैं।

सामान्य-उद्देश्य वाले स्मार्ट पॉइंटर्स
Main article: C++ smart pointers
सी ++ 11 प्रदान करता है std::unique_ptr, और सुधार std::shared_ptr और std::weak_ptr टीआर1 से। std::auto_ptr पदावनत किया गया है।

एक्स्टेंसिबल रैंडम नंबर सुविधा
सी मानक पुस्तकालय फ़ंक्शन के माध्यम से छद्म यादृच्छिक संख्या उत्पन्न करने की क्षमता प्रदान करता है rand. हालाँकि, एल्गोरिथ्म पूरी तरह से पुस्तकालय विक्रेता को सौंप दिया गया है। सी ++ ने इस कार्यक्षमता को बिना किसी बदलाव के विरासत में मिला है, लेकिन सी ++ 11 छद्म यादृच्छिक संख्या उत्पन्न करने के लिए एक नई विधि प्रदान करता है।

C++11 की यादृच्छिक संख्या कार्यक्षमता दो भागों में विभाजित है: एक जनरेटर इंजन जिसमें यादृच्छिक संख्या जनरेटर की स्थिति होती है और छद्म यादृच्छिक संख्या उत्पन्न करता है; और एक वितरण, जो परिणाम की सीमा और वितरण (गणित) को निर्धारित करता है। इन दोनों को मिलाकर एक रैंडम नंबर जेनरेटर ऑब्जेक्ट बनाया जाता है।

सी मानक के विपरीत rand, C++11 तंत्र तीन बेस जनरेटर इंजन एल्गोरिदम के साथ आएगा:
* linear_congruential_engine,
* subtract_with_carry_engine, और
* mersenne_twister_engine.

C++11 कई मानक वितरण भी प्रदान करता है:
* uniform_int_distribution,
* uniform_real_distribution,
* bernoulli_distribution,
* binomial_distribution,
* geometric_distribution,
* negative_binomial_distribution,
* poisson_distribution,
* exponential_distribution,
* gamma_distribution,
* weibull_distribution,
* extreme_value_distribution,
* normal_distribution,
* lognormal_distribution,
* chi_squared_distribution,
* cauchy_distribution,
* fisher_f_distribution,
* student_t_distribution,
* discrete_distribution,
* piecewise_constant_distribution और
* piecewise_linear_distribution.

इस उदाहरण में जनरेटर और वितरण संयुक्त हैं:

<वाक्यविन्यास लैंग = सीपीपी>
#शामिल <यादृच्छिक>
#शामिल <कार्यात्मक>

एसटीडी::uniform_int_distribution<int> वितरण (0, 99);
एसटीडी :: mt19937 इंजन; // मेर्सन ट्विस्टर MT19937
ऑटो जनरेटर = एसटीडी :: बाइंड (वितरण, इंजन);
int यादृच्छिक = जनरेटर (); // 0 और 99 के बीच एक समान इंटीग्रल वैरिएट उत्पन्न करें।
int random2 = वितरण (इंजन); // वितरण और इंजन वस्तुओं का उपयोग करके सीधे एक और नमूना उत्पन्न करें।
</वाक्यविन्यास हाइलाइट>

रैपर संदर्भ
एडेप्टर पैटर्न संदर्भ टेम्पलेट वर्ग के एक उदाहरण से प्राप्त किया जाता है reference_wrapper. रैपर संदर्भ सामान्य संदर्भों के समान होते हैं ('&') सी ++ भाषा का। किसी भी वस्तु से आवरण संदर्भ प्राप्त करने के लिए फ़ंक्शन टेम्पलेट ref प्रयोग किया जाता है (निरंतर संदर्भ के लिए cref प्रयोग किया जाता है)।

फ़ंक्शन टेम्प्लेट के लिए आवरण संदर्भ सबसे ऊपर उपयोगी होते हैं, जहाँ प्रतियों के बजाय मापदंडों के संदर्भ की आवश्यकता होती है:
<वाक्यविन्यास लैंग = सीपीपी>
// यह फ़ंक्शन पैरामीटर 'आर' का संदर्भ लेगा और इसे बढ़ा देगा।
शून्य फंक (इंट एंड आर) {आर ++; }

// टेम्प्लेट फ़ंक्शन।
टेम्पलेट <कक्षा एफ, कक्षा पी> शून्य जी (एफ एफ, पी टी) {एफ (टी); }

मुख्य प्रवेश बिंदु()
{
    इंट मैं = 0;
    जी (फंक, आई); // 'जी <शून्य (इंट एंड आर), इंट>' तत्काल है
                 // तो 'मैं' संशोधित नहीं किया जाएगा।
    एसटीडी :: अदालत << मैं << एसटीडी :: endl; // आउटपुट -> 0

    जी (फंक, एसटीडी :: रेफरी (i)); // 'g<void(int &r),reference_wrapper<int>>' तत्काल है
                           // फिर 'i' को संशोधित किया जाएगा।
    एसटीडी :: अदालत << मैं << एसटीडी :: endl; // आउटपुट -> 1
}
</वाक्यविन्यास हाइलाइट>

यह नई उपयोगिता मौजूदा में जोड़ी गई थी  <utility> शीर्ष लेख और C++ भाषा के और विस्तार की आवश्यकता नहीं थी।

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

एक उदाहरण इसकी विशेषताओं को स्पष्ट कर सकता है:
<वाक्यविन्यास लैंग = सीपीपी>
std::function<int (int, int)> func; // रैपर निर्माण का उपयोग करना
                                    // टेम्प्लेट क्लास 'फंक्शन'।
एसटीडी :: प्लस <int> जोड़ें; // 'प्लस' को 'टेम्प्लेट <कक्षा टी> टी प्लस (टी, टी);' के रूप में घोषित किया गया है
                    // फिर 'ऐड' टाइप 'इंट ऐड (इंट एक्स, इंट वाई)' है।
फंक = जोड़ें; // ठीक है - पैरामीटर और रिटर्न प्रकार समान हैं।

int a = func (1, 2); // नोट: यदि रैपर 'func' किसी फ़ंक्शन को संदर्भित नहीं करता है,
                     // अपवाद 'एसटीडी :: bad_function_call' फेंक दिया गया है।

एसटीडी :: समारोह <बूल (लघु, लघु)> func2;
अगर (!func2)
{
    // सच है क्योंकि 'func2' को अभी तक कोई फ़ंक्शन असाइन नहीं किया गया है।

    बूल सन्निकट (लंबा x, लंबा y);
    func2 = और आसन्न; // ओके - पैरामीटर और रिटर्न प्रकार परिवर्तनीय हैं।

    संरचना परीक्षण
    {
        बूल ऑपरेटर () (लघु एक्स, लघु वाई);
    };
    टेस्ट कार;
    func = एसटीडी :: रेफरी (कार); // 'std :: ref' एक टेम्पलेट फ़ंक्शन है जो रैपर लौटाता है
                          // संरचना 'कार' के सदस्य फ़ंक्शन 'ऑपरेटर ()' का।
}
फंक = फंक 2; // ओके - पैरामीटर और रिटर्न प्रकार परिवर्तनीय हैं।
</वाक्यविन्यास हाइलाइट>

टेम्पलेट वर्ग function हेडर के अंदर परिभाषित किया गया था <functional>, C++ भाषा में किसी बदलाव की आवश्यकता के बिना।

मेटाप्रोग्रामिंग के लिए टाइप लक्षण
मेटाप्रोग्रामिंग में एक प्रोग्राम बनाना शामिल होता है जो किसी अन्य प्रोग्राम (या स्वयं) को बनाता या संशोधित करता है। यह संकलन के दौरान या निष्पादन के दौरान हो सकता है। ISO/IEC JTC 1/SC 22|C++ मानक समिति ने टेम्प्लेट के माध्यम से संकलन के दौरान मेटाप्रोग्रामिंग के लिए एक पुस्तकालय शुरू करने का निर्णय लिया है।

यहाँ C++ 03 मानक का उपयोग करते हुए मेटा-प्रोग्राम का एक उदाहरण दिया गया है: पूर्णांक घातांकों की गणना के लिए टेम्पलेट उदाहरणों का पुनरावर्तन:

<वाक्यविन्यास लैंग = सीपीपी>
टेम्पलेट <इंट बी, इंट एन>
संरचना पॉव
{
    // पुनरावर्ती कॉल और पुनर्संयोजन।
    एनम {मूल्य = बी * पॉव <बी, एन -1> :: मूल्य};
};

टेम्पलेट <इंट बी>
संरचना पॉव <बी, 0>
{
    // एन == 0 समाप्ति की स्थिति।
    एनम {मूल्य = 1};
};
int quartic_of_three = पॉव<3, 4>::मान;
</वाक्यविन्यास हाइलाइट>

कई एल्गोरिदम विभिन्न प्रकार के डेटा पर काम कर सकते हैं; C++ का टेम्प्लेट (प्रोग्रामिंग) सामान्य प्रोग्रामिंग का समर्थन करता है और कोड को अधिक कॉम्पैक्ट और उपयोगी बनाता है। फिर भी, एल्गोरिदम के लिए उपयोग किए जा रहे डेटा प्रकारों के बारे में जानकारी की आवश्यकता होना आम बात है। यह जानकारी प्रकार के गुणों का उपयोग करके टेम्पलेट वर्ग की तात्कालिकता के दौरान निकाली जा सकती है।

प्रकार के गुण किसी वस्तु की श्रेणी और किसी वर्ग (या किसी संरचना) की सभी विशेषताओं की पहचान कर सकते हैं। उन्हें नए हेडर में परिभाषित किया गया है <type_traits>.

अगले उदाहरण में टेम्पलेट फ़ंक्शन 'विस्तृत' है, जो दिए गए डेटा प्रकारों के आधार पर, दो प्रस्तावित एल्गोरिदम में से एक को तुरंत चालू करेगा (algorithm.do_it).

<वाक्यविन्यास लैंग = सीपीपी>
// संचालन का पहला तरीका।
टेम्प्लेट <बूल बी> स्ट्रक्चर एल्गोरिथम
{
    टेम्प्लेट <कक्षा T1, वर्ग T2> स्थिर int do_it (T1 &, T2 &) { /*...*/ }
};

// संचालन का दूसरा तरीका।
टेम्पलेट <> संरचना एल्गोरिथम <सच>
{
    टेम्प्लेट <कक्षा T1, वर्ग T2> स्थिर int do_it (T1, T2) {/*...*/ }
};

// 'विस्तृत' त्वरित रूप से संचालित करने का सही तरीका स्वचालित रूप से तुरंत चालू हो जाएगा।
टेम्प्लेट <कक्षा टी 1, कक्षा टी 2>
int विस्तृत (T1 A, T2 B)
{
    // दूसरे तरीके का उपयोग केवल तभी करें जब 'T1' एक पूर्णांक हो और यदि 'T2' हो
    // फ़्लोटिंग पॉइंट में, अन्यथा पहले तरीके का उपयोग करें।
    वापसी एल्गोरिथम<std::is_integral<T1>::value && std::is_floating_point<T2>::value>::do_it(A, B);
}
</वाक्यविन्यास हाइलाइट>

प्रकार के लक्षणों के माध्यम से, शीर्षलेख में परिभाषित किया गया है <type_traits>, टाइप ट्रांसफ़ॉर्मेशन ऑपरेशंस बनाना भी संभव है (static_cast और const_cast टेम्पलेट के अंदर अपर्याप्त हैं)।

इस प्रकार की प्रोग्रामिंग सुरुचिपूर्ण और संक्षिप्त कोड उत्पन्न करती है; हालाँकि, इन तकनीकों का कमजोर बिंदु डिबगिंग है: संकलन के दौरान यह असुविधाजनक है और प्रोग्राम निष्पादन के दौरान बहुत कठिन है।

फ़ंक्शन ऑब्जेक्ट्स के रिटर्न प्रकार की गणना के लिए समान विधि
संकलन-समय पर टेम्पलेट फ़ंक्शन ऑब्जेक्ट का रिटर्न प्रकार निर्धारित करना सहज नहीं है, खासकर अगर रिटर्न मान फ़ंक्शन के पैरामीटर पर निर्भर करता है। उदहारण के लिए:

<वाक्यविन्यास लैंग = सीपीपी>
संरचना साफ़ करें
{
    इंट ऑपरेटर () (इंट) कास्ट; // पैरामीटर प्रकार है
    डबल ऑपरेटर () (डबल) कास्ट; // वापसी प्रकार के बराबर।
};

टेम्पलेट <कक्षा ओबीजे>
क्लास कैलकुलस
{
जनता:
    Template<class Arg> Arg operator()(Arg& a) const
    {
        वापसी सदस्य (ए);
    }
निजी:
    ओबीजे सदस्य;
};
</वाक्यविन्यास हाइलाइट>

क्लास टेम्प्लेट को इंस्टेंट करना Calculus<Clear>, की कार्य वस्तु calculus के फ़ंक्शन ऑब्जेक्ट के रूप में हमेशा समान रिटर्न प्रकार होगा Clear. हालाँकि, दी गई कक्षा Confused नीचे:

<वाक्यविन्यास लैंग = सीपीपी>
संरचना भ्रमित
{
    डबल ऑपरेटर () (इंट) कास्ट; // पैरामीटर प्रकार नहीं है
    इंट ऑपरेटर () (डबल) कास्ट; // वापसी प्रकार के बराबर।
};
</वाक्यविन्यास हाइलाइट>
तत्काल करने का प्रयास कर रहा है Calculus<Confused> की वापसी प्रकार का कारण होगा Calculus वर्ग के समान नहीं होना Confused. कंपाइलर रूपांतरण के बारे में चेतावनियां उत्पन्न कर सकता है int को double और इसके विपरीत।

TR1 पेश करता है, और C++ 11 टेम्प्लेट क्लास को अपनाता है std::result_of जो प्रत्येक घोषणा के लिए फ़ंक्शन ऑब्जेक्ट के रिटर्न प्रकार को निर्धारित करने और उपयोग करने की अनुमति देता है। जो वस्तु CalculusVer2 का उपयोग करता है std::result_of ऑब्जेक्ट फ़ंक्शन ऑब्जेक्ट के रिटर्न प्रकार को प्राप्त करने के लिए:
<वाक्यविन्यास लैंग = सीपीपी>
टेम्प्लेट <कक्षा ओब्ज>
क्लास कैलकुलसVer2
{
जनता:
    टेम्पलेट <कक्षा आर्ग>
    typename std::result_of<Obj(Arg)>::type operator()(Arg& a) const
    {
        वापसी सदस्य (ए);
    }
निजी:
    ओबीजे सदस्य;
};
</वाक्यविन्यास हाइलाइट>
इस प्रकार कार्य वस्तु के उदाहरणों में CalculusVer2<Confused> कोई रूपांतरण, चेतावनियाँ या त्रुटियाँ नहीं हैं।

के TR1 संस्करण से एकमात्र परिवर्तन std::result_of यह है कि TR1 संस्करण ने कार्यान्वयन को फ़ंक्शन कॉल के परिणाम प्रकार को निर्धारित करने में सक्षम होने में विफल होने की अनुमति दी। समर्थन के लिए C++ में परिवर्तन के कारण decltype, C++11 का संस्करण std::result_of अब इन विशेष मामलों की आवश्यकता नहीं है; कार्यान्वयन सभी मामलों में एक प्रकार की गणना करने के लिए आवश्यक हैं।

बेहतर सी संगतता
C (प्रोग्रामिंग भाषा) के साथ संगतता के लिए, C99 से, इन्हें जोड़ा गया:
* प्रीप्रोसेसर:
** विविध मैक्रोज़,
** सन्निकट संकीर्ण/चौड़े स्ट्रिंग शाब्दिकों का संयोजन,
** _Pragma() - के बराबर #pragma.
* long long - पूर्णांक प्रकार जो कम से कम 64 बिट लंबा हो।
* __func__ - मैक्रो उस फ़ंक्शन के नाम का मूल्यांकन करता है जिसमें वह है।
* शीर्षलेख:
** cstdbool (stdbool.h),
** cstdint (stdint.h),
** cinttypes (inttypes.h).

विशेषताएं मूल रूप से नियोजित लेकिन हटाई गई या शामिल नहीं
एक अलग टीआर के लिए शीर्षक:
* मॉड्यूल
* दशमलव प्रकार
* गणित विशेष कार्य
स्थगित:
* अवधारणाएं (सी ++)
* अधिक पूर्ण या आवश्यक कचरा संग्रह समर्थन
* प्रतिबिंब
* मैक्रो स्कोप

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

गतिशील अपवाद विनिर्देशों को हटा दिया गया है।गैर-अपवाद-फेंकने वाले कार्यों का संकलन-समय विनिर्देश इसके साथ उपलब्ध है noexcept कीवर्ड, जो अनुकूलन के लिए उपयोगी है।

std::auto_ptr पदावनत किया गया है, द्वारा प्रतिस्थापित किया गया है std::unique_ptr.

फंक्शन ऑब्जेक्ट बेस क्लासेस (std::unary_function, std::binary_function), पॉइंटर्स टू फ़ंक्शंस और एडेप्टर टू पॉइंटर्स टू मेम्बर्स, और बाइंडर क्लासेस सभी पदावनत हैं।

यह भी देखें
*सी11 (सी मानक संशोधन)

संदर्भ



बाहरी संबंध
Template:बाहरी संबंध
* The C++ Standards Committee
* C++0X: The New Face of Standard C++
* Herb Sutter's blog coverage of C++11
* Anthony Williams' blog coverage of C++11
* A talk on C++0x given by Bjarne Stroustrup at the University of Waterloo Archived 2009-01-23 at the Wayback Machine
* The State of the Language: An Interview with Bjarne Stroustrup (15 August 2008)
* Wiki page to help keep track of C++ 0x core language features and their availability in compilers
* Online C++11 standard library reference
* Online C++11 compiler
* Bjarne Stroustrup's C++11 FAQ
* More information on C++11 features:range-based for loop,why auto_ptr is deprecated,etc.