Primeiros programas em C: tipos, operadores e laços

Um programa em C começa como texto simples e é executado como código de máquina. O compilador conecta essas duas formas. Salvar uma edição altera o código-fonte; isso não altera o executável gerado anteriormente.

Leia um programa completo

Salve isto como hello.c:

#include <stdio.h>

int main(void)
{
    printf("Hello, world!\n");
    return 0;
}

#include <stdio.h> disponibiliza declarações para entrada e saída padrão, incluindo printf. A execução começa em main. Em int main(void), int nomeia o tipo de retorno e void significa que não há parâmetros. As chaves delimitam o corpo. A chamada a printf escreve o texto entre aspas; \n passa para uma nova linha. return 0; encerra o programa e informa sucesso ao sistema operacional. Um código diferente de zero pode informar falha. Desde C99, chegar ao fim de main também retorna zero.

Instruções simples terminam com ponto e vírgula. A linha de inclusão não. C diferencia maiúsculas de minúsculas: Printf e printf são nomes diferentes. Espaços entre tokens geralmente não afetam o programa, mas uma indentação consistente torna visível a estrutura dos blocos.

Compile e depois execute

No terminal, abra a pasta que contém o código-fonte e digite:

gcc -std=c17 -Wall -Wextra hello.c -o hello
./hello

O primeiro comando gera um executável chamado hello; o segundo o executa a partir da pasta atual. Sua saída é Hello, world!, seguida de uma nova linha. Você pode usar clang no lugar de gcc. Sem -o hello, o nome usual da saída no Linux ou macOS é a.out. Executáveis do Windows usam .exe. O make hello do CS50 é um atalho que solicita à ferramenta de compilação que invoque o compilador.

Depois de alterar a saudação, salve, compile novamente e execute outra vez. Se a compilação falhar, um executável antigo ainda pode estar presente. Executá-lo mostra o comportamento antigo, portanto verifique se a compilação foi bem-sucedida antes de avaliar sua edição.

O que a compilação faz

O pré-processador trata diretivas como #include, inserindo o texto do cabeçalho. O compilador propriamente dito traduz C para linguagem de montagem. O montador produz código-objeto, que ainda pode conter nomes não resolvidos. O ligador combina o código-objeto e resolve referências como printf. O código de biblioteca pode ser copiado para um executável por ligação estática ou fornecido por uma biblioteca compartilhada carregada quando o programa é executado.

Você pode interromper a compilação em etapas intermediárias:

Um arquivo-objeto ainda não é o executável final. Um executável pode funcionar sem o compilador, mas é gerado para um sistema operacional e um processador específicos. Para levar o programa a outra plataforma, compile o código-fonte nela.

Comentários e versões da linguagem

// inicia um comentário que termina na nova linha. /* ... */ pode abranger várias linhas, mas esses comentários não podem ser aninhados: o primeiro */ encerra o comentário. Use comentários para explicar uma decisão que o código, por si só, não esclarece.

Selecione explicitamente a versão da linguagem. C17 dá suporte aos exemplos acima, incluindo comentários //, long long e declarações em cabeçalhos de for. C23 acrescenta recursos como bool como palavra-chave; foi publicado como ISO/IEC 9899:2024. -Wall -Wextra ativa avisos úteis. Os padrões dos compiladores variam, portanto um -std=c17 explícito deixa claras as regras pretendidas para a linguagem.

O momento em que um problema aparece ajuda a encontrar sua causa. Um programa pode falhar na compilação, parar durante a execução ou terminar com a resposta errada. Essas situações exigem verificações diferentes.

Diferencie os tipos de problema

Um aviso pode identificar código inválido ou comportamento indefinido, além de um erro comum. Uma compilação bem-sucedida não garante um programa correto.

Leia um diagnóstico

Uma mensagem do compilador normalmente fornece uma localização no código-fonte, uma gravidade e uma descrição. Uma mensagem como hello.c:5:16: error: expected ';' after expression aponta para a falta de um ponto e vírgula perto da linha 5. Às vezes, o compilador percebe o problema na linha seguinte. Examine a linha indicada e a imediatamente anterior.

Corrija primeiro o primeiro erro e compile novamente. Uma aspa não fechada pode fazer linhas posteriores parecerem parte de uma cadeia de caracteres; uma chave sem par pode fazer declarações posteriores parecerem estar no bloco errado. Várias mensagens podem desaparecer após uma correção. Não comece alterando todas as linhas mencionadas na saída.

Para este trecho:

int total = 6
printf("%d\n", total);

A declaração precisa de um ponto e vírgula após 6. A linha de printf pode ser onde o compilador detecta pela primeira vez que a declaração anterior não terminou. Verifique também a escrita exata, o pareamento de parênteses e chaves e o cabeçalho que declara uma função de biblioteca. Uma chamada a printf precisa de <stdio.h>; chamadas a funções não declaradas não são permitidas em C99 e versões posteriores.

Leve os avisos a sério

Compile com -Wall -Wextra. Essas opções ajudam a detectar uma atribuição em uma condição, variáveis não usadas, comparações entre valores com e sem sinal e formatos de saída incompatíveis. Por exemplo, printf("%d\n", 3.5); solicita um inteiro, mas passa um double; o formato não converte o argumento para você. Corrija o formato para %f ou converta o valor deliberadamente. -Werror faz os avisos interromperem a compilação.

Entenda o comportamento indefinido

Comportamento indefinido significa que C não impõe requisitos ao comportamento do programa. Estouro de inteiro com sinal, divisão inteira por zero e algumas leituras de variáveis não inicializadas podem causá-lo. Um programa pode parar, imprimir um valor inesperado ou parecer funcionar. As configurações do compilador podem mudar o que acontece.

Uma mensagem como “Floating point exception” pode até resultar de uma divisão inteira por zero em alguns sistemas. Diagnostique a operação e a entrada, não apenas as palavras de uma mensagem do sistema operacional. Verifique o divisor antes de executar a divisão.

Rastreie um resultado incorreto

Para um erro de lógica, preveja um caso pequeno à mão e compare-o com a saída real. Acrescente chamadas temporárias a printf para mostrar um total acumulado ou o valor testado por uma condição. Altere uma causa de cada vez e compile novamente após cada alteração. Teste valores comuns e limites como zero, um, uma entrada negativa e a maior entrada esperada. Um rastreamento mostra onde o programa diverge pela primeira vez da sua previsão.

Uma variável dá nome a um valor armazenado. Seu tipo informa a C como interpretar esse armazenamento. Você declara o tipo antes de usar a variável, e ela mantém esse tipo durante todo o seu tempo de vida.

Dê um valor inicial a cada variável

int count = 0;
double length_m = 1.8;
count = count + 1;

As duas primeiras linhas declaram e inicializam variáveis. A terceira atribui um novo valor a uma variável existente: ela lê o valor atual de count, soma um e armazena o resultado novamente. A atribuição é uma ação, portanto count = count + 1 faz sentido, embora não fosse uma equação matemática.

