आधुनिक C ++ ऐसी सुविधाएँ है जिनके बारे में सभी प्रोग्रामर को जानना आवश्यक है

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

ऐसा मत सोचो कि भाषा आसान हो गई है। यह अभी भी सबसे जटिल व्यापक रूप से इस्तेमाल की जाने वाली प्रोग्रामिंग भाषाओं में से एक कहा जा सकता है, अगर सबसे जटिल नहीं है। लेकिन आधुनिक सी ++ पहले की तुलना में बहुत अधिक मित्रवत हो गया है।



आज हम भाषा के कुछ नए फीचर्स के बारे में बात करेंगे (C ++ 11 से शुरू होकर, जो कि पहले से ही 8 साल पुराना है), जिसके बारे में किसी भी प्रोग्रामर को पता होगा।

ऑटो कीवर्ड

जब से auto कीवर्ड C ++ 11 में दिखाई दिया, प्रोग्रामर का जीवन आसान हो गया है। इस कीवर्ड के लिए धन्यवाद, संकलनकर्ता संकलन प्रकारों को संकलन समय पर आउटपुट कर सकता है, जो हमें हमेशा स्वयं को निर्दिष्ट करने से बचाता है। यह बहुत सुविधाजनक निकला, उदाहरण के लिए, ऐसे मामलों में जहां आपको डेटा प्रकारों के साथ काम करना होगा जैसे कि map<string,vector<pair<int,int>>> । auto कीवर्ड का उपयोग करते समय, कुछ बातों पर विचार करना चाहिए। एक उदाहरण पर विचार करें:

 auto an_int = 26; //    ,     - int auto a_bool = false; //   bool auto a_float = 26.04; //   float auto ptr = &a_float; //       auto data; // #1     ?    - . 

इस उदाहरण में अंतिम पंक्ति पर ध्यान दें, जिस पर टिप्पणी #1 के रूप में चिह्नित की गई है (इसके बाद, इसी तरह हम उन पंक्तियों को चिह्नित करेंगे जो हम उदाहरण के बाद, पार्स करेंगे)। इस लाइन में कोई इनिशलाइज़र नहीं है, आप ऐसा नहीं कर सकते। इस लाइन पर स्थित कोड कंपाइलर को यह जानने से रोकता है कि संबंधित चर का प्रकार क्या होना चाहिए।

प्रारंभ में, C ++ में auto कीवर्ड बहुत सीमित था। फिर, भाषा के हाल के संस्करणों में, auto ने सुविधाओं को जोड़ा। यहाँ एक और उदाहरण है:

 auto merge(auto a, auto b) //            auto! {   std::vector<int> c = do_something(a, b);   return c; } std::vector<int> a = { ... }; // #1 -  std::vector<int> b = { ... }; // #2  -  auto c = merge(a,b); //       

लाइनों #1 और #2 घुंघराले ब्रेसिज़ का उपयोग करके वैरिएबल इनिशियलाइज़ेशन लागू करते हैं - C ++ 11 में एक और नई सुविधा।

याद रखें कि auto कीवर्ड का उपयोग करते समय, कंपाइलर के पास चर के प्रकार का पता लगाने का कोई तरीका होना चाहिए।

अब, एक दिलचस्प सवाल। यदि आप auto a = {1, 2, 3} जैसे एक डिजाइन का उपयोग करते हैं तो क्या होता है auto a = {1, 2, 3} ? यह क्या है सदिश, या संकलन त्रुटि का कारण?

