C++ => Escriba palabras clave

clase

Introduce la definición de un tipo de clase .

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

Introduce un especificador de tipo elaborado, que especifica que el siguiente nombre es el nombre de un tipo de clase. Si el nombre de la clase ya se ha declarado, se puede encontrar incluso si está oculto por otro nombre. Si el nombre de la clase no se ha declarado ya, se declara hacia adelante.

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 parámetro de tipo en la declaración de una plantilla .

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

En la declaración de un parámetro de plantilla de plantilla , la class palabra clave precede al nombre del parámetro. Dado que el argumento para un parámetro de plantilla de plantilla solo puede ser una plantilla de clase, el uso de class aquí es redundante. Sin embargo, la gramática de C ++ lo requiere.
```
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();
}
```

Tenga en cuenta que sense 2 y sense 3 pueden combinarse en la misma declaración. Por ejemplo:

template <class T>
class foo {
};

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

C ++ 11

En la declaración o definición de una enumeración, declara que la enumeración es una enumeración de ámbito .
```
enum class Format {
    TEXT,
    PDF,
    OTHER,
};
Format f = F::TEXT;
```

estructura

Intercambiable con class , excepto por las siguientes diferencias:

Si un tipo de clase se define utilizando la struct palabras clave, la accesibilidad predeterminada de las bases y los miembros es public lugar de private .
struct no se puede utilizar para declarar un parámetro de tipo de plantilla o un parámetro de plantilla de plantilla; Sólo la class puede.

enumerar

Introduce la definición de un tipo de enumeración .

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

C ++ 11

En C ++ 11, enum puede ser seguido opcionalmente por class o struct para definir una enumeración de ámbito . Además, las enumeraciones con y sin ámbito pueden tener su tipo subyacente explícitamente especificado por : T después del nombre de enumeración, donde T refiere a un tipo entero.

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

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

Los enumeradores en enum normales también pueden estar precedidos por el operador del alcance, aunque todavía se considera que están en el alcance en que se definió la enum .

   Language l1, l2;

   l1 = ENGLISH;
   l2 = Language::OTHER;

Introduce un especificador de tipo elaborado, que especifica que el siguiente nombre es el nombre de un tipo de enumeración previamente declarado. (Un especificador de tipo elaborado no se puede usar para declarar hacia delante un tipo de enumeración). Una enumeración se puede nombrar de esta manera incluso si está oculta por otro nombre.
```
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 declaración de enumeración opaca, que declara una enumeración sin definirla. Puede volver a declarar una enumeración previamente declarada o declarar hacia adelante una enumeración que no se haya declarado previamente.
Una enumeración que se declara primero como ámbito no se puede declarar más tarde como sin ámbito, o viceversa. Todas las declaraciones de una enumeración deben coincidir en el tipo subyacente.
Al declarar hacia adelante una enumeración sin ámbito, el tipo subyacente debe especificarse explícitamente, ya que no se puede inferir hasta que se conozcan los valores de los enumeradores.
```
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
```

Unión

Introduce la definición de un tipo de unión .

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

Introduce un especificador de tipo elaborado, que especifica que el siguiente nombre es el nombre de un tipo de unión. Si el nombre de la unión ya se ha declarado, se puede encontrar incluso si está oculto por otro nombre. Si el nombre del sindicato no se ha declarado ya, se declara hacia adelante.

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

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

C++
Escriba palabras clave

Buscar..

clase

estructura

enumerar

Unión