C++ => Typ trefwoorden

klasse

Introduceert de definitie van een klasse type.

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

Introduceert een uitgebreide typespecificatie, die aangeeft dat de volgende naam de naam is van een klassetype. Als de klassenaam al is gedeclareerd, kan deze worden gevonden, zelfs als deze is verborgen onder een andere naam. Als de klassenaam nog niet is aangegeven, wordt deze doorgestuurd.

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

Introduceert een typeparameter in de aangifte van een sjabloon .

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

In de verklaring van een template template parameter , het trefwoord class voorafgaat aan de naam van de parameter. Aangezien het argument voor een sjabloonsjabloonparameter alleen een klassensjabloon kan zijn, is het gebruik van class hier overbodig. De grammatica van C ++ vereist dit echter.
```
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();
}
```

Merk op dat sense 2 en sense 3 in dezelfde verklaring kunnen worden gecombineerd. Bijvoorbeeld:

template <class T>
class foo {
};

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

C ++ 11

Verklaart in de verklaring of definitie van een opsomming een opsomming .

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

struct

Uitwisselbaar met class , behalve de volgende verschillen:

Als een klassetype wordt gedefinieerd met behulp van het trefwoord struct , dan is de standaardtoegankelijkheid van bases en leden public plaats van private .
struct kan niet worden gebruikt om een sjabloontype-parameter of sjabloon-sjabloonparameter te declareren; alleen class kan.

enum

Introduceert de definitie van een opsommingstype .

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

C ++ 11

In C ++ 11 kan enum optioneel worden gevolgd door class of struct om een scoped enum te definiëren. Bovendien kunnen zowel scoped- als unscoped-enums hun onderliggende type expliciet specificeren door : T na de enum-naam, waarbij T verwijst naar een geheel getal.

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

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

Tellers in normale enum kunnen ook worden voorafgegaan door de scope-operator, hoewel ze nog steeds worden beschouwd als in de scope waarin de enum is gedefinieerd.

   Language l1, l2;

   l1 = ENGLISH;
   l2 = Language::OTHER;

Introduceert een uitgebreide typespecificatie, die aangeeft dat de volgende naam de naam is van een eerder aangegeven opsommingstype. (Een uitgewerkte typeaanduiding kan niet worden gebruikt om een opsommingstype vooruit te declareren.) Een opsomming kan op deze manier worden genoemd, zelfs als deze is verborgen onder een andere naam.
```
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

Introduceert een ondoorzichtige opsomming, die een opsomming verklaart zonder deze te definiëren. Het kan een eerder aangegeven opsomming opnieuw opgeven of een opsomming die niet eerder is aangegeven, doorsturen.
Een opsomming die eerst als scoped is verklaard, kan later niet als scoped worden verklaard, of omgekeerd. Alle verklaringen van een opsomming moeten overeenkomen met het onderliggende type.
Bij het voorwaarts declareren van een niet-gescandeerd opsomming, moet het onderliggende type expliciet worden opgegeven, omdat het niet kan worden afgeleid totdat de waarden van de opsommers bekend zijn.
```
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
```

unie

Introduceert de definitie van een unietype .

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

Introduceert een uitgebreide typespecificatie die aangeeft dat de volgende naam de naam is van een unietype. Als de naam van de vakbond al is gedeclareerd, kan deze worden gevonden, zelfs als deze is verborgen onder een andere naam. Als de vakbondsnaam nog niet is aangegeven, wordt deze op voorhand verklaard.

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

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

C++
Typ trefwoorden

Zoeken…

klasse

struct

enum

unie