Zoeken…
Invoering
Traditioneel is een letterlijke uitdrukking een uitdrukking die een constante aanduidt waarvan het type en de waarde duidelijk blijken uit zijn spelling. 42 is bijvoorbeeld een letterlijke letter, terwijl x niet is, omdat men de verklaring moet zien om het type te kennen en eerdere coderegels moet lezen om de waarde ervan te kennen.
C ++ 11 heeft echter ook door de gebruiker gedefinieerde lettertypen toegevoegd , die geen letterlijke tekens in de traditionele zin zijn, maar die kunnen worden gebruikt als afkorting voor functieaanroepen.
waar
Een trefwoord dat een van de twee mogelijke waarden van het type bool aangeeft.
bool ok = true;
if (!f()) {
ok = false;
goto end;
}
vals
Een trefwoord dat een van de twee mogelijke waarden van het type bool aangeeft.
bool ok = true;
if (!f()) {
ok = false;
goto end;
}
nullptr
Een trefwoord dat een nulaanwijzerconstante aangeeft. Het kan worden geconverteerd naar elke aanwijzer of aanwijzer-naar-lid-type, wat een nulaanwijzer van het resulterende type oplevert.
Widget* p = new Widget();
delete p;
p = nullptr; // set the pointer to null after deletion
Merk op dat nullptr zelf geen aanwijzer is. Het type nullptr is een fundamenteel type dat bekend staat als 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
}
deze
Binnen een lidfunctie van een klasse is het sleutelwoord this een pointer naar de instantie van de klasse waarop de functie werd genoemd. this kan niet worden gebruikt in een statische lidfunctie.
struct S {
int x;
S& operator=(const S& other) {
x = other.x;
// return a reference to the object being assigned to
return *this;
}
};
Het type this hangt af van de cv-kwalificatie van de lidfunctie: als X::f const , dan is het type this in f const X* , dus this kan niet worden gebruikt om niet-statische gegevensleden te wijzigen vanuit een const lid functie. Evenzo neemt this volatile kwalificatie over van de functie waarin het voorkomt.
this kan ook worden gebruikt in een brace-of-equal-initializer voor een niet-statisch gegevenslid.
struct S;
struct T {
T(const S* s);
// ...
};
struct S {
// ...
T t{this};
};
this is een waarde, dus het kan niet worden toegewezen.
Integer letterlijk
Een letterlijk getal is een primaire uitdrukking van de vorm
- decimaal-letterlijke
Het is een niet-nul decimaal cijfer (1, 2, 3, 4, 5, 6, 7, 8, 9), gevolgd door nul of meer decimale cijfers (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
int d = 42;
- octal-letterlijke
Het is het cijfer nul (0) gevolgd door nul of meer octale cijfers (0, 1, 2, 3, 4, 5, 6, 7)
int o = 052
- hex-letterlijke
Het is de tekenreeks 0x of de tekenreeks 0X gevolgd door een of meer hexadecimale cijfers (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;
- binair-letterlijk (sinds C ++ 14)
Het is de tekenreeks 0b of de tekenreeks 0B gevolgd door een of meer binaire cijfers (0, 1)
int b = 0b101010; // C++14
Het geheel-achtervoegsel, indien opgegeven, kan een of beide van de volgende bevatten (als beide worden verstrekt, kunnen ze in elke volgorde verschijnen:
- unsigned-suffix (het karakter u of het karakter U)
unsigned int u_1 = 42u;
- lang-achtervoegsel (het teken l of het teken L) of het lang-lang-achtervoegsel (de tekenreeks ll of de tekenreeks LL) (sinds C ++ 11)
De volgende variabelen worden ook met dezelfde waarde geïnitialiseerd:
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
Notes
Letters in gehele getallen zijn niet hoofdlettergevoelig: 0xDeAdBaBeU en 0XdeadBABEu vertegenwoordigen hetzelfde nummer (één uitzondering is het lang-lang-achtervoegsel, dat is ll of LL, nooit lL of Ll)
Er zijn geen negatieve gehele getallen. Uitdrukkingen zoals -1 passen de unaire min-operator toe op de waarde die wordt voorgesteld door de letterlijke waarde, wat impliciete type conversies kan inhouden.
In C vóór C99 (maar niet in C ++) mogen niet-gecodeerde decimale waarden die niet in long int passen, het type unsigned long int hebben.
Bij gebruik in een controlerende expressie van #if of #elif werken alle ondertekende integer-constanten alsof ze het type std :: intmax_t hebben en alle niet-ondertekende integer-constanten doen alsof ze het type std :: uintmax_t hebben.