C++ => Palabras clave de la declaración variable

const

Un especificador de tipo; cuando se aplica a un tipo, produce la versión const-calificada del tipo. Consulte la palabra clave const para obtener detalles sobre el significado de const .

const int x = 123;
x = 456;    // error
int& r = x; // error

struct S {
    void f();
    void g() const;
};
const S s;
s.f(); // error
s.g(); // OK

decltype

C ++ 11

Cede el tipo de su operando, que no se evalúa.

Si el operando e es un nombre sin paréntesis adicionales, entonces decltype(e) es el tipo declarado de e .
```
int x = 42;
std::vector<decltype(x)> v(100, x); // v is a vector<int>
```
Si el operando e es un acceso de miembro de clase sin paréntesis adicionales, entonces decltype(e) es el tipo declarado del miembro al que se accedió.
```
struct S {
    int x = 42;
};
const S s;
decltype(s.x) y; // y has type int, even though s.x is const
```
En todos los demás casos, decltype(e) produce tanto el tipo como la categoría de valor de la expresión e , como sigue:
- Si e es un valor de tipo T , entonces decltype(e) es T& .
- Si e es un xvalor de tipo T , entonces decltype(e) es T&& .
- Si e es un prvalor de tipo T , entonces decltype(e) es T
Esto incluye el caso con paréntesis extraños.
```
int f() { return 42; }
int& g() { static int x = 42; return x; }
int x = 42;
decltype(f()) a = f(); // a has type int
decltype(g()) b = g(); // b has type int&
decltype((x)) c = x;   // c has type int&, since x is an lvalue
```

C ++ 14

La forma especial decltype(auto) deduce el tipo de una variable de su inicializador o el tipo de retorno de una función de las declaraciones de return en su definición, utilizando las reglas de deducción de decltype de decltype lugar de las de auto .

const int x = 123;
auto y = x;           // y has type int
decltype(auto) z = x; // z has type const int, the declared type of x

firmado

Una palabra clave que forma parte de ciertos nombres de tipo entero.

Cuando se usa solo, int está implícito, de modo que signed , signed int e int son del mismo tipo.
Cuando se combina con char , produce el tipo signed char , que es un tipo diferente de char , incluso si char también está firmado. signed char tiene un rango que incluye al menos -127 a +127, ambos inclusive.
Cuando se combina con short , long o long long , es redundante, ya que esos tipos ya están firmados.
signed no se puede combinar con bool , wchar_t , char16_t o char32_t .

Ejemplo:

signed char celsius_temperature;
std::cin >> celsius_temperature;
if (celsius_temperature < -35) {
    std::cout << "cold day, eh?\n";
}

no firmado

Un especificador de tipo que solicita la versión sin firmar de un tipo entero.

Cuando se usa solo, int está implícito, por lo que unsigned es del mismo tipo que unsigned int .
El tipo unsigned char es diferente del tipo char , incluso si char no está firmado. Puede contener enteros hasta al menos 255.
unsigned también se puede combinar con short , long o long long . No se puede combinar con bool , wchar_t , char16_t o char32_t .

Ejemplo:

char invert_case_table[256] = { ..., 'a', 'b', 'c', ..., 'A', 'B', 'C', ... };
char invert_case(char c) {
    unsigned char index = c;
    return invert_case_table[index];
    // note: returning invert_case_table[c] directly does the
    // wrong thing on implementations where char is a signed type
}

volátil

Un calificador de tipo; cuando se aplica a un tipo, produce la versión calificada volátil del tipo. La calificación volátil desempeña el mismo papel que la calificación const en el sistema de tipos, pero la volatile no impide que se modifiquen los objetos; en cambio, obliga al compilador a tratar todos los accesos a tales objetos como efectos secundarios.

En el ejemplo a continuación, si memory_mapped_port no fuera volátil, el compilador podría optimizar la función para que realice solo la escritura final, lo que sería incorrecto si sizeof(int) es mayor que 1. La calificación de volatile obliga a tratar todo sizeof(int) escribe como diferentes efectos secundarios y, por tanto, realiza todos ellos (en orden).

extern volatile char memory_mapped_port;
void write_to_device(int x) {
    const char* p = reinterpret_cast<const char*>(&x);
    for (int i = 0; i < sizeof(int); i++) {
        memory_mapped_port = p[i];
    }
}

Modified text is an extract of the original Stack Overflow Documentation

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

C++
Palabras clave de la declaración variable

Buscar..

const

decltype

firmado

no firmado

volátil