C++11: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 146: Line 146:
function_name({1.0f, -3.45f, -0.4f});</blockquote>मानक लाइब्रेरी में इसके उदाहरणों में सम्मिलित हैं <code>std::min()</code> और <code>std::max()</code> टेम्पलेट्स ले रहा है <code>std::initializer_list</code>संख्यात्मक प्रकार का।
function_name({1.0f, -3.45f, -0.4f});</blockquote>मानक लाइब्रेरी में इसके उदाहरणों में सम्मिलित हैं <code>std::min()</code> और <code>std::max()</code> टेम्पलेट्स ले रहा है <code>std::initializer_list</code>संख्यात्मक प्रकार का।


मानक कंटेनरों को इन तरीकों से भी आरंभ किया जा सकता है:
मानक कंटेनरों को इन तरीकों से भी आरंभ किया जा सकता है:<blockquote>std::vector<std::string> v = { "xyzzy", "plugh", "abracadabra" };


'''एसटीडी :: वेक्टर <एसटीडी :: स्ट्रिंग> वी = {xyzzy, प्लग, abracadabra};
std::vector<std::string> v({ "xyzzy", "plugh", "abracadabra" });
एसटीडी :: वेक्टर <एसटीडी :: स्ट्रिंग> वी ({xyzzy, प्लग, abracadabra});
 
एसटीडी :: वेक्टर <एसटीडी :: स्ट्रिंग> वी {xyzzy, प्लग,''' abracadabra}; // नीचे यूनिफ़ॉर्म इनिशियलाइज़ेशन देखें
std::vector<std::string> v{ "xyzzy", "plugh", "abracadabra" }; // see "Uniform initialization" below</blockquote>


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


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


स्ट्रक्वैरियेबल बेसिकस्ट्रक्वैरियेबल
{
{
    int x;
    इंट एक्स;
    double y;
    डबल वाई;
};
};
struct AltStruct
{
    AltStruct(int x, double y)
        : x_{x}
        , y_{y}
    {}
private:
    int x_;
    double y_;
};
BasicStruct var1{5, 3.2};


संरचना AltStruct
AltStruct var2{2, 4.3};
{
इस प्रकार  <code>var1</code> को इनिशियलाईज करने के लिए किया जाता हैं जैसे कि यह कुल प्रारंभिकरण था। इसका अर्थ यह हैं कि यह किसी ऑब्जेक्ट के प्रत्येक डेटा मेम्बर के परिवर्तन में प्रारंभकर्ता सूची से संबंधित मान के साथ प्रतिलिपि के आधार पर प्रारंभ किया जाता हैं। जहां आवश्यक हो वहां निहित प्रकार के रूपांतरण का उपयोग किया जाता हैं। यदि कोई रूपांतरण सम्मिलित नहीं होता हैं, या केवल संकुचित रूपांतरण सम्मिलित होता है, तो प्रोग्राम बुरी तरह कार्य करने लगते है। जिसका फिर इनिशियलाईजेशन करके <code>var2</code> द्वारा कंस्ट्रक्टर को काॅल किया जाता हैं।
    AltStruct(int x, डबल y)
        : x_{x}
        , Y y}
    {}


निजी:
इस प्रकार इस पर आधारित एक प्रोग्राम दिया गया है:
    इंट x_;
struct IdString
    डबल वाई_;
{
};
    std::string name;
    int identifier;
};
IdString get_string()
{
    return {"foo", 42}; //Note the lack of explicit type.


बेसिक स्ट्रक्वैरियेबल var1{5, 3.2};
}
AltStruct var2{2, 4.3};
यूनिफ़ॉर्म इनिशियलाइज़ेशन कंस्ट्रक्टर सिंटैक्स को प्रतिस्थापित नहीं करता है, जिसकी अभी भी कई बार आवश्यकता होती है। यदि किसी वर्ग में प्रारंभकर्ता सूची कन्स्ट्रक्टर रहता है तो (<code><nowiki>TypeName(initializer_list<SomeType>);</nowiki></code>) का निर्माण इसके अन्य रूपों पर प्राथमिकता के लिए किया जाता है, इस प्रकार प्रारंभकर्ता सूची अनुक्रम कन्स्ट्रक्टर के प्रकार के अनुरूप होता हैं। सी ++ 11 का संस्करण <code>std::vector</code> इसके टेम्पलेट प्रकार के लिए प्रारंभकर्ता सूची के रूप में कन्स्ट्रक्टर पर आधारित होता है। इस प्रकार यह कोड:<blockquote>std::vector<int> the_vec{4};</blockquote>इनिशियलाइज़र लिस्ट कंस्ट्रक्टर को कॉल करती हैं, न कि कंस्ट्रक्टर को, इस प्रकार <code>std::vector</code> एक आकार का पैरामीटर उपयोग करता है और उस आकार के साथ वैक्टर बनाता है। इसके बाद वाले कंस्ट्रक्टर तक पहुंचने के लिए, उपयोगकर्ता को सीधे मानक कंस्ट्रक्टर सिंटैक्स का उपयोग करने की आवश्यकता होती हैं।


