नई C ++ 14 विशेषताओं का अवलोकन: भाग 1

अप्रैल में, ब्रिस्टल में C ++ समिति की एक बैठक हुई, जिसमें नए C ++ 14 मानक में संशोधन के पहले प्रस्तावों पर विचार किया गया। इस लेख में चर्चा किए गए सभी परिवर्तनों को इस बैठक में अनुमोदित किया गया था और पहले से ही नए मानक (N3690 दिनांक 15 मई, 2013) के मसौदे के नवीनतम संस्करण में सम्मान की जगह ले रहे हैं।

संक्षिप्त सूची:

• नियमित कार्यों के लिए स्वचालित रूप से रिटर्न प्रकार का पता लगाएं
• कैप्चर-बाय-मूव के समर्थन के साथ कैप्चर किए गए लैम्ब्डा वेरिएबल्स की जेनेरिक इनिशियलाइज़ेशन
• सामान्यीकृत (बहुरूपी) लंबोदर भाव
• constexpr कार्यों को बनाने पर सरलीकृत प्रतिबंध
• परिवर्तनीय टेम्पलेट
• exchange
• make_unique
• अलग लाइन
• मानक पुस्तकालय प्रकारों के लिए कस्टम साहित्य
• optional
• shared_mutex और shared_lock
• dynarray

भाषा में ही बदलाव आता है

नियमित कार्यों के लिए स्वचालित रूप से रिटर्न प्रकार का पता लगाएं

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

 auto iterate(int len) //   - int { for (int i = 0; i < len; ++i) if (search (i)) return i; return -1; } auto h() { return h(); } // ,      auto sum(int i) { if (i == 1) return i; //   - int else return sum(i-1)+i; //     } template <class T> auto f(T t) { return t; } //       []()->auto& { return f(); } //   

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

 // foo.h class Foo { public: auto getA() const; }; // foo.cpp #include "foo.h" auto Foo::getA() const { return something; } // main.cpp #include "foo.h" int main() { Foo bar; auto a = bar.getA(); // ,    } 

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

कैप्चर-बाय-मूव के समर्थन के साथ कैप्चर किए गए लैम्ब्डा वेरिएबल्स की जेनेरिक इनिशियलाइज़ेशन

C ++ 11 में, लैम्ब्डा कैप्चर-बाय-मूव का समर्थन नहीं करता है। उदाहरण के लिए, निम्नलिखित कोड संकलित नहीं किया जाएगा:

 #include <memory> #include <iostream> #include <utility> template <class T> void run(T&& runnable) { runnable(); }; int main() { std::unique_ptr<int> result(new int{42}); run([result](){std::cout << *result << std::endl;}); } 

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

 [ x { move(x) }, y = transform(y, z), foo, bar, baz ] { ... } 

इस स्थिति में, x को x ले जाकर सीधे इनिशियलाइज़ किया जाएगा, कॉल transform के परिणाम से y को इनिशियलाइज़ किया जाएगा, और बाकी को वैल्यू द्वारा कैप्चर किया जाएगा। एक और उदाहरण:

 int x = 4; auto y = [&r = x, x = x+1]()->int { r += 2; return x+2; }(); //  ::x  6,   y 7-. 

स्पष्ट रूप से आरंभिक रूप से कैप्चर किए गए चर के प्रकार को स्पष्ट रूप से इंगित करना निषिद्ध नहीं है:

 [int x = get_x()] { ... } [Container y{get_container()}] { ... } [int z = 5] { ... } 

कई लोग आश्चर्यचकित हो सकते हैं कि वे केवल निम्न विधि का समर्थन क्यों नहीं करते हैं:

 [&&x] { ... } 

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

सामान्यीकृत (बहुरूपी) लंबोदर भाव

C ++ 11 में, लैम्ब्डा अभिव्यक्तियाँ एक ऐसी कक्षा की वस्तुओं का निर्माण करती हैं, जिसमें एक गैर-मानक फ़ंक्शन कॉल ऑपरेटर होता है। यह संशोधन प्रस्तावित करता है:

• auto टाइप स्पेसिफिक अर्थ जेनेरिक (टेम्प्लेट) लैम्बडा पैरामीटर का उपयोग करने की अनुमति दें
• लंबो फ़ंक्शन से रूपांतरण की अनुमति दें जो मूल्य को संबंधित फ़ंक्शन-पॉइंटर पर कब्जा नहीं करता है

