C++ => Geben Sie Schlüsselwörter ein

Klasse

Führt die Definition eines Klassentyps ein .

class foo {
    int x;
  public:
    int get_x();
    void set_x(int new_x);
};

Führt einen ausführlichen Typbezeichner ein, der angibt, dass der folgende Name der Name eines Klassentyps ist. Wenn der Klassenname bereits deklariert wurde, kann er auch gefunden werden, wenn er von einem anderen Namen ausgeblendet wird. Wenn der Klassenname noch nicht deklariert wurde, wird er vorwärts deklariert.

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();
};

Führt einen Typparameter in die Deklaration einer Vorlage ein .

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

In der Deklaration eines Template - class Template - Parameter , das Schlüsselwort class steht vor dem Namen des Parameters. Da das Argument für einen Vorlagenvorlagenparameter nur eine Klassenvorlage sein kann, ist die Verwendung der class hier überflüssig. Die Grammatik von C ++ erfordert es jedoch.
```
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();
}
```

Beachten Sie, dass Sinn 2 und Sinn 3 in derselben Deklaration zusammengefasst werden können. Zum Beispiel:

template <class T>
class foo {
};

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

C ++ 11

In der Deklaration oder Definition einer Aufzählung wird die Aufzählung als eine Aufzählung definiert .
```
enum class Format {
    TEXT,
    PDF,
    OTHER,
};
Format f = F::TEXT;
```

struct

Mit class austauschbar, mit Ausnahme der folgenden Unterschiede:

Wenn ein Klassentyp mit dem Schlüsselwort struct , ist der Standardzugriff für Basen und Member public und nicht private .
struct kann nicht verwendet werden, um einen Vorlagentypparameter oder einen Vorlagenvorlagenparameter zu deklarieren. Nur die class kann.

enum

Führt die Definition eines Aufzählungstyps ein .

enum Direction {
    UP,
    LEFT,
    DOWN,
    RIGHT
};
Direction d = UP;

C ++ 11

In C ++ 11 kann der enum optional eine class oder eine struct folgen, um eine Aufzählung mit Bereich zu definieren. Darüber hinaus kann der zugrunde liegende Typ sowohl für bereichs- als auch für nicht begrenzte Enums explizit angegeben werden durch : T nach dem Namen der Enummen, wobei T auf einen Integer-Typ verweist.

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

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

Enumeratoren in normalen enum können auch vom Bereichsoperator vorangestellt werden, obwohl sie immer noch in dem Bereich liegen, in dem die enum definiert wurde.

   Language l1, l2;

   l1 = ENGLISH;
   l2 = Language::OTHER;

Führt einen ausführlichen Typbezeichner ein, der angibt, dass der folgende Name der Name eines zuvor deklarierten Aufzählungstyps ist. (Ein ausführlicher Typbezeichner kann nicht zur Vorwärtsdeklaration eines Aufzählungstyps verwendet werden.) Eine Aufzählung kann auf diese Weise auch dann benannt werden, wenn sie von einem anderen Namen verborgen wird.
```
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
```

C ++ 11

Führt eine opake Enum-Deklaration ein, die eine Enumeration deklariert, ohne sie zu definieren. Es kann entweder eine zuvor deklarierte Aufzählung erneut deklarieren oder eine zuvor deklarierte Aufzählung vorwärts deklarieren.
Eine Enumeration, die zuerst als Gültigkeitsbereich deklariert wurde, kann später nicht als unbegrenzt deklariert werden oder umgekehrt. Alle Deklarationen einer Aufzählung müssen im zugrunde liegenden Typ übereinstimmen.
Bei der Vorwärtsdeklaration eines unscoped-Enums muss der zugrunde liegende Typ explizit angegeben werden, da er nicht abgeleitet werden kann, bis die Werte der Enumeratoren bekannt sind.
```
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
```

Union

Führt die Definition eines Unionstyps ein .

// Example is from POSIX
union sigval {
    int     sival_int;
    void   *sival_ptr;
};

Führt einen ausführlichen Typbezeichner ein, der angibt, dass der folgende Name der Name eines Unionstyps ist. Wenn der Unionsname bereits deklariert wurde, kann er auch gefunden werden, wenn er von einem anderen Namen verborgen wird. Wenn der Unionsname noch nicht deklariert wurde, wird er vorwärts deklariert.

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

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

C++
Geben Sie Schlüsselwörter ein

Suche…

Klasse

struct

enum

Union