का आरंभीकरण <code>var1</code> व्यवहार करता है जैसे कि यह कुल-प्रारंभिकरण था। यही है, किसी ऑब्जेक्ट के प्रत्येक डेटा सदस्य, बदले में, प्रारंभकर्ता-सूची से संबंधित मान के साथ प्रतिलिपि-प्रारंभिक किया जाएगा। जहां आवश्यक हो वहां निहित प्रकार के रूपांतरण का उपयोग किया जाएगा। यदि कोई रूपांतरण सम्मिलित नहीं है, या केवल एक संकुचित रूपांतरण सम्मिलित है, तो प्रोग्राम खराब रूप से बना हुआ है। का आरंभीकरण <code>var2</code> कंस्ट्रक्टर को आमंत्रित करता है।
==== टाइप अनुमान ====
सी ++ 03 में वैरियेबल का उपयोग करने के लिए, इसके प्रकार को स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए। चूंकि, टेम्प्लेट प्रकार और टेम्प्लेट मेटाप्रोग्रामिंग तकनीकों के आगमन के साथ इसके प्रकारों पर विशेष रूप से किसी फ़ंक्शन का अच्छी तरह से परिभाषित वापसी मान सरलीकरण से व्यक्त नहीं किया जा सकता है। इस प्रकार इंटरमीडिएट्स को वैरिएबल्स में स्टोर करना कठिन रहता है, संभवतः किसी दिए गए मेटाप्रोग्रामिंग लाइब्रेरी के इंटर्नल्स के ज्ञान की आवश्यकता है।