इस प्रकार, एक ही टेम्पलेट लैम्ब्डा का उपयोग विभिन्न संदर्भों में किया जा सकता है:

 void f1(int (*)(int)) { } void f2(char (*)(int)) { } void g(int (*)(int)) { } // #1 void g(char (*)(char)) { } // #2 void h(int (*)(int)) { } // #3 void h(char (*)(int)) { } // #4 auto glambda = [](auto a) { return a; }; f1(glambda); // OK f2(glambda); // : ID   g(glambda); // :  h(glambda); // OK:  #3,       ID int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK 

सार्वभौमिक लिंक और टेम्पलेट्स के साथ, तर्क की एक चर संख्या (चर टेम्पलेट) के साथ, का उपयोग करने की संभावना के बारे में मत भूलना:

 auto vglambda = [](auto printer) { return [=](auto&& ... ts) { // OK: ts -     printer(std::forward<decltype(ts)>(ts)...); }; }; auto p = vglambda( [](auto v1, auto v2, auto v3) { std::cout << v1 << v2 << v3; } ); p(1, 'a', 3.14); // OK:  1a3.14 

constexpr कार्यों को बनाने पर सरलीकृत प्रतिबंध

शुरू किए गए बदलावों को constexpr कार्यों में उपयोग करने की अनुमति constexpr है:

• परिवर्तनीय घोषणा ( static , thread_local और thread_local चर को छोड़कर)
• if और switch (लेकिन goto नहीं)
• for (रेंज आधारित के for सहित), while और do-while
• constexpr गणना से उत्पन्न वस्तुओं की स्थिति में परिवर्तन

 constexpr int abs(int x) { if (x < 0) x = -x; return x; // OK } constexpr int first(int n) { static int value = n; // :   return value; } constexpr int uninit() { int a; // :   return a; } constexpr int prev(int x) { return --x; } // OK constexpr int g(int x, int n) { // OK int r = 1; while (--n > 0) r *= x; return r; } 

इसके अलावा, एक नियम को हटा दिया गया था जिसके द्वारा गैर-स्थैतिक सदस्य कार्यों को स्पष्ट रूप से एक constexpr क्वालिफायर (इस पर अधिक) प्राप्त हुआ।

परिवर्तनीय टेम्पलेट

यह सुविधा आपको constexpr एल्गोरिथ्म के साथ अधिक सुविधाजनक संयोजन के लिए constexpr वेरिएबल टेम्प्लेट बनाने और उपयोग करने की अनुमति देती है (यह न केवल अंतर्निहित प्रकारों के साथ उपयोग करना संभव है, बल्कि उपयोगकर्ता द्वारा परिभाषित प्रकारों के साथ):

 template<typename T> constexpr T pi = T(3.1415926535897932385); template<typename T> T circular_area(T r) { return pi<T> * r * r; } struct matrix_constants { template<typename T> using pauli = hermitian_matrix<T, 2>; template<typename T> constexpr pauli<T> sigma1 = { { 0, 1 }, { 1, 0 } }; template<typename T> constexpr pauli<T> sigma2 = { { 0, -1i }, { 1i, 0 } }; template<typename T> constexpr pauli<T> sigma3 = { { 1, 0 }, { -1, 0 } }; }; 

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

exchange

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

 //   template<typename T, typename U=T> T exchange(T& obj, U&& new_val) { T old_val = std::move(obj); obj = std::forward<U>(new_val); return old_val; } 

आदिम प्रकारों के लिए, यह फ़ंक्शन नियमित कार्यान्वयन के समान है। जटिल प्रकारों के लिए, यह फ़ंक्शन आपको इसकी अनुमति देता है:

• यदि इस प्रकार के लिए एक चाल निर्माणकर्ता को परिभाषित किया जाता है तो पुरानी वस्तु की नकल करने से बचें
• किसी भी प्रकार को नए मान के रूप में स्वीकार करें, किसी भी रूपांतरण असाइनमेंट ऑपरेटर का उपयोग करके लाभ उठाएं
• यदि यह अस्थायी है या यहां ले जाया गया है, तो किसी नई वस्तु की नकल करने से बचें

उदाहरण के लिए, std::unique_ptr::reset का कार्यान्वयन std::unique_ptr::reset :

 template<typename T, typename D> void unique_ptr<T, D>::reset(pointer p = pointer()) { pointer old = ptr_; ptr_ = p; if (old) deleter_(old); } 

इसमें सुधार किया जा सकता है:

 template<typename T, typename D> void unique_ptr<T, D>::reset(pointer p = pointer()) { if (pointer old = std::exchange(ptr_, p)) deleter_(old); } 

make_unique

C ++ 11 में, स्मार्ट पॉइंटर्स के साथ, make_shared जैसा एक फंक्शन make_shared । यह आपको साझा करने के लिए मेमोरी के आवंटन को अनुकूलित करने की अनुमति देता है, साथ ही अपवादों के बारे में सुरक्षा में सुधार करता है। हालाँकि, unique_ptr लिए एक समान अनुकूलन संभव नहीं है, अपवादों के बारे में बढ़ी हुई सुरक्षा कभी भी चोट नहीं पहुंचाएगी। उदाहरण के लिए, यहां, दोनों मामलों में, हम एक मेमोरी लीक प्राप्त कर सकते हैं यदि एक वस्तु बनाते समय एक अपवाद को फेंक दिया गया था और दूसरी वस्तु पहले से ही बनाई गई थी, लेकिन अभी तक unique_ptr में नहीं रखी गई है:

 void foo(std::unique_ptr<A> a, std::unique_ptr<B> b); int main() { foo(new A, new B); foo(std::unique_ptr<A>{new A}, foo(std::unique_ptr<B>{new B}); } 

इस स्थिति को हल करने के लिए, make_unique फ़ंक्शन को जोड़ने का निर्णय लिया गया था। इस प्रकार, C ++ 14 लगभग पूरी तरह से (बहुत दुर्लभ मामलों के अपवाद के साथ) प्रोग्रामर को new को त्यागने और ऑपरेटरों को delete करता है।
उपयोग उदाहरण:

 #include <iostream> #include <string> #include <memory> using namespace std; void foo(std::unique_ptr<string> a, std::unique_ptr<string> b) {} int main() { cout << *make_unique<int>() << endl; cout << *make_unique<int>(1729) << endl; cout << "\"" << *make_unique<string>() << "\"" << endl; cout << "\"" << *make_unique<string>("meow") << "\"" << endl; cout << "\"" << *make_unique<string>(6, 'z') << "\"" << endl; auto up = make_unique<int[]>(5); for (int i = 0; i < 5; ++i) { cout << up[i] << " "; } cout << endl; foo(make_unique<string>(), make_unique<string>()); //    auto up1 = make_unique<string[]>("error"); //  auto up2 = make_unique<int[]>(10, 20, 30, 40); //  auto up3 = make_unique<int[5]>(); //  auto up4 = make_unique<int[5]>(11, 22, 33, 44, 55); //  } /* Output: 0 1729 "" "meow" "zzzzzz" 0 0 0 0 0 */ 

अलग लाइन

स्ट्रिंग्स का उपयोग करते समय जिसमें इनपुट / आउटपुट धाराओं के साथ एक स्थान शामिल होता है, हमेशा अपेक्षित परिणाम प्राप्त किए जा सकते हैं। उदाहरण के लिए:

 std::stringstream ss; std::string original = "foolish me"; std::string round_trip; ss << original; ss >> round_trip; std::cout << original; // : foolish me std::cout << round_trip; // : foolish assert(original == round_trip); // assert  

यह संशोधन मानक में एक फ़ंक्शन का परिचय देता है जो आपको पढ़ते समय लिखने और हटाने के दौरान पंक्ति के आरंभ और अंत में दोहरे उद्धरण जोड़कर ऐसी स्थितियों को सही ढंग से संभालने की अनुमति देता है। उदाहरण के लिए:

 std::stringstream ss; std::string original = "foolish me"; std::string round_trip; ss << quoted(original); ss >> quoted(round_trip); std::cout << original; // : foolish me std::cout << round_trip; // : foolish me assert(original == round_trip); // assert   

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

 std::cout << "She said \"Hi!\""; // : She said "Hi!" std::cout << quoted("She said \"Hi!\""); // : "She said \"Hi!\"" 

यह संशोधन बूस्ट काउंटरपार्ट पर आधारित है ।

मानक पुस्तकालय प्रकारों के लिए कस्टम साहित्य

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

• basic_string लिए s ऑपरेटर
• चारणो में शामिल प्रकारों के लिए ऑपरेटर h , min , s , ms , us , ns :: अवधि

उदाहरण के लिए:

 auto mystring = "hello world"s; //  std::string auto mytime = 42ns; //  chrono::nanoseconds 

उपयोगकर्ता के शाब्दिक संघर्ष नहीं करते हैं क्योंकि वे विभिन्न प्रकार के मापदंडों को स्वीकार करते हैं।

optional

यह संशोधन एक वैकल्पिक वस्तु को दर्शाता मानक पुस्तकालय में एक नए प्रकार का परिचय देता है। संभव उपयोग:

• यह निर्दिष्ट करने की क्षमता कि कौन से फ़ंक्शन पैरामीटर वैकल्पिक हैं
• अशक्त अवस्था (नियमित (कच्चे) पॉइंटर्स का उपयोग किए बिना) का उपयोग करने की क्षमता
• आरएआईआई वस्तुओं के जीवनकाल को मैन्युअल रूप से नियंत्रित करने की क्षमता
• महंगी (मानक) ऑब्जेक्ट कंस्ट्रक्टर्स को छोड़ने की क्षमता

उपयोग की एक अनुमानित विधि:

 optional<int> str2int(string); //     ,   int get_int_form_user() { string s; for (;;) { cin >> s; optional<int> o = str2int(s); // 'o'    ,     if (o) { //   'o'  ? return *o; //   } } } 

यह संशोधन बूस्ट काउंटरपार्ट पर आधारित है ।
इस वर्ग के बारे में लेखक के लेख का अनुवाद यहां पाया जा सकता है ।

shared_mutex और shared_lock

बहु-थ्रेडेड प्रोग्राम विकसित करते समय, कभी-कभी यह आवश्यक हो जाता है कि एक वस्तु को कई वस्तुओं को पढ़ा जा सके या अद्वितीय लेखन का उपयोग किया जा सके। यह संशोधन इस उद्देश्य के लिए डिज़ाइन किए गए मानक shared_mutex लाइब्रेरी में जोड़ता है। lock फ़ंक्शन अद्वितीय पहुंच देता है, और इसे पहले जोड़े गए lock_guard और unique_lock साथ उपयोग किया जा सकता है। साझा पहुंच प्राप्त करने के लिए, आपको lock_shared फ़ंक्शन का उपयोग करने की आवश्यकता है, और यह जोड़ा गया RAII shared_lock माध्यम से ऐसा करना बेहतर है:

 using namespace std; shared_mutex rwmutex; { shared_lock<shared_mutex> read_lock(rwmutex); //  } { unique_lock<shared_mutex> write_lock(rwmutex); //  lock_guard //  } 

यह ध्यान देने योग्य है कि किसी भी लॉक की लागत, यहां तक ​​कि पढ़ने के लिए, एक नियमित म्यूटेक्स का उपयोग करने की तुलना में अधिक महंगा है।
यह संशोधन बूस्ट काउंटरपार्ट पर आधारित है ।

dynarray

वर्तमान सी मानक में गतिशील सरणियाँ हैं, जिनका आकार केवल रन समय पर निर्धारित किया जा सकता है। नियमित सरणियों की तरह, वे जो डेटा बनाते हैं वह स्टैक पर होता है। C ++ 14 ऐसे सरणियों का दावा करता है, लेकिन यह अपनी तरह के गतिशील सरणी को भी परिभाषित करता है - std::dynarray , जो रनटाइम पर अपने आकार को भी पहचानता है और बाद में इसे बदल नहीं सकता है, हालांकि, यह या तो ऑब्जेक्ट्स को स्टैक पर रख सकता है, या उन्हें ढेर पर रखें, जबकि std::array और std::vector समान कई तरीकों से एक इंटरफ़ेस है। संशोधन के अनुसार, स्टैक का उपयोग करते समय मामलों के लिए, इस वर्ग को संकलक द्वारा स्पष्ट रूप से अनुकूलित किया जा सकता है।

निष्कर्ष

मूल रूप से, C ++ 14 को एक मामूली बग-फिक्स रिलीज़ के रूप में तैनात किया गया है, जो समय सीमा के कारण या कुछ अन्य कारणों से किए गए C ++ 11 की कमियों को ठीक करता है। सी ++ मानक का वर्तमान मसौदा यहां पाया जा सकता है ।

अद्यतन:
dynarray और optional को अलग-अलग तकनीकी विशिष्टताओं में रखा गया था।
नई C ++ 14 विशेषताओं का अवलोकन: भाग 2