Literały numeryczne, wartości logicznych i wskaźników

Literał to element programu, który bezpośrednio reprezentuje wartość. W tym artykule opisano literały typu liczba całkowita, zmiennoprzecinkowa, wartość logiczna i wskaźnik. Aby uzyskać informacje na temat literałów ciągów i znaków, zobacz Ciąg i literały znaków (C++). Możesz również zdefiniować własne literały na podstawie dowolnej z tych kategorii. Aby uzyskać więcej informacji, zobacz Literały zdefiniowane przez użytkownika (C++).

Literałów można używać w wielu kontekstach, ale najczęściej do inicjowania nazwanych zmiennych i przekazywania argumentów do funkcji:

const int answer = 42;      // integer literal
double d = sin(108.87);     // floating point literal passed to sin function
bool b = true;              // boolean literal
MyClass* mc = nullptr;      // pointer literal

Czasami ważne jest, aby poinformować kompilator, jak interpretować literał lub jaki konkretny typ ma nadać. Odbywa się to przez dołączanie prefiksów lub sufiksów do literału. Na przykład prefiks 0x nakazuje kompilatorowi interpretowanie liczby, która następuje po niej jako wartość szesnastkowa, na przykład 0x35. Sufiks ULL informuje kompilator o traktowaniu wartości jako typu, jak w elemencie unsigned long long5894345ULL. Zobacz poniższe sekcje, aby uzyskać pełną listę prefiksów i sufiksów dla każdego typu literału.

Literały liczb całkowitych

Literały liczb całkowitych zaczynają się od cyfry i nie mają części ułamkowych ani wykładników. Można określić literały liczb całkowitych w postaci dziesiętnej, binarnej, ósemkowej lub szesnastkowej. Opcjonalnie można określić literał liczby całkowitej jako niepodpisany, a jako długi lub długi typ przy użyciu sufiksu.

Jeśli nie ma prefiksu lub sufiksu, kompilator da typ int wartości literału całkowitego (32 bity), jeśli wartość będzie pasować, w przeciwnym razie nada typowi long long (64 bity).

Aby określić literał całkowity dziesiętny, rozpocznij specyfikację cyfrą niezerową. Przykład:

int i = 157;        // Decimal literal
int j = 0198;       // Not a decimal number; erroneous octal literal
int k = 0365;       // Leading zero specifies octal literal, not decimal
int m = 36'000'000  // digit separators make large values more readable

Aby określić literał całkowitej ósemki, rozpocznij specyfikację od 0, a następnie sekwencję cyfr w zakresie od 0 do 7. Cyfry 8 i 9 to błędy podczas określania literału ósemkowego. Przykład:

int i = 0377;   // Octal literal
int j = 0397;   // Error: 9 is not an octal digit

Aby określić literał całkowity szesnastkowy, rozpocznij specyfikację 0x od lub 0X (wielkość liter "x" nie ma znaczenia), a następnie sekwencję cyfr w zakresie 0 przez 9 i a (lub ) do f (lub AF). Cyfry szesnastkowe od a (lub A) do f (lub F) reprezentują wartości z zakresu od 10 do 15. Przykład:

int i = 0x3fff;   // Hexadecimal literal
int j = 0X3FFF;   // Equal to i

Aby określić niepodpisany typ, użyj sufiksu u lub U . Aby określić typ długi, użyj sufiksu l lub L . Aby określić typ całkowity 64-bitowy, użyj sufiksu LL lub ll. Sufiks i64 jest nadal obsługiwany, ale nie zalecamy go. Jest on specyficzny dla firmy Microsoft i nie jest przenośny. Przykład:

unsigned val_1 = 328u;                  // Unsigned value
long val_2 = 0x7FFFFFL;                 // Long value specified
                                        //  as hex literal
unsigned long val_3 = 0776745ul;        // Unsigned long value
auto val_4 = 108LL;                           // signed long long
auto val_4 = 0x8000000000000000ULL << 16;     // unsigned long long

Separatory cyfr: można użyć znaku pojedynczego cudzysłowu (apostrofu), aby oddzielić wartości w większej liczbie, aby ułatwić im odczytywanie przez ludzi. Separatory nie mają wpływu na kompilację.

long long i = 24'847'458'121;

Literały zmiennoprzecinkowe

Literały zmiennoprzecinkowe określają wartości, które muszą mieć część ułamkową. Te wartości zawierają punkty dziesiętne (.) i mogą zawierać wykładniki.

Literały zmiennoprzecinkowe mają znakową (czasami nazywaną mantissa), która określa wartość liczby. Mają wykładnik, który określa wielkość liczby. Ponadto mają opcjonalny sufiks określający typ literału. Znak jest określany jako sekwencja cyfr, po której następuje kropka, a następnie opcjonalna sekwencja cyfr reprezentujących część ułamkową liczby. Przykład:

18.46
38.

Wykładnik, jeśli jest obecny, określa wielkość liczby jako moc 10, jak pokazano w poniższym przykładzie:

18.46e0      // 18.46
18.46e1      // 184.6

Wykładnik może być określony przy użyciu lub eE, które mają takie samo znaczenie, a następnie opcjonalny znak (+ lub -) i sekwencję cyfr. Jeśli wykładnik jest obecny, końcowy punkt dziesiętny jest niepotrzebny w liczbach całkowitych, takich jak 18E0.

Literały zmiennoprzecinkowe domyślnie wpisz double. Używając sufiksów f lub l lub LF (sufiks nie uwzględnia wielkości liter), literał można określić jako float lub long double.

Chociaż long double i double mają tę samą reprezentację, nie są one tego samego typu. Na przykład można mieć przeciążone funkcje, takie jak

void func( double );

oraz

void func( long double );

Literały logiczne

Literały logiczne to true i false.

Literał wskaźnika (C++11)

Język C++ wprowadza nullptr literał określający wskaźnik zainicjowany zero. W kodzie nullptr przenośnym należy użyć zamiast typu całkowitego zero lub makr, takich jak NULL.

Literały binarne (C++14)

Literał binarny można określić za pomocą prefiksu 0B lub 0b , po którym następuje sekwencja wartości 1 i 0:

auto x = 0B001101 ; // int
auto y = 0b000001 ; // int

Unikaj używania literałów jako "stałych magicznych"

Literały można używać bezpośrednio w wyrażeniach i instrukcjach, chociaż nie zawsze jest to dobra praktyka programowa:

if (num < 100)
    return "Success";

W poprzednim przykładzie lepszym rozwiązaniem jest użycie nazwanej stałej, która przekazuje wyraźne znaczenie, na przykład "MAXIMUM_ERROR_THRESHOLD". A jeśli zwracana wartość "Success" jest widoczna dla użytkowników końcowych, lepszym rozwiązaniem może być użycie nazwy stałej ciągu. Stałe ciągów można przechowywać w jednej lokalizacji w pliku, który można lokalizować w innych językach. Używanie nazwanych stałych pomaga samodzielnie i innym osobom zrozumieć intencję kodu.

Zobacz też

Konwencje leksykalne
Literały ciągów języka C++
Literały zdefiniowane przez użytkownika w języku C++