A inicialização ocorre em uma declaração; a atribuição pode ocorrer depois. Em int a, b = 5;, apenas b é inicializada. Uma variável local a tem valor indeterminado até que você armazene um valor nela. Sua leitura pode produzir comportamento imprevisível, incluindo comportamento indefinido. Inicialize contadores e totais ao declará-los, como em int total = 0;.

A atribuição copia o valor naquele momento:

int width = 4;
int area = width * 3;
width = 7;
printf("%d %d\n", width, area);

Isso imprime 7 12. A atribuição a area calculou 12 uma vez. Ela não criou uma fórmula que recalcula sempre que width muda. Para atualizar area, atribua a ela um novo cálculo.

Escolha nomes legíveis

Um identificador pode conter letras, algarismos e sublinhados, mas não pode começar com um algarismo nem ser uma palavra-chave. height_cm e second_place são válidos; 2nd_place não é, e my-score é interpretado como subtração. Nomes diferenciam maiúsculas de minúsculas, portanto total e Total são diferentes. Nomes que incluem um significado ou uma unidade facilitam a análise de fórmulas.

Respeite o escopo de bloco

Um nome local está disponível desde sua declaração até o fim de seu bloco. Desde C99, declarações podem aparecer entre outras instruções.

int count = 2;
{
    int count = 9;
    printf("%d\n", count);
}
printf("%d\n", count);

A declaração interna oculta o nome externo enquanto esse bloco é executado. A saída é 9 e depois 2, em linhas separadas. São duas variáveis, não duas atribuições a uma variável. Declarar o mesmo nome duas vezes em um bloco é um erro. Reutilizar nomes em blocos aninhados é permitido, mas dificulta o acompanhamento do código; portanto, prefira nomes que deixem clara cada função.

Dê nomes a valores fixos

const int SECONDS_PER_MINUTE = 60;
#define MAX_HEIGHT 8

const cria uma variável tipada à qual não se pode atribuir um novo valor por esse nome. Uma instrução posterior SECONDS_PER_MINUTE = 90; exige um diagnóstico. O inicializador fornece o valor fixo na declaração.

#define cria uma substituição do pré-processador: ocorrências posteriores de MAX_HEIGHT são substituídas pelo token 8 antes da compilação. Não há = nem ponto e vírgula nessa diretiva. Um ponto e vírgula passaria a fazer parte da substituição e poderia invalidar uma expressão como height > MAX_HEIGHT.

Um nome como SECONDS_PER_MINUTE informa ao leitor por que 60 aparece em um cálculo e oferece um único lugar para manter esse valor. Letras maiúsculas são uma convenção de nomenclatura, não uma regra que torna um valor constante. A declaração ou diretiva fornece esse comportamento.

Tipos inteiros armazenam números inteiros exatamente dentro de uma faixa fixa. Escolha um tipo pelos valores que o programa precisa tratar, incluindo resultados intermediários, e por fazerem ou não sentido valores negativos.

Tamanhos e faixas

O padrão garante larguras mínimas: pelo menos 8 bits para char, 16 para short e int, 32 para long e 64 para long long. Cada tipo nessa sequência tem pelo menos a largura do anterior. Os tamanhos reais dependem da plataforma.

sizeof(int) informa o tamanho em bytes como um size_t; imprima-o com %zu. O cabeçalho <limits.h> fornece nomes como INT_MIN, INT_MAX, UINT_MAX, LLONG_MAX e CHAR_BIT, o número de bits por byte.

Com N bits de valor, um inteiro sem sinal tem valores de 0 a 2ᴺ − 1. Um inteiro com sinal em complemento de dois com N bits varia de −2ᴺ⁻¹ a 2ᴺ⁻¹ − 1. Assim, um int de 32 bits varia de −2.147.483.648 a 2.147.483.647, enquanto um unsigned int de 32 bits chega a 4.294.967.295. C23 exige complemento de dois; C17 também permitia outras representações.

Em um padrão de complemento de dois de 8 bits, o bit mais significativo tem peso −128. 11111111 representa −1, e 10000000 representa −128. Para formar −5, comece com 00000101, inverta os bits para 11111010 e some um para obter 11111011.

Caracteres também são inteiros

Um char armazena um código de caractere em um byte. Use aspas simples para uma constante de caractere, como em 'A'. Em ASCII, 'A' tem código 65 e '0' tem código 48. printf("%c %d\n", 'A', 'A'); imprime A 65 em ASCII. Uma constante de caractere em C tem tipo int, portanto sizeof('A') é sizeof(int).

char sem qualificador pode ter ou não sinal, dependendo da implementação. Use signed char ou unsigned char quando a faixa numérica for importante. <stdint.h> oferece tipos inteiros de largura exata, como int32_t e uint8_t, em plataformas que dão suporte a essas larguras exatas; as plataformas mais comuns dão esse suporte.

Leia literais inteiros

Uma constante decimal como 42 tem tipo int quando cabe nele. Sufixos solicitam outros tipos: 42u é sem sinal, 42L é long, 42LL é long long e 42ULL é unsigned long long. Hexadecimal usa 0x, como em 0x2A. Um zero inicial indica octal: 052 também significa 42, e 010 significa 8. 09 é um octal inválido. C23 acrescenta notação binária, como 0b101010.

Valores lógicos e escolha de tipo

Em C17, inclua <stdbool.h> para usar bool, true e false; C23 os torna palavras-chave. Uma conversão para bool resulta em falso para zero e verdadeiro para todo valor diferente de zero, incluindo 0.5. Imprima um valor booleano com %d para ver 0 ou 1.

Use int para contagens comuns e contadores de laço. Use long long ou um tipo de largura exata adequado quando a faixa puder exceder cerca de 2,1 bilhões. Tipos sem sinal são adequados para padrões de bits, mas uma subtração abaixo de zero sofre redução modular para um valor grande, portanto eles ainda precisam de verificações de faixa.

Um tipo de ponto flutuante armazena uma aproximação de um número real. Ele tem uma faixa ampla, mas apenas um número fixo de algarismos significativos. Faixa e precisão respondem a perguntas diferentes: qual pode ser a magnitude de um valor e quão bem valores próximos podem ser distinguidos.

Escolha um tipo de ponto flutuante

Em sistemas IEEE 754 comuns, float ocupa 4 bytes e oferece cerca de 6–7 algarismos decimais significativos. double ocupa 8 bytes e oferece cerca de 15–16. Seus maiores valores finitos são aproximadamente 3,4 × 10³⁸ e 1,8 × 10³⁰⁸. long double é pelo menos tão preciso quanto double, com formato dependente da plataforma. double é uma escolha padrão útil para grandezas medidas.

Constantes como 2.0, 3.14 e 1e-3 são double; 1e-3 significa 0,001. Acrescente f para float, como em 2.5f, ou L para long double. A constante 2 é um inteiro, portanto pode resultar em divisão inteira onde 2.0 produziria divisão de ponto flutuante.

