दस सी ++ 11 सुविधाएँ हर सी ++ डेवलपर का उपयोग करना चाहिए

यह आलेख कई सी ++ 11 विशेषताओं की चर्चा करता है जो सभी डेवलपर्स को जानना चाहिए और उपयोग करना चाहिए। भाषा और मानक पुस्तकालय में कई नए अतिरिक्त हैं, यह लेख केवल सतही रूप से उनमें से कुछ को कवर करता है। हालाँकि, मेरा मानना ​​है कि इन नए फीचर्स में से कुछ सभी C ++ डेवलपर्स के लिए सामान्य हो जाना चाहिए। संभवतः कई समान लेख हैं, इसमें मैं उन विशेषताओं की एक सूची बनाने की कोशिश करूंगा, जिन्हें रोजमर्रा के उपयोग में शामिल किया जाना चाहिए।

कार्यक्रम में आज:

• auto
• nullptr
• रेंज-आधारित लूप
• override और final
• जोर से टाइप किया हुआ enum
• स्मार्ट संकेत
• लैम्ब्डा
• गैर-सदस्य begin() और end()
• static_assert और संपत्ति वर्ग
• विस्थापन का शब्दार्थ

# 1 - ऑटो

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

 auto i = 42; // i - int auto l = 42LL; // l - long long auto p = new foo(); // p - foo* 

