aula2

2ª Aula - Terça-feira, 28 de julho de 2026

Conteúdo

Estruturas condicionais

Motivação

Uma dona de casa pede ao filho:

— Vá à mercearia comprar um litro de leite; se houver ovos, compre seis.

Infelizmente, seu filho é programador, e chegou em casa tendo comprado seis litros de leite.

Definição

O bloco de código no interior de um comando condicional só é executado se uma condição for verdadeira.

	se (condição) {
	   bloco de instruções
	}

Condições

Para que possamos falar de condições, precisamos relembrar o que são valores e variáveis booleanos.

Variáveis booleanas são espaços de memória – mais especificamente, na memória RAM do computador – preparados para comportar dados do tipo booleano. Dados booleanos são binários, podendo assumir os valores booleanos “true” ou “false”, representados pelos números 1 e 0, respectivamente.

As condições são elementos fundamentais da estrutura de decisão, ou “estrutura condicional”, na qual permite alterar o fluxo de execução do programa; sem essas estruturas, o programa seria obrigado a executar todas as instruções nele escritas, na ordem em que foram escritas.

Uma estrutura condicional possui, obrigatoriamente, uma palavra reservada, seguida de uma condição entre parênteses – "( )" – e um par de chaves – "{ }". Dentro das chaves, estará o bloco de instruções a ser executado se a condição for satisfeita.

	#include <stdbool.h>
	
	bool condicao = true;]
	
	printf("condicao: %d\n", condicao);

condicao: 1

Operações relacionais e operações lógicas têm como resultado valores booleanos. Por isso, pode-se tanto guardar o resultado dessas em variáveis booleanas, quanto utilizá-las como as próprias condições.

	int a = 1, b = -1;
	
	printf("a == b?: %d\n", a == b);
	printf("a != b?: %d\n", a != b);
	printf("a > b?: %d\n", a > b);
	printf("a < b?: %d\n", a < b);
	printf("a >= b?: %d\n", a >= b);
	printf("a <= b?: %d\n", a <= b);
	printf("a && b?: %d\n", a && b);
	printf("a || b?: %d\n", a || b);
	printf("!a: %d\n", !a);
	printf("!b: %d\n", !b);

a == b?: 0
a != b?: 1
a > b?: 1
a < b?: 0
a >= b?: 1
a <= b?: 0
a && b?: 1
a || b?: 1
!a: 0
!b: 0

Comandos condicionais

`if`

Essa palavra reservada da linguagem C significa “se”, em português. Trata-se de uma “conjunção”, mais especificamente, uma conjunção condicional, pois impõe uma condição para a realização ou não do acontecimento da oração principal. Por exemplo:

“se chover hoje, não vou à aula”

	int a = 1, b = -1;
	
	if (a == b) {
    printf("%d é igual a %d!\n", a, b);
  }

`else`

“else” traduz para “senão”, escrito junto; uma palavra só. “Senão” é uma conjunção alternativa, dependente de uma condição imposta anteriormente.

“hoje não deve chover. Senão, não vou à aula”

“hoje não deve chover. Caso contrário, não vou à aula”

O else oferece uma alternativa de comportamento caso a condição imposta pelo if não for satisfeita.

  if (a == b) {
    printf("%d é igual a %d!\n", a, b);
      
  } else {
    printf("%d NÃO é igual a %d!\n", a, b);
  }

1 NÃO é igual a -1!

`if-aninhado`

É possível “chamar” comandos condicionais dentro de outros comandos condicionais.

Faz-se isso para evitar realizar validações redundantes ou desnecessárias. Por exemplo, se as variáveis a e b fossem iguais, e as validações if (a < b) e if (a > b) não estivessem aninhadas, o programa realizaria essas operações entre parênteses a troco de nada, pois já se sabia que a e b não são diferentes, logo, uma não poderia ser maior ou menor que a outra.

	if (a == b) {
	  printf("%d é igual a %d!\n", a, b);
	}
	
	if (a != b) {
	  printf("%d NÃO é igual a %d!\n", a, b);
	
	  if (a < b) {
	    printf("%d é menor %d!\n", a, b);
	  }
	
	  if (a > b) {
	    printf("%d é maior %d!\n", a, b);
	  }
	}

1 NÃO é igual a -1!
1 é maior -1!

`else if`

“else if” traduz para “senão se”, que é uma locução condicional. Isto é, “senão” e “se“ têm, cada uma, um significado próprio. Mas, quando juntas, elas têm um terceiro significado.

Assim como o else, else if também só pode ser empregado se um if já houver sido utilizado anteriormente. Ou seja, se uma condição já houver sido imposta.

Além de o programa só executar as instruções em seu interior se a condição imposta pelo if não for satisfeita, o else if impõe uma segunda condição.