Observe a aproximação armazenada

Muitas frações decimais não têm uma forma binária finita exata. Em um sistema comum de precisão dupla:

printf("%.20f\n", 0.1);
printf("%.17f\n", 0.1 + 0.2);

As saídas são 0.10000000000000000555 e 0.30000000000000004. Os algarismos adicionais mostram a aproximação armazenada. Eles explicam por que 0.1 + 0.2 == 0.3 pode ser falso.

Use uma tolerância ao comparar medidas calculadas:

#include <math.h>
/* inside main */
if (fabs(a - b) < 1e-9) {
    printf("Close enough\n");
}

fabs retorna uma diferença absoluta. Escolha a tolerância de acordo com a escala e a precisão dos valores; 1e-9 é um exemplo, não uma configuração universal. Algumas compilações no Linux precisam de -lm ao final do comando do compilador para ligar as funções matemáticas.

A precisão afeta números inteiros grandes

Um double binário representa exatamente todos os inteiros até 2⁵³. Um float binário deixa de representar todos os inteiros acima de 2²⁴ = 16.777.216: atribuir 16.777.217 a esse float resulta em 16.777.216. Uma faixa maior não significa que todos os incrementos inteiros permaneçam disponíveis.

A impressão arredonda o valor binário armazenado. printf("%.2f\n", 2.675); geralmente imprime 2.67, pois o valor armazenado é um pouco menor que 2,675. Para quantias exatas em centavos inteiros, use um inteiro como long long cents = 1999; e formate a exibição ao final.

Converta e arredonde deliberadamente

A conversão para inteiro descarta a fração em direção a zero: (int)3.99 é 3, e (int)-3.99 é −3. round de <math.h> retorna um valor de ponto flutuante arredondado para o inteiro mais próximo, com valores intermediários afastados de zero: round(-2.5) resulta em −3,0. Converta esse resultado para inteiro somente quando ele couber no tipo. Uma conversão de ponto flutuante para inteiro cuja parte inteira esteja fora da faixa tem comportamento indefinido.

Na aritmética IEEE, resultados fora da faixa finita podem tornar-se infinito. Uma divisão de ponto flutuante de um valor diferente de zero por zero pode produzir infinito; zero dividido por zero produz NaN, que significa “não é um número”. Um NaN é considerado diferente até de si mesmo em uma comparação. Esses são comportamentos de ponto flutuante IEEE; a divisão inteira por zero tem comportamento indefinido.

printf transforma valores em texto usando uma cadeia de formatação. Caracteres comuns são impressos como escritos. Uma conversão que começa com % informa como exibir o próximo argumento.

Faça cada conversão corresponder ao argumento

printf("%d samples, %.2f kg\n", 4, 1.5);

Isso imprime 4 samples, 1.50 kg e uma nova linha. As conversões correspondem aos argumentos em ordem. Um formato não converte o tipo do argumento fornecido para o tipo que você pretendia.

Um argumento float é promovido a double em printf, portanto ambos usam %f; %lf é equivalente aqui. Passar 3 para %f é uma incompatibilidade de tipo, não uma solicitação para imprimir 3.0. Use 3.0 ou (double)3. Um tipo incompatível ou um argumento ausente pode causar comportamento indefinido. Compile com avisos ativados para que literais de cadeia de formatação sejam verificados.

Defina largura e precisão

Uma largura é um número mínimo de caracteres, incluindo sinal e ponto decimal. Uma precisão de ponto flutuante após o ponto controla as casas decimais de %f. Em %8.2f, oito é a largura mínima e dois é o número de casas após o ponto decimal. Um número mais largo é impresso por completo; a largura não o corta.

Com o inteiro 42, %5d produz 42, %-5d produz 42 , %05d produz 00042 e %+d produz +42. Sem uma precisão, %f imprime seis casas decimais.

printf("%-6s%8s\n", "Item", "Price");
printf("%-6s%8.2f\n", "Tea", 2.5);
printf("%-6s%8.2f\n", "Cake", 12.75);

Cada rótulo ocupa um campo de seis caracteres alinhado à esquerda, seguido de um campo de preço de oito caracteres alinhado à direita. Ambos os preços têm duas casas decimais, portanto seus pontos decimais ficam alinhados. Os espaços vêm das larguras de campo, não de uma separação automática entre argumentos.

Exibições científica e geral

%e usa notação científica: 12345,678 é impresso como 1.234568e+04 na precisão padrão. Para %g, a precisão conta algarismos significativos, com seis por padrão. Ele usa notação científica quando o expoente decimal é menor que −4 ou pelo menos igual à precisão e remove zeros à direita. Assim, %g imprime 0,0001 como 0.0001, 0,00001 como 1e-05 e 1000000,0 como 1e+06. Ele não escolhe simplesmente a forma mais curta possível.

Imprima caracteres especiais

Dentro de uma cadeia de caracteres em C, \n significa nova linha, \t significa tabulação, \\ significa uma barra invertida e \" significa uma aspa. Um sinal de porcentagem em um formato é %%: printf("100%%\n"); imprime 100% e uma nova linha.

printf não acrescenta espaços nem quebras de linha por conta própria. printf("Count:"); printf("%d", 4); imprime Count:4. Um terminal pode atrasar a exibição de texto sem uma nova linha; fflush(stdout); envia uma solicitação pendente antes de pedir a entrada.

scanf lê texto, converte-o e armazena valores em variáveis. Verifique seu resultado antes de usar essas variáveis. Um texto que começa com algarismos pode ser aceito apenas em parte, portanto uma conversão bem-sucedida e uma linha de entrada totalmente válida são coisas diferentes.

Forneça um destino do tipo correto

int count;
double mass_kg;
if (scanf("%d %lf", &count, &mass_kg) != 2) {
    return 1;
}

O & passa o endereço de cada variável para que scanf possa armazenar nela. %d precisa de um int, %u de um inteiro sem sinal, %ld de um long e %lld de um long long. Para entrada de ponto flutuante, %f precisa de um float e %lf de um double. Ao contrário de printf, essas duas conversões não são intercambiáveis. Um & ausente ou um tipo de destino incorreto pode causar comportamento indefinido.

%d lê em decimal. %i também reconhece entrada hexadecimal e octal com zero inicial; com %i, o texto “010” significa 8. Use %d para contagens decimais comuns.

Verifique o valor de retorno

scanf retorna o número de atribuições concluídas. Para dois valores solicitados, sucesso significa 2. Uma conversão malsucedida deixa seu destino inalterado. Ele ainda pode estar não inicializado, portanto não o use a menos que a contagem de retorno confirme o sucesso. EOF significa que a entrada terminou ou que ocorreu um erro de entrada antes da conclusão da primeira conversão.

Para scanf("%d:%d", &h, &m), os dois-pontos devem aparecer literalmente. A entrada “14:30” preenche ambas as variáveis. A entrada “14 30” preenche h, depois falha ao encontrar os dois-pontos e deixa m inalterada. O valor de retorno é 1.

