C++
कीवर्ड

परिचय

वाक्य - विन्यास

• asm ( स्ट्रिंग-शाब्दिक );
• noexcept ( अभिव्यक्ति ) // अर्थ 1
• noexcept ( स्थिर-अभिव्यक्ति ) // अर्थ 2
• noexcept // अर्थ 2
• sizeof unary-अभिव्यक्ति
• sizeof ( टाइप-आईडी )
• sizeof ... ( पहचानकर्ता ) // C ++ 11 के बाद से
• टाइपनेम नेस्टेड-नाम-निर्दिष्ट पहचानकर्ता // अर्थ 1
• टाइपनेम नेस्टेड-नेम- स्पेसियर टेम्पलेट ( ऑप्ट ) सिंपल-टेम्पलेट-आईडी // अर्थ 1
• टाइपनेम पहचानकर्ता ( ऑप्ट ) // अर्थ 2
• typename ... पहचानकर्ता (वैकल्पिक) // 2 अर्थ; C ++ 11 के बाद से
• टाइपनेम पहचानकर्ता ( ऑप्ट ) = टाइप-आईडी // अर्थ 2
• टेम्पलेट < टेम्पलेट-पैरामीटर-सूची > टाइपनेम ... ( ऑप्ट ) पहचानकर्ता ( ऑप्ट ) // अर्थ 3
• टेम्पलेट < टेम्पलेट-पैरामीटर-सूची > टाइपनेम पहचानकर्ता ( ऑप्ट ) = आईडी-अभिव्यक्ति // अर्थ ३

टिप्पणियों

एएसएम

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

asm स्टेटमेंट एक परिभाषा है , एक अभिव्यक्ति नहीं है, इसलिए यह ब्लॉक स्कोप या नेमस्पेस स्कोप (वैश्विक गुंजाइश सहित) पर दिखाई दे सकता है। हालाँकि, चूंकि इनलाइन असेंबली को C ++ भाषा के नियमों द्वारा बाध्य नहीं किया जा सकता है, इसलिए asm एक constexpr फ़ंक्शन के अंदर प्रकट नहीं हो सकता है।

उदाहरण:

[[noreturn]] void halt_system() {
    asm("hlt");
}

मुखर

1. जब एकल-तर्क निर्माता पर लागू किया जाता है, तो उस निर्माता को निहित रूपांतरण करने के लिए उपयोग करने से रोकता है।

   class MyVector {
     public:
       explicit MyVector(uint64_t size);
   };
   MyVector v1(100);  // ok
   uint64_t len1 = 100;
   MyVector v2{len1}; // ok, len1 is uint64_t
   int len2 = 100;
   MyVector v3{len2}; // ill-formed, implicit conversion from int to uint64_t
   

   चूँकि C ++ 11 ने initializer सूचियाँ पेश कीं, C ++ 11 में और बाद में, explicit से किसी भी तर्क के साथ एक कंस्ट्रक्टर पर लागू किया जा सकता है, जिसका अर्थ एकल-तर्क मामले में है।

   struct S {
       explicit S(int x, int y);
   };
   S f() {
       return {12, 34};  // ill-formed
       return S{12, 34}; // ok
   }
   

noexcept

void g1() {}
void g2() noexcept {}
void (*p1)() noexcept = &g1; // ill-formed, since g1 is not noexcept
void (*p2)() noexcept = &g2; // ok; types match
void (*p3)() = &g1;          // ok; types match
void (*p4)() = &g2;          // ok; implicit conversion

नाम लिखो

1. एक योग्य नाम के बाद, typename निर्दिष्ट करता है कि यह एक प्रकार का नाम है। यह अक्सर टेम्प्लेट में आवश्यक होता है, विशेष रूप से, जब नेस्टेड नेम स्पेसियर वर्तमान तात्कालिकता के अलावा एक निर्भर प्रकार है। इस उदाहरण में, std::decay<T> पैरामीटर टेम्पलेट पर निर्भर करता है T , आदेश नेस्टेड प्रकार नाम के लिए में इतने type , हम साथ पूरे योग्य नाम उपसर्ग की जरूरत typename । अधिक डिटिल्स के लिए, मुझे "टेम्पलेट" और "टाइपनेम" कीवर्ड कहां और क्यों डालने हैं?

   template <class T>
   auto decay_copy(T&& r) -> typename std::decay<T>::type;
   