“hoje não vai chover, portanto, irei à aula. Senão, se me derem carona, eu irei à aula”

“hoje não vai chover, portanto, irei à aula. Caso contrário, se me derem carona, eu irei à aula”

Esse comando serve mais ao próposito de legibilidade do que ao de evitar redundâncias, apesar de que esse seja um efeito colateral desejável. Compare o código que utiliza o else if com o do exemplo imediatamente anterior. Percebe que o else if cria uma conexão entre as validações? Subentende-se que a condição imposta pelo else if é, de alguma forma, oposta àquela imposta pelo if.

	if (a == b) {
	  printf("%d é igual a %d!\n", a, b);
	
	} else if (a != b) {
		printf("%d NÃO é igual a %d!\n", a, b);
	    
	  if (a < b) {
	      printf("%d é menor %d!\n", a, b);
	
	  } else if (a > b) {
	    printf("%d é maior %d!\n", a, b);
	  }
	}

1 NÃO é igual a -1!
1 é maior -1!

`switch case`

“switch” significa “alternar”, “trocar” ou, ainda, “mudar” em português.

“case”, por sua vez, significa “caso”, ou melhor, “modo”.

O comando switch case oferece opções de blocos de instruções a serem executados, a depender de qual caso está sendo atendido. O caso, aqui, equivale à condição.

Esse comando pode ser substituído de maneira equivalente por if-else-if’s concatenados; trata-se uma opção programador-iniciante-friendly.

	if (a == b) {
    caso = 1;
	
	} else if (a > b) {
	
    caso = 2;
	
	} else {
	
    caso = 3;
	}
	
	switch (caso) {
    case 1:
      printf("%d é igual a %d!\n", a, b);
      break;
	
    case 2:
      printf("%d é maior %d!\n", a, b);
      break;
	
    case 3:
      printf("%d é menor %d!\n", a, b);
      break;
	}

1 é maior -1!

Operador condicional `?:`

Também chamado de “ternário”, o operador ?: pode abstrair a utilização do bloco if-else.

A sua estrutura consiste em: uma operação relacional ou lógica, seguida do operador ?, e das instruções a serem executadas a depender do resultado da operação, separadas por :. À esquerda do :, está a instrução que deve ser executada se a operação retornar true; à direita, a instrução a ser executada caso a operação retorne false.

a != b ? printf("%d NÃO é igual a %d!\n", a, b) : printf("%d é igual a %d!\n", a, b);

1 NÃO é igual a -1!

O filho programador

O que confere humor à anedota com a qual esta aula se inicia é a ambiguidade do discurso da mãe, que tem como consequência uma interpretação errônea por parte do filho.

O próximo bloco de código explicita a lógica adotada pelo filho ao tomar sua decisão, enquanto o bloco posterior exemplifica o que a mãe esperava que ele concluísse.

#include <stdbool.h>

bool mercearia = true, temOvos = true;
int ovosComprados = 0, litrosDeLeiteComprados = 0;

if (mercearia) {

  if (temOvos) {
    litrosDeLeiteComprados = 6;

  } else {
    litrosDeLeiteComprados = 1;
  }
}

printf("Ovos comprados: %d\n", ovosComprados);
printf("Litros de leite comprados: %d\n", litrosDeLeiteComprados);

Ovos comprados: 0
Litros de leite comprados: 6

#include <stdbool.h>

bool mercearia = true, temOvos = true;
int ovosComprados = 0, litrosDeLeiteComprados = 0;

if (mercearia) {

  litrosDeLeiteComprados = 1;

  if (temOvos) {
    ovosComprados = 6;
  }
}

printf("Ovos comprados: %d\n", ovosComprados);
printf("Litros de leite comprados: %d\n", litrosDeLeiteComprados);

Ovos comprados: 6
Litros de leite comprados: 1

Estruturas de repetição

Motivação

Até então, somos capazes de declarar variáveis e incrementá-las de uma unidade, caso alguma condição for satisfeita. Mas, e se desejarmos “contar” até, por exemplo, 1000. Ou 1000000?

int contador = 0;

if (contador <= 1000) {
	contador += 1; // contador = contador + 1;
}

if (contador <= 1000) {
	contador += 1;
}

if (contador <= 1000) {
	contador += 1;
}

if (contador <= 1000) {
	contador += 1;
}

if (contador <= 1000) {
	contador += 1;
}

...

Definição

Uma “estrutura de repetição” executa um bloco de código sucessivamente enquanto uma determinada condição for verdadeira.

enquanto (se condição é verdadeira -> entrar no loop) {

   série de instruções
  
   se (objetivo foi atingido) {
     tornar a condição falsa
   }
 }

Comandos de repetição

`while`

“while” significa “enquanto” em português.

Este comando é utilizado quando se desconhece o número execuções (do loop; do bloco de instruções no interior do loop) necessárias para atingir determinado objetivo.

