O tipo de uma constante do tipo inteiro é normalmente int, se o valor couber nesse tipo, mas aqui estão as regras completas. O tipo de uma constante do tipo inteiro é o primeiro nesta sequência que pode representar corretamente o valor:

• int

• unsigned int

• long int

• unsigned long int

• long long int

• unsigned long long int

E que não seja excluído pelas regras a seguir:

• Se a constante tiver o sufixo ‘l’ ou ‘L’, isso exclui os dois primeiros tipos (não longos).

• Se a constante tiver o sufixo ‘ll’ ou ‘LL’, isso exclui os primeiros quatro tipos (não long long).

• Se a constante tiver o sufixo ‘u’ ou ‘U’, isso exclui os tipos com sinal.

• Caso contrário, se a constante for decimal (não binária, octal ou hexadecimal), isso exclui os tipos sem sinal.

Exemplos de Sufixos:

3000000000u      // três bilhões como unsigned int.
0LL              // zero como long long int.
0403l            // 259 como long int.

Os sufixos em constantes do tipo inteiro são raramente usados. Quando o tipo preciso é importante, é mais claro converter explicitamente (veja Conversão de Tipo Explícita).

Veja Tipos de Dados Inteiros.

Uma constante do tipo inteiro consiste em um número que especifica o valor, seguido opcionalmente por sufixos para especificar o tipo de dado.

As constantes mais simples do tipo inteiro são números escritos na base 10 (decimal), como 5, 77 e 403. Uma constante decimal não pode começar com o caractere ‘0’ (zero), pois isso a tornaria uma constante octal.

Você pode obter o efeito de uma constante do tipo inteiro negativa colocando um sinal de menos no início. Em termos gramaticais, isso é uma expressão aritmética, e não uma constante, mas se comporta como uma constante verdadeira.

As constantes do tipo inteiro também podem ser escritas em octal (base 8), hexadecimal (base 16) ou binário (base 2).

• Uma constante octal começa com o caractere ‘0’ (zero), seguido por qualquer número de dígitos octais (‘0’ a ‘7’):

0      // zero
077    // 63
0403   // 259

Tecnicamente, a constante 0 é uma constante octal, mas podemos considerá-la decimal, pois o valor é o mesmo.

• Uma constante hexadecimal começa com ‘0x’ (maiúsculo ou minúsculo), seguido por dígitos hexadecimais (‘0’ a ‘9’, assim como ‘a’ até ‘f’ em maiúsculo ou minúsculo):

0xff   // 255
0XA0   // 160
0xffFF // 65535

• Uma constante binária começa com ‘0b’ (maiúsculo ou minúsculo), seguida por bits (cada um representado pelos caracteres ‘0’ ou ‘1’):

0b101  // 5

As constantes binárias são uma extensão do GNU C e não fazem parte do padrão C.

Às vezes, é necessário um espaço após uma constante do tipo inteiro para evitar confusão léxica com os tokens seguintes. Veja Números Inválidos.

Uma constante é uma expressão que representa um valor específico, representando explicitamente o valor desejado. C permite constantes para números, caracteres e strings. Já vimos constantes numéricas e de strings nos exemplos.

Um número complexo consiste em uma parte real mais uma parte imaginária. (Você pode omitir uma das partes se ela for zero.) Esta seção explica como escrever constantes numéricas com valores imaginários. Ao adicionar essas constantes a constantes numéricas de valor real ordinário, podemos criar constantes com valores complexos.

A forma simples de escrever uma constante numérica imaginária é anexar o sufixo ‘i’ ou ‘I’, ou ‘j’ ou ‘J’, a uma constante inteira ou de ponto flutuante. Por exemplo, 2.5fi tem o tipo _Complex float e 3i tem o tipo _Complex int. As quatro letras de sufixo alternativas são todas equivalentes.

A outra maneira de escrever uma constante imaginária é multiplicar uma constante real por _Complex_I, que representa o número imaginário i. O padrão C não suporta sufixos com ‘i’ ou ‘j’, então este método mais trabalhoso é necessário.

Para escrever uma constante complexa com uma parte real não nula e uma parte imaginária não nula, escreva as duas separadamente e as some, assim:

4.0 + 3.0i

Isso dá o valor 4 + 3i, com o tipo _Complex double.