2. टेम्पलेट की घोषणा में एक प्रकार के पैरामीटर का परिचय देता है। इस संदर्भ में, यह class साथ विनिमेय है।

   template <typename T>
   const T& min(const T& x, const T& y) {
       return b < a ? b : a;
   } 
   

इस आकार का

एक अपर ऑपरेटर जो अपने ऑपरेंड के बाइट्स में आकार देता है, जो एक अभिव्यक्ति या एक प्रकार हो सकता है। यदि ऑपरेंड एक अभिव्यक्ति है, तो इसका मूल्यांकन नहीं किया जाता है। आकार std::size_t का एक स्थिर अभिव्यक्ति है std::size_t ।

यदि ऑपरेंड एक प्रकार का है, तो इसे छोटा किया जाना चाहिए।

• किसी फ़ंक्शन प्रकार के लिए sizeof लागू करना अवैध है।
• void सहित sizeof प्रकार को अपूर्ण रूप से लागू करना अवैध है।
• यदि आकार प्रकार को संदर्भ प्रकार T& T&& लागू किया जाता है, तो यह sizeof(T) बराबर है।
• जब sizeof प्रकार को एक वर्ग प्रकार पर लागू किया जाता है, तो यह उस प्रकार की पूरी वस्तु में बाइट्स की संख्या पैदा करता है, जिसमें मध्य या अंत में किसी भी पैडिंग बाइट्स शामिल हैं। इसलिए, एक sizeof अभिव्यक्ति का मान कभी नहीं हो सकता है। 0. अधिक विवरण के लिए ऑब्जेक्ट प्रकारों का लेआउट देखें।
• char , signed char और unsigned char प्रकारों का आकार 1 है। इसके विपरीत, एक बाइट को char ऑब्जेक्ट को स्टोर करने के लिए आवश्यक मेमोरी की मात्रा के रूप में परिभाषित किया गया है। इसका अर्थ हमेशा यह 8 बिट नहीं है, जैसा कि कुछ सिस्टम है char वस्तुओं 8 बिट से अधिक समय।

यदि expr एक अभिव्यक्ति है, तो sizeof( expr ) sizeof(T) बराबर है जहाँ T , expr का प्रकार है ।

int a[100];
std::cout << "The number of bytes in `a` is: " << sizeof a;
memset(a, 0, sizeof a); // zeroes out the array

template <class... T>
void f(T&&...) {
    std::cout << "f was called with " << sizeof...(T) << " arguments\n";
}

विभिन्न कीवर्ड

शून्य C ++

1. जब फ़ंक्शन रिटर्न प्रकार के रूप में उपयोग किया जाता है, तो शून्य कीवर्ड निर्दिष्ट करता है कि फ़ंक्शन मान वापस नहीं करता है। जब किसी फ़ंक्शन की पैरामीटर सूची के लिए उपयोग किया जाता है, तो शून्य निर्दिष्ट करता है कि फ़ंक्शन कोई पैरामीटर नहीं लेता है। जब एक पॉइंटर की घोषणा में उपयोग किया जाता है, तो शून्य निर्दिष्ट करता है कि पॉइंटर "सार्वभौमिक" है।

2. यदि एक पॉइंटर का प्रकार शून्य है *, पॉइंटर किसी भी वैरिएबल को इंगित कर सकता है जो कि कॉन्स्टैंट या वाष्पशील कीवर्ड के साथ घोषित नहीं किया गया है। एक शून्य पॉइंटर को किसी अन्य प्रकार के लिए डाले जाने तक डिरेल नहीं किया जा सकता है। एक शून्य पॉइंटर को किसी अन्य प्रकार के डेटा पॉइंटर में परिवर्तित किया जा सकता है।