bool condicao = true;
int contador = 0;

while (condicao) {
   contador += 1; 
   // contador = contador + 1;

   if (contador >= 3) {
     condicao = false;
   }
}

`do-while`

Também pode ser utilizado quando não se sabe o número final de iterações. Contudo, o bloco de instruções no interior do loop é executado pelo menos uma vez, pois a condição só é testada ao fim da estrutura.

O verbo “do” é um imperativo: “faça!”. No código, isso se reflete na arbitrariedade com que o programa executa o bloco de instruções no body da estrutura antes de validar a condição.

int contador = 0;

do {
   contador += 1; 
   // contador = contador + 1;
} while (contador != 3);

`for`

Nese contexto, a melhor tradução para “for” é “por”. Ou melhor, “por enquanto”.

Pode ser utilizado quando o número de iterações é conhecido. A condição de parada é explicitada por meio de três comandos: uma atribuição, uma operação relacional e um incremento.

bool condicao = true;
int contador = 0;

for (int i = 0; i < 3; i++) {
   contador += 1; // contador = contador + 1;
}

bool condicao = true;
int contador = 0;

for (int i = 3; i > 0; i--) {
   contador += 1; // contador = contador + 1;
}

bool condicao = true;
int contador = 0;

for (int i = 0; i <= 2; i++) {
   contador += 1; // contador = contador + 1;
}

`break`

Interrompe a execução atual do loop e impede as execuções posteriores. Expulsa o programa do loop.

bool condicao = true;
int contador = 0;

for (int i = 0; i <= 2; i--) {
   contador += 1; // contador = contador + 1;
   
   if (i < 0) { // se i for negativo
     break;
   }
}

`continue`

Interrompe a execução atual do loop, pulando para a próxima execução.

while (condicao) {
   contador += 1; // contador = contador + 1;

   if (contador == 3) {
     continue;
   }
  
   if (contador >= 3) {
     condicao = false;
   }
 }

Comando “go-to”

`goto`

Este comando desvia o fluxo de execução do programa de forma incondicional, arbitrária.

Esse comando passou a ser demonizado quando surgiu a programação estruturada e modularizada, quando os programas passaram a ser entendidos a partir de sua estrutura, e não de seu fluxo de execução.

O que o goto faz é um desvio no fluxo de controle do programa. Assim como fazem os comandos de repetição, o break e o continue.

Isso significa que a sua utilização deve ser defendida e incentivada?

Existe um motivo muito melhor embasado que justifica que ele seja evitado: o uso desmedido do goto pode comprometer a legibilidade do código.

Esse comando utiliza de rótulos, seguidos por ‘:’, para indicar ao programa para qual linha de código ele deve ser redirecionado. Esses rótulos têm um escopo local, isto é, só podem ser chamados dentro da função em que foram criados.

Ainda, esses rótulos podem ser chamados antes de sua declaração. Isto é, alguém que está lendo um código de terceiros pela primeira vez pode se deparar com um rótulo nas linhas iniciais, enquanto o goto que desvia para lá pode estar no fim do código. Isso não parece ser um problema e, de fato, não é; contudo, vem a ser um problema se o código estiver apinhado de rótulos.

O comando pode ser conveniente para programadores que conhecem o seu funcionamento e as dificuldades às quais ele pode submeter o código. O seu uso é, sim, desencorajado, e algumas linguagens até limitam a sua utilização com recursos de sintaxe; mas não deve ser evitado à todo custo.

int main(int argc, char **argv){

    int n;
    
    printf("Forneça um número: \n");
    scanf("%d", &n);

  	if (n % 2 == 0) {
      
        goto par;

    } else {
      
        goto impar;

    }

    par:
        printf("%d é um número par!\n", n);
        return 0;
        
    impar:
        printf("%d é um número ímpar!\n", n);
        return 0;
}

Forneça um número: 
3
3 é um número ímpar!

Referências

https://github.com/programacao101/programacao101/blob/master/Livro/Introdu%C3%A7%C3%A3o%20%C3%A0%20Programa%C3%A7%C3%A3o.pdf
https://www.geeksforgeeks.org/c/decision-making-in-c/
https://www.normaculta.com.br/conjuncao/
https://www.todamateria.com.br/senao-ou-se-nao/
https://ciberduvidas.iscte-iul.pt/consultorio/perguntas/as-regras-do-se-nao-e-do-senao/10379
https://www.freecodecamp.org/portuguese/news/operador-ternario-em-c/
https://learn.microsoft.com/pt-br/cpp/c-language/goto-and-labeled-statements-c?view=msvc-170
https://www.geeksforgeeks.org/c/goto-statement-in-c/
https://pt.stackoverflow.com/questions/20660/por-que-o-uso-de-goto-%C3%A9-considerado-ruim
https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.pdf

