दिलचस्प पोस्ट
एक इंटरफ़ेस लागू करने वाला JAXB क्लास जेनरेट कर रहा है दशमलव स्पीड डबल बनाम यूनिकोडडेकोड त्रुटि: 'utf8' कोडेक बाइट 0x9c डीकोड नहीं कर सकता मैं जावास्क्रिप्ट के साथ पृष्ठभूमि का रंग कैसे बदलूं? एंड्रॉइड एनडीके: बैकट्र्रेस प्राप्त करना Async कार्य समाप्त होने तक प्रतीक्षा कर रहा है वाग्त्र्ट एसएसएएस प्रमाणीकरण विफलता तत्वों के सेट में एक विशेषता का न्यूनतम मूल्य खोजने के लिए मैं कैसे XPath का उपयोग कर सकता हूं? हाइबरनेट मानदंड 3 टेबल के साथ जुड़ें कैसे Excel में DataTable निर्यात करने के लिए इनपुट को बदलने वाली केवल किस्पेस को पकड़ें? क्या आप सेटिंग में सेटिंग्स बना सकते हैं.बंडल डिफ़ॉल्ट भी अगर आप सेटिंग ऐप नहीं खोलते हैं इन्पुट फॉर्म से Base64 एन्कोड फाइल-डेटा प्राप्त करें ऑब्जेक्ट इस गुण या पद्धति का समर्थन नहीं करता Windows 64bit Rails क्या जावा 8 गेटर्स वैकल्पिक प्रकार लौटाएंगे?

सी ++ 11 में बदलावों को किस प्रकार से बदल दिया जाता है?

मुझे पता है कि कम से कम एक सी + + 11 में हुए परिवर्तनों में से कुछ पुराने कोड को संकलन बंद करने का कारण होगा: मानक explicit operator bool() के operator void*() पुराने उदाहरणों की जगह, की शुरुआत। यह माना जाता है कि यह कोड जो टूट जाएगा, वह शायद कोड है जो पहले स्थान पर वैध नहीं होना चाहिए, फिर भी यह अभी भी एक तोड़ बदलना है: प्रोग्राम जो अब मान्य नहीं थे, वे अब नहीं हैं।

क्या कोई अन्य तोड़ने वाले परिवर्तन हैं?

वेब के समाधान से एकत्रित समाधान "सी ++ 11 में बदलावों को किस प्रकार से बदल दिया जाता है?"

एफडीआईएस में असंगति का एक खंड है, परिशिष्ट C.2 "C ++ और ISO C ++ 2003" पर।

संक्षेप में, यहां पर एफडीआईएस को समझाते हुए, इसे (बेहतर) SO उत्तर के रूप में उपयुक्त बनाने के लिए। मैंने मतभेदों को स्पष्ट करने के लिए अपने स्वयं के कुछ उदाहरण जोड़े।

कुछ लाइब्रेरी से संबंधित असंगतियां हैं जहां पर मुझे इसके बारे में बिल्कुल पता नहीं है, इसलिए मैं उन लोगों के लिए उनको अधिक विस्तृत करने के लिए छोड़ देता हूं।

कोर भाषा


 #define u8 "abc" const char *s = u8"def"; // Previously "abcdef", now "def" 

 #define _x "there" "hello"_x // now a user-defined-string-literal. Previously, expanded _x . 

नए कीवर्ड: एलाग्नास, एल्ग्नॉफ, चार् 16_टी, चार 32_ टी, कॉन्स्टेक्सप्रो, डेप्लेप्ले, नोएसेसेप्ट, नोलेप्टर, स्टेटिक_एस्टर्ट, और थ्रेड_लोकल


लंबे समय तक हस्ताक्षरित एक हस्ताक्षरित पूर्णांक प्रकार से कुछ लंबे समय तक हस्ताक्षर किए जा सकते हैं।


मान्य C ++ 2003 कोड का उपयोग करता है जो पूर्णांक प्रभाग का परिणाम 0 या नकारात्मक अनंत पर ओर जाता है, जबकि सी ++ 0x हमेशा परिणाम की ओर 0 की ओर जाता है

(बेशक ज्यादातर लोगों के लिए वास्तव में एक संगतता समस्या नहीं है)।


मान्य C ++ 2003 कोड जो कीवर्ड auto को स्टोरेज श्रेणी निर्दिष्टकर्ता के रूप में उपयोग करता है, वह C ++ 0x में अमान्य हो सकता है।