कोई यह भी कर सकता है:
सी ++ 11 इसकी दो विधियों से कम करने की अनुमति देता है। सबसे पहले यह स्पष्ट रूप से प्रारंभ होने के साथ वैरियेबल की उचित परिभाषा का उपयोग करता हैं। इस प्रकार <code>auto</code> कीवर्ड को उपयोग किया जाता हैं।<ref>{{cite web |url=http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1478.pdf |author1=Jaakko Järvi |author2=Bjarne Stroustrup |author3=Douglas Gregor |author4=Jeremy Siek |title=Decltype and auto, Programming Language C++, Document no: N1478=03-0061 |date=April 28, 2003 |access-date=June 6, 2015 |archive-date=May 28, 2015 |archive-url=https://web.archive.org/web/20150528112722/http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1478.pdf |url-status=live }}</ref><ref>{{cite web|url=http://accu.org/index.php/journals/1859|title="Auto – A Necessary Evil?" Overload Journal #115|author=Roger Orr|date=June 2013|access-date=2015-06-06|archive-date=2015-06-06|archive-url=https://web.archive.org/web/20150606155637/http://accu.org/index.php/journals/1859|url-status=live}}</ref> यह विशिष्ट प्रकार के प्रारंभकर्ता का मुख्य वैरियेबल बनाता है:
auto some_strange_callable_type = std::bind(&some_function, _2, _1, some_object);
<blockquote>auto other_variable = 5;</blockquote>इसके जैसा एक और उदाहरण <code>some_strange_callable_type</code>  है जो विशेष टेम्प्लेट फ़ंक्शन को ओवरराइड करता है। इस प्रकार <code>std::bind</code> उन विशेष तर्कों के लिए रिटर्न मान को संकलक द्वारा अपने सिमेंटिक विश्लेषण कर्तव्यों के भाग के रूप में सरलीकृत करके निर्धारित किया जाता है, लेकिन उपयोगकर्ता के लिए निरीक्षण पर निर्धारित करना सरल नहीं है।


जैसे <code>other_variable</code> भी अच्छी तरह से परिभाषित किया जाता है, लेकिन उपयोगकर्ता के लिए यह निर्धारित करना सरल है। यह  <code>int</code>  पूर्णांक शाब्दिक मानों के समान प्रकार का मान संग्रहित करता हैं।


संरचना IdString
इस कीवर्ड का उपयोग <code>auto</code> सी ++ में कीवर्ड के शब्दार्थ को पुन: उपयोग करने के लिए किया जाता है, जो मूल रूप से टाइपलेस पूर्ववर्ती भाषा बी (प्रोग्रामिंग लैंग्वेज) में उपयोग किया गया था, एक अनपेक्षित [[स्वचालित चर|स्वचालित वैरियेबल]] परिभाषा को दर्शाने की संबंधित भूमिका के लिए उचित उदाहरण हैं।
{
    एसटीडी :: स्ट्रिंग नाम;
    इंट पहचानकर्ता;
};


आईडीस्ट्रिंग get_string ()
इसके पश्चात कीवर्ड <code>[[decltype]]</code> संकलन-समय पर अभिव्यक्ति करने के प्रकार को निर्धारित करने के लिए उपयोग किया जाता हैं। उदाहरण के लिए:<blockquote>int some_int;
{
    वापसी {फू, 42}; // स्पष्ट प्रकार की कमी पर ध्यान दें।
}


यूनिफ़ॉर्म इनिशियलाइज़ेशन कंस्ट्रक्टर सिंटैक्स को प्रतिस्थापित नहीं करता है, जिसकी अभी भी कई बार आवश्यकता होती है। यदि किसी वर्ग में प्रारंभकर्ता सूची कन्स्ट्रक्टर है (<code><nowiki>TypeName(initializer_list<SomeType>);</nowiki></code>), तो यह निर्माण के अन्य रूपों पर प्राथमिकता लेता है, बशर्ते प्रारंभकर्ता सूची अनुक्रम कन्स्ट्रक्टर के प्रकार के अनुरूप हो। सी ++ 11 का संस्करण <code>std::vector</code> इसके टेम्पलेट प्रकार के लिए प्रारंभकर्ता सूची कन्स्ट्रक्टर है। इस प्रकार यह कोड:
decltype(some_int) other_integer_variable = 5;</blockquote><code>auto</code> के साथ मिलकर यह अधिक उपयोगी हो जाता है, क्योंकि auto वैरियेबल एक प्रकार से केवल संकलक के लिए उपयोग किया जाता है। चूंकि <code>decltype</code> कोड में अभिव्यक्तियों के लिए भी बहुत उपयोगी हो सकता है जो [[ऑपरेटर ओवरलोडिंग]] और विशेष प्रकारों से अधिक उपयोगी होता हैं।


एसटीडी :: वेक्टर <int> the_vec {4};
<code>auto</code> कोड की वाचलता को कम करने के लिए भी उपयोगी है। उदाहरण के लिए <blockquote>for (std::vector<int>::const_iterator itr = myvec.cbegin(); itr != myvec.cend(); ++itr)</blockquote>प्रोग्रामर इस प्रकार के छोटे-छोटे स्टेटमेंट का उपयोग करता है।<blockquote>for (auto itr = myvec.cbegin(); itr != myvec.cend(); ++itr)</blockquote>जिसे और अधिक संकुचित किया जा सकता है क्योंकि myvec पुनरावृत्तियों को प्रारंभ या समाप्त करता है:<blockquote>for (const auto& x : myvec)</blockquote>यह अंतर बढ़ता है क्योंकि प्रोग्रामर नेस्ट कंटेनरों को प्रारंभ करता है, चूंकि ऐसी स्थितियों में <code>typedef</code>कोड की मात्रा कम करने का अच्छा तरीका है।


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


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


सी ++ 11 इसे दो तरीकों से कम करने की अनुमति देता है। सबसे पहले, एक स्पष्ट प्रारंभ के साथ एक वैरियेबल की परिभाषा का उपयोग कर सकते हैं <code>auto</code> कीवर्ड।<ref>{{cite web |url=http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1478.pdf |author1=Jaakko Järvi |author2=Bjarne Stroustrup |author3=Douglas Gregor |author4=Jeremy Siek |title=Decltype and auto, Programming Language C++, Document no: N1478=03-0061 |date=April 28, 2003 |access-date=June 6, 2015 |archive-date=May 28, 2015 |archive-url=https://web.archive.org/web/20150528112722/http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1478.pdf |url-status=live }}</ref><ref>{{cite web|url=http://accu.org/index.php/journals/1859|title="Auto – A Necessary Evil?" Overload Journal #115|author=Roger Orr|date=June 2013|access-date=2015-06-06|archive-date=2015-06-06|archive-url=https://web.archive.org/web/20150606155637/http://accu.org/index.php/journals/1859|url-status=live}}</ref> यह विशिष्ट प्रकार के प्रारंभकर्ता का एक वैरियेबल बनाता है:
{


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


के जैसा <code>some_strange_callable_type</code> बस वह है जो विशेष टेम्प्लेट फ़ंक्शन ओवरराइड करता है <code>std::bind</code> उन विशेष तर्कों के लिए रिटर्न। इस प्रकार को संकलक द्वारा अपने सिमेंटिक विश्लेषण कर्तव्यों के भाग के रूप में सरली से निर्धारित किया जाता है, लेकिन उपयोगकर्ता के लिए निरीक्षण पर निर्धारित करना सरल नहीं है।
auto a = v[0];        // a has type int
के जैसा <code>other_variable</code> भी अच्छी तरह से परिभाषित है, लेकिन उपयोगकर्ता के लिए यह निर्धारित करना सरल है। यह है एक <code>int</code>, जो पूर्णांक शाब्दिक के समान प्रकार है।


यह कीवर्ड का उपयोग <code>auto</code> सी ++ में इस कीवर्ड के शब्दार्थ का पुन: उपयोग किया जाता है, जो मूल रूप से टाइपलेस पूर्ववर्ती भाषा बी (प्रोग्रामिंग लैंग्वेज) में उपयोग किया गया था # एक अनपेक्षित [[स्वचालित चर|स्वचालित वैरियेबल]] परिभाषा को दर्शाने की संबंधित भूमिका में उदाहरण।
decltype(v[0]) b = 1; // b has type const int&, the return type of


आगे, कीवर्ड <code>[[decltype]]</code> संकलन-समय पर अभिव्यक्ति के प्रकार को निर्धारित करने के लिए उपयोग किया जा सकता है। उदाहरण के लिए:
//  std::vector<int>::operator[](size_type) const


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


के साथ मिलकर यह अधिक उपयोगी है <code>auto</code>, क्योंकि auto वैरियेबल का प्रकार केवल संकलक के लिए जाना जाता है। चूंकि, <code>decltype</code> कोड में अभिव्यक्तियों के लिए भी बहुत उपयोगी हो सकता है जो [[ऑपरेटर ओवरलोडिंग]] और विशेष प्रकारों का भारी उपयोग करता है।
auto d = c;          // d has type int


<code>auto</code> कोड की वाचालता को कम करने के लिए भी उपयोगी है। उदाहरण के लिए, लिखने के अतिरिक्त
decltype(c) e;        // e has type int, the type of the entity named by c


for (std::vector<int>::const_iterator itr = myvec.cbegin(); itr != myvec.cend(); ++itr)
decltype((c)) f = c; // f has type int&, because (c) is an lvalue


प्रोग्रामर छोटे का उपयोग कर सकता है
decltype(0) g;        // g has type int, because 0 is an rvalue


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


जिसे और अधिक संकुचित किया जा सकता है क्योंकि myvec पुनरावृत्तियों को प्रारंभ/समाप्त करता है:
==== लूप के लिए रेंज आधारित ====
<code>for</code>  C++11 के सिंटैक्स का विस्तार करता है, तथा तत्वों की इस श्रृंखला पर सरल पुनरावृत्ति की अनुमति देने के लिए कथन का उपयोग किया जाता हैं जो इस प्रकार हैं:<blockquote>int my_array[5] = {1, 2, 3, 4, 5};


के लिए (स्थिरांक ऑटो और x: myvec)
// double the value of each element in my_array:


यह अंतर बढ़ता है क्योंकि प्रोग्रामर नेस्ट कंटेनरों को प्रारंभ करता है, चूंकि ऐसे मामलों में <code>typedef</code>कोड की मात्रा कम करने का एक अच्छा तरीका है।
for (int& x : my_array)


द्वारा दर्शाया गया प्रकार <code>decltype</code> द्वारा निकाले गए प्रकार से भिन्न हो सकते हैं <code>auto</code>.
x *= 2;


#सम्मिलित <वेक्टर>
// similar but also using type inference for array elements
मुख्य प्रवेश बिंदु()
{
    स्थिरांक एसटीडी :: वेक्टर वी (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 के सिंटैक्स का विस्तार करता है <code>for</code> तत्वों की एक श्रृंखला पर सरल पुनरावृत्ति की अनुमति देने के लिए कथन:


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


// समान लेकिन सरणी तत्वों के लिए प्रकार अनुमान का भी उपयोग करना
x *= 2;</blockquote><code>for</code> का यह रूप  जिसे "नेस्टेड लूप" भी कहा जाता है, इस सूची में प्रत्येक तत्व पर पुनरावृति करता हैं। यह सी स्टाइल सारणियों के लिए इनिशियलाइज़र सूचियों और किसी भी प्रकार के लिए फंक्शन का उपोग करेगा इस प्रकार <code>begin()</code> और <code>end()</code> के लिए परिभाषित फंक्शन जो पुनरावृत्तियों को लौटाते हैं। आरंभ/समाप्त संयोजन वाले सभी मानक लाइब्रेरी कंटेनर श्रेणी-आधारित के लिए कथन के साथ फंक्शन का उपयोग करेंगे।
के लिए (ऑटो और एक्स: my_array)
==== लैम्ब्डा फ़ंक्शंस और एक्सप्रेशन ====
    एक्स * = 2;
{{main article|अनामिनस # सी ++ (सी ++ 11 के बाद से)}}
 
 
का यह रूप <code>for</code>, जिसे "श्रेणी-आधारित के लिए" कहा जाता है, सूची में प्रत्येक तत्व पर पुनरावृति करेगा। यह सी-स्टाइल सरणियों, इनिशियलाइज़र सूचियों और किसी भी प्रकार के लिए फंक्शन करेगा <code>begin()</code> और <code>end()</code> इसके लिए परिभाषित फंक्शन जो पुनरावृत्तियों को लौटाते हैं। आरंभ/समाप्त जोड़े वाले सभी मानक लाइब्रेरी कंटेनर श्रेणी-आधारित के लिए कथन के साथ फंक्शन करेंगे।


==== लैम्ब्डा फ़ंक्शंस और एक्सप्रेशन ====
C++11 एनामिनस फंक्शन्स को बनाने की क्षमता प्रदान करता है, जिसे लैम्ब्डा फ़ंक्शन कहा जाता है।<ref>{{cite web
{{main article|Anonymous function#C++ (since C++11)}}
C++11 अनाम फंक्शन्स को बनाने की क्षमता प्रदान करता है, जिसे लैम्ब्डा फ़ंक्शन कहा जाता है।<ref>{{cite web
|url=http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf
|url=http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf
|title=Document no: N1968=06-0038- Lambda expressions and closures for C++
|title=Document no: N1968=06-0038- Lambda expressions and closures for C++
Line 277: Line 264:
}}</ref>
}}</ref>


इन्हें निम्नानुसार परिभाषित किया गया है:
इन्हें निम्नानुसार परिभाषित किया गया है:<blockquote>[](int x, int y) -> int { return x + y; }</blockquote>इस प्रकार रिटर्न फंक्शन के द्वारा (<code>-> int</code> इस उदाहरण में) इन सभी को छोड़ा जा सकता है। <code>return</code> फंक्शन एक ही मान लौटाता हैं।
 
[](int x, int y) -> int {वापसी x + y; }


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


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


टेम्पलेट <class एलएचएस, class आरएचएस>
टेम्पलेट <class एलएचएस, class आरएचएस>

Revision as of 23:03, 18 March 2023

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

C++11, C++ प्रोग्रामिंग भाषा के लिए मानकीकरण के लिए अंतर्राष्ट्रीय संगठन/अंतर्राष्ट्रीय इंटरनेशनल इलेक्ट्रोटेक्नीकल कमीशन मानक का संस्करण है। C++ 11 ने C++ मानक के पूर्व संस्करण को परिवर्तित कर दिया हैं, जिसे C++ 03 कहा जाता है,[1] और बाद में इसे C++14 से परिवर्तित कर दिया हैं । इसका नाम विनिर्देन के प्रकाशन वर्ष के अनुसार भाषा संस्करणों के नामकरण की परंपरा का पालन करता है, चूंकि इसे पूर्व में C++0x नाम दिया गया था क्योंकि यह 2010 से पहले प्रकाशित होने का आशय था।[2]

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