auto का उपयोग करने से आपको कोड को छोटा करने की अनुमति मिलती है (जब तक, निश्चित रूप से, प्रकार int नहीं है, जो एक अक्षर कम है)। STL पुनरावृत्तियों के बारे में सोचें कि आपको कंटेनरों से गुजरने के लिए हमेशा लिखना चाहिए। इस प्रकार, यह केवल सादगी के लिए typedef की परिभाषा को अप्रचलित बनाता है।

 std::map<std::string, std::vector<int>> map; for(auto it = begin(map); it != end(map); ++it) { // do smth } // ,  ++03  ++11 // C++03 for (std::vector<std::map<int, std::string>>::const_iterator it = container.begin(); it != container.end(); ++it) { // do smth } // C++11 for (auto it = container.begin(); it != container.end(); ++it) { // do smth } 

यह ध्यान दिया जाना चाहिए कि वापसी मूल्य auto नहीं हो सकता है। हालांकि, आप फ़ंक्शन के रिटर्न प्रकार के बजाय auto उपयोग कर सकते हैं। इस मामले में, auto संकलक को यह नहीं बताता है कि उसे किस प्रकार का निर्धारण करना चाहिए, यह केवल फ़ंक्शन के अंत में रिटर्न प्रकार की तलाश करने के लिए इसे एक कमांड देता है। नीचे दिए गए उदाहरण में, compose फ़ंक्शन का रिटर्न प्रकार + ऑपरेटर का रिटर्न प्रकार है, जो टाइप T और E के मूल्यों को बताता है E

 template <typename T, typename E> auto compose(T a, E b) -> decltype(a+b) // decltype -        { return a+b; } auto c = compose(2, 3.14); // c - double 

# 2 - nullptr

पहले, बिंदुओं को खींचने के लिए, NULL मैक्रो का उपयोग किया गया था, जो कि शून्य है - एक पूर्णांक प्रकार, जो स्वाभाविक रूप से समस्याएं पैदा करता था (उदाहरण के लिए, जब फ़ंक्शन ओवरलोड थे)। nullptr का अपना स्वयं का std::nullptr_t , जो हमें पूर्व की समस्याओं से बचाता है। nullptr से किसी भी प्रकार के अशक्त सूचक और bool (जैसे false ) के लिए निहितार्थ रूपांतरण हैं, लेकिन पूर्णांक प्रकार के लिए कोई रूपांतरण नहीं हैं।

 void foo(int* p) {} void bar(std::shared_ptr<int> p) {} int* p1 = NULL; int* p2 = nullptr; if(p1 == p2) {} foo(nullptr); bar(nullptr); bool f = nullptr; int i = nullptr; // :    int   reinterpret_cast 

# 3 - रेंज-आधारित लूप

C ++ 11 में, एक सेट पर पुनरावृत्ति के लिए foreach प्रतिमान के लिए समर्थन जोड़ा गया था। नए रूप में, पुनरावृति ऑब्जेक्ट के लिए begin() और end() विधियों को ओवरलोड किए जाने पर पुनरावृत्तियों का प्रदर्शन किया जा सकता है।

यह तब उपयोगी होता है जब आप केवल एक सरणी / कंटेनर के तत्वों को प्राप्त करना चाहते हैं या अनुक्रमणिका, पुनरावृत्तियों, या तत्वों की संख्या के बारे में चिंता किए बिना उनके साथ कुछ करना चाहते हैं।

 std::map<std::string, std::vector<int>> map; std::vector<int> v; v.push_back(1); v.push_back(2); v.push_back(3); map["one"] = v; for(const auto &kvp: map) { std::cout << kvp.first << std::endl; for(auto v: kvp.second) std::cout << v << std::endl; } int arr[] = {1,2,3,4,5}; for(int &e: arr) e *= e; 

# 4 - ओवरराइड और फाइनल

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

 class B { public: virtual void f(short) {std::cout << "B::f" << std::endl;} }; class D : public B { public: virtual void f(int) {std::cout << "D::f" << std::endl;} }; 

D::f ओवरराइड्स B::f । हालांकि, उनके पास अलग-अलग हस्ताक्षर हैं, एक विधि short स्वीकार करता है, दूसरा int स्वीकार करता है, इसलिए B::f एक ही नाम के साथ एक और विधि है, अतिभारित, और अतिरंजित नहीं। इस प्रकार, बेस क्लास के लिए एक पॉइंटर के माध्यम से काम करते हुए, आप f() कॉल कर सकते हैं और "ओवरराइड" विधि के आउटपुट की प्रतीक्षा कर सकते हैं: "D :: f", लेकिन आउटपुट "B :: f" होगा।

यहां एक और संभावित त्रुटि है: पैरामीटर समान हैं, लेकिन आधार वर्ग में विधि स्थिर है, लेकिन व्युत्पन्न एक में यह नहीं है।

 class B { public: virtual void f(int) const {std::cout << "B::f " << std::endl;} }; class D : public B { public: virtual void f(int) {std::cout << "D::f" << std::endl;} }; 

फिर, ये ओवरराइड फ़ंक्शंस के बजाय दो अतिभारित हैं।
सौभाग्य से, अब इन त्रुटियों से छुटकारा पाने का एक तरीका है। दो नए पहचानकर्ता (कीवर्ड नहीं) जोड़े गए थे: override , यह इंगित करने के लिए कि विधि बेस क्लास में वर्चुअल विधि का एक ओवरराइड है, और final , यह दर्शाता है कि व्युत्पन्न वर्ग को वर्चुअल विधि को ओवरराइड नहीं करना चाहिए। पहला उदाहरण अब इस तरह दिखता है:

 class B { public: virtual void f(short) {std::cout << "B::f" << std::endl;} }; class D : public B { public: virtual void f(int) override {std::cout << "D::f" << std::endl;} }; 

अब यह एक संकलन त्रुटि को फेंक देगा (ठीक उसी तरह यदि आप दूसरे उदाहरण में override का उपयोग करेंगे):

 'D::f': method with override specifier 'override' did not override any base class methods 

दूसरी ओर, यदि आप एक ऐसी विधि बनाना चाहते हैं जिसका उद्देश्य ओवरराइड (पदानुक्रम के नीचे) न हो, तो इसे final रूप में चिह्नित किया जाना चाहिए। एक व्युत्पन्न वर्ग में, आप एक ही समय में दोनों पहचानकर्ताओं का उपयोग कर सकते हैं।

 class B { public: virtual void f(int) {std::cout << "B::f" << std::endl;} }; class D : public B { public: virtual void f(int) override final {std::cout << "D::f" << std::endl;} }; class F : public D { public: virtual void f(int) override {std::cout << "F::f" << std::endl;} }; 

final रूप में घोषित एक फ़ंक्शन को फ़ंक्शन F::f() द्वारा ओवरराइड नहीं किया जा सकता है - इस मामले में, यह क्लास D लिए बेस क्लास ( ) की विधि को ओवरराइड करता है D

# 5 - दृढ़ता से टाइप किया हुआ एनम

C ++ में "पारंपरिक" गणना में कुछ कमियां हैं: वे अपने मूल्यों को आस-पास के दायरे में निर्यात करते हैं (जिससे नाम संघर्ष हो सकता है), वे पूरी तरह से रूपांतरित हो जाते हैं और उपयोगकर्ता-परिभाषित प्रकार नहीं हो सकते।

C ++ 11 में इन समस्याओं को एक नई श्रेणी के एन्यूमरेशन की शुरूआत के साथ तय किया गया था जिसे दृढ़ता से टाइप किए गए एनम कहा जाता है। उन्हें enum class keyword द्वारा परिभाषित किया गया है। वे अब अपने आस-पास के मानों को आस-पास के दायरे में निर्यात नहीं करते हैं, उन्हें अब पूर्ण रूप से पूर्णांक प्रकार में परिवर्तित नहीं किया जा सकता है, और उपयोगकर्ता-परिभाषित प्रकार हो सकता है (यह विकल्प "पारंपरिक" गणना "के लिए भी जोड़ा जाता है)।

 enum class Options {None, One, All}; Options o = Options::All; 

# 6 - स्मार्ट पॉइंटर्स

हब पर और इस विषय पर लिखे गए अन्य संसाधनों पर, कई लेख हैं, इसलिए मैं केवल संदर्भ गिनती और स्वचालित मेमोरी डीलक्लेशन के साथ स्मार्ट पॉइंटर्स का उल्लेख करना चाहता हूं:

1. unique_ptr : का उपयोग तब किया जाना चाहिए जब मेमोरी रिसोर्स को साझा नहीं किया जाना चाहिए (इसमें कॉपी कंस्ट्रक्टर नहीं है), लेकिन इसे किसी अन्य unique_ptr को पास किया जा सकता है
2. share_ptr : का उपयोग तब किया जाना चाहिए जब मेमोरी संसाधन साझा किया जाना चाहिए
3. weak_ptr : shared_ptr किए गए ऑब्जेक्ट द्वारा नियंत्रित ऑब्जेक्ट के लिए एक संदर्भ होता है, लेकिन लिंक की गिनती नहीं करता है; आपको चक्रीय निर्भरता से छुटकारा पाने की अनुमति देता है

निम्न उदाहरण unique_ptr प्रदर्शित unique_ptr । किसी अन्य unique_ptr लिए किसी ऑब्जेक्ट का स्वामित्व स्थानांतरित करने के लिए, std :: unique_ptr (इस फ़ंक्शन को अंतिम पैराग्राफ में चर्चा की जाएगी) का उपयोग करें। स्वामित्व हस्तांतरित करने के बाद, हस्तांतरित स्वामित्व वाला स्मार्ट सूचक शून्य हो जाता है और get() वापस nullptr हो जाएगा।

 void foo(int* p) { std::cout << *p << std::endl; } std::unique_ptr<int> p1(new int(42)); std::unique_ptr<int> p2 = std::move(p1); // transfer ownership if(p1) foo(p1.get()); (*p2)++; if(p2) foo(p2.get()); 

दूसरा उदाहरण shared_ptr प्रदर्शित करता है। उपयोग समान है, हालांकि शब्दार्थ अलग हैं, क्योंकि स्वामित्व अब साझा है।

 void foo(int* p) { } void bar(std::shared_ptr<int> p) { ++(*p); } std::shared_ptr<int> p1(new int(42)); std::shared_ptr<int> p2 = p1; bar(p1); foo(p2.get()); 

पहली घोषणा निम्नलिखित के बराबर है:

 auto p3 = std::make_shared<int>(42); 

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

 void foo(std::shared_ptr<int> p, int init) { *p = init; } foo(std::shared_ptr<int>(new int(42)), seed()); 

यह समस्या make_shared का उपयोग करके हल की make_shared ।
और अंत में, weak_ptr साथ एक उदाहरण। ध्यान दें कि आपको ऑब्जेक्ट को एक्सेस करने के लिए lock() कॉल करके ऑब्जेक्ट के लिए shared_ptr करना होगा।

 auto p = std::make_shared<int>(42); std::weak_ptr<int> wp = p; { auto sp = wp.lock(); std::cout << *sp << std::endl; } p.reset(); if(wp.expired()) std::cout << "expired" << std::endl; 

# 7 - लंबोदर

नए मानक ने आखिरकार लंबोदर भावों के लिए समर्थन जोड़ा है। हम जहां भी एक फनकार या std::function की उम्मीद है, हम लंबोदा का उपयोग कर सकते हैं। एक लंबोदर, आम तौर पर बोल रहा है, एक फ़नकार का एक छोटा अंकन है, एक गुमनाम फ़नकार जैसा कुछ है। अधिक विवरण पढ़े जा सकते हैं, उदाहरण के लिए, MSDN पर।

 std::vector<int> v; v.push_back(1); v.push_back(2); v.push_back(3); std::for_each(std::begin(v), std::end(v), [](int n) {std::cout << n << std::endl;}); auto is_odd = [](int n) {return n%2==1;}; auto pos = std::find_if(std::begin(v), std::end(v), is_odd); if(pos != std::end(v)) std::cout << *pos << std::endl; 

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

 auto fib = [&fib](int n) {return n < 2 ? 1 : fib(n-1) + fib(n-2);}; 

 error C3533: 'auto &': a parameter cannot have a type that contains 'auto' error C3531: 'fib': a symbol whose type contains 'auto' must have an initializer error C3536: 'fib': cannot be used before it is initialized error C2064: term does not evaluate to a function taking 1 arguments 

चक्रीय निर्भरता है। इससे छुटकारा पाने के लिए, आपको std::function का उपयोग करके फ़ंक्शन के प्रकार को स्पष्ट रूप से निर्धारित करना होगा।

 std::function<int(int)> lfib = [&lfib](int n) {return n < 2 ? 1 : lfib(n-1) + lfib(n-2);}; 

# 8 - गैर-सदस्य शुरू () और अंत ()

आपने शायद देखा कि पहले के उदाहरणों में, मैंने begin() और end() फ़ंक्शन का उपयोग किया था। यह मानक पुस्तकालय के लिए एक नया अतिरिक्त है। वे सभी एसटीएल कंटेनरों के साथ काम करते हैं और किसी भी प्रकार के साथ काम करने के लिए विस्तारित किया जा सकता है।

चलो, उदाहरण के लिए, पिछले उदाहरण जहां मैं एक वेक्टर का उत्पादन करता हूं और फिर पहले विषम तत्व की तलाश करता हूं। यदि हम std::vector को C-like सरणी से बदलते हैं, तो कोड इस तरह दिखेगा:

 int arr[] = {1,2,3}; std::for_each(&arr[0], &arr[0]+sizeof(arr)/sizeof(arr[0]), [](int n) {std::cout << n << std::endl;}); auto is_odd = [](int n) {return n%2==1;}; auto begin = &arr[0]; auto end = &arr[0]+sizeof(arr)/sizeof(arr[0]); auto pos = std::find_if(begin, end, is_odd); if(pos != end) std::cout << *pos << std::endl; 

begin() और end() इसे निम्नानुसार फिर से लिखा जा सकता है:

 int arr[] = {1,2,3}; std::for_each(std::begin(arr), std::end(arr), [](int n) {std::cout << n << std::endl;}); auto is_odd = [](int n) {return n%2==1;}; auto pos = std::find_if(std::begin(arr), std::end(arr), is_odd); if(pos != std::end(arr)) std::cout << *pos << std::endl; 

यह std::vector के साथ कोड के लिए लगभग पूरी तरह से समान है। इस प्रकार, हम सभी प्रकारों के लिए एक सार्वभौमिक विधि लिख सकते हैं जो begin() और end() द्वारा समर्थित हैं।

 template <typename Iterator> void bar(Iterator begin, Iterator end) { std::for_each(begin, end, [](int n) {std::cout << n << std::endl;}); auto is_odd = [](int n) {return n%2==1;}; auto pos = std::find_if(begin, end, is_odd); if(pos != end) std::cout << *pos << std::endl; } template <typename C> void foo(C c) { bar(std::begin(c), std::end(c)); } template <typename T, size_t N> void foo(T(&arr)[N]) { bar(std::begin(arr), std::end(arr)); } int arr[] = {1,2,3}; foo(arr); std::vector<int> v; v.push_back(1); v.push_back(2); v.push_back(3); foo(v); 

# 9 - static_assert और संपत्ति वर्ग

static_assert संकलन समय पर कथन की जाँच करता है। यदि कथन सत्य है, तो कुछ भी नहीं होता है। यदि यह गलत है, तो संकलक निर्दिष्ट त्रुटि संदेश प्रदर्शित करता है।

 template <typename T, size_t Size> class Vector { static_assert(Size > 3, "Size is too small"); T _points[Size]; }; int main() { Vector<int, 16> a1; Vector<double, 2> a2; return 0; } 

 error C2338: Size is too small see reference to class template instantiation 'Vector<T,Size>' being compiled with [ T=double, Size=2 ] 

संपत्ति वर्गों के साथ उपयोग किए जाने पर static_assert अधिक उपयोगी हो जाता है। यह कक्षाओं का एक संग्रह है जो संकलन समय पर प्रकार की जानकारी प्रदान करता है। वे <type_traits> हैडर में उपलब्ध हैं। इस हेडर में कई तरह की कक्षाएं हैं: हेल्पर क्लास, ट्रांसफॉर्मेशन क्लास और प्रॉपर्टी क्लासेज।
निम्न उदाहरण में, add फ़ंक्शन केवल पूर्णांक प्रकारों के साथ काम करने वाला है।

 template <typename T1, typename T2> auto add(T1 t1, T2 t2) -> decltype(t1 + t2) { return t1 + t2; } 

हालाँकि, यदि आप निम्नलिखित लिखते हैं तो कोई संकलन त्रुटि नहीं होगी:

 std::cout << add(1, 3.14) << std::endl; std::cout << add("one", 2) << std::endl; 

कार्यक्रम बस "4.14" और "ई" प्रदर्शित करता है। static_assert का उपयोग करते static_assert , इन दो पंक्तियों को संकलन समय पर static_assert त्रुटि static_assert देगा।

 template <typename T1, typename T2> auto add(T1 t1, T2 t2) -> decltype(t1 + t2) { static_assert(std::is_integral<T1>::value, "Type T1 must be integral"); static_assert(std::is_integral<T2>::value, "Type T2 must be integral"); return t1 + t2; } 

 error C2338: Type T2 must be integral see reference to function template instantiation 'T2 add<int,double>(T1,T2)' being compiled with [ T2=double, T1=int ] error C2338: Type T1 must be integral see reference to function template instantiation 'T1 add<const char*,int>(T1,T2)' being compiled with [ T1=const char *, T2=int ] 

# 10 - आंदोलन के शब्दार्थ

यह C ++ 11 में उठाया गया एक और महत्वपूर्ण विषय है। इस विषय पर, आप पैराग्राफ नहीं, बल्कि कई लेख लिख सकते हैं, इसलिए मैं बहुत गहराई तक नहीं गया।

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

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

एक चाल निर्माणकर्ता और एक चाल असाइनमेंट ऑपरेटर - ये दो विशेष कार्य पैरामीटर T && लेते हैं, जो एक प्रतिद्वंद्विता है। वास्तव में, वे वस्तु को संशोधित कर सकते हैं।

निम्न उदाहरण एक डमी बफर कार्यान्वयन दिखाता है। बफर को एक नाम से पहचाना जाता है, जिसमें T के तत्वों की एक सरणी के लिए एक सूचक ( std::unique_ptr में लिपटे std::unique_ptr ) और एक चर होता है जिसमें सरणी का आकार होता है।

 template <typename T> class Buffer { std::string _name; size_t _size; std::unique_ptr<T[]> _buffer; public: // default constructor Buffer(): _size(16), _buffer(new T[16]) {} // constructor Buffer(const std::string& name, size_t size): _name(name), _size(size), _buffer(new T[size]) {} // copy constructor Buffer(const Buffer& copy): _name(copy._name), _size(copy._size), _buffer(new T[copy._size]) { T* source = copy._buffer.get(); T* dest = _buffer.get(); std::copy(source, source + copy._size, dest); } // copy assignment operator Buffer& operator=(const Buffer& copy) { if(this != &copy) { _name = copy._name; if(_size != copy._size) { _buffer = nullptr; _size = copy._size; _buffer = (_size > 0)? new T[_size] : nullptr; } T* source = copy._buffer.get(); T* dest = _buffer.get(); std::copy(source, source + copy._size, dest); } return *this; } // move constructor Buffer(Buffer&& temp): _name(std::move(temp._name)), _size(temp._size), _buffer(std::move(temp._buffer)) { temp._buffer = nullptr; temp._size = 0; } // move assignment operator Buffer& operator=(Buffer&& temp) { assert(this != &temp); // assert if this is not a temporary _buffer = nullptr; _size = temp._size; _buffer = std::move(temp._buffer); _name = std::move(temp._name); temp._buffer = nullptr; temp._size = 0; return *this; } }; template <typename T> Buffer<T> getBuffer(const std::string& name) { Buffer<T> b(name, 128); return b; } int main() { Buffer<int> b1; Buffer<int> b2("buf2", 64); Buffer<int> b3 = b2; Buffer<int> b4 = getBuffer<int>("buf4"); b1 = getBuffer<int>("buf5"); return 0; } 

डिफ़ॉल्ट कॉपी कंस्ट्रक्टर और कॉपी असाइनमेंट ऑपरेटर आपको परिचित होना चाहिए। C ++ 11 में नया मूव कंस्ट्रक्टर और मूव असाइनमेंट ऑपरेटर है। यदि आप इस कोड को निष्पादित करते हैं, तो आप देखेंगे कि जब b4 बनाया जाता है, तो मूव कंस्ट्रक्टर को कहा जाता है। इसके अलावा, जब b1 एक मान सौंपा b1 , तो मूव असाइनमेंट ऑपरेटर कहलाता है। इसका कारण getBuffer() फ़ंक्शन द्वारा लौटाया गया मान है।

आपने शायद std का उपयोग किया है :: जब एक चर नाम और एक बफ़र के लिए एक पॉइंटर को प्रारंभ करते हुए मूव कंस्ट्रक्टर में ले जाएँ । नाम है स्ट्रिंग std::string और std::string भी आंदोलन के शब्दार्थ को लागू करता है। वही unique_ptr लिए जाता है। हालाँकि, अगर हमने केवल _name(temp._name) लिखा है, तो कॉपी कंस्ट्रक्टर को बुलाया जाएगा। लेकिन इस मामले में std::string लिए मूव कंस्ट्रक्टर को क्यों नहीं बुलाया गया? तथ्य यह है कि भले ही Buffer लिए मूव कंस्ट्रक्टर को एक प्रतिद्वंद्विता के साथ बुलाया गया था, कंस्ट्रक्टर के अंदर यह अभी भी एक लवल्यू के रूप में दिखाई देता है। इसे फिर से बनाने के लिए और आपको std::move का उपयोग करना होगा। यह फ़ंक्शन केवल अंतराल के संदर्भ को अंतराल में बदल देता है।

एक निष्कर्ष के बजाय

C ++ 11 में कई चीजें हैं जिनके बारे में आपको बात करनी चाहिए और करनी चाहिए; यह लेख कई संभावित शुरुआतओं में से एक था। इस लेख ने भाषा सुविधाओं की एक श्रृंखला और एक मानक पुस्तकालय की शुरुआत की जिसे हर C ++ डेवलपर को जानना चाहिए। हालांकि, कहा गया है कि सभी की गहरी समझ के लिए, यह लेख पर्याप्त नहीं है, इसलिए अतिरिक्त साहित्य के बिना ऐसा करने का कोई तरीका नहीं है।