Entenda espaços em branco e entradas parciais

Conversões numéricas ignoram espaços, tabulações e novas linhas iniciais. %c lê o próximo caractere, incluindo uma nova linha que tenha restado. Use scanf(" %c", &choice) para ignorar caracteres de espaço em branco antes de ler um caractere visível. Evite uma nova linha no final do formato: ela pode fazer a chamada aguardar um caractere posterior que não seja espaço em branco.

Com %d, “12abc” armazena 12 e deixa “abc” sem ler. “3.7” armazena 3 e deixa “.7”. “abc” não armazena nada e retorna 0. Chamar a mesma conversão novamente sem consumir a entrada inválida pode falhar para sempre no mesmo caractere.

Recupere-se de uma conversão malsucedida

int n, result;
while ((result = scanf("%d", &n)) != 1) {
    if (result == EOF) {
        return 1;
    }
    int ch;
    while ((ch = getchar()) != '\n' && ch != EOF) {
    }
    printf("Try again: ");
    fflush(stdout);
}

getchar retorna um int, o que permite representar tanto um caractere quanto EOF. O laço interno descarta a linha em que houve falha. O laço externo tenta novamente, mas ainda aceita um prefixo numérico como 12 em “12abc”. Exigir que o próximo caractere seja '\n' verifica a regra mais restrita de um inteiro imediatamente seguido de uma nova linha; essa regra também rejeita espaços finais. Uma regra que permita espaços ou uma última linha terminada em EOF precisa tratá-los explicitamente.

Após uma conversão bem-sucedida, verifique a faixa permitida, como de 1 a 8 para uma configuração de altura. scanf não rejeita com segurança um valor numérico fora da faixa: um valor grande demais para seu destino tem comportamento indefinido. Use entradas de teste que caibam no tipo escolhido. Para calcular um resultado como massa dividida pela altura ao quadrado, valide medidas positivas e mantenha o quadrado agrupado como height_m * height_m.

Toda expressão em C tem um valor e um tipo. O tipo determina como uma operação funciona. A divisão inteira, por exemplo, não consegue preservar um resultado fracionário, mesmo que você o armazene depois em uma variável de ponto flutuante.

Quocientes e restos

+, - e * somam, subtraem e multiplicam. / divide, e % fornece um resto inteiro. Multiplicação, divisão e resto têm precedência maior que adição e subtração.

Quando ambos os operandos da divisão são inteiros, C trunca o quociente em direção a zero. 17 / 5 é 3, -7 / 2 é −3 e 7 / -3 é −2. O resto satisfaz a identidade da divisão: multiplicar o quociente pelo divisor e somar o resto resulta no dividendo. Assim, -7 % 2 é −1 e 7 % -3 é 1. Um resto diferente de zero tem o sinal do dividendo.

Para verificar se um número é par, use n % 2 == 0. Para verificar se um inteiro positivo ou negativo é ímpar, use n % 2 != 0; verificar se é exatamente 1 não detecta valores ímpares negativos. % precisa de operandos inteiros; <math.h> fornece fmod para restos de ponto flutuante. Um divisor inteiro igual a zero torna / e % indefinidos, portanto verifique-o antes da operação.

Para 135 minutos, 135 / 60 fornece duas horas inteiras e 135 % 60 fornece os 15 minutos restantes. Para um inteiro decimal positivo, % 10 extrai seu último algarismo e / 10 o remove: 4096 fornece 6 e 409.

Preserve frações quando precisar delas

int correct = 45, total = 60;
double percent = 100.0 * correct / total;

A constante de ponto flutuante faz a multiplicação ser de ponto flutuante, e a divisão resulta em 75,0. Em correct / total * 100, a primeira operação é uma divisão inteira e resulta em zero. Multiplicar esse zero não recupera a fração perdida. Fazer primeiro a multiplicação inteira, correct * 100 / total, resulta em 75 neste caso, desde que o produto caiba no tipo.

Armazene um novo valor

Uma atribuição avalia seu lado direito e armazena o valor convertido à esquerda. A expressão de atribuição tem esse valor armazenado, portanto a = b = 0; define ambas as variáveis como zero, agrupando da direita para a esquerda.

Atribuições compostas combinam cálculo e armazenamento: x += 5 soma cinco a x, e x /= 2 divide x por dois usando seu tipo atual. Todo o operando da direita pertence ao cálculo. Se x for 4, x *= 2 + 1 o torna 12, pois multiplica por três.

Atualizações prefixadas e pós-fixadas

++ soma um e -- subtrai um. Em uma linha isolada, i++; e ++i; têm o mesmo efeito final. Dentro de uma expressão maior, a forma pós-fixada produz o valor antigo; a prefixada produz o novo valor.

Mantenha as modificações fáceis de ordenar. i = i++ + 1; e printf("%d %d\n", n, n++); têm usos conflitantes não sequenciados da mesma variável e comportamento indefinido. Separe a leitura, a atualização e a saída em instruções quando sua ordem for importante.

C converte valores à medida que cada operador é aplicado. A variável de destino recebe o resultado final; ela não altera retroativamente operações anteriores da expressão.

Converta antes de dividir

int sum = 7, count = 2;
double a = sum / count;
double b = (double)sum / count;
double c = (double)(sum / count);

a torna-se 3,0: os dois operandos inteiros produzem o inteiro 3, que é então convertido. b torna-se 3,5: a conversão explícita converte sum antes da divisão, portanto count também é convertido para double. c torna-se 3,0: sua conversão explícita está fora da divisão e ocorre depois que a fração foi descartada.

A mesma regra se aplica dentro de uma expressão mais longa. 7 / 2 * 2.0 resulta em 6,0, pois o primeiro resultado é o inteiro 3. 7 / 2.0 * 2 resulta em 7,0. Percorra os operadores na ordem de seu agrupamento, anotando o tipo de cada valor intermediário.

Encontre um tipo aritmético comum

Se algum operando for de ponto flutuante, a aritmética geralmente converte para o tipo de ponto flutuante mais amplo envolvido: long double, depois double, depois float. Para inteiros, tipos pequenos primeiro passam pela promoção inteira. Em plataformas com char de 8 bits, short de 16 bits e int de 32 bits, todo valor dos tipos menores cabe em int, portanto esses tipos são promovidos a int.

Com unsigned char a = 200, b = 100;, a + b é o inteiro 300 em um sistema com byte de 8 bits e int de 32 bits. Não há redução modular em 255 durante a adição. Armazenar 300 em um caractere sem sinal de 8 bits o reduz para 44. A promoção também pode produzir estouro com sinal: dois valores unsigned short de 50.000 são multiplicados como int, mas 2.500.000.000 excede um INT_MAX de 32 bits.

Para tipos com e sem sinal, a hierarquia e a faixa representável determinam o tipo comum. int com unsigned int é convertido para sem sinal. Um tipo com sinal de hierarquia superior pode manter a operação com sinal quando representa todos os valores do tipo sem sinal; caso contrário, a aritmética ainda pode ser sem sinal.

