Ricerca…
introduzione
Tradizionalmente, un letterale è un'espressione che denota una costante il cui tipo e valore sono evidenti dalla sua ortografia. Ad esempio, 42 è un valore letterale, mentre x non lo è dato che uno deve vedere la sua dichiarazione per conoscerne il tipo e leggere le righe di codice precedenti per conoscerne il valore.
Tuttavia, C ++ 11 ha aggiunto anche valori letterali definiti dall'utente , che non sono letterali nel senso tradizionale, ma possono essere utilizzati come una scorciatoia per le chiamate di funzione.
vero
Una parola chiave che indica uno dei due possibili valori di tipo bool .
bool ok = true;
if (!f()) {
ok = false;
goto end;
}
falso
Una parola chiave che indica uno dei due possibili valori di tipo bool .
bool ok = true;
if (!f()) {
ok = false;
goto end;
}
nullptr
Una parola chiave che denota una costante del puntatore nullo. Può essere convertito in qualsiasi puntatore o tipo puntatore-membro, ottenendo un puntatore nullo del tipo risultante.
Widget* p = new Widget();
delete p;
p = nullptr; // set the pointer to null after deletion
Si noti che nullptr non è esso stesso un puntatore. Il tipo di nullptr è un tipo fondamentale noto come std::nullptr_t .
void f(int* p);
template <class T>
void g(T* p);
void h(std::nullptr_t p);
int main() {
f(nullptr); // ok
g(nullptr); // error
h(nullptr); // ok
}
Questo
All'interno di una funzione di membro di una classe, la parola chiave this è un puntatore all'istanza della classe in cui è stata chiamata la funzione. this non può essere usato in una funzione membro statica.
struct S {
int x;
S& operator=(const S& other) {
x = other.x;
// return a reference to the object being assigned to
return *this;
}
};
Il tipo di this dipende dalla qualifica cv della funzione membro: se X::f è const , il tipo di this all'interno di f è const X* , quindi this non può essere usato per modificare membri di dati non statici all'interno di un funzione membro const . Allo stesso modo, this eredita la qualifica volatile dalla funzione in cui appare.
this può anche essere utilizzato in un inizializzatore controvento o uguale per un membro dati non statico.
struct S;
struct T {
T(const S* s);
// ...
};
struct S {
// ...
T t{this};
};
this è un valore, quindi non può essere assegnato a.
Intero letterale
Un intero letterale è un'espressione primaria della forma
- decimale letterale
È una cifra decimale diversa da zero (1, 2, 3, 4, 5, 6, 7, 8, 9), seguita da zero o più cifre decimali (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
int d = 42;
- ottale letterale
È la cifra zero (0) seguita da zero o più cifre ottali (0, 1, 2, 3, 4, 5, 6, 7)
int o = 052
- hex-letterale
È la sequenza di caratteri 0x o la sequenza di caratteri 0X seguita da una o più cifre esadecimali (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C , d, D, e, E, f, F)
int x = 0x2a; int X = 0X2A;
- binario-letterale (dal C ++ 14)
È la sequenza di caratteri 0b o la sequenza di caratteri 0B seguita da una o più cifre binarie (0, 1)
int b = 0b101010; // C++14
Il suffisso intero, se fornito, può contenere uno o entrambi i seguenti elementi (se sono forniti entrambi, possono apparire in qualsiasi ordine:
- suffisso senza segno (il carattere u o il carattere U)
unsigned int u_1 = 42u;
- lungo-suffisso (il carattere l del carattere L) o il suffisso lungo-lungo (la sequenza di caratteri ll o la sequenza di caratteri LL) (dal C ++ 11)
Anche le seguenti variabili sono inizializzate allo stesso valore:
unsigned long long l1 = 18446744073709550592ull; // C++11
unsigned long long l2 = 18'446'744'073'709'550'592llu; // C++14
unsigned long long l3 = 1844'6744'0737'0955'0592uLL; // C++14
unsigned long long l4 = 184467'440737'0'95505'92LLU; // C++14
Gli appunti
Le lettere nei valori letterali interi non fanno distinzione tra maiuscole e minuscole: 0xDeAdBaBeU e 0XdeadBABEu rappresentano lo stesso numero (un'eccezione è il suffisso long-long, che è ll o LL, mai lL o Ll)
Non ci sono letterali interi negativi. Espressioni come -1 applicano l'operatore unario meno al valore rappresentato dal valore letterale, che può implicare conversioni di tipo implicito.
In C precedenti a C99 (ma non in C ++), i valori decimali non troncati che non si adattano a int lungo possono avere il tipo unsigned long int.
Quando usate in un'espressione di controllo di #if o #elif, tutte le costanti di interi con segno agiscono come se avessero tipo std :: intmax_t e tutte le costanti di interi non firmati agiscono come se avessero tipo std :: uintmax_t.