Como escrever instruções if em C, com fluxogramas para entendimento visual.
if (cond) { ... } forma básicaelse trata o caso falsoelse if para três ou mais ramos — o mais restrito primeirocond ? a : bif faz.if (condicao) { // executa quando a condição for verdadeira }
int score = 75; if (score >= 60) { printf("Aprovado\n"); }
score >= 60 é verdadeiro, o corpo dentro de { } é executado. Se score for 50, a condição é falsa e o corpo é totalmente ignorado.| Operador | Significado | Exemplo | Verdadeiro quando |
|---|---|---|---|
== | igual a | x == 5 | x é 5 |
!= | diferente de | x != 0 | x não é 0 |
< | menor que | x < 10 | x é menor que 10 |
<= | menor ou igual | x <= 10 | x é no máximo 10 |
> | maior que | x > 0 | x é maior que 0 |
>= | maior ou igual | x >= 60 | x é pelo menos 60 |
= e == são diferentes: = é atribuição, == é comparação. Veja "Erros comuns" abaixo.bool dedicado (o C99 adicionou stdbool.h), então valores de verdade são apenas inteiros.1, -1, 100, 3.14 ...if (1) // sempre verdadeiro - o corpo sempre roda if (0) // sempre falso - o corpo nunca roda if (score) // verdadeiro quando score é diferente de zero
{ } importam{ } agrupam várias instruções no corpo do if. Para um corpo de uma única instrução, as chaves são tecnicamente opcionais — mas iniciantes devem sempre escrevê-las.if (x > 0) { printf("positivo\n"); count++; }
if (x > 0) printf("positivo\n"); count++; // NAO esta dentro do if - sempre roda
count++; pareça estar dentro do if, sem chaves somente a próxima instrução conta como corpo.else é a cláusula "caso contrário". Quando a condição do if é falsa, o corpo do else é executado no lugar.int score = 45; if (score >= 60) { printf("Aprovado\n"); } else { printf("Reprovado\n"); }
if quando verdadeiro, o corpo do else quando falso. Nunca os dois, nunca nenhum.else não aceita condiçãoelse sozinho cobre "qualquer caso que o if não pegou," então não há onde colocar uma condição. Se você precisa de um "caso contrário" condicional, use else if (visto abaixo).// C invalido else (x < 0) { ... } // tambem invalido if (x > 0) { ... } else else { ... }
else é opcionalelse não é obrigatório. Se você só se importa com o caso "verdadeiro," basta deixá-lo de fora.if (age >= 18) { printf("adulto\n"); } else { printf("menor\n"); }
if (errors > 0) { printf("aviso\n"); } // nao faz nada no sucesso
if + else cobre dois resultados. Para três ou mais casos, encadeie else if. Isso é só uma forma abreviada de "coloque outro if dentro do else."int score = 75; if (score >= 90) { printf("Excelente\n"); } else if (score >= 70) { printf("Bom\n"); } else if (score >= 50) { printf("Aprovado\n"); } else { printf("Reprovado\n"); }
score >= 50 primeiro, notas de 90 e 70 também batem ali, então todo mundo apenas "Passa." Sempre coloque a condição mais restrita (mais estreita) primeiro.else final captura "nenhum dos anteriores." Omita-o e nada acontece quando nenhum caso bate — uma inação silenciosa. Escrevê-lo explicitamente é mais seguro.= (atribuição) com == (igualdade)int x = 10; if (x = 5) { // = simples - era pra ser comparacao printf("x eh 5\n"); }
x = 5 atribui 5 a x, e o valor da expressão é 5.printf roda todas as vezes.== para comparação. Algumas equipes colocam a constante à esquerda (if (5 == x)) para que um erro de digitação como = vire um erro de compilação.if (cond); — ponto e vírgula perdidoif (score >= 60); // ; perdido { printf("Aprovado\n"); }
if (cond); significa "execute uma instrução vazia quando verdadeiro" — um if inútil.{ ... } que vem depois é apenas um bloco comum, sem relação com o if, então sempre executa.; imediatamente após if (cond) — vá direto ao {.double com ==double x = 0.1 + 0.2; if (x == 0.3) { // quase nunca verdadeiro! printf("igual\n"); }
0.1 + 0.2 é na verdade 0.30000000000000004 — não exatamente igual a 0.3.
#include <math.h>if (fabs(x - 0.3) < 1e-9) { ... }
0 < x < 10 — notação matemática não funcionaif (0 < x < 10) { ... } // analisado da esquerda pra direita - nao eh o que voce pensa!
0 < x é avaliado primeiro, resultando em 1 (verdadeiro) ou 0 (falso).(resultado) < 10 — tanto 0 quanto 1 são menores que 10, então a expressão inteira é sempre verdadeira.&&:if (0 < x && x < 10) { ... }
else pendenteif (a > 0) if (b > 0) printf("ambos positivos\n"); else printf("???\n"); // pertence a qual if?
else liga-se ao if não pareado mais próximo — o if (b > 0) interno. A indentação não diz nada aqui.{ } para matar a ambiguidade.
if (!x) é o mesmo que if (x == 0)! é o NÃO lógico: inverte verdadeiro para falso e vice-versa. if (x) executa quando x é diferente de zero; if (!x) executa quando x é zero. Você vê esse atalho em código C real o tempo todo.
| Nome | Tipo | Valor |
|---|
else if para classificar: A/B/C/D== 0, >= 100)&& (ex.: idade 18+ E cidadão)if dentro de ifTeste seu entendimento desta aula!
Em C, 0 é falso e qualquer coisa diferente de zero é verdadeiro. Quando a condição é 0, o bloco if é pulado.
= é atribuição, então 5 é armazenado em x. O resultado da atribuição é 5 (diferente de zero, logo verdadeiro), significando que o ramo sempre roda. Um bug clássico — você quis dizer ==.
Cada if pode ter apenas um else. Use else if para desvios múltiplos.
int x = 0; if (x) printf("A\n"); else printf("B\n");
if (x) com x=0 é falso, então o corpo do if é pulado e o printf("B\n") do else roda.
int x = 10; if (x = 0) printf("zero\n"); else printf("diferente de zero: %d\n", x);
x = 0 atribui 0 a x, e a expressão avalia para 0. Como condição, 0 é falso, então o else roda — mas x já foi sobrescrito para 0, então sai "diferente de zero: 0".
Essa é a clássica armadilha = vs ==: sua variável muda silenciosamente.
int score = 45; if (score >= 60); { printf("Aprovado\n"); }
O ; perdido transforma o if numa instrução vazia. O bloco que segue não tem nada a ver com o if, então sempre roda.
if (a > 0) if (b > 0) printf("ambos positivos\n"); else printf("a eh negativo\n");
O infame else pendente. Apesar da indentação, else liga-se ao if mais próximo — neste caso if (b > 0). Com b = -3, a condição interna é falsa, então o else imprime "a é negativo" — mesmo a sendo positivo!
Use { } para evitar isso sempre.
if (10 <= x <= 20)if (x >= 10 || x <= 20)if (x >= 10 && x <= 20)if (x >= 10 & x <= 20)Comparações encadeadas no estilo matemático não existem em C. Use && (E lógico) para juntar dois testes. A opção 2 com || (OU) é sempre verdadeira; a opção 4 usa & bit a bit, que é um operador totalmente diferente.
if (x != 0 && y / x > 2) { printf("grande\n"); } else { printf("pequeno\n"); }
O && de C usa avaliação por curto-circuito: se o lado esquerdo for falso, o lado direito não é avaliado. Aqui x != 0 é falso, então y / x é pulado — sem divisão por zero, e o else imprime "pequeno".
Esse padrão é prático para coisas como checar se um ponteiro não é NULL antes de desreferenciá-lo.
if (x / 3 == 0)if (x % 3 == 0)if (x mod 3 == 0)if (x \ 3 == 0)O operador módulo em C é %. "x é divisível por n?" → x % n == 0. "x é par?" → x % 2 == 0. Um padrão que vale memorizar.
x = 75, o que imprime?int x = 75; if (x >= 80) printf("A\n"); else if (x >= 60) printf("B\n"); else if (x >= 40) printf("C\n"); else printf("D\n");
Avaliado de cima para baixo:
1. x >= 80: 75 está abaixo de 80 → falso → segue em frente.
2. x >= 60: verdadeiro → imprime B, a cadeia termina.
O else if e o else restantes nem chegam a ser avaliados. Esse é o ponto principal de uma cadeia else-if.
score = 55, o que imprime?int score = 55; if (score >= 50) { printf("A\n"); } else if (score >= 90) { printf("B\n"); } else { printf("C\n"); }
score >= 50 é verdadeiro, então "A" imprime e a cadeia termina. Mesmo uma nota de 95 imprime "A" — o ramo "B" é inatingível.
Esse é o clássico bug de ordenação de condições: coloque a condição mais restrita primeiro, senão os ramos mais estreitos viram código morto.
x = -5, quantas linhas são impressas?int x = -5; if (x > 0) { printf("positivo\n"); } if (x == 0) { printf("zero\n"); } if (x < 0) { printf("negativo\n"); }
Esses três ifs são independentes — cada um é avaliado por vez. Só x < 0 é verdadeiro, então exatamente uma linha imprime.
if / else if / else seria melhor? Mesmo resultado aqui, mas ele para de avaliar após o primeiro match. Use if / else if / else sempre que as condições forem mutuamente exclusivas.
day = 0, o que imprime?int day = 0; if (day >= 1 && day <= 5) { printf("Dia util\n"); } else if (day == 6 || day == 0) { printf("Fim de semana\n"); } else { printf("Invalido\n"); }
1. day >= 1 && day <= 5: day = 0 falha no primeiro teste → falso.
2. day == 6 || day == 0: a segunda metade é verdadeira → a expressão inteira é verdadeira → imprime "Fim de semana."
|| (OU) é verdadeiro quando pelo menos um operando é verdadeiro. && (E) precisa de ambos. Fácil de trocar sem querer.
if (x > 0) printf("A"); if (x == 0) printf("B"); if (x < 0) printf("C");
if (x > 0) printf("A"); else if (x == 0) printf("B"); else printf("C");
if (x > 0) printf("A"); else { if (x == 0) printf("B"); else printf("C"); }
if (x > 0) { printf("A"); return; } if (x == 0) { printf("B"); return; } printf("C");
Só a versão 1 é diferente. As versões 2, 3 e 4 cada uma executa exatamente um ramo, mas a versão 1 sempre avalia os três ifs mesmo depois de um match anterior. Isso importa se as condições tiverem efeitos colaterais, forem caras, ou se x for modificado dentro de um ramo.
A versão 2 (if / else if / else) é geralmente a forma mais clara de dizer "escolha exatamente um."
if (a > b) { if (a > 10) { printf("grande\n"); } else { printf("medio\n"); } } else { printf("pequeno\n"); }
1. a > b externo: 5 > 3 → verdadeiro, então entramos no bloco interno.
2. a > 10 interno: 5 > 10 → falso, então o ramo else roda e imprime "médio."
3. O else externo é pulado inteiramente.
if-else aninhado funciona como uma árvore: o externo decide qual subárvore, e o interno escolhe a folha.
score=85, o que isto faz?if (score >= 90) printf("A\n"); printf("excelente\n"); else if (score >= 70) printf("B\n");
Erro de compilação.
Sem chaves, o corpo do if é só printf("A\n");. O próximo printf("excelente\n"); vira uma instrução fora do if.
Agora o else if não tem um if imediatamente antes dele — há uma instrução sobrando no meio — então o compilador reclama com "else sem if anterior."
Lição: sempre envolva corpos de múltiplas instruções em { }.