C++ => कीवर्ड टाइप करें

कक्षा

एक वर्ग प्रकार की परिभाषा प्रस्तुत करता है।
```
class foo {
    int x;
  public:
    int get_x();
    void set_x(int new_x);
};
```
एक विस्तृत प्रकार विनिर्देशक का परिचय देता है , जो निर्दिष्ट करता है कि निम्न नाम एक वर्ग प्रकार का नाम है। यदि वर्ग नाम पहले से ही घोषित किया गया है, तो इसे दूसरे नाम से छिपाए जाने पर भी पाया जा सकता है। यदि वर्ग नाम पहले से घोषित नहीं किया गया है, तो इसे आगे घोषित किया जाता है।
```
class foo; // elaborated type specifier -> forward declaration
class bar {
  public:
    bar(foo& f);
};
void baz();
class baz; // another elaborated type specifer; another forward declaration
           // note: the class has the same name as the function void baz()
class foo {
    bar b;
    friend class baz; // elaborated type specifier refers to the class,
                      // not the function of the same name
  public:
    foo();
};
```
टेम्पलेट की घोषणा में एक प्रकार के पैरामीटर का परिचय देता है।
```
template <class T>
const T& min(const T& x, const T& y) {
    return b < a ? b : a;
}
```
टेम्प्लेट टेम्पलेट पैरामीटर की घोषणा में, कीवर्ड class पैरामीटर के नाम से पहले होता है। चूंकि एक टेम्पलेट टेम्पलेट पैरामीटर के लिए तर्क केवल एक क्लास टेम्पलेट हो सकता है, इसलिए यहां class का उपयोग अनावश्यक है। हालाँकि, C ++ के व्याकरण को इसकी आवश्यकता होती है।
```
template <template <class T> class U>
//                           ^^^^^ "class" used in this sense here;
//                                 U is a template template parameter
void f() {
    U<int>::do_it();
    U<double>::do_it();
}
```
ध्यान दें कि भाव 2 और इंद्रिय 3 को एक ही घोषणा में जोड़ा जा सकता है। उदाहरण के लिए:
```
template <class T>
class foo {
};

foo<class bar> x; // <- bar does not have to have previously appeared.
```

सी ++ 11

एनम की घोषणा या परिभाषा में, एनम को एक स्कॉप्ड एनम घोषित करता है।
```
enum class Format {
    TEXT,
    PDF,
    OTHER,
};
Format f = F::TEXT;
```

struct

निम्नलिखित अंतरों को छोड़कर, class साथ विनिमेय:

यदि कीवर्ड struct का उपयोग करके एक वर्ग प्रकार को परिभाषित किया जाता है, तो आधार और सदस्यों की डिफ़ॉल्ट पहुंच private बजाय public होती है।
टेम्पलेट प्रकार पैरामीटर या टेम्पलेट टेम्पलेट पैरामीटर घोषित करने के लिए struct उपयोग नहीं किया जा सकता है; केवल class कर सकते हैं।

enum

एक गणन प्रकार की परिभाषा का परिचय देता है।
```
enum Direction {
    UP,
    LEFT,
    DOWN,
    RIGHT
};
Direction d = UP;
```

सी ++ 11

सी ++ 11 में, enum वैकल्पिक रूप से पालन किया जा सकता class या struct एक परिभाषित करने के लिए दायरे वाला enum । इसके अलावा, स्कूप्ड और अनकैप्ड दोनों प्रकार के एनम में उनके अंतर्निहित प्रकार स्पष्ट रूप से निर्दिष्ट हो सकते हैं : T एनम नाम के बाद, जहां T एक पूर्णांक प्रकार को संदर्भित करता है।

   enum class Format : char {
       TEXT,
       PDF,
       OTHER
   };
   Format f = Format::TEXT;

   enum Language : int {
       ENGLISH,
       FRENCH,
       OTHER
   };

सामान्य enum एस में एन्यूमरेटर्स भी स्कोप ऑपरेटर से पहले हो सकते हैं, हालांकि उन्हें अभी भी माना जाता है कि enum को परिभाषित किया गया था।

   Language l1, l2;

   l1 = ENGLISH;
   l2 = Language::OTHER;

एक विस्तृत प्रकार विनिर्देशक का परिचय देता है , जो निर्दिष्ट करता है कि निम्नलिखित नाम पहले घोषित एनुम प्रकार का नाम है। (एक विस्तृत प्रकार के विनिर्देशक का उपयोग किसी एनुम प्रकार को अग्रेषित करने के लिए नहीं किया जा सकता है।) किसी अन्य नाम द्वारा छिपाए जाने पर भी एक एनम को इस तरह से नाम दिया जा सकता है।
```
enum Foo { FOO };
void Foo() {}
Foo foo = FOO;      // ill-formed; Foo refers to the function
enum Foo foo = FOO; // ok; Foo refers to the enum type
```

सी ++ 11

एक अपारदर्शी एनम घोषणा का परिचय देता है , जो एक एनम को परिभाषित किए बिना घोषित करता है। यह या तो पहले से घोषित एनम को फिर से घोषित कर सकता है, या पहले से घोषित नहीं किया गया एनीम को अग्रेषित करता है।
पहले से घोषित की गई एक एनम को बाद में अनकैप्ड, या इसके विपरीत घोषित नहीं किया जा सकता है । एक एनुम की सभी घोषणाओं को अंतर्निहित प्रकार में सहमत होना चाहिए।
जब एक अनकैप्ड एनम को फॉरवर्ड घोषित किया जाता है, तो अंतर्निहित प्रकार को स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए, क्योंकि यह तब तक पता नहीं लगाया जा सकता है जब तक एन्यूमरेटर्स के मान ज्ञात नहीं होते हैं।
```
enum class Format; // underlying type is implicitly int
void f(Format f);
enum class Format {
    TEXT,
    PDF,
    OTHER,
};

enum Direction;    // ill-formed; must specify underlying type
```

संघ

एक संघ प्रकार की परिभाषा प्रस्तुत करता है।
```
// Example is from POSIX
union sigval {
    int     sival_int;
    void   *sival_ptr;
};
```
एक विस्तृत प्रकार विनिर्देशक का परिचय देता है , जो निर्दिष्ट करता है कि निम्नलिखित नाम एक संघ प्रकार का नाम है। यदि संघ नाम पहले ही घोषित किया जा चुका है, तो इसे किसी अन्य नाम से छिपाए जाने पर भी पाया जा सकता है। यदि संघ का नाम पहले से घोषित नहीं किया गया है, तो इसे आगे घोषित किया जाता है।
```
union foo; // elaborated type specifier -> forward declaration
class bar {
  public:
    bar(foo& f);
};
void baz();
union baz; // another elaborated type specifer; another forward declaration
           // note: the class has the same name as the function void baz()
union foo {
    long l;
    union baz* b; // elaborated type specifier refers to the class,
                  // not the function of the same name
};
```

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

C++
कीवर्ड टाइप करें

खोज…

कक्षा

struct

enum

संघ