A armadilha dos tipos com e sem sinal

Com um inteiro sem sinal de 32 bits, -1 < 0u é falso. O −1 com sinal é convertido para o valor sem sinal 4.294.967.295 antes da comparação. Da mesma forma, 2u - 10 resulta em 4.294.967.288. Um resultado de sizeof também é sem sinal, o que importa ao compará-lo com uma contagem possivelmente negativa. Ative avisos e mantenha quantidades relacionadas em tipos compatíveis.

Conversões no armazenamento podem perder informações

Uma conversão de ponto flutuante para inteiro trunca em direção a zero. Sua parte inteira deve caber no tipo, ou o comportamento será indefinido. Um inteiro convertido para um tipo sem sinal de N bits é reduzido módulo 2ᴺ; −1 torna-se o maior valor sem sinal. Em C17, uma conversão de inteiro fora da faixa para um tipo com sinal tem resultado definido pela implementação ou gera um sinal definido pela implementação. Essa conversão é distinta do estouro indefinido na aritmética com sinal.

Constantes de caractere também participam de operações aritméticas. '7' - '0' resulta em 7 porque C garante códigos consecutivos para algarismos decimais. Em ASCII, as letras também são consecutivas, mas não suponha essa propriedade para todo conjunto de caracteres. Em fórmulas inteiras, multiplicar antes de dividir só pode preservar informações úteis se esse produto couber em seu tipo de cálculo.

Uma condição verifica se algo é verdadeiro. Uma operação bit a bit atua sobre os bits individuais de um inteiro. C fornece operadores diferentes para essas tarefas, mesmo quando seus símbolos são parecidos.

Compare valores e combine testes

As comparações <, >, <=, >=, == e != produzem um int: 1 para verdadeiro e 0 para falso. Em uma condição, zero é falso e qualquer valor diferente de zero é verdadeiro. Assim, if (count) testa se count é diferente de zero. == compara dois valores; = atribui um novo valor.

&& significa que ambas as condições devem ser verdadeiras, || significa que pelo menos uma deve ser verdadeira, e ! inverte o valor lógico. Eles retornam 0 ou 1. Uma faixa de 1 a 8 precisa de duas comparações:

height >= 1 && height <= 8

1 <= height <= 8 não expressa essa faixa em C. Ela é agrupada como (1 <= height) <= 8, portanto a segunda comparação recebe 0 ou 1 e é sempre verdadeira. Para testar valores fora da faixa, escreva height < 1 || height > 8.

Negar uma condição composta altera ambas as partes: !(a && b) é equivalente a !a || !b, e !(a || b) a !a && !b. Essas são as leis de De Morgan. Elas explicam por que estar fora de um intervalo precisa de um “ou”, embora estar dentro precise de um “e”.

Coloque uma proteção antes da operação arriscada

if (d != 0 && n / d > 2) {
    printf("Above two\n");
}

&& avalia primeiro seu lado esquerdo. Se esse lado for falso, ignora o lado direito. || ignora seu lado direito quando o esquerdo é verdadeiro. Essa avaliação de curto-circuito permite que uma condição de proteção resguarde uma operação posterior. Inverter as duas partes acima faria a divisão antes de verificar o divisor. Para inteiros com sinal, há uma questão separada de faixa quando INT_MIN é dividido por −1 em um sistema de complemento de dois; proteja também esse par quando valores arbitrários forem possíveis.

Um teste de ano bissexto combina divisibilidade e exceções: (y % 4 == 0 && y % 100 != 0) || y % 400 == 0. O ano 2000 passa no teste de 400; 1900 falha porque a exceção dos séculos se aplica.

Trabalhe com um bit por vez

& bit a bit mantém os bits ativados em ambos os operandos; | mantém os bits ativados em pelo menos um; ^ mantém os bits diferentes; ~ inverte os bits. Com 12 (1100) e 10 (1010), os resultados são 8, 14 e 6 para &, | e ^.

Deslocamentos movem bits. Para valores não negativos cujo resultado caiba no tipo, x << k multiplica por 2ᵏ, e x >> k descarta k bits menos significativos, dividindo por 2ᵏ com o resto descartado. Use tipos sem sinal em operações com bits. Em C17, deslocar por uma quantidade negativa ou maior ou igual à largura do tipo promovido é indefinido; deslocar um valor negativo com sinal à esquerda é indefinido, e deslocá-lo à direita é definido pela implementação.

As posições dos bits começam em zero. flags | (1u << 3) ativa o bit 3; flags & ~(1u << 3) o desativa; (flags >> 3) & 1u o lê. 1 & 2 é 0 porque não há bit ativado em comum, enquanto 1 && 2 é 1 porque ambos os valores são diferentes de zero. Operadores bit a bit avaliam ambos os operandos e não podem substituir condições lógicas de proteção.

Duas perguntas ajudam você a ler uma expressão: quais operandos pertencem a cada operador e quando acontecem operações com efeitos colaterais? A precedência e a associatividade respondem à pergunta sobre agrupamento. Elas geralmente não determinam a ordem de avaliação dos operandos.

Siga a precedência

Operadores mais altos nesta tabela têm maior precedência. Cada linha está abaixo da anterior; os operadores separados por “depois” têm níveis distintos.

Parênteses prevalecem sobre o agrupamento. 2 + 3 * 4 é 14; (2 + 3) * 4 é 20.

Use a associatividade em níveis iguais

A maioria dos operadores aritméticos binários é agrupada da esquerda para a direita. 10 - 4 - 3 significa (10 - 4) - 3, que é 3. 100 / 10 / 2 resulta em 5. A atribuição é agrupada da direita para a esquerda, portanto a = b = 0 armazena zero em ambas as variáveis. O agrupamento descreve a estrutura da expressão; ele não estabelece uma regra geral de execução da esquerda para a direita.

Para int a = 3, b = 4, c = 5;, rastreie a + b * c > 20 && c % 2 == 1. A multiplicação resulta em 20, a adição resulta em 23 e 23 > 20 resulta em 1. O resto é 1, e seu teste de igualdade resulta em 1. O 1 && 1 final é 1.

Proteja testes de bits e atribuições com parênteses

x & 1 == 0 significa x & (1 == 0), portanto sempre produz zero. Escreva (x & 1) == 0 para testar o bit menos significativo. A adição também tem precedência maior que o deslocamento: 1 << 2 + 1 é 1 << 3, ou 8.

A atribuição tem precedência menor que a comparação. a = b == c armazena o 0 ou 1 da comparação em a. Em while ((ch = getchar()) != '\n'), os parênteses internos fazem a atribuição receber primeiro o caractere. Sem eles, ch receberia um resultado de comparação.

Escolha um valor ou sequencie duas ações

