C++11

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++ में सुधार करें
 * पहले की असुरक्षित तकनीकों के सुरक्षित विकल्प प्रदान करके प्रकार की सुरक्षा बढ़ाएँ
 * प्रदर्शन और सीधे हार्डवेयर के साथ फंक्शन करने की क्षमता बढ़ाएँ
 * वास्तविक दुनिया की समस्याओं के लिए उचित समाधान प्रदान करें
 * शून्य-ओवरहेड सिद्धांत लागू करें (कुछ उपयोगिताओं द्वारा आवश्यक अतिरिक्त समर्थन का उपयोग तभी किया जाना चाहिए जब उपयोगिता का उपयोग किया जाता है)
 * विशेषज्ञ प्रोग्रामरों द्वारा आवश्यक किसी भी उपयोगिता को हटाए बिना सी ++ को पढ़ाने और सीखने में सरल बनाएं

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

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

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

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

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

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

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

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

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

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

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

int some_value[get_five + 7]; // Create an array of 12 integers. Ill-formed C++ यह सी ++ 03 में मान्य नहीं था, क्योंकि  स्थिर अभिव्यक्ति नहीं है। सी ++ 03 कंपाइलर के पास यह जानने का कोई तरीका नहीं है कि क्या   वास्तव में रनटाइम पर स्थिर है। सैद्धांतिक रूप में यह फ़ंक्शन वैश्विक वैरिएबल को प्रभावित करता हैं, तथा अन्य गैर-रनटाइम स्थिर फंक्शन्स आदि को कॉल कर सकते हैं।

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

int some_value[get_five + 7]; // Create an array of 12 integers. Valid C++11 यह संकलक को समझने और सत्यापित करने की अनुमति देता है कि  संकलन-समय स्थिरांक है।

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

template class std::vector;

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

extern template class std::vector;

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

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

प्रारंभकर्ता सूचियां
सी ++ 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 प्रारंभकर्ता-सूचियों को बढ़ाता है, इसलिए इन्हें मानक कंटेनर समेत सभी वर्गों के लिए   का उपयोग किया जा सकता है।

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

} यह अनुमति देता है इस प्रकार  पूर्णांकों के अनुक्रम से निर्मित होता हैं, जैसे:"SequenceClass some_var = {1, 4, 5, 6};"यह कंस्ट्रक्टर विशेष प्रकार का कंस्ट्रक्टर है, जिसे इनिशियलाइज़र लिस्ट कन्स्ट्रक्टर कहा जाता है। ऐसे कन्स्ट्रक्टर वाले वर्गों को विशेष रूप से युनिफार्म लोकेटर के समय माना जाता है।

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

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

यद्यपि इसका निर्माण विशेष रूप से संकलक द्वारा किया जाता है, a  ऐसा वास्तविक प्रकार है, और इसलिए इसका उपयोग क्लास कंस्ट्रक्टर के अतिरिक्त अन्य स्थानों पर भी किया जा सकता है। नियमित फंक्शन टाइप किए जा सकते हैं  एस तर्क के रूप में किया जाता हैं। उदाहरण के लिए: void function_name(std::initializer_list list); // Copying is cheap; see above

function_name({1.0f, -3.45f, -0.4f}); मानक लाइब्रेरी में इसके उदाहरणों में सम्मिलित हैं  और   टेम्पलेट्स ले रहा है  संख्यात्मक प्रकार का।

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

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

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

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

स्ट्रक्वैरियेबल बेसिकस्ट्रक्वैरियेबल {   इंट एक्स; डबल वाई; };

संरचना AltStruct {   AltStruct(int x, डबल y)        : x_{x} , Y y}   {}

निजी: इंट x_; डबल वाई_; };

बेसिक स्ट्रक्वैरियेबल var1{5, 3.2}; AltStruct var2{2, 4.3};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

टेम्पलेट ऑटो एडिंग_फंक (स्थिरांक एलएचएस और एलएचएस, स्थिरांक आरएचएस और आरएचएस) -> decltype (एलएचएस + आरएचएस) {वापसी एलएचएस + आरएचएस;} इस सिंटैक्स का उपयोग अधिक सांसारिक फंक्शन घोषणाओं और परिभाषाओं के लिए किया जा सकता है:

स्ट्रक्वैरियेबल समस्ट्रक्वैरियेबल{ ऑटो func_name (int x, int y) -> int; };

ऑटो कुछ संरचना :: func_name (int x, int y) -> int {   वापसी एक्स + वाई; }

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

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

क्लास समटाइप { जनता: कुछ प्रकार (int new_number) {       निर्माण (नया_नंबर); }

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

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

इंट संख्या; };

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

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

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

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

क्लास समटाइप {   इंट संख्या;

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

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

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

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

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

क्लास बेस क्लास { जनता: बेसक्लास (इंट वैल्यू); };

वर्ग व्युत्पन्न वर्ग: सार्वजनिक आधार वर्ग { जनता: बेस क्लास का उपयोग :: बेस क्लास; };

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

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

निजी: इंट वैल्यू = 5; };

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

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

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

संरचना आधार {   वर्चुअल शून्य some_func (फ्लोट); };

संरचना व्युत्पन्न: आधार {   आभासी शून्य some_func (int); };

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

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

संरचना आधार {   वर्चुअल शून्य some_func (फ्लोट); };

संरचना व्युत्पन्न: आधार {   वर्चुअल शून्य some_func (int) ओवरराइड; // खराब गठित - बेस क्लास विधि को ओवरराइड नहीं करता है }; e> विशेष पहचानकर्ता का अर्थ है कि संकलक यह देखने के लिए आधार वर्ग (तों) की जाँच करेगा कि क्या इस सटीक हस्ताक्षर के साथ कोई आभासी फंक्शन है। और अगर वहाँ नहीं है, तो संकलक एक त्रुटि का संकेत देगा।

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

स्ट्रक्वैरियेबल बेस1 फाइनल { };

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

संरचना आधार2 {   आभासी शून्य च  अंतिम; };

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

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

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

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

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

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

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

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

चार * पीसी = नलप्टर; // ठीक 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 गणना के एक विशेष वर्गीकरण की अनुमति देता है जिसमें इनमें से कोई भी समस्या नहीं है। इसका उपयोग करके व्यक्त किया जाता है  (  पर्यायवाची के रूप में भी स्वीकार किया जाता है) घोषणा:

एनम वर्ग गणना {   Val1, Val2, वैल3 = 100, वैल4 // = 101 };

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

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

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

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

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

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

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

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

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

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

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

टेम्प्लेट <बूल टेस्ट> क्लास समटाइप; एसटीडी :: वेक्टर <कुछ टाइप <1> 2>> एक्स 1; // एक एसटीडी के रूप में व्याख्या :: SomeType के वेक्टर, // इसके बाद 2 >> X1 है, जो घोषणाकर्ता के लिए मान्य सिंटैक्स नहीं है। 1 सत्य है। एसटीडी :: वेक्टर <कुछ टाइप <(1> 2) >> एक्स 1; // एसटीडी के रूप में व्याख्या :: कुछ प्रकार के वेक्टर <गलत>, // इसके बाद डिक्लेरेटर x1 आता है, जो वैध C++11 सिंटैक्स है। (1>2) असत्य है।

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

संरचना बिंदु {   बिंदु {} बिंदु (int x, int y): x_(x), y_(y) {} इंट x_, y_; };

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

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

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

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

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

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

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

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

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

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

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

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

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

R (स्ट्रिंग डेटा \ Stuff ) आर सीमांकक (स्ट्रिंग डेटा \ सामग्री) सीमांकक 

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