C++ => Mots-clés de type

classe

Introduit la définition d'un type de classe .

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

Introduit un spécificateur de type élaboré, qui spécifie que le nom suivant est le nom d'un type de classe. Si le nom de la classe a déjà été déclaré, il peut être trouvé même s'il est masqué par un autre nom. Si le nom de la classe n'a pas déjà été déclaré, il est déclaré en avant.

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

Introduit un paramètre de type dans la déclaration d'un modèle .

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

Dans la déclaration d'un paramètre de modèle de modèle , la class mot clé précède le nom du paramètre. L'argument pour un paramètre de modèle de modèle ne pouvant être qu'un modèle de classe, l'utilisation de la class ici est redondante. Cependant, la grammaire de C ++ l’exige.
```
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();
}
```

Notez que le sens 2 et le sens 3 peuvent être combinés dans la même déclaration. Par exemple:

template <class T>
class foo {
};

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

C ++ 11

Dans la déclaration ou la définition d'une énumération, déclare l'énumération comme une énumération de portée .
```
enum class Format {
    TEXT,
    PDF,
    OTHER,
};
Format f = F::TEXT;
```

struct

Interchangeable avec la class , sauf pour les différences suivantes:

Si un type de classe est défini à l'aide du mot struct clé struct , l'accessibilité par défaut des bases et des membres est public plutôt que private .
struct ne peut pas être utilisé pour déclarer un paramètre de type de modèle ou un paramètre de modèle de modèle; seule class peut.

enum

Introduit la définition d'un type d'énumération .

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

C ++ 11

En C ++ 11, enum peut éventuellement être suivi par class ou struct pour définir un enum de portée . De plus, le type sous-jacent peut être explicitement spécifié par : T suivant le nom enum, où T désigne un type entier.

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

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

Les énumérateurs dans les enum normales peuvent également être précédés de l’opérateur scope, bien qu’ils soient toujours considérés comme faisant partie de la portée dans laquelle l’ enum été définie.

   Language l1, l2;

   l1 = ENGLISH;
   l2 = Language::OTHER;

Introduit un spécificateur de type élaboré, qui spécifie que le nom suivant est le nom d'un type enum déclaré précédemment. (Un spécificateur de type élaboré ne peut pas être utilisé pour déclarer en avant un type enum.) Une énumération peut être nommée de cette manière même si elle est masquée par un autre nom.
```
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

Introduit une déclaration enum opaque, qui déclare une énumération sans la définir. Il peut soit redéclarer une énumération précédemment déclarée, soit déclarer en avant une énumération qui n'a pas encore été déclarée.
Une énumération déclarée comme première portée ne peut plus être déclarée ultérieurement comme étant non tronquée, ou inversement. Toutes les déclarations d'une énumération doivent correspondre à un type sous-jacent.
Lors de la déclaration en avant d'un enum non tronqué, le type sous-jacent doit être explicitement spécifié, car il ne peut être inféré tant que les valeurs des énumérateurs ne sont pas connues.
```
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
```

syndicat

Introduit la définition d'un type d' union .

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

Introduit un spécificateur de type élaboré, qui spécifie que le nom suivant est le nom d'un type d'union. Si le nom de l'union a déjà été déclaré, il peut être trouvé même s'il est masqué par un autre nom. Si le nom du syndicat n'a pas encore été déclaré, il est déclaré en avant.

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

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

C++
Mots-clés de type

Recherche…

classe

struct

enum

syndicat