रूपांतरणों को कम करने से C ++ 03 के साथ असंगति उत्पन्न हो गए। उदाहरण के लिए, निम्न कोड C ++ 2003 में मान्य है लेकिन इस अंतर्राष्ट्रीय मानक में अमान्य है क्योंकि इंटेल के लिए डबल एक संकुचित रूपांतरण है:

 int x[] = { 2.0 }; 

स्पष्ट रूप से घोषित विशेष सदस्य फ़ंक्शंस हटाए गए हैं, जब अंतर्निहित परिभाषा बीमार रूप से बनती होती।

एक वैध C ++ 2003 प्रोग्राम जो इन विशेष सदस्य कार्यों में से किसी एक संदर्भ में उपयोग करता है जहां परिभाषा की आवश्यकता नहीं है (उदाहरण के लिए, किसी एक्सप्रेशन में जिसका संभावित मूल्यांकन नहीं किया गया है) बीमार रूप से बन जाता है

मेरे द्वारा उदाहरण:

 struct A { private: A(); }; struct B : A { }; int main() { sizeof B(); /* valid in C++03, invalid in C++0x */ } 

इस तरह के आकार की चाल कुछ एसएफआईएनएई द्वारा उपयोग की गई है, और अब इसे बदलना होगा 🙂


उपयोगकर्ता द्वारा घोषित नाशकों के पास एक अपवाद अपवाद विनिर्देश है।

मेरे द्वारा उदाहरण:

 struct A { ~A() { throw "foo"; } }; int main() { try { A a; } catch(...) { } } 

यह कोड C ++ 0x में terminate होता है, लेकिन सी ++ 03 में नहीं है चूंकि A::~A में C ++ 0x का noexcept(true) अपवाद विनिर्देश नहीं है noexcept(true)


सी ++ 0x में एक वैध सी ++ 2003 घोषणापत्र का export गलत है


एक मान्य C ++ 2003 अभिव्यक्ति जिसमें > एक दूसरे के तुरंत अनुसरण किया जाता है > अब दो टेम्पलेट्स को बंद करने के रूप में माना जा सकता है

सी +0 03 में, >> हमेशा शिफ्ट ऑपरेटर टोकन होगा


आंतरिक लिंकेज के साथ फ़ंक्शन के आश्रित कॉल की अनुमति दें

मेरे द्वारा उदाहरण:

 static void f(int) { } void f(long) { } template<typename T> void g(T t) { f(t); } int main() { g(0); } 

सी ++ 03 में, यह कॉल f(long) , लेकिन सी ++ 0x में, यह कॉल f(int) । यह ध्यान दिया जाना चाहिए कि C ++ 03 और C ++ 0x दोनों में, निम्नलिखित कॉल f(B) (तात्कालिक संदर्भ अभी भी extern लिंक्ड घोषणाओं को समझता है)।

 struct B { }; struct A : B { }; template<typename T> void g(T t) { f(t); } static void f(A) { } void f(B) { } int main() { A a; g(a); } 

बेहतर मेलिंग f(A) को नहीं लिया जाता है, क्योंकि इसमें बाह्य संबंध नहीं है।


पुस्तकालय परिवर्तन

मान्य C ++ 2003 कोड जो C ++ 0x की सी ++ लायब्रेरी में जोड़ा गया कोई पहचानकर्ता का उपयोग करता है, यह अंतर्राष्ट्रीय मानक में अलग-अलग परिणामों को संकलित या उत्पादन करने में विफल हो सकता है।


वैध C ++ 2003 कोड है कि #includes इस अंतर्राष्ट्रीय मानक में नए C ++ 0x मानक लाइब्रेरी शीर्षलेख के नामों के साथ हेडर #includes हो सकते हैं।


मान्य सी ++ 2003 कोड जो कि स्वैप को <algorithm> में होने की उम्मीद में संकलित किया गया है, इसके बजाय <utility>


वैश्विक नाम स्थान posix अब मानकीकरण के लिए आरक्षित है


वैध C ++ 2003 कोड जो override , final , carries_dependency , या carries_dependency को परिभाषित करता है, मैक्रो के रूप में सी ++ 0x में अमान्य है।

ऑटो कीवर्ड का अर्थ बदल गया है।

परिवर्तन तोड़कर?