वास्तव में, प्रपत्र std::initializer_list<type> का निर्माण C ++ 11 में दिखाई दिया। प्रारंभिक मानों की कोष्ठक सूची को auto कीवर्ड का उपयोग करके एक कंटेनर के रूप में माना जाएगा।

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

 void populate(auto &data) { //    !   data.insert({"a",{1,4}});   data.insert({"b",{3,1}});   data.insert({"c",{2,3}}); } auto merge(auto data, auto upcoming_data) { //         auto result = data;   for(auto it: upcoming_data) {       result.insert(it);   }   return result; } int main() {   std::map<std::string, std::pair<int,int>> data;   populate(data);   std::map<std::string, std::pair<int,int>> upcoming_data;   upcoming_data.insert({"d",{5,3}});   auto final_data = merge(data,upcoming_data);   for(auto itr: final_data) {       auto [v1, v2] = itr.second; // #1               std::cout << itr.first << " " << v1 << " " << v2 << std:endl;   }   return 0; } 

लाइन #1 पर एक नज़र डालें। अभिव्यक्ति auto [v1,v2] = itr.second , C ++ 17 की एक नई विशेषता का प्रतिनिधित्व करता है। चर घोषित करते समय यह तथाकथित अपघटन होता है। भाषा के पिछले संस्करणों में, प्रत्येक मूल्य को व्यक्तिगत रूप से निकाला जाना था। इस तंत्र के लिए धन्यवाद, इस तरह के ऑपरेशन करना अधिक सुविधाजनक हो गया है।

इसके अलावा, यदि आपको लिंक का उपयोग करके डेटा के साथ काम करने की आवश्यकता है, तो इस निर्माण में केवल एक चरित्र को जोड़ने के लिए पर्याप्त है, इसे निम्न रूप में परिवर्तित करें: auto &[v1,v2] = itr.second ।

लम्बोदर भाव

C ++ 11 लैम्ब्डा अभिव्यक्ति के लिए समर्थन का परिचय देता है। वे जावास्क्रिप्ट में अनाम कार्यों से मिलते जुलते हैं, उनकी तुलना बिना नाम वाली कार्यात्मक वस्तुओं से की जा सकती है। वे अपने विवरण के आधार पर विभिन्न स्कोपों ​​में चर पर कब्जा करते हैं, जिसके लिए कॉम्पैक्ट सिंटैक्टिक निर्माण का उपयोग किया जाता है। इसके अलावा, उन्हें चर के लिए सौंपा जा सकता है।

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

 std::vector<std::pair<int,int>> data = {{1,3}, {7,6}, {12, 4}}; //        std::sort(begin(data), end(data), [](auto a, auto b) { //   - auto!   return a.second < b.second; }); 

आप इस छोटे से उदाहरण में बहुत सारी दिलचस्प चीजें पा सकते हैं।

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

अब ध्यान दें कि लंबोदर अभिव्यक्ति वर्ग कोष्ठक से शुरू होती है - [] । यह चर का तथाकथित मुखौटा है। यह अभिव्यक्ति के दायरे को निर्धारित करता है, अर्थात यह आपको स्थानीय चर और वस्तुओं के साथ लंबोदर अभिव्यक्ति के रिश्ते को नियंत्रित करने की अनुमति देता है।

यहाँ आधुनिक C ++ सुविधाओं के लिए समर्पित इस भंडार से एक अंश है:

• [] - अभिव्यक्ति कुछ भी कैप्चर नहीं करती है। इसका मतलब यह है कि एक लंबोदर अभिव्यक्ति में स्थानीय चर का उस क्षेत्र से उपयोग करना असंभव है जो इसके लिए बाहरी है। अभिव्यक्ति में केवल मापदंडों का उपयोग किया जा सकता है।
• [=] - अभिव्यक्ति स्थानीय वस्तुओं के मूल्यों को पकड़ती है (अर्थात, स्थानीय चर, पैरामीटर)। इसका मतलब है कि उनका उपयोग किया जा सकता है, लेकिन संशोधित नहीं।
• [&] - अभिव्यक्ति स्थानीय वस्तुओं के संदर्भ को कैप्चर करती है। उन्हें संशोधित किया जा सकता है, जैसा कि निम्नलिखित उदाहरण में दिखाया गया है।
• [this] - अभिव्यक्ति this सूचक के मूल्य को पकड़ती है।
• [a, &b] - अभिव्यक्ति ऑब्जेक्ट के मूल्य और ऑब्जेक्ट b संदर्भ को b ।

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

 std::vector<int> data = {2, 4, 4, 1, 1, 3, 9}; int factor = 7; for_each(begin(data), end(data), [&factor](int &val) { //    factor     val = val * factor;   factor--; // #1   - ,  -    factor   }); for(int val: data) {   std::cout << val << ' '; // 14 24 20 4 3 6 9 } 

यहां, यदि factor चर को मान द्वारा एक्सेस किया गया था (तब चर मुखौटा [factor] का उपयोग लंबोदर अभिव्यक्ति का वर्णन करने के लिए किया जाएगा), तो लाइन #1 में factor मान को बदला नहीं जा सकता है - सिर्फ इसलिए कि हमारे पास अधिकार नहीं होंगे ऐसा ऑपरेशन करना। इस उदाहरण में, हमें ऐसे कार्यों का अधिकार है। ऐसी स्थितियों में, उन क्षमताओं का दुरुपयोग न करना महत्वपूर्ण है जो संदर्भ द्वारा चर प्रदान करते हैं।

इसके अलावा, ध्यान दें कि val संदर्भ द्वारा भी एक्सेस किया जाता है। यह सुनिश्चित करता है कि लैम्ब्डा फ़ंक्शन में होने वाले डेटा परिवर्तन vector को प्रभावित करते हैं।

वैरिएबल इनिशियलाइज़ेशन एक्सप्रेशन इफ़ेक्ट्स इन और स्विच कंस्ट्रक्शंस

मुझे वास्तव में यह C ++ 17 नवाचार पसंद आया जब मैंने इसके बारे में पता लगाया। एक उदाहरण पर विचार करें:

 std::set<int> input = {1, 5, 3, 6}; if(auto it = input.find(7); it==input.end()){ //   - ,  -    std::cout << 7 << " not found" << std:endl; } else {   //    else      it   std::cout << 7 << " is there!" << std::endl; } 

यह पता चला है कि अब आप वेरिएबल्स को इनिशियलाइज़ कर सकते हैं और if एक या switch ब्लॉक करते हैं if उनके उपयोग की तुलना कर सकते हैं। इससे सटीक कोड लिखने में मदद मिलती है। यहाँ संरचना का एक योजनाबद्ध विवरण विचाराधीन है:

 if( init-statement(x); condition(x)) {   //    } else {   //     x   //    } 

कॉन्स्टैक्स का उपयोग करके संकलन-समय की गणना करना

constexpr हमें बेहतरीन अवसर प्रदान करता है। मान लें कि हमारे पास कुछ प्रकार की अभिव्यक्ति है, जिसकी गणना करने की आवश्यकता है, जबकि इसके मूल्य, इसी चर के साथ इसे शुरू करने के बाद, नहीं बदलेगा। इस तरह की अभिव्यक्ति को अग्रिम में गणना की जा सकती है और मैक्रो के रूप में उपयोग किया जा सकता है। या, C ++ 11 में क्या संभव हो गया है, constexpr उपयोग करें।

प्रोग्रामर प्रोग्राम निष्पादन के दौरान की गई गणना की मात्रा को कम करने का प्रयास करते हैं। नतीजतन, यदि संकलन प्रक्रिया के दौरान कुछ संचालन किए जा सकते हैं और इस तरह प्रोग्राम निष्पादन के दौरान सिस्टम से लोड हटा दिया जाता है, तो निष्पादन के दौरान कार्यक्रम के व्यवहार पर इसका अच्छा प्रभाव पड़ेगा। यहाँ एक उदाहरण है:

 #include <iostream> constexpr long long fact(long long n) { //       constexpr return n == 1 ? 1 : (fact(n-1) * n); } int main() { const long long bigval = fact(20); std::cout<<bigval<<std::endl; } 

यह constexpr का उपयोग करने का एक बहुत ही सामान्य उदाहरण है।

चूंकि हमने फैक्टरियल को constexpr रूप में गणना करने के लिए फ़ंक्शन की घोषणा की, इसलिए कंपाइलर प्रोग्राम के संकलन के समय fact(20) मान की पूर्व-गणना कर सकता है। परिणामस्वरूप, संकलन के बाद, स्ट्रिंग const long long bigval = fact(20); को const long long bigval = 2432902008176640000; बदला जा सकता है const long long bigval = 2432902008176640000; ।

ध्यान दें कि फ़ंक्शन को दिया गया तर्क एक स्थिर द्वारा दर्शाया गया है। यह constexpr का उपयोग करके घोषित किए गए फ़ंक्शन का उपयोग करने की एक महत्वपूर्ण विशेषता है। उनके पास दिए गए तर्कों को भी constexpr साथ या constexpr साथ घोषित किया जाना चाहिए। अन्यथा, ऐसे कार्य सामान्य कार्यों की तरह व्यवहार करेंगे, अर्थात, संकलन के दौरान, उनके मूल्यों की अग्रिम गणना नहीं की जाएगी।

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

यह ध्यान रखना दिलचस्प है कि बाद में, C ++ 17 में, कॉन्स्ट्रेप- इफ़ और कॉन्स्ट्रेप-लैंबडा निर्माण दिखाई दिए।

टपल डेटा संरचनाएं

pair डेटा संरचना की तरह, tuple डेटा संरचना (टपल) एक निश्चित आकार के विभिन्न प्रकारों के मूल्यों का एक संग्रह है। यहाँ एक उदाहरण है:

 auto user_info = std::make_tuple("M", "Chowdhury", 25); //  auto     //    std::get<0>(user_info); std::get<1>(user_info); std::get<2>(user_info); //  C++ 11     tie std::string first_name, last_name, age; std::tie(first_name, last_name, age) = user_info; //  C++ 17, ,       auto [first_name, last_name, age] = user_info; 

कभी-कभी, tuple डेटा संरचना के बजाय, std::array का उपयोग करना अधिक सुविधाजनक होता है। यह डेटा संरचना C भाषा में प्रयुक्त साधारण सरणियों के समान है, जो C ++ मानक पुस्तकालय से अतिरिक्त सुविधाओं से सुसज्जित है। यह डेटा संरचना C ++ 11 में दिखाई दी।

स्वचालित रूप से कक्षा टेम्पलेट तर्क प्रकार का संदर्भ देना

इस सुविधा का नाम लंबा और जटिल दिखता है, लेकिन वास्तव में यहां कुछ भी जटिल नहीं है। यहाँ मुख्य विचार यह है कि C ++ 17 में, मानक श्रेणी के टेम्प्लेट के लिए टेम्पलेट तर्कों के प्रकार का उत्पादन भी किया जाता है। पहले, यह केवल कार्यात्मक टेम्पलेट्स के लिए समर्थित था। परिणामस्वरूप, यह पता चलता है कि वे इस तरह लिखते थे:

 std::pair<std::string, int> user = {"M", 25}; 

C ++ 17 की रिलीज़ के साथ, इस निर्माण को अब इसके साथ बदला जा सकता है:

 std::pair user = {"M", 25}; 

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

 std::tuple<std::string, std::string, int> user ("M", "Chy", 25); 

अब एक ही चीज़ इस तरह दिखती है:

 std::tuple user2("M", "Chy", 25); 

यह ध्यान देने योग्य है कि इन सुविधाओं को उन लोगों के लिए कुछ ध्यान देने योग्य नहीं लगेगा जो विशेष रूप से सी ++ टेम्पलेट से परिचित नहीं हैं।

स्मार्ट पॉइंटर्स

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

सौभाग्य से, C ++ 11 ने स्मार्ट पॉइंटर्स पेश किए जो नियमित पॉइंटर्स की तुलना में बहुत अधिक सुविधाजनक हैं। वे प्रोग्रामर को संभव होने पर संसाधनों को मुक्त करके मेमोरी लीक से बचने में मदद करते हैं। इसके अलावा, वे अपवादों के लिए सुरक्षा गारंटी प्रदान करते हैं।

परिणाम

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

प्रिय पाठकों! आधुनिक सी ++ की विशेषताएं आपको सबसे दिलचस्प और उपयोगी लगती हैं?