3. एक शून्य पॉइंटर एक फ़ंक्शन को इंगित कर सकता है, लेकिन सी ++ में क्लास के सदस्य को नहीं।

   void vobject;   // C2182  
   void *pv;   // okay  
   int *pint; int i;  
   int main() {  
   pv = &i;  
      // Cast optional in C required in C++  
   pint = (int *)pv;  
   

वाष्पशील C ++

1. एक प्रकार का क्वालीफायर जिसे आप यह घोषित करने के लिए उपयोग कर सकते हैं कि हार्डवेयर द्वारा किसी ऑब्जेक्ट को प्रोग्राम में संशोधित किया जा सकता है।

   volatile declarator ;
   

आभासी C ++

1. वर्चुअल कीवर्ड एक वर्चुअल फंक्शन या वर्चुअल बेस क्लास घोषित करता है।

   virtual [type-specifiers] member-function-declarator  
   virtual [access-specifier] base-class-name 
   

पैरामीटर

1. प्रकार-विनिर्देशक वर्चुअल सदस्य फ़ंक्शन के रिटर्न प्रकार को निर्दिष्ट करता है।

2. सदस्य-फ़ंक्शन- घोषणाकर्ता एक सदस्य फ़ंक्शन की घोषणा करता है।

3. access- Specier आधार वर्ग, सार्वजनिक, संरक्षित या निजी तक पहुंच के स्तर को परिभाषित करता है। वर्चुअल कीवर्ड से पहले या बाद में दिखाई दे सकता है।

4. आधार-वर्ग-नाम पहले घोषित वर्ग प्रकार की पहचान करता है

यह सूचक है

1. यह पॉइंटर एक ऐसा पॉइंटर है जो केवल क्लास, स्ट्रक्चर या यूनियन टाइप के नॉनस्टैटिक मेंबर फंक्शन्स के भीतर ही पहुंच सकता है। यह उस ऑब्जेक्ट को इंगित करता है जिसके लिए सदस्य फ़ंक्शन कहा जाता है। स्थैतिक सदस्य कार्यों में यह सूचक नहीं होता है।

   this->member-identifier  
   

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

myDate.setMonth( 3 );  

can be interpreted this way:


setMonth( &myDate, 3 );  

The object's address is available from within the member function as the this pointer. Most uses of this are implicit. It is legal, though unnecessary, to explicitly use this when referring to members of the class. For example:


void Date::setMonth( int mn )  
{  
   month = mn;            // These three statements  
   this->month = mn;      // are equivalent  
   (*this).month = mn;  
}  

The expression *this is commonly used to return the current object from a member function:


return *this;  

The this pointer is also used to guard against self-reference:


if (&Object != this) {  
// do not execute in cases of self-reference 

स्टेटमेंट (C ++) को आज़माएं, फेंकें और पकड़ें

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

    MyData md;  
try {  
   // Code that could throw an exception  
   md = GetNetworkResource();  
}  
catch (const networkIOException& e) {  
   // Code that executes when an exception of type  
   // networkIOException is thrown in the try block  
   // ...  
   // Log error message in the exception object  
   cerr << e.what();  
}  
catch (const myDataFormatException& e) {  
   // Code that handles another exception type  
   // ...  
   cerr << e.what();  
}  
  
// The following syntax shows a throw expression  
MyData GetNetworkResource()  
{  
   // ...  
   if (IOSuccess == false)  
      throw networkIOException("Unable to connect");  
   // ...  
   if (readError)  
      throw myDataFormatException("Format error");   
   // ...  
}

कोशिश खंड के बाद का कोड कोड का संरक्षित खंड है। थ्रो एक्सप्रेशन फेंकता है - यानी एक अपवाद। कैच क्लॉज के बाद कोड ब्लॉक अपवाद हैंडलर है। यह हैंडलर है जो उस अपवाद को पकड़ता है जिसे फेंक दिया जाता है यदि फेंक और पकड़ने के प्रकार के प्रकार संगत हैं।

    try {  
   throw CSomeOtherException();  
}  
catch(...) {  
   // Catch all exceptions – dangerous!!!  
   // Respond (perhaps only partially) to the exception, then  
   // re-throw to pass the exception to some other handler  
   // ...  
   throw;  
}

दोस्त (C ++)

1. कुछ परिस्थितियों में, उन कार्यों के लिए सदस्य-स्तरीय पहुंच प्रदान करना अधिक सुविधाजनक है जो किसी वर्ग के सदस्य या अलग वर्ग के सभी सदस्यों के लिए नहीं हैं। केवल कक्षा कार्यान्वयनकर्ता ही यह घोषित कर सकता है कि उसके मित्र कौन हैं। एक समारोह या वर्ग खुद को किसी भी वर्ग के मित्र के रूप में घोषित नहीं कर सकता है। कक्षा की परिभाषा में, अपने वर्ग के निजी और संरक्षित सदस्यों तक पहुँच प्रदान करने के लिए मित्र कीवर्ड और गैर-सदस्य फ़ंक्शन या अन्य वर्ग के नाम का उपयोग करें। टेम्प्लेट परिभाषा में, एक प्रकार के पैरामीटर को मित्र के रूप में घोषित किया जा सकता है।

2. यदि आप एक मित्र फ़ंक्शन की घोषणा करते हैं जो पहले घोषित नहीं किया गया था, तो उस फ़ंक्शन को एन्क्लोज़िंग नॉनक्लास स्कोप में निर्यात किया जाता है।

   class friend F  
   friend F;
   class ForwardDeclared;// Class name is known.  
   class HasFriends  
   {  
      friend int ForwardDeclared::IsAFriend();// C2039 error expected  
   };  
   

मित्र कार्य करता है

1. एक फ्रेंड फंक्शन एक ऐसा फंक्शन है जो किसी क्लास का सदस्य नहीं है, लेकिन क्लास के प्राइवेट और प्रोटेक्टेड सदस्यों तक उसकी पहुंच है। वे सामान्य बाहरी कार्य हैं जिन्हें विशेष पहुँच विशेषाधिकार दिए गए हैं।

2. मित्र वर्ग के दायरे में नहीं हैं, और उन्हें तब तक सदस्य-चयन ऑपरेटरों ((और ->) का उपयोग करने के लिए नहीं कहा जाता है जब तक कि वे दूसरे वर्ग के सदस्य नहीं हैं।

3. एक मित्र फ़ंक्शन उस वर्ग द्वारा घोषित किया जाता है जो पहुंच प्रदान कर रहा है। मित्र घोषणा को वर्ग घोषणा में कहीं भी रखा जा सकता है। यह एक्सेस कंट्रोल कीवर्ड से प्रभावित नहीं है।

   #include <iostream>  
   
   using namespace std;  
   class Point  
   {  
       friend void ChangePrivate( Point & );  
   public:  
       Point( void ) : m_i(0) {}  
       void PrintPrivate( void ){cout << m_i << endl; }  
   
   private:  
   int m_i;  
   };  
   
   void ChangePrivate ( Point &i ) { i.m_i++; }  
   
   int main()  
   {  
      Point sPoint;  
      sPoint.PrintPrivate();  
      ChangePrivate(sPoint);  
      sPoint.PrintPrivate();  
       // Output: 0  
              1  
   }  
   

कक्षा के सदस्य मित्र के रूप में

class B;  

class A {  
public:  
   int Func1( B& b );  

private:  
   int Func2( B& b );  
};  

class B {  
private:  
int _b;  

   // A::Func1 is a friend function to class B  
   // so A::Func1 has access to all members of B  
   friend int A::Func1( B& );  
};  

int A::Func1( B& b ) { return b._b; }   // OK  
int A::Func2( B& b ) { return b._b; }   // C2248