C++11

Not to be confused with C11 (सी मानक संशोधन).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template class std::vector<MyClass>;

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

extern template class std::vector<MyClass>;

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

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

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

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

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

{

struct Object

{

float first;

int second;

};

Object scalar = {0.43f, 10}; //One Object, with first=0.43f and second=10

Object anArray[] = {{13.4f, 3}, {43.28f, 29}, {5.934f, 17}}; //An array of three Objects

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

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

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

}

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

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

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

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

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

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

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

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

std::vector<std::string> v = { "xyzzy", "plugh", "abracadabra" };

std::vector<std::string> v({ "xyzzy", "plugh", "abracadabra" });

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

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

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

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

  struct BasicStruct

{
    int x;
    double y;
};

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

private:
    int x_;
    double y_;
};

BasicStruct var1{5, 3.2};

AltStruct var2{2, 4.3};

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

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

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

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

}

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

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

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

टाइप अनुमान

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

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

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

auto other_variable = 5;

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

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

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

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

int some_int; decltype(some_int) other_integer_variable = 5;

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

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

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

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

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

for (const auto& x : myvec)

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

#include <vector>

int main()

{

const std::vector<int> v(1);

auto a = v[0]; // a has type int

decltype(v[0]) b = 1; // b has type const int&, the return type of

// std::vector<int>::operator[](size_type) const

auto c = 0; // c has type int

auto d = c; // d has type int

decltype(c) e; // e has type int, the type of the entity named by c

decltype((c)) f = c; // f has type int&, because (c) is an lvalue

decltype(0) g; // g has type int, because 0 is an rvalue

}

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

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

int my_array[5] = {1, 2, 3, 4, 5};

// double the value of each element in my_array:

for (int& x : my_array)

x *= 2;

// similar but also using type inference for array elements

for (auto& x : my_array)

x *= 2;

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

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

Main article: अनामिनस §  सी ++ (सी ++ 11 के बाद से)

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

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

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

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

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

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

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

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

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

 template<class Lhs, class Rhs>

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

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

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

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

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

struct SomeStruct

{

auto func_name(int x, int y) -> int;

};

auto SomeStruct::func_name(int x, int y) -> int

{

return x + y;

}

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

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

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

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

    SomeType()
    {
        Construct(42);
    }

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

    int number;

};

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

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

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

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

class SomeType

{

int number;

public:

SomeType(int new_number) : number(new_number) {}

SomeType() : SomeType(42) {}

};

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

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

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

इसका प्रारूप इस प्रकार है:

class BaseClass
{
public:
    BaseClass(int value);
};

class DerivedClass : public BaseClass
{
public:
    using BaseClass::BaseClass;

}

सदस्य इनिशियलाइजेशन के लिए, सी++11 इस सिंटैक्स की अनुमति देता है:

class SomeClass
{
public:
    SomeClass() {}
    explicit SomeClass(int new_value) : value(new_value) {}

private:
    int value = 5;

};

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

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

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

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

struct Base

{

virtual void some_func(float);

};

struct Derived : Base

{

virtual void some_func(int);

};

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

struct Base

{

virtual void some_func(float);

};

struct Derived : Base

{

virtual void some_func(int) override; // ill-formed - doesn't override a base class method

};

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

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

struct Base1 final { };

struct Derived1 : Base1 { }; // ill-formed because the class Base1 has been marked final

struct Base2
{
    virtual void f() final;
};

struct Derived2 : Base2
{
    void f(); // ill-formed because the virtual function Base2::f has been marked final
};

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

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

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

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

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

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

void foo(char *); void foo(int);

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

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

पश्चगामी संगतता कारणों के लिए, 0 एक वैध शून्य सूचक स्थिर रहता है।

char *pc = nullptr; // OK

int *pi = nullptr; // OK

bool b = nullptr; // OK. b is false.

int i = nullptr; // error

foo(nullptr); // calls foo(nullptr_t), not foo(int);

