C++ => Parole chiave di dichiarazione variabile

const

Un identificatore di tipo; quando viene applicato a un tipo, produce la versione const-qualified del tipo. Vedere la parola chiave const per i dettagli sul significato di 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

Rende il tipo del suo operando, che non viene valutato.

Se l'operando e è un nome senza parentesi aggiuntive, decltype(e) è il tipo dichiarato di e .
```
int x = 42;
std::vector<decltype(x)> v(100, x); // v is a vector<int>
```
Se l'operando e è un membro della classe di accesso senza parentesi aggiuntivi, quindi decltype(e) è il tipo dichiarato degli Stati accesso.
```
struct S {
    int x = 42;
};
const S s;
decltype(s.x) y; // y has type int, even though s.x is const
```
In tutti gli altri casi, decltype(e) restituisce sia il tipo che la categoria di valore dell'espressione e , come segue:
- Se e è un lvalue di tipo T , quindi decltype(e) è T& .
- Se e è un xvalue di tipo T , decltype(e) è T&& .
- Se e è un valore di tipo T , allora decltype(e) è T
Questo include il caso con parentesi estranee.
```
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 speciale decltype(auto) deduce il tipo di variabile dal suo inizializzatore o il tipo di ritorno di una funzione dalle dichiarazioni di return nella sua definizione, usando le regole di deduzione di tipo di decltype piuttosto che quelle di 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

firmato

Una parola chiave che fa parte di determinati nomi di tipi interi.

Se usato da solo, int è implicito, così che signed , signed int e int sono dello stesso tipo.
Quando combinato con char , restituisce il tipo signed char , che è un tipo diverso da char , anche se char è anche firmato. signed char ha un intervallo che include almeno da -127 a +127 inclusi.
Se combinato con short , long o long long , è ridondante, poiché questi tipi sono già firmati.
signed non può essere combinato con bool , wchar_t , char16_t , o char32_t .

Esempio:

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

unsigned

Un identificatore di tipo che richiede la versione senza segno di un tipo intero.

Se usato da solo, int è implicito, quindi unsigned è lo stesso tipo di unsigned int .
Il unsigned char è diverso dal tipo char , anche se char non è firmato. Può contenere numeri interi fino ad almeno 255.
unsigned può anche essere combinato con short , long o long long . Non può essere combinato con bool , wchar_t , char16_t o char32_t .

Esempio:

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
}

volatile

Un qualificatore di tipo; quando applicato a un tipo, produce la versione qualificata volatile del tipo. La qualifica volatile ha lo stesso ruolo della qualifica const nel sistema di tipi, ma la volatile non impedisce la modifica degli oggetti; al contrario, obbliga il compilatore a trattare tutti gli accessi a tali oggetti come effetti collaterali.

Nell'esempio seguente, se memory_mapped_port non fosse volatile, il compilatore potrebbe ottimizzare la funzione in modo che esegua solo la scrittura finale, che sarebbe errata se sizeof(int) è maggiore di 1. La qualifica volatile lo costringe a trattare tutte le sizeof(int) scrive come diversi effetti collaterali e quindi li esegue tutti (nell'ordine).

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

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

C++
Parole chiave di dichiarazione variabile

Ricerca…

const

decltype

firmato

unsigned

volatile