condition ? first : second avalia a condição e depois apenas a expressão do valor selecionado. max = (a > b) ? a : b; escolhe um valor; um if pode escolher um bloco de ações. O operador vírgula avalia primeiro sua expressão à esquerda e produz o valor de sua expressão à direita. Ele pode coordenar duas atualizações em um cabeçalho de for. Vírgulas entre argumentos de função são separadores e não estabelecem essa ordem.

Mantenha efeitos colaterais separados

C deixa não especificadas muitas ordens de avaliação de operandos e argumentos. n++ * n++ tem alterações não sequenciadas na mesma variável, portanto tem comportamento indefinido. Parênteses adicionais não corrigem a falta de sequenciamento. Use instruções separadas quando uma ação precisar preceder outra. &&, ||, ?: e o operador vírgula fornecem regras específicas de sequenciamento; a precedência aritmética comum não oferece essa garantia.

Uma instrução if escolhe se uma ação será executada. Sua condição deve estar entre parênteses. Zero significa falso; todo valor diferente de zero significa verdadeiro.

Use chaves para mostrar o ramo

if (temperature < 0) {
    printf("Freezing\n");
} else {
    printf("At or above freezing\n");
}

O primeiro bloco é executado para uma temperatura negativa. Em exatamente zero, a comparação é falsa e o bloco else é executado. Leia o limite diretamente de <, <=, > ou >=; a mensagem deve corresponder a esse limite.

Sem chaves, apenas a próxima instrução é controlada:

if (temperature > 30)
    printf("Hot\n");
printf("Drink water\n");

A segunda mensagem é executada em qualquer temperatura. A indentação ajuda as pessoas, mas não altera a gramática. As chaves permitem acrescentar uma segunda instrução a um ramo sem deixá-la acidentalmente fora dele.

Ordene uma sequência de else-if

Uma sequência if–else if–else executa o primeiro ramo cuja condição seja verdadeira e ignora os demais. Para faixas de pontuação, comece pelo maior limite inferior:

if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else if (score >= 70) {
    grade = 'C';
} else {
    grade = 'F';
}

Uma pontuação de 85 falha no primeiro teste e passa no segundo. Uma pontuação de 90 passa no primeiro. Se você testasse score >= 70 primeiro, 85 entraria nesse ramo e nunca chegaria ao ramo B pretendido. Instruções if separadas comportam-se de maneira diferente: cada condição é testada independentemente, portanto vários blocos podem ser executados.

Observe dois pequenos erros de sintaxe

if (x = 5) atribui 5 e depois trata esse valor diferente de zero como verdadeiro. Use if (x == 5) para comparar. Com if (x = 0), a atribuição ainda acontece, mas a condição é falsa. Avisos ajudam a revelar atribuições acidentais em condições.

Em if (x > 0);, o ponto e vírgula é uma instrução controlada vazia. Um bloco colocado após ele é executado independentemente, mesmo quando x é negativo. Não acrescente um ponto e vírgula entre uma condição if e seu bloco pretendido.

Associe cada else explicitamente

Um else associa-se ao if anterior mais próximo que ainda não tenha um else. Em decisões aninhadas, use chaves para deixar clara a associação pretendida. O aninhamento é útil quando testes malsucedidos precisam de mensagens diferentes: primeiro teste se uma medida é válida e depois teste se seu valor está na faixa desejada. Combinar ambos com && funciona quando apenas uma ação compartilhada é necessária.

Coloque exceções antes de regras gerais

Anos bissextos oferecem uma decisão ordenada útil. Primeiro, teste a divisibilidade por 400, que indica ano bissexto. Em seguida, teste a divisibilidade por 100, que indica que não é ano bissexto. Depois, teste a divisibilidade por 4; caso contrário, o ano não é bissexto. Para 2000, o primeiro ramo se aplica. Para 1900, o segundo se aplica. Verificar apenas a divisibilidade por quatro deixaria passar a exceção dos séculos. A ordem importa porque regras gerais podem incluir casos com uma exceção mais específica.

Um switch escolhe um ponto de início usando um valor inteiro. Ele é útil para um caractere de comando ou número de menu com várias alternativas fixas. A execução pode então continuar nos casos seguintes, a menos que você a interrompa.

Encontre um caso correspondente e saia dele

switch (choice) {
    case 1:
        printf("Start\n");
        break;
    case 2:
        printf("Pause\n");
        break;
    default:
        printf("Unknown choice\n");
        break;
}

Com choice igual a 2, o programa começa em case 2, imprime Pause e sai do switch no break. Se nenhum caso corresponder, a execução começa em default. Sem um default, um valor sem correspondência faz o programa ignorar o switch.

A expressão de controle deve ter um tipo inteiro, incluindo char ou uma enumeração. Cada caso deve ser uma expressão constante inteira distinta, como 3, 'q' ou um nome adequado definido com #define. Em C17, uma variável const int não é uma expressão constante inteira para um rótulo case. Valores de ponto flutuante e cadeias de caracteres não podem controlar um switch.

Entenda a continuação entre casos

Rótulos case marcam pontos de entrada, não blocos separados que terminam automaticamente. Remova o primeiro break acima e uma escolha de 1 imprimirá tanto Start quanto Pause. O programa não testa se choice é 2 antes de continuar por esse caso. A execução para apenas em uma transferência de controle ou no fim do switch.

Vários rótulos podem compartilhar uma ação:

case 'y':
case 'Y':
    printf("Yes\n");
    break;

Ambos os caracteres levam à mesma ação. Quando um caso realiza uma tarefa e continua deliberadamente em outro, explique a intenção com um comentário. C23 também oferece [[fallthrough]];. Avisos podem ajudar a encontrar um break ausente, mas agrupar rótulos deliberadamente não exige repetir a ação.

Dê um bloco às variáveis locais de um caso

Em C17, uma declaração não pode vir diretamente após um rótulo case. Use chaves ao redor das instruções desse caso:

case 3: {
    int delay = 5;
    printf("%d\n", delay);
    break;
}

O bloco também mantém delay local ao caso. C23 flexibiliza a restrição de uma declaração após um rótulo, mas as chaves ainda deixam o escopo claro.

Escolha entre switch e if

Use switch para alternativas inteiras exatas. Use if–else if para desigualdades, condições que envolvam várias variáveis ou medidas de ponto flutuante. Faixas de pontuação de mesma amplitude às vezes podem ser convertidas em casos exatos por divisão inteira. Com pontuações de 0 a 100, score / 10 resulta em 8 para 85; os casos 9 e 10 podem compartilhar a faixa mais alta. Valide esse domínio para que pontuações negativas ou excessivas não sejam silenciosamente atribuídas a uma faixa.

Um switch dentro de um laço

Um break sai do switch ou laço mais próximo que o contém. Dentro de um switch que está em um laço, o break encerra apenas o switch. Para encerrar o laço do menu, defina uma variável de controle verificada por sua condição ou retorne de main quando o programa tiver que terminar. Um continue nesse switch se aplica ao laço que o contém, levando-o à próxima iteração. Rastreie a qual estrutura cada transferência se destina antes de decidir se o menu para.