Essa soma pode incluir várias constantes reais, ou nenhuma. Da mesma forma, pode incluir várias constantes imaginárias, ou nenhuma. Por exemplo:

_Complex double foo, bar, quux;

foo = 2.0i + 4.0 + 3.0i; /* A parte imaginária é 5.0. */
bar = 4.0 + 12.0; /* A parte imaginária é 0.0. */
quux = 3.0i + 15.0i; /* A parte real é 0.0. */

Veja Tipos de Dados Complexos.

Uma constante de ponto flutuante deve ter um ponto decimal, um expoente de dez, ou ambos; isso a distingue de uma constante do tipo inteiro.

Para indicar um expoente, use ‘e’ ou ‘E’. O valor do expoente segue em seguida, sempre como um número decimal; ele pode opcionalmente começar com um sinal. O expoente n significa multiplicar o valor da constante por dez elevado à potência n.

Assim, ‘1500.0’, ‘15e2’, ‘15e+2’, ‘15.0e2’, ‘1.5e+3’, ‘.15e4’ e ‘15000e-1’ são seis maneiras de escrever um número de ponto flutuante cujo valor é 1500. Todas são equivalentes em princípio.

Exemplos com Pontos Decimais:

1.0
1000.
3.14159
.05
.0005

Constantes Equivalentes com Expoentes:

1e0, 1.0000e0
100e1, 100e+1, 100E+1, 1e3, 10000e-1
3.14159e0
5e-2, .0005e+2, 5E-2, .0005E2
.05e-2

Uma constante de ponto flutuante normalmente tem o tipo double. Você pode forçá-la a ser do tipo float adicionando ‘f’ ou ‘F’ no final. Por exemplo:

3.14159f
3.14159e0f
1000.f
100E1F
.0005f
.05e-2f

Da mesma forma, adicionar ‘l’ ou ‘L’ no final força a constante a ser do tipo long double.

Você também pode usar expoentes em constantes de ponto flutuante em hexadecimal, mas como ‘e’ seria interpretado como um dígito hexadecimal, o caractere ‘p’ ou ‘P’ (de "potência") indica um expoente.

O expoente em uma constante de ponto flutuante hexadecimal é um inteiro decimal com sinal opcional que especifica uma potência de 2 (não 10 ou 16) a ser multiplicada no número.

Exemplos:

0xAp2        // 40 em decimal
0xAp-1       // 5 em decimal
0x2.0Bp4     // 32.6875 em decimal
0xE.2p3      // 113 em decimal
0x123.ABCp0  // 291.6708984375 em decimal
0x123.ABCp4  // 4666.734375 em decimal
0x100p-8     // 1
0x10p-4      // 1
0x1p+4       // 16
0x1p+8       // 256

Veja Tipos de Dados de Ponto Flutuante.

Uma constante de caractere é escrita com aspas simples, como em 'c'. No caso mais simples, c é um único caractere ASCII que a constante deve representar. A constante tem o tipo int, e seu valor é o código do caractere correspondente. Por exemplo, 'a' representa o código do caractere para a letra ‘a’: 97, no caso.

Para colocar o caractere ‘'’ (aspas simples) na constante de caractere, use a barra invertida (‘\’) como escape. Essa constante de caractere fica assim: '\''. A barra invertida aqui funciona como um caractere de escape, e tal sequência, começando com ‘\’, é chamada de sequência de escape.

Para colocar o caractere ‘\’ (barra invertida) na constante de caractere, use outra barra invertida como escape. Essa constante de caractere fica assim: '\\'.

Aqui estão todas as sequências de escape que representam caracteres específicos em uma constante de caractere. Os valores numéricos mostrados são os códigos ASCII correspondentes, como números decimais:

‘\e’ é uma extensão do GNU C; para seguir o padrão C, escreva ‘\33’. (O número após a barra invertida é octal.) Para especificar uma constante de caractere usando decimal, use um cast; por exemplo, (unsigned char) 27.

Você também pode escrever códigos de caracteres em octal e hexadecimal como ‘\octalcode’ ou ‘\xhexcode’. Decimal não é uma opção aqui, então códigos octais não precisam começar com ‘0’.