Exercícios

Faça um programa que leia 3 valores inteiros e imprima o maior deles.
Faça um programa que lê três números inteiros e uma operação (outro número inteiro entre 1 e 3). As operações são as seguintes:
1. Maior: mostra o maior dos três números;
2. Menor: mostra o menor dos três números;
3. Média: calcula a média dos três números, com duas casas decimais
Seu programa deve executar cada uma das operações através do comando switch. Se uma operação inválida for inserida, imprimir na tela a palavra “Erro”.
Faça um programa que mostre uma contagem na tela de 233 a 457, só que contando de 3 em 3 quando estiver entre 300 e 400 e de 5 em 5 quando não estiver. Utilize do {} while ().
Faça um programa que pegue um número do teclado e calcule a soma de todos os números de 1 até ele. Use o laço for(). Por exemplo, se o usuário fornece a entrada “7”, o programa deve imprimir 28, pois $1+2+3+4+5+6+7=28$.

Gabarito

Exercício 1:

	printf("1. Faça um programa que leia 3 valores inteiros e imprima o maior deles.\n");

  int x, y, z;

  printf("Insira um valor inteiro para x: \n");
  scanf("%d", &x);

  printf("Insira umvalor inteiro para y: \n");
  scanf("%d", &y);

  printf("Insira umvalor inteiro para z: \n");
  scanf("%d", &z);

  if ((x>=y)&&(x>=z)) {
      printf("Entre %d, %d e %d, o maior valor é %d", x, y, z, x);  
  }
  
  if ((y>=x)&&(y>=z)) {
      printf("Entre %d, %d e %d, o maior valor é %d", x, y, z, y);    
  }

  if ((z>=x)&&(z>=y)) {
      printf("Entre %d, %d e %d, o maior valor é %d", x, y, z, z);
  }

Exercício 2:

	printf("2. Faça um programa que lê três números inteiros e uma operação (outro número inteiro entre 1 e 3). As operações são as seguintes:\n"
  "a. Maior: mostra o maior dos três números;\n"
  "b. Menor: mostra o menor dos três números;\n"
  "c. Média: calcula a média dos três números, com duas casas decimais.\n");

  int a, b, c, operacao;
  float media;

  printf("Insira um valor inteiro para a: \n");
  scanf("%d", &a);

  printf("Insira um valor inteiro para b: \n");
  scanf("%d", &b);

  printf("Insira um valor inteiro para c: \n");
  scanf("%d", &c);

  printf("Qual operação você deseja realizar?: \n");
  scanf("%d", &operacao);

  switch(operacao){
    case 1: 
      printf("Entre %d, %d e %d, o maior valor é ", a, b, c);

      if (a>=b&&a>=c) {
          printf("%d\n", a);
      }

      if (b>=a&&b>=c) {
          printf("%d\n", b);
      }

      if (c>=a&&c>=b) {
          printf("%d\n", c);
      }
      
      break;

    case 2:
      printf("Entre %d, %d e %d, o menor valor é ", a, b, c);

      if (a<=b&&a<=c) {
          printf("%d\n", a);
      }

      if (b<=a&&b<=c) {
          printf("%d\n", b);
      }

      if (c<=a&&c<=b) {
          printf("%d\n", c);
      }; 
      
      break;

    case 3:

      printf("A média de %d, %d e %d é ", a, b, c);

      media = ((a+b+c)/3.00);
      printf("%.2f\n", media); 
      
      break;
  }

Exercício 3:

	printf("Faça um programa que mostre uma contagem na tela de 233 a 457,"
				 "só que contando de 3 em 3 quando estiver entre 300 e 400 e de 5 em 5 quando não estiver." 
         "Utilize do {} while ().\n");

  int i;

  for (i=233; i<=300; i+=5) {
      printf("%d\n", i);
  }

  for( i=303; i<=400; i+=3) {
      printf("%d\n", i);
  }

  for (i=402; i<=457; i+=5) {
      printf("%d\n", i);
  }

  break;

Exercício 4:

	printf("Faça um programa que pegue um número do teclado e calcule a soma de todos os números de 1 até ele." 
	       "Use laço for(). Por exemplo, se o usuário fornece a entrada “7”," 
	       "o programa deve imprimir 28, pois 1+2+3+4+5+6+7=28.\n");
	
	int n = 0, soma = 0, aux = 1;
	printf("Forneça um número inteiro e positivo: \n");
	scanf("%d", &n);
	
	printf("A soma é ");
	
	for (int i = n; i >= 1; i--) {
    soma += i;

    printf("%d", aux);
    aux++;

    if (i > 1) {
        printf(" + ");
    } else {
        printf(" = ");
    }
	}
	
	printf("%d\n", soma);