Um laço while testa uma condição antes de cada passagem. Um laço do–while testa após o corpo, portanto é executado pelo menos uma vez. Escolha a forma que coloca o teste onde o programa precisa dele.

Rastreie um cálculo controlado por condição

int n = 4096, sum = 0;
while (n > 0) {
    sum += n % 10;
    n /= 10;
}

n % 10 extrai um algarismo, e n /= 10 o remove. Os valores após as passagens são:

A condição seguinte é falsa, portanto o laço termina com uma soma dos algarismos igual a 19. Se n começar em zero, o corpo é executado zero vezes e a soma permanece zero. Entradas negativas também ignoram esse laço, portanto um programa que as aceite precisa de uma regra definida.

Um laço de contagem define um contador, testa-o e o atualiza. Outros laços avançam lendo dados ou chegando a um break. Ao dividir 100 repetidamente pela metade com divisão inteira, os valores são 50, 25, 12, 6, 3 e 1: são necessárias seis passagens para chegar a um.

Deixe a entrada controlar a repetição

int x, sum = 0, count = 0;
while (scanf("%d", &x) == 1 && x != 0) {
    sum += x;
    count++;
}
if (count != 0) {
    printf("%.2f\n", (double)sum / count);
}

Para a entrada “5 8 3 0”, a sentinela zero encerra o laço e não é somada. A soma é 16, a contagem é 3 e a média exibida é 5.33. O teste da contagem de retorno protege o uso de x; o teste da contagem protege a divisão caso o primeiro valor seja zero. Esse cálculo também exige entradas e totais que caibam em int.

Sem a verificação da sentinela, while (scanf("%d", &x) == 1) para quando uma conversão numérica falha ou a entrada termina. Em um terminal, Ctrl+D normalmente sinaliza o fim da entrada no Linux e no macOS; no Windows, use Ctrl+Z seguido de Enter.

Execute uma vez antes de testar

int height;
do {
    printf("Height (1-8): ");
    fflush(stdout);
    if (scanf("%d", &height) != 1) {
        return 1;
    }
} while (height < 1 || height > 8);

A solicitação e a leitura ocorrem antes do teste de faixa. Os valores zero e nove fazem o laço se repetir; os valores um e oito são aceitos. O ponto e vírgula após while (...) é obrigatório nessa forma. A verificação da conversão encerra este exemplo em caso de entrada não numérica; o teste de faixa sozinho não consegue tratar uma conversão malsucedida.

Avance em todo caminho que continua

break sai imediatamente do laço mais interno. continue ignora o restante do corpo e retorna à condição em um laço while. Se uma atualização estiver abaixo de um continue, ela também será ignorada. Assim, um laço pode continuar testando o mesmo valor para sempre.

Antes de executar um laço, identifique o que muda e por que a condição de parada será alcançada. Um while (1) deliberado pode parar por meio de break; uma atualização de contador ausente é uma situação diferente. Ctrl+C interrompe um programa travado em um terminal. Teste a menor entrada e o valor no limite de parada para detectar erros de zero passagens e de uma passagem a mais.

Um laço for mantém um padrão de contagem em um único cabeçalho. Laços aninhados repetem uma tarefa interna para cada passagem externa. Ambos ficam mais fáceis de verificar quando você lista os valores reais do contador e identifica todas as saídas.

Acompanhe o cabeçalho em ordem

for (int i = 0; i < 3; i++) {
    printf("%d ", i);
}

A inicialização é executada uma vez. Depois, a condição é testada, o corpo é executado se ela for verdadeira e a atualização é executada antes do próximo teste. A saída é 0 1 2 . A variável declarada no cabeçalho é local ao laço; declare-a antes dele se precisar de seu valor final depois.

Para n não negativo, i = 0; i < n; i++ é executado n vezes, visitando de zero a n − 1. Com i <= n, é executado uma vez a mais. Para um passo positivo s de a até um b incluído, a contagem é (b - a) / s + 1 usando divisão inteira, desde que a aritmética e as atualizações do contador caibam no tipo. De 2 a 20 em passos de 3, os valores são 2, 5, 8, 11, 14, 17, 20: sete passagens.

Mantenha o acumulador fora do laço

int total = 0;
for (int i = 1; i <= 100; i++) {
    total += i;
}

O total final é 5050. A inicialização deve ocorrer uma vez antes do laço. Mover int total = 0; para o corpo cria um novo total a cada passagem, perdendo o trabalho anterior.

Escolha contadores que possam chegar ao fim

Um ponto e vírgula diretamente após o cabeçalho do for torna o corpo vazio. Um bloco seguinte é executado uma vez após o laço. Use chaves ligadas diretamente ao cabeçalho para tornar o corpo visível.

Uma contagem regressiva sem sinal com i >= 0 não pode parar dessa maneira: valores sem sinal são sempre não negativos, e decrementar zero causa redução modular para o máximo. Um contador de ponto flutuante que soma 0.1 repetidamente pode passar pelo valor exato 1.0 sem atingi-lo, portanto x != 1.0 não é confiável como regra de parada. Conte com um inteiro e calcule uma medida como x = i / 10.0 dentro do corpo.

Construa linhas com laços aninhados

Para cada passagem externa, o laço interno começa e executa sua própria sequência. Três passagens externas e quatro passagens internas fixas executam o corpo interno doze vezes. Quando o limite interno depende da linha, conte cada linha separadamente.

int height = 3;
for (int row = 1; row <= height; row++) {
    for (int s = 0; s < height - row; s++) printf(" ");
    for (int h = 0; h < row; h++) printf("#");
    printf("\n");
}

As linhas contêm dois espaços e uma cerquilha, um espaço e duas cerquilhas e, em seguida, três cerquilhas. A nova linha vem após os laços internos, portanto cada passagem externa produz uma linha.

Ignore trabalho ou pare antecipadamente

continue em um laço for vai para a atualização e depois para o próximo teste. Um laço que soma apenas valores ímpares de 1 a 9 pode ignorar valores pares e terminar com 25. break sai imediatamente do laço mais interno. Em laços aninhados, um break interno não interrompe o laço externo.

Um laço for costuma ser a escolha mais clara para uma faixa conhecida de contagem; while é adequado para repetição controlada por dados, e do–while é adequado para uma tarefa que deve ocorrer antes do teste. Reescrever um laço for como while exige cuidado especial com continue, pois a atualização ainda deve ocorrer nesse caminho.

A faixa de um inteiro é finita. Uma resposta matemática pode ser válida e ainda assim grande demais para o tipo C usado para calculá-la. As consequências dependem de a operação ser sem sinal, com sinal ou uma conversão.

A aritmética sem sinal sofre redução modular

Um resultado sem sinal de N bits é reduzido módulo 2ᴺ. Com um unsigned int de 32 bits, UINT_MAX + 1u resulta em zero, 0u - 1u resulta em 4.294.967.295 e 3u - 5u resulta em 4.294.967.294. O resultado é definido, mas pode estar errado para a tarefa: subtrair cinco itens de um estoque de três não deveria produzir bilhões de itens.

