Recherche…
Introduction
Traditionnellement, un littéral est une expression désignant une constante dont le type et la valeur sont évidents. Par exemple, 42 est un littéral, tandis que x n'est pas puisque l'on doit voir sa déclaration pour connaître son type et lire les lignes de code précédentes pour connaître sa valeur.
Cependant, C ++ 11 a également ajouté des littéraux définis par l'utilisateur , qui ne sont pas des littéraux au sens traditionnel mais peuvent être utilisés comme raccourci pour les appels de fonctions.
vrai
Un mot-clé désignant l'une des deux valeurs possibles du type bool .
bool ok = true;
if (!f()) {
ok = false;
goto end;
}
faux
Un mot-clé désignant l'une des deux valeurs possibles du type bool .
bool ok = true;
if (!f()) {
ok = false;
goto end;
}
nullptr
Un mot clé indiquant une constante de pointeur nul. Il peut être converti en n'importe quel type de pointeur ou de pointeur sur membre, produisant un pointeur nul du type résultant.
Widget* p = new Widget();
delete p;
p = nullptr; // set the pointer to null after deletion
Notez que nullptr n'est pas lui-même un pointeur. Le type de nullptr est un type fondamental appelé 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
}
ce
Dans une fonction membre d'une classe, le mot this clé this est un pointeur sur l'instance de la classe sur laquelle la fonction a été appelée. this ne peut pas être utilisé dans une fonction membre statique.
struct S {
int x;
S& operator=(const S& other) {
x = other.x;
// return a reference to the object being assigned to
return *this;
}
};
Le type de this dépend de la qualification cv de la fonction membre: si X::f est const , alors le type de this dans f est const X* , donc this ne peut pas être utilisé pour modifier des données non statiques Fonction membre const . De même, this hérite de la qualification volatile de la fonction dans laquelle elle apparaît.
this peut également être utilisé dans un initialiseur d' accolade ou d'égale pour un membre de données non statique.
struct S;
struct T {
T(const S* s);
// ...
};
struct S {
// ...
T t{this};
};
this une valeur, donc il ne peut pas être assigné à.
Littéral entier
Un littéral entier est une expression primaire de la forme
- littéral décimal
C'est un chiffre décimal non nul (1, 2, 3, 4, 5, 6, 7, 8, 9), suivi de zéro ou plusieurs chiffres décimaux (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
int d = 42;
- littéral octal
C'est le chiffre zéro (0) suivi de zéro ou plusieurs chiffres octaux (0, 1, 2, 3, 4, 5, 6, 7)
int o = 052
- hex-littéral
C'est la séquence de caractères 0x ou la séquence de caractères 0X suivie d'un ou plusieurs chiffres hexadécimaux (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;
- littéral binaire (depuis C ++ 14)
C'est la séquence de caractères 0b ou la séquence de caractères 0B suivie d'un ou plusieurs chiffres binaires (0, 1)
int b = 0b101010; // C++14
Le suffixe d'entier, s'il est fourni, peut contenir l'un des deux ou les deux suivants (si les deux sont fournis, ils peuvent apparaître dans n'importe quel ordre:
- unsigned-suffix (le caractère u ou le caractère U)
unsigned int u_1 = 42u;
- suffixe long (le caractère l ou le caractère L) ou le long suffixe long (la séquence de caractères ll ou la séquence de caractères LL) (depuis C ++ 11)
Les variables suivantes sont également initialisées à la même valeur:
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
Remarques
Les lettres dans les littéraux entiers sont insensibles à la casse: 0xDeAdBaBeU et 0XdeadBABEu représentent le même nombre (une exception est le suffixe long-long, qui est soit ll ou LL, jamais lL ou Ll)
Il n'y a pas de littéral entier négatif. Des expressions telles que -1 appliquent l'opérateur unaire moins à la valeur représentée par le littéral, ce qui peut impliquer des conversions de types implicites.
Dans C avant C99 (mais pas dans C ++), les valeurs décimales non mappées qui ne rentrent pas dans long int peuvent avoir le type unsigned long int.
Lorsqu'elles sont utilisées dans une expression de contrôle de #if ou #elif, toutes les constantes entières signées agissent comme si elles avaient le type std :: intmax_t et toutes les constantes entières non signées agissent comme si elles avaient le type std :: uintmax_t.