ठीक है, एक बात के लिए, यदि आप decltype , constexpr , nullptr , आदि पहचानकर्ता के रूप में इस्तेमाल decltype , तो आपको परेशानी हो सकती है …

असंगतता अनुभाग द्वारा कवर नहीं किए गए कुछ मुख्य असंगतियां:


सी ++ 0x एक टेम्पलेट के रूप में इंजेक्शन वर्ग के नाम को मानता है, यदि नाम टेम्पलेट टेम्पलेट पैरामीटर के लिए एक तर्क के रूप में पारित किया गया है, और एक प्रकार के रूप में यदि यह एक टेम्पलेट प्रकार पैरामीटर को पारित किया गया है।

मान्य सी + 03 03 कोड अलग तरीके से व्यवहार कर सकता है यदि यह इंजेक्शन वर्ग के नाम पर निर्भर करता है तो इन स्थितियों में हमेशा एक प्रकार होता है। उदाहरण कोड को मेरी झूठी पीआर से लिया गया

 template<template<typename> class X> struct M { }; template<template<typename> class X> void g(int = 0); // #1 template<typename T> void g(long = 0); // #2 template<typename T> struct A { void f() { g<A>(); /* is ambiguous in C++0x */ g<A>(1); /* should choose #1 in C++0x */ } }; void h() { A<int> a; af(); } 

सी ++ 03 में, कोड दूसरी बार दोनों को कॉल करता है।


C ++ 0x कुछ नाम बनाते हैं जो सी ++ 03 में निर्भर थे, अब गैर-निर्भर होने के लिए। और गैर-आश्रित योग्य नामों के लिए नाम खोज की आवश्यकता होती है जो वर्तमान वर्ग के टेम्पलेट के सदस्यों को तत्काल दोहराया जाने के लिए दोहराया जाता है, और सत्यापन की आवश्यकता है कि ये नाम टेम्प्लेट परिभाषा संदर्भ में किए गए तरीके से समान रूप से देखने लगते हैं।

वैध सी +0 03 कोड जो कि इस परिवर्तन के कारण प्रभुत्व नियम पर निर्भर करता है अब संकलन नहीं कर सकता है।

उदाहरण:

 struct B { void f(); }; template<typename T> struct A : virtual B { void f(); }; template<typename T> struct C : virtual B, A<T> { void g() { this->f(); } }; int main() { C<int> c; cg(); } 

यह मान्य C ++ 03 कोड जो कॉल करता है A<int>::f C ++ 0x में मान्य नहीं है, क्योंकि जब इन्हें तत्काल भेजते समय A<int>::f को B::f विरोध में मिल जाता है, तो एक संघर्ष उत्पन्न होता है पर-परिभाषा देखने के साथ

इस बिंदु पर, यह स्पष्ट नहीं है कि यह एफडीआईएस में एक दोष है या नहीं। समिति इस बारे में अवगत है और स्थिति का मूल्यांकन करेगी।


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

