Literais de ponteiro, numéricos e boolianos

Um literal é um elemento de programa que representa diretamente um valor. Este artigo aborda literais do tipo inteiro, ponto flutuante, booliano e ponteiro. Para obter informações sobre literais de cadeia de caracteres e caracteres, consulte Literais de cadeia de caracteres e caracteres (C++). Você também pode definir seus próprios literais com base em qualquer uma dessas categorias. Para obter mais informações, consulte Literais definidos pelo usuário (C++).

Você pode usar literais em muitos contextos, mas, geralmente, para inicializar variáveis nomeadas e passar argumentos para funções:

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

Às vezes, é importante dizer ao compilador como interpretar um literal ou qual tipo específico dar a ele. É feito acrescentando prefixos ou sufixos ao literal. Por exemplo, o prefixo 0x diz ao compilador que interprete o número que o segue como um valor hexadecimal, por exemplo 0x35. O sufixo ULL informa ao compilador para tratar o valor como um tipo unsigned long long, como em 5894345ULL. Consulte as seções a seguir para obter a lista completa de prefixos e sufixos para cada tipo literal.

Literais inteiros

Literais inteiros começam com um dígito e não têm partes fracionárias ou expoentes. Você pode especificar literais de inteiro no formato decimal, binário, octal ou hexadecimal. Opcionalmente, você pode especificar um literal inteiro como sem sinal e como um tipo longo ou longo longo usando um sufixo.

Quando nenhum prefixo ou sufixo estiver presente, o compilador fornecerá um tipo int de valor literal integral (32 bits), se o valor se ajustar, caso contrário, ele fornecerá o tipo long long (64 bits).

Para especificar um literal integral decimal, inicie a especificação com um dígito diferente de zero. Por exemplo:

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

Para especificar um literal integral octal, inicie a especificação com 0, seguido por uma sequência de dígitos no intervalo de 0 a 7. Os dígitos 8 e 9 são erros na especificação de uma constante octal. Por exemplo:

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

Para especificar um literal integral hexadecimal, inicie a especificação com 0x ou 0X (não importa se “x” é minúsculo ou maiúsculo), seguido por uma sequência de dígitos no intervalo de 0 a 9 e a (ou A) a f (ou F). Os dígitos hexadecimais de a (ou A) a f (ou F) representam valores no intervalo de 10 a 15. Por exemplo:

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

Para especificar um tipo sem sinal, use o sufixo u ou U. Para especificar um tipo longo, use o sufixo l ou L. Para especificar um tipo integral de 64 bits, use o sufixo LL ou ll. O sufixo i64 ainda tem suporte, mas não recomendamos. É específico da Microsoft e não é portátil. Por exemplo:

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

Separadores de dígitos: você pode usar o caractere de aspa única (apóstrofo) para separar valores de lugar em números maiores a fim de torná-los mais fáceis de ler para os humanos. Os separadores não têm nenhum efeito na compilação.

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

Literais de ponto flutuante

Os literais de ponto flutuante especificam os valores que devem ter uma parte fracionária. Esses valores contêm pontos decimais (.) e podem conter expoentes.

Literais de ponto flutuante têm um significand (às vezes chamado de mantissa), que especifica o valor do número. Eles têm um expoente, que especifica a magnitude do número. E eles têm um sufixo opcional que especifica o tipo do literal. O significand é especificado como uma sequência de dígitos seguida por um ponto final, seguidos por uma sequência opcional de dígitos que representa a parte fracionária do número. Por exemplo:

18.46
38.

O expoente, se presente, especifica a magnitude do número como uma potência de 10, como mostrado no seguinte exemplo:

18.46e0      // 18.46
18.46e1      // 184.6

O expoente pode ser especificado usando e ou E, que têm o mesmo significado, seguido por um sinal opcional (+ ou -) ou uma sequência de dígitos. Se um expoente estiver presente, o ponto decimal à direita é desnecessário em números inteiros como 18E0.

Os literais de ponto flutuante têm como padrão o tipo double. Usando os sufixos f ou l ou F ou L (o sufixo não diferencia maiúsculas de minúsculas), o literal pode ser especificado como float ou long double.

Embora long double e double tenham a mesma representação, eles não têm o mesmo tipo. Por exemplo, você pode ter funções sobrecarregadas, como

void func( double );

e

void func( long double );

Literais boolianos

Os literais boolianos são true e false.

Literal de ponteiro (C++11)

O C++ apresenta o literal nullptr para especificar um ponteiro inicializado em zero. No código portátil, nullptr deve ser usado em vez de zero de tipo integral ou macros como NULL.

Literais binários (C++14)

Um literal binário pode ser especificado pelo uso do prefixo 0B ou 0b, seguido por uma sequência de 1s e 0s:

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

Evite usar literais como "magic constants"

Você pode usar literais diretamente em expressões e instruções, embora nem sempre seja uma boa prática de programação:

if (num < 100)
    return "Success";

No exemplo anterior, uma prática melhor é usar uma constante nomeada que transmita um significado claro, por exemplo, "MAXIMUM_ERROR_THRESHOLD". E se o valor retornado "Sucesso" for visto pelos usuários finais, talvez seja melhor usar uma constante de cadeia de caracteres nomeada. Você pode manter constantes de cadeia de caracteres em um único local em um arquivo que pode ser localizado em outras linguagens. O uso de constantes nomeadas ajuda você e outras pessoas a entender a intenção do código.

Confira também

Convenções lexicais
Literais da cadeia de caracteres do C++
Literais definidas pelo usuário do C++