Valori letterali numerici, booleani e puntatore

Un valore letterale è un elemento del programma che rappresenta direttamente un valore. Questo articolo illustra i valori letterali di tipo integer, a virgola mobile, booleano e puntatore. Per informazioni sui valori letterali stringa e carattere, vedere Valori letterali stringa e carattere (C++). È anche possibile definire valori letterali personalizzati in base a una di queste categorie. Per altre informazioni, vedere Valori letterali definiti dall'utente (C++).

È possibile usare i valori letterali in molti contesti, ma in genere vengono usati per inizializzare le variabili denominate e passare argomenti alle funzioni:

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

In alcuni casi è importante indicare al compilatore come interpretare un valore letterale o il tipo specifico da assegnare a tale valore. Questa operazione viene eseguita aggiungendo prefissi o suffissi al valore letterale. Ad esempio, il prefisso 0x indica al compilatore di interpretare il numero che lo segue come valore esadecimale, ad esempio 0x35. Il ULL suffisso indica al compilatore di considerare il valore come unsigned long long tipo, come in 5894345ULL. Per un elenco completo di prefissi e suffissi per ogni tipo di valore letterale, vedere le sezioni seguenti.

Valori letterali Integer

I valori letterali Integer iniziano con una cifra e non includono parti frazionarie o esponenti. È possibile specificare valori letterali integer in formato decimale, binario, ottale o esadecimale. Facoltativamente, è possibile specificare un valore letterale integer come senza segno e come tipo long o long usando un suffisso .

Quando non è presente alcun prefisso o suffisso, il compilatore darà un tipo di int valore letterale integrale (32 bit), se il valore verrà inserito, altrimenti darà il tipo long long (64 bit).

Per specificare un valore letterale integrale decimale, iniziare la specifica con un numero diverso da zero. Ad esempio:

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

Per specificare un valore letterale integrale ottale, iniziare la specifica con 0, seguito da una sequenza di cifre comprese nell'intervallo da 0 a 7. Le cifre 8 e 9 costituiscono errore nella specifica di un valore letterale ottale. Ad esempio:

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

Per specificare un valore letterale integrale esadecimale, iniziare la specifica con 0x o 0X (il caso di "x" non è rilevante), seguito da una sequenza di cifre nell'intervallo 0 tra 9 e a (o A) tra f (o F). Le cifre esadecimali da a (o A) a f (o F) rappresentano i valori compresi nell'intervallo da 10 a 15. Ad esempio:

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

Per specificare un tipo senza segno, usare il u suffisso o U . Per specificare un tipo long, usare il l suffisso o L . Per specificare un tipo integrale a 64 bit, usare il suffisso LL o ll. Il suffisso i64 è ancora supportato, ma non è consigliabile. È specifico di Microsoft e non è portatile. Ad esempio:

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

Separatori di cifre: è possibile usare il carattere virgolette singole (apostrofo) per separare i valori di posizione in numeri più grandi per renderli più facili da leggere per gli esseri umani. I separatori non hanno effetto sulla compilazione.

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

Valori letterali a virgola mobile

I valori letterali a virgola mobile specificano valori che devono avere una parte decimale. Questi valori contengono punti decimali (.) e possono contenere esponenti.

I valori letterali a virgola mobile hanno un significando (talvolta chiamato mantissa), che specifica il valore del numero. Hanno un esponente, che specifica la grandezza del numero. E hanno un suffisso facoltativo che specifica il tipo del valore letterale. Il significando viene specificato come sequenza di cifre seguita da un punto, seguita da una sequenza facoltativa di cifre che rappresenta la parte frazionaria del numero. Ad esempio:

18.46
38.

L'esponente, se presente, specifica la grandezza del numero come potenza di 10, come illustrato nell'esempio seguente:

18.46e0      // 18.46
18.46e1      // 184.6

L'esponente può essere specificato usando e o E, che hanno lo stesso significato, seguito da un segno facoltativo (+ o -) e da una sequenza di cifre. Se un esponente è presente, il separatore decimale finale è inutile in numeri interi come 18E0.

Per impostazione predefinita, i valori letterali a virgola mobile sono di tipo double. Usando i suffissi o o o (il suffisso f non fa distinzione tra maiuscole e minuscole), il valore letterale può essere specificato come float o long double.LFl

Anche se long double e double hanno la stessa rappresentazione, non sono dello stesso tipo. Ad esempio, è possibile avere funzioni di overload, ad esempio

void func( double );

e

void func( long double );

valori letterali booleani

I valori letterali booleani sono true e false.

Valore letterale puntatore (C + + 11)

C++ introduce il nullptr valore letterale per specificare un puntatore inizializzato zero. Nel codice portabile è nullptr consigliabile usare anziché macro di tipo integrale, ad esempio NULL.

Valori letterali binari (C++14)

È possibile specificare un valore letterale binario mediante il prefisso 0B o 0b, seguito da una sequenza di 1 e 0:

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

Evitare di usare i valori letterali come "costanti magiche"

È possibile usare i valori letterali direttamente in espressioni e istruzioni, anche se non è sempre una buona norma di programmazione:

if (num < 100)
    return "Success";

Nell'esempio precedente, una procedura migliore consiste nell'usare una costante denominata che trasmette un significato chiaro, ad esempio "MAXIMUM_ERROR_THRESHOLD". Se il valore restituito "Success" viene visualizzato dagli utenti finali, potrebbe essere preferibile usare una costante stringa denominata. È possibile mantenere costanti stringa in un'unica posizione in un file che può essere localizzato in altre lingue. L'uso di costanti denominate consente sia a se stessi che ad altri di comprendere la finalità del codice.

Vedi anche

Convenzioni lessicali
Valori letterali stringa C++
Valori letterali definiti dall'utente C++