C++11

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

};

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

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

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

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

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

};

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

सीक्वेंस क्लास some_var = {1, 4, 5, 6};

यह कंस्ट्रक्टर एक विशेष प्रकार का कंस्ट्रक्टर है, जिसे इनिशियलाइज़र-लिस्ट-कन्स्ट्रक्टर कहा जाता है। ऐसे कन्स्ट्रक्टर वाले वर्गों को विशेष रूप से वर्दी प्रारंभिकरण के दौरान माना जाता है (देखें # वर्दी प्रारंभिकरण)

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

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

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

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

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

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

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

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

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

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

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

स्ट्रक्वैरियेबल बेसिकस्ट्रक्वैरियेबल {

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

};

संरचना AltStruct {

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

निजी:

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

};

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

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

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

संरचना IdString {

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

};

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

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

}

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

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

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

टाइप अनुमान

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1. सम्मिलित <वेक्टर>

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

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

}

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

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

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

   एक्स * = 2;

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

   एक्स * = 2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

टेम्पलेट

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

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

स्ट्रक्वैरियेबल समस्ट्रक्वैरियेबल{

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

};

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

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

}

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

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

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

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

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

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

निजी:

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

   इंट संख्या;

};

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

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

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

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

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

   इंट संख्या;

जनता:

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

};

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

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

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

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

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

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

};

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

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

};

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

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

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

निजी:

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

};

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

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

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

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

संरचना आधार {

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

};

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

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

};

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

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

संरचना आधार {

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

};

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

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

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

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

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

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

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

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

};

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

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

};

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

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

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

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

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

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

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

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

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

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

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

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

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

• /

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

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

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

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

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

};

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

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

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

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

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

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

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

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

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

समकोण कोष्ठक

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

};

संघ यू {

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

};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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