O valor da constante de caractere tem o tipo int. No entanto, o código do caractere é tratado inicialmente como um valor do tipo char, que é então convertido para int. Se o código do caractere for maior que 127 (0177 em octal), o int resultante pode ser negativo em uma plataforma onde o tipo char tem 8 bits e é com sinal.

Uma constante do tipo string representa uma série de caracteres. Ela começa com ‘"’ e termina com ‘"’; entre esses delimitadores estão os conteúdos da string. Caracteres especiais como ‘"’, ‘\’ e nova linha podem ser escapados nas constantes do tipo string da mesma forma que nas constantes de caracteres. Em uma constante do tipo string, ‘'’ não precisa ser escapado.

Uma constante do tipo string define um array de caracteres que contém os caracteres especificados seguidos pelo caractere nulo (código 0). Usar a constante do tipo string é equivalente a usar o nome de um array com esses conteúdos. Em casos simples, onde não há sequências de escape com barra invertida, o comprimento em bytes da constante do tipo string é igual ao número de caracteres escritos nela mais um (para o caractere nulo).

Como acontece com qualquer array em C, usar a constante do tipo string em uma expressão converte o array em um ponteiro (veja Ponteiros) para o elemento zero do array (veja Acessando Elementos de Arrays). Esse ponteiro terá o tipo char * porque aponta para um elemento do tipo char. char * é um exemplo de designador de tipo para um tipo de ponteiro (veja Designadores de Tipo para Ponteiros). Esse tipo é usado para strings em geral, não apenas para strings expressas como constantes em um programa.

Assim, a constante do tipo string "Foo!" é quase equivalente a declarar um array como este:

E então usar string_array_1 no programa. No entanto, existem duas diferenças:

1. A constante do tipo string não define um nome para o array.

2. A constante do tipo string provavelmente será armazenada em uma área de memória somente leitura.

Novas linhas não são permitidas no texto de uma constante do tipo string. O motivo para essa proibição é detectar o erro de omitir o ‘"’ de fechamento. Para inserir uma nova linha em uma constante do tipo string, escreva-a como ‘\n’ na constante do tipo string.

Um caractere nulo real no código fonte dentro de uma constante do tipo string gera um aviso (warning) do compilador. Para colocar um caractere nulo no meio de uma constante do tipo string, escreva ‘\0’ ou ‘\000’.

Constantes do tipo string consecutivas são efetivamente concatenadas. Assim,

Isso é útil para escrever uma string que contém várias linhas, como esta:

A sequência de uma barra invertida e uma nova linha é ignorada em qualquer lugar de um programa C, inclusive dentro de uma constante do tipo string. Assim, você pode escrever constantes do tipo string em várias linhas desta forma:

No entanto, a concatenação é a forma recomendada de fazer isso.

Você também pode escrever constantes do tipo string "estranhas" como esta:

Mas não faça isso—escreva assim:

Tome cuidado para não passar uma constante do tipo string para uma função que modifica a string recebida. A memória onde a constante do tipo string está armazenada pode ser somente leitura, o que causaria um sinal fatal SIGSEGV, normalmente terminando a função (veja Sinais). Ainda pior, a memória pode não ser somente leitura. Nesse caso, a função poderia modificar a constante do tipo string, prejudicando o conteúdo de outras constantes do tipo string que deveriam conter o mesmo valor e foram unificadas pelo compilador.

Você também pode usá-los em constantes do tipo caractere largo (veja Constantes do Tipo Caractere Largo), como neste exemplo:

E em constantes do tipo string larga (veja Constantes do Tipo String Larga), como neste exemplo:

Além disso, você pode usar esses códigos em um identificador:

Uma constante do tipo caractere largo (wide char) representa caracteres com mais de 8 bits no código do caractere. Esta é uma funcionalidade pouco comum que precisamos documentar, mas que provavelmente você nunca usará. Se você está apenas aprendendo C, pode ignorar esta seção.

A constante original do tipo caractere largo em C é escrita como ‘L’ (maiúscula!) seguida imediatamente por uma constante de caractere comum (sem espaço intermediário). Seu tipo de dado é wchar_t, que é um alias definido em stddef.h para um dos tipos de inteiro padrão. Dependendo da plataforma, pode ser de 16 bits ou 32 bits. Se for de 16 bits, essas constantes de caractere usam a forma UTF-16 do Unicode; se forem de 32 bits, usam o UTF-32.

