C++ => Digitare parole chiave

classe

Introduce la definizione di un tipo di classe .

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

Introduce un identificatore di tipo elaborato, che specifica che il nome seguente è il nome di un tipo di classe. Se il nome della classe è già stato dichiarato, può essere trovato anche se nascosto da un altro nome. Se il nome della classe non è stato già dichiarato, viene dichiarato in avanti.

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

Introduce un parametro di tipo nella dichiarazione di un modello .

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

Nella dichiarazione di un parametro modello di modello , la class parola chiave precede il nome del parametro. Poiché l'argomento per un parametro modello di template può essere solo un modello di classe, l'uso della class qui è ridondante. Tuttavia, la grammatica di C ++ lo richiede.
```
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();
}
```

Si noti che il senso 2 e il senso 3 possono essere combinati nella stessa dichiarazione. Per esempio:

template <class T>
class foo {
};

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

C ++ 11

Nella dichiarazione o definizione di enum, dichiara l'enum come enum di ambito .
```
enum class Format {
    TEXT,
    PDF,
    OTHER,
};
Format f = F::TEXT;
```

struct

Intercambiabile con la class , ad eccezione delle seguenti differenze:

Se un tipo di classe viene definito utilizzando la struct parole chiave, l'accessibilità predefinita di basi e membri è public anziché private .
struct non può essere utilizzato per dichiarare un parametro di tipo template o un parametro template template; solo la class può.

enum

Introduce la definizione di un tipo di enumerazione .

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

C ++ 11

In C ++ 11, enum può facoltativamente essere seguito da una class o da una struct per definire un enumerato ambito . Inoltre, enumerazioni sia con scope sia senza ambito possono avere il loro tipo sottostante esplicitamente specificato da : T seguendo il nome enum, dove T riferisce ad un tipo intero.

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

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

Enumerators in normale enum s possono anche essere preceduti dall'operatore portata, anche se sono ancora considerati nell'ambito del enum è stato definito in.

   Language l1, l2;

   l1 = ENGLISH;
   l2 = Language::OTHER;

Introduce un identificatore di tipo elaborato, che specifica che il nome seguente è il nome di un tipo enum dichiarato in precedenza. (Un identificatore di tipo elaborato non può essere usato per inoltrare un tipo di enum.) Un enum può essere chiamato in questo modo anche se nascosto da un altro nome.
```
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

Introduce una dichiarazione enum opaca, che dichiara un enum senza definirlo. Può o ridichiarare un enum precedentemente dichiarato, o inoltrare-dichiarare un enum che non è stato precedentemente dichiarato.
Un enum prima dichiarato come ambito non può in seguito essere dichiarato come senza ambito, o viceversa. Tutte le dichiarazioni di enum devono concordare nel tipo sottostante.
Quando si inoltra una enumerazione senza ambito, il tipo sottostante deve essere esplicitamente specificato, poiché non può essere dedotto fino a quando i valori degli enumeratori non saranno noti.
```
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
```

unione

Introduce la definizione di un tipo di unione .

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

Introduce un identificatore di tipo elaborato, che specifica che il nome seguente è il nome di un tipo di unione. Se il nome del sindacato è già stato dichiarato, può essere trovato anche se nascosto da un altro nome. Se il nome del sindacato non è stato già dichiarato, viene dichiarato in avanti.

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

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

C++
Digitare parole chiave

Ricerca…

classe

struct

enum

unione