/*

Note that foo(nullptr_t) will actually call foo(char *) in the example above using an implicit conversion,

only if no other functions are overloading with compatible pointer types in scope.

If multiple overloadings exist, the resolution will fail as it is ambiguous,

unless there is an explicit declaration of foo(nullptr_t).

In standard types headers for सी++11, the nullptr_t type should be declared as:

typedef decltype(nullptr) nullptr_t;

but not as:

typedef int nullptr_t; // prior versions of सी++ which need NULL to be defined as 0

typedef void *nullptr_t; // ANSI C which defines NULL as ((void*)0)

• /

मुख्यतः पूर्वक टाइप की गई गणनाएं

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

सी++11 गणना के एक विशेष वर्गीकरण की अनुमति देता है जिसमें इनमें से कोई भी समस्या नहीं है। इस प्रकार इसका उपयोग करके व्यक्त किया जाता है enum class (enum struct पर्यायवाची के रूप में भी स्वीकार किया जाता है) घोषणा: enum class Enumeration { Val1, Val2, Val3 = 100, Val4 // = 101

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

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

enum class Enum2 : unsigned int {Val1, Val2};

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

enum Enum3 : unsigned long {Val1 = 1, Val2};

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

enum Enum1; // Invalid in सी++03 and सी++11; the underlying type cannot be determined.

enum Enum2 : unsigned int; // Valid in सी++11, the underlying type is specified explicitly.

enum class Enum3; // Valid in सी++11, the underlying type is int.

enum class Enum4 : unsigned int; // Valid in सी++11.

enum Enum2 : unsigned short; // Invalid in सी++11, because Enum2 was formerly declared with a different underlying type.

समकोण कोष्ठक

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

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

template<bool Test> class SomeType;

std::vector<SomeType<1>2>> x1; // Interpreted as a std::vector of SomeType<true>,

// followed by "2 >> x1", which is not valid syntax for a declarator. 1 is true.

std::vector<SomeType<(1>2)>> x1; // Interpreted as std::vector of SomeType<false>,

// followed by the declarator "x1", which is valid सी++11 syntax. (1>2) is false.

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

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

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

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

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

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

template <typename First, typename Second, int Third>

class SomeType;

template <typename Second>

typedef SomeType<OtherType, Second, 5> TypedefName; // Invalid in सी++03

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

template <typename First, typename Second, int Third>

class SomeType;

template <typename Second>

using TypedefName = SomeType<OtherType, Second, 5>;

using सिंटैक्स का उपयोग सी++ 11 में टाइप अलियासिंग के रूप में भी किया जा सकता है:

typedef void (*FunctionType)(double); // Old style using FunctionType = void (*)(double); // New introduced syntax

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

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

यदि union सदस्य के पास एक गैर-तुच्छ विशेष सदस्य फंक्शन है, संकलक इसके लिए समकक्ष सदस्य फ़ंक्शन उत्पन्न नहीं करता हैं। इस प्रकार union और इसे मैन्युअल रूप से परिभाषित किया जाना चाहिए।

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

#include <new> // Needed for placement 'new'.

struct Point

{

Point() {}

Point(int x, int y): x_(x), y_(y) {}

int x_, y_;

};

union U

{

int z;

double w;

Point p; // Invalid in सी++03; valid in सी++11.

U() {} // Due to the Point member, a constructor definition is now needed.

U(const Point& pt) : p(pt) {} // Construct Point object using initializer list.

U& operator=(const Point& pt) { new(&p) Point(pt); return *this; } // Assign Point object using placement 'new'.

};

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

कोर भाषा फंक्शनक्षमता में सुधार

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

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

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

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

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

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

सी++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[] है, जिसका उपयोग अपर केस 'यू' उपसर्ग के अनुसार किया जाता हैं।

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

u8 यह एक यूनिकोड कैरेक्टर \u2018 है।

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

यू यह एक यूनिकोड वर्ण \U00002018 है।

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

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

#include <new> // Needed for placement 'new'.

struct Point

{

Point() {}

Point(int x, int y): x_(x), y_(y) {}

int x_, y_;

};

union U

{

int z;

double w;

Point p; // Invalid in सी++03; valid in सी++11.

U() {} // Due to the Point member, a constructor definition is now needed.

U(const Point& pt) : p(pt) {} // Construct Point object using initializer list.

U& operator=(const Point& pt) { new(&p) Point(pt); return *this; } // Assign Point object using placement 'new'.

};