C++ => Mots-clés de déclaration de variable

const

Un spécificateur de type; Appliqué à un type, génère la version qualifiée du type. Voir le mot-clé const pour plus de détails sur la signification 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

Donne le type de son opérande, qui n'est pas évalué.

Si l'opérande e est un nom sans parenthèses supplémentaires, decltype(e) est le type déclaré de e .
```
int x = 42;
std::vector<decltype(x)> v(100, x); // v is a vector<int>
```
Si l'opérande e est un accès de membre de classe sans parenthèses supplémentaires, decltype(e) est le type déclaré du membre accédé.
```
struct S {
    int x = 42;
};
const S s;
decltype(s.x) y; // y has type int, even though s.x is const
```
Dans tous les autres cas, decltype(e) fournit à la fois le type et la catégorie de valeur de l'expression e , comme suit:
- Si e est une lvalue de type T , alors decltype(e) est T& .
- Si e est une valeur x de type T , alors decltype(e) est T&& .
- Si e est une valeur de type T , alors decltype(e) est T
Cela inclut le cas avec des parenthèses étrangères.
```
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 forme spéciale decltype(auto) déduit le type d'une variable de son initialiseur ou le type de retour d'une fonction des instructions de return dans sa définition, en utilisant les règles de déduction de type de decltype plutôt que celles 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

signé

Un mot-clé qui fait partie de certains noms de type entier.

Utilisé seul, int est implicite, de sorte que signed , signed int et int sont du même type.
Lorsqu'il est combiné avec l' char , donne le type signed char , qui est un type différent de char , même si char est également signé. signed char a une portée qui comprend au moins -127 à +127 inclus.
Lorsqu'il est associé à un format short , long ou long long , il est redondant, car ces types sont déjà signés.
signed ne peut pas être combiné avec bool , wchar_t , char16_t ou char32_t .

Exemple:

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

non signé

Un spécificateur de type qui demande la version non signée d'un type entier.

Utilisé seul, int est implicite, donc unsigned est du même type que unsigned int .
Le type unsigned char est différent du type char , même si char n'est pas signé. Il peut contenir des nombres entiers jusqu’à 255.
unsigned peut également être combiné avec short , long ou long long . Il ne peut pas être combiné avec bool , wchar_t , char16_t ou char32_t .

Exemple:

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
}

volatil

Un qualificatif de type; appliqué à un type, produit la version qualifiée volatile du type. La qualification volatile joue le même rôle que la qualification const dans le système de type, mais volatile n'empêche pas la modification des objets; au contraire, il oblige le compilateur à traiter tous les accès à de tels objets comme des effets secondaires.

Dans l'exemple ci-dessous, si memory_mapped_port n'était pas volatile, le compilateur pourrait optimiser la fonction afin qu'elle n'effectue que l'écriture finale, ce qui serait incorrect si sizeof(int) est supérieur à 1. La qualification volatile oblige à traiter toutes les sizeof(int) écrit en tant qu'effets secondaires différents et les exécute donc (dans l'ordre).

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

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

C++
Mots-clés de déclaration de variable

Recherche…

const

decltype

signé

non signé

volatil