Também existem constantes Unicode do tipo caractere largo que especificam explicitamente a largura. Essas constantes começam com ‘u’ ou ‘U’ em vez de ‘L’. O prefixo ‘u’ especifica uma constante Unicode de 16 bits, e o prefixo ‘U’ especifica uma constante Unicode de 32 bits. Seus tipos são, respectivamente, char16_t e char32_t; esses tipos são declarados no arquivo de cabeçalho uchar.h. Essas constantes de caractere são válidas mesmo se uchar.h não for incluído, mas alguns usos podem ser inconvenientes sem incluir o cabeçalho para declarar esses nomes de tipo.

O caractere representado em uma constante do tipo caractere largo pode ser um caractere ASCII comum. L'a', u'a' e U'a' são todos válidos e todos iguais a 'a'.

Em todos os três tipos de constantes do tipo caractere largo, você pode escrever diretamente um caractere Unicode não ASCII na constante; o valor da constante será o código Unicode do caractere. Ou você pode especificar o caractere Unicode com uma sequência de escape (veja Códigos de Caracteres Unicode).

Escrever ‘u8’ imediatamente antes de uma constante do tipo string, sem espaço intermediário, significa representar essa string na codificação UTF-8 como uma sequência de bytes. O UTF-8 representa caracteres ASCII com um único byte e representa caracteres Unicode não ASCII (códigos 128 e acima) como sequências de múltiplos bytes. Aqui está um exemplo de uma constante do tipo string UTF-8:

u8"A cónstàñt"

Essa constante ocupa 13 bytes mais o caractere nulo de terminação, porque cada uma das letras acentuadas é uma sequência de dois bytes.

Concatenar uma string comum com uma string UTF-8 conceitualmente produz outra string UTF-8. No entanto, se a string comum contiver códigos de caracteres 128 ou superiores, os resultados não podem ser considerados confiáveis.

Uma constante do tipo string larga (wide string) representa um array de caracteres de 16 bits ou 32 bits. Elas são raramente usadas; se você está apenas aprendendo C, pode ignorar esta seção.

Existem três tipos de constantes do tipo string larga, que diferem no tipo de dado usado para cada caractere na string. Cada constante desse tipo é equivalente a um array de números inteiros, mas o tipo desses inteiros depende do tipo específico da constante. Quando utilizada em uma expressão, a constante será convertida em um ponteiro para o primeiro elemento do array, como ocorre normalmente com arrays em C (veja Acessando Elementos de um Array). Para cada tipo de constante do tipo string larga, indicamos aqui o tipo desse ponteiro.

char16_t Este é um tipo de constante do tipo string Unicode de 16 bits: cada elemento é um código de caractere Unicode de 16 bits com o tipo char16_t, de forma que a string possui o tipo de ponteiro char16_t *. (Este é um designador de tipo; veja Designadores de Tipo para Ponteiros.) A constante é escrita como ‘u’ (em letra minúscula) seguida (sem espaço intermediário) de uma constante do tipo string com a sintaxe usual.

char32_t Este é um tipo de constante do tipo string Unicode de 32 bits: cada elemento é um código de caractere Unicode de 32 bits, e a string possui o tipo char32_t *. A constante é escrita como ‘U’ (em letra maiúscula) seguida (sem espaço intermediário) de uma constante do tipo string com a sintaxe usual.

wchar_t Este é o tipo original de constante do tipo string larga. A constante é escrita como ‘L’ (em letra maiúscula) seguida (sem espaço intermediário) de uma constante do tipo string com a sintaxe usual, e a string possui o tipo wchar_t *.

A largura do tipo de dado wchar_t depende da plataforma de destino, o que torna esse tipo de string larga um pouco menos útil em comparação com os tipos mais novos.

Os tipos char16_t e char32_t são declarados no cabeçalho uchar.h. O tipo wchar_t é declarado no cabeçalho stddef.h.

Constantes consecutivas do tipo string larga do mesmo tipo se concatenam, assim como constantes do tipo string comuns. Uma constante do tipo string larga concatenada com uma constante do tipo string comum resulta em uma constante do tipo string larga. No entanto, não é possível concatenar duas constantes do tipo string larga de tipos diferentes. Além disso, não é possível concatenar uma constante do tipo string larga (de qualquer tipo) com uma constante do tipo string UTF-8.