उदाहरण:

 struct A { protected: int B; }; typedef AB; struct C : B { // inheriting constructor, instead of bringing A::B into scope using B::B; }; int main() { C c; cB = 0; } 

उपरोक्त उदाहरण कोड सी ++ 03 में अच्छी तरह से बनाया गया है, लेकिन सी ++ 0x में बीमार बनाया गया है, A::B में अभी भी main में अनुपलब्ध है।

स्पष्ट रूपांतरण प्रचालकों को कैसे बदलना शुरू करना है? पुराना संस्करण अभी भी "मान्य" के रूप में पहले होगा

हां, operator void*() const से explicit operator bool() const बदलना एक ब्रेकिंग बदलाव होगा, लेकिन तभी यह किसी ऐसे तरीके से प्रयोग किया जाता है जो स्वयं में गलत और बाहर हो। अनुरूप कोड टूट नहीं होगा।

अब, एक और तोड़ने वाला परिवर्तन, एकमात्र आरंभीकरण के दौरान संकीर्ण रूपांतरणों पर प्रतिबंध लगा रहा है :

 int a[] = { 1.0 }; // error 

संपादित करें : बस यादृच्छिक, std::identity<T> को C ++ 0x में हटा दिया जाएगा (नोट देखें)। यह प्रकार निर्भर करने के लिए एक सुविधा संरचना है। चूंकि स्ट्रैट वास्तव में बहुत कुछ नहीं करता, इसलिए इसे ठीक करना चाहिए:

 template<class T> struct identity{ typedef T type; }; 

स्ट्रीम निष्कासन विफलता अलग तरह से व्यवहार किया जाता है

उदाहरण

 #include <sstream> #include <cassert> int main() { std::stringstream ss; ss << '!'; int x = -1; assert(!(ss >> x)); // C++03 and C++11 assert(x == -1); // C++03 assert(x == 0); // C++11 } 

प्रस्ताव बदलें

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3246.html#23

मानक संदर्भ

[C++03: 22.2.2.1.2/11]: चरण 2 प्रसंस्करण का परिणाम इनमें से एक हो सकता है

  • चरण 2 में वर्णों का एक क्रम संचित किया गया है जो कि val के प्रकार के मूल्य में ( scanf के नियमों के अनुसार) परिवर्तित होता है। यह मान val और ios_base::goodbit में संग्रहीत है ios_base::goodbit में संग्रहीत है
  • चरण 2 में एकत्र हुए वर्णों का अनुक्रम scanf को एक इनपुट विफलता की रिपोर्ट करने के लिए कारण होगा। ios_base::failbit को err को सौंपा गया है [ed: कुछ भी val में संग्रहीत नहीं है।]

[C++11: 22.4.2.1.2/3]: [..] संग्रहीत करने के लिए संख्यात्मक मान इनमें से एक हो सकता है:

  • शून्य, यदि रूपांतरण फ़ंक्शन पूरे क्षेत्र को परिवर्तित करने में विफल रहता हैios_base::failbit को err को सौंपा गया है
  • सबसे सकारात्मक प्रतिनिधित्व योग्य मूल्य, यदि मान val में प्रतिनिधित्व करने के लिए बहुत बड़ा सकारात्मक मान का प्रतिनिधित्व करता है। ios_base::failbit को err को सौंपा गया है
  • एक अहस्ताक्षरित पूर्णांक प्रकार के लिए सबसे नकारात्मक प्रतिनिधित्व योग्य मान या शून्य, यदि मान val में प्रतिनिधित्व करने के लिए बहुत बड़ा नकारात्मक मान का प्रतिनिधित्व करता है। ios_base::failbit को err को सौंपा गया है
  • परिवर्तित मूल्य, अन्यथा।

परिणामी संख्यात्मक मान को val में संग्रहित किया जाता है

क्रियान्वयन

  • जीसीसी 4.8 सी ++ के लिए सही ढंग से आउटपुट 11 :

    निषेध `x == -1 'असफल रहा

  • जीसीसी 4.5-4.8 सी ++ 03 के लिए सभी आउटपुट निम्न, जो एक बग प्रतीत होता है:

    निषेध `x == -1 'असफल रहा

  • विजुअल सी ++ 2008 एक्सप्रेस सही सी ++ 03 के लिए आउटपुट:

    निषेध विफल: x == 0

  • विजुअल सी ++ 2012 एक्सप्रेस सी ++ 11 के लिए गलत रूप से आउटपुट, जो एक स्थिति-का-कार्यान्वयन जारी होगा:

    निषेध विफल: x == 0

कंटेनर लाइब्रेरी में कई बदलाव हैं जो अधिक कुशल कोड की अनुमति देते हैं लेकिन कुछ कोने वाले मामलों के लिए चुपचाप पीछे की ओर संगतता को तोड़ते हैं।

उदाहरण के लिए, std::vector , डिफ़ॉल्ट निर्माण, सी ++ 0x, और परिवर्तनों को तोड़ने पर विचार करें ।

पिछड़े संगतता को तोड़ने में अंतर्निहित कदम की बहुत चर्चा हुई है

( प्रासंगिक चर्चा के साथ एक पुराने पृष्ठ )

यदि आप टिप्पणियों में पढ़ते हैं, तो अंतर्निहित चाल वापसी भी एक तोड़फोड़ बदलाव है।

 struct x { x(int) {} }; void f(auto x = 3) { } int main() { f(); } 

सी +0 03: वैध।

सी ++ 0x: error: parameter declared 'auto'

भाषा सुविधाएं

  1. {} का उपयोग करके वर्दी और सामान्य आरंभीकरण
  2. ऑटो
  3. संकुचन की रोकथाम
  4. constexpr
  5. लूप के आधार पर रेंज
  6. nullptr
  7. enum वर्ग
  8. static_assert
  9. std :: initializer_list
  10. Rvalue संदर्भ (चाल शब्दों)
  11. >>
  12. lambdas
  13. विविधतात्मक टेम्पलेट्स
  14. प्रकार और टेम्पलेट aliases
  15. यूनिकोड वर्ण
  16. लंबे समय तक पूर्णांक प्रकार
  17. संरेखण और संरेखण
  18. decltype
  19. कच्चे स्ट्रिंग शाब्दिक
  20. सामान्यीकृत पीओडी
  21. सामान्यीकृत यूनियनों
  22. टेम्पलेट तर्क के रूप में स्थानीय कक्षाएं
  23. प्रत्यय वापसी प्रकार वाक्यविन्यास
  24. [[carries_dependency]] और [[noreturn]]
  25. बिना किसी निर्दिष्ट विनिर्देशक
  26. निष्कासन ऑपरेटर
  27. C99 विशेषताएं:
    • विस्तारित अभिन्न प्रकार
    • संकीर्ण / चौड़ी स्ट्रिंग के संयोजन
    • _ _ STDC_HOSTED _ _
    • _Pragma (एक्स)
    • vararg मैक्रोज़ और खाली मैक्रो तर्क
  28. _ _ फंक _ _
  29. इनलाइन नामस्थान
  30. डिस्ट्रेटिंग कन्स्ट्रक्टर
  31. इन-क्लास सदस्य आरंभिक
  32. डिफ़ॉल्ट और हटाएं
  33. स्पष्ट रूपांतरण ऑपरेटर
  34. उपयोगकर्ता द्वारा परिभाषित लीटरल्स
  35. बाह्य टेम्पलेट
  36. फ़ंक्शन टेम्पलेट्स के लिए डिफ़ॉल्ट टेम्पलेट तर्क
  37. कंस्ट्रक्टरों का भर्ती करना
  38. ओवरराइड और अंतिम
  39. सरल और अधिक सामान्य SFINAE नियम
  40. मेमोरी मॉडल
  41. thread_local

मानक पुस्तकालय घटक

  1. कंटेनरों के लिए initializer_list
  2. कंटेनरों के लिए शब्दों को स्थानांतरित करें
  3. forward_list
  4. हैश कंटेनर
    • unordered_map
    • unordered_multimap
    • unordered_set
    • unordered_multiset
  5. संसाधन प्रबंधन संकेतक
    • unique_ptr
    • shared_ptr
    • weak_ptr
  6. संगामिति समर्थन
    • धागा
    • mutexes
    • ताले
    • हालत चर
  7. उच्च स्तरीय संगामिति समर्थन
    • packaged_thread
    • भविष्य
    • पक्का वादा
    • async
  8. tuples
  9. regex
  10. यादृच्छिक संख्या
    • uniform_int_distribution
    • सामान्य वितरण
    • random_engine
    • आदि।
  11. पूर्णांक प्रकार नाम, जैसे int16_t, uint32_t, और int_fast64_t
  12. सरणी
  13. अपवादों को कॉपी और पुनर्स्थापित करना
  14. सिस्टम में गड़बड़ी
  15. कंटेनरों के लिए जगह () की जगहें
  16. constexpr फ़ंक्शंस
  17. बिना एक्सैसेट कार्यों का व्यवस्थित उपयोग
  18. फ़ंक्शन और बाइंड करें
  19. संख्यात्मक मान रूपांतरणों के लिए स्ट्रिंग
  20. स्कॉच आबंटक
  21. लक्षण टाइप करें
  22. समय उपयोगिताओं: अवधि और समय_पंजी
  23. अनुपात
  24. quick_exit
  25. अधिक एल्गोरिदम, जैसे कि चाल (), कॉपी_आईफ़ (), और is_sorted ()
  26. कचरा संग्रह एबीआई
  27. एटोमिक्स

पदावनत सुविधाओं

  1. डिस्ट्रिक्ट के साथ एक क्लास के लिए प्रतिलिपि कन्स्ट्रक्टर और प्रतिलिपि असाइनमेंट की जनरेशन।
  2. अक्षर का एक अक्षर अक्षरशः असाइन करें *
  3. सी + + 98 अपवाद विनिर्देश
    • unexcepted_handler
    • set_unexpected
    • get_unexpected
    • अप्रत्याशित
  4. फ़ंक्शन ऑब्जेक्ट्स और संबंधित फ़ंक्शन
  5. auto_ptr
  6. रजिस्टर
  7. ++ एक बुल पर
  8. निर्यात
  9. सी शैली डाली