Para uint8_t b = 255;, b = b + 1; armazena zero. Em um sistema típico com int de 32 bits, a adição ocorre primeiro como int e produz 256; converter esse valor de volta para um tipo sem sinal de 8 bits produz zero. Um armazenamento pequeno sem sinal não significa que toda operação intermediária tenha esse tipo pequeno.

O estouro na aritmética com sinal é indefinido

Com um int de 32 bits, somar um a INT_MAX exige 2.147.483.648. C não define o resultado aritmético com sinal. O hardware pode parecer fazer uma redução modular para INT_MIN, mas o compilador pode otimizar com base na suposição de que estouro com sinal nunca ocorre. Uma verificação como if (x + 1 < x) pode ser removida para inteiros com sinal, pois toda adição definida de um a um inteiro com sinal resulta em um valor maior.

Não calcule primeiro para depois examinar o dano. Uma operação indefinida já terá acontecido antes que um teste posterior seja executado.

Um destino de maior faixa pode chegar tarde demais

int a = 50000, b = 50000;
long long product = a * b;

A multiplicação é realizada como int, portanto estoura em um sistema com int de 32 bits. A largura do destino não pode corrigir isso. (long long)a * b muda o tipo da operação antes da multiplicação e produz 2.500.000.000.

Fatoriais crescem rapidamente: 12! é 479.001.600 e cabe em um inteiro com sinal de 32 bits; 13! é 6.227.020.800 e não cabe. Com aritmética sem sinal de 32 bits, 13! sofre redução modular para 1.932.053.504. Um long long com sinal de 64 bits comporta 20! = 2.432.902.008.176.640.000, mas não 21!.

A conversão tem regras próprias

Converter um inteiro para um tipo sem sinal usa redução modular. Em C17, converter um inteiro fora da faixa para um tipo com sinal produz um resultado ou sinal definido pela implementação. Converter um valor de ponto flutuante cuja parte inteira truncada não caiba no destino inteiro tem comportamento indefinido. Ler um número fora da faixa por meio de uma conversão numérica de scanf também é indefinido.

Falhas de faixa podem ter grandes efeitos

O primeiro voo do Ariane 5, em 4 de junho de 1996, foi perdido depois que um valor de ponto flutuante não coube em um inteiro com sinal de 16 bits no software de referência inercial. Esse programa foi escrito em Ada; a lição sobre verificar faixas de conversão também se aplica a C.

Um contador de segundos com sinal de 32 bits iniciado na época Unix chega a 2.147.483.647 às 03:14:07 UTC de 19 de janeiro de 2038. Sistemas que usam essa representação de tempo precisam de uma com maior faixa. Em 2015, a FAA também tratou do software de controle dos geradores do Boeing 787, que poderia estourar após 248 dias de alimentação contínua. Essas falhas mostram por que tanto o longo tempo de execução quanto os valores intermediários devem entrar em uma estimativa de faixa.

Os limites de ponto flutuante são diferentes: sistemas IEEE comuns podem produzir infinito, e um float pode perder precisão para números inteiros antes de atingir seu máximo. A redução modular de inteiros sem sinal produz um valor numérico comum; o estouro com sinal não oferece nenhum resultado confiável.

Comece pelo maior valor que cada cálculo pode produzir. Inclua produtos intermediários e atualizações de contadores, não apenas a resposta final. Depois, escolha um tipo ou uma verificação prévia que mantenha cada operação dentro da faixa.

Amplie a faixa do cálculo antecipadamente

Um inteiro com sinal de 32 bits comporta cerca de 2,1 bilhões, enquanto um long long com sinal de 64 bits comporta até 9.223.372.036.854.775.807. Um contador de milissegundos atinge o limite com sinal de 32 bits em cerca de 24,9 dias. Use um tipo de 64 bits quando uma duração puder ser maior.

Escreva (long long)a * b para ampliar a faixa de um produto inteiro antes de ele ser calculado. Constantes também importam: 86400LL * days inicia a multiplicação em long long. (long long)(a * b) converte apenas após o produto de menor faixa, portanto não pode evitar seu estouro. Tipos de maior faixa ainda têm limites; compare os maiores valores possíveis com eles.

Verifique a adição usando subtração

Para int a e int b, inclua <limits.h> e teste:

if ((b > 0 && a > INT_MAX - b) ||
    (b < 0 && a < INT_MIN - b)) {
    printf("Sum out of range\n");
} else {
    int sum = a + b;
    printf("%d\n", sum);
}

Cada subtração é protegida pelo sinal de b, mantendo a própria verificação representável. Para 2.000.000.000 mais 200.000.000, INT_MAX - b é 1.947.483.647, menor que a, portanto a adição é recusada. O caso de igualdade cabe: quando a é igual a INT_MAX - b, a soma é exatamente INT_MAX.

Verifique a multiplicação positiva por divisão

Para operandos int positivos, a > INT_MAX / b significa que o produto excederia o máximo. A condição evita calcular o produto e evita um divisor zero porque b é positivo. Em um cálculo de fatorial, o teste antes de multiplicar 12! por 13 detecta que 479.001.600 é maior que 165.191.049. Pare antes dessa multiplicação.

Para um estoque sem sinal, teste stock >= requested antes de subtrair. Mudar apenas para um tipo sem sinal não evita um resultado sem sentido causado por redução modular.

Reescreva expressões intermediárias arriscadas

O ponto médio (low + high) / 2 pode estourar mesmo quando sua resposta cabe no tipo. Quando 0 <= low <= high e ambos são int, use low + (high - low) / 2. A diferença é não negativa e está dentro da faixa, e o resultado nunca excede high. Essas condições são importantes; a fórmula não é uma demonstração geral para extremos com sinal arbitrários.

Contadores de laço também precisam de faixa. Um short de 16 bits não consegue chegar a 40000, portanto um laço que o use para contar até esse ponto não pode terminar como pretendido. Use um tipo de contador que possa representar o limite e qualquer atualização final.

Use aritmética com verificação de estouro e testes

C23 fornece <stdckdint.h> com ckd_add, ckd_sub e ckd_mul. Por exemplo, ckd_add(&r, a, b) armazena um resultado e retorna verdadeiro quando a resposta matemática não cabe em r. GCC e clang também fornecem __builtin_add_overflow, __builtin_sub_overflow e __builtin_mul_overflow como extensões do compilador.

Avisos detectam alguns estouros de constantes e erros envolvendo valores com e sem sinal. No GCC ou clang, -fsanitize=undefined -g pode relatar um estouro com sinal alcançado durante um teste; -ftrapv solicita interrupções para estouros em adição, subtração e multiplicação com sinal. Teste zero, um, menos um, a maior entrada esperada e valores nos limites e logo abaixo deles. Uma ferramenta de teste verifica os caminhos que você executa, portanto mantenha no código o raciocínio sobre as faixas.