💻 LÓGICA EM C

Estruturas Condicionais

Controle o fluxo do programa com if, else if e else na linguagem C

🔀 if — Condicional simples ▼
condicional C

O que é?

O if testa uma condição. Se for verdadeira (diferente de zero), o bloco entre chaves {} é executado. Se for falsa, o bloco é ignorado.

condição? ┌────┴────┐ SIM NÃO │ │ bloco pula executa bloco └────┬────┘ continua
c — sintaxe 
if (condição) {
    // código executado se verdadeiro
}
c — exemplo 
#include <stdio.h>

int main() {
    int idade = 20;

    if (idade >= 18) {
        printf("Maior de idade!\n");
    }

    return 0;
}
💡 Dica: Em C, qualquer valor diferente de 0 é considerado verdadeiro. Zero é falso.
🧪 Simulador — if simples
idade =
🔁 if / else — Dois caminhos ▼
condicional C

O que é?

O else define o que acontece quando a condição do if é falsa. Sempre exatamente um dos dois blocos é executado.

c — sintaxe 
if (condição) {
    // executa se VERDADEIRO
} else {
    // executa se FALSO
}
c — exemplo prático 
int nota = 5;

if (nota >= 7) {
    printf("Aprovado!\n");
} else {
    printf("Reprovado!\n");
}
🧪 Simulador — if / else
nota =
🌿 if / else if / else — Múltiplos caminhos ▼
condicional C

O que é?

O else if adiciona condições intermediárias. As condições são testadas em ordem — o primeiro bloco verdadeiro é executado e os demais são ignorados.

c — sintaxe 
if (condição1) {
    // 1ª opção
} else if (condição2) {
    // 2ª opção
} else if (condição3) {
    // 3ª opção
} else {
    // nenhuma das anteriores
}
c — classificação de notas 
float nota = 7.5;

if (nota >= 9) {
    printf("Excelente!\n");
} else if (nota >= 7) {
    printf("Aprovado!\n");
} else if (nota >= 5) {
    printf("Recuperação!\n");
} else {
    printf("Reprovado!\n");
}
🧪 Simulador — classificação de notas
nota =
⚡ Operador Ternário ▼
condicional C

O que é?

Versão compacta do if/else em uma linha. Útil para atribuições simples. Sintaxe: condição ? valor_se_true : valor_se_false

c — sintaxe 
int resultado = (condição) ? valor_true : valor_false;
c — exemplo 
int x = 10;
int y = 20;

int maior = (x > y) ? x : y;
printf("Maior: %d\n", maior); // Maior: 20

// Equivale a:
if (x > y)
    maior = x;
else
    maior = y;
🧪 Simulador — maior de dois números
x = y =

Estruturas de Repetição

Execute blocos de código repetidamente com for, while e do-while

🔄 for — Loop com contador ▼
loop C

Quando usar?

Use for quando você sabe quantas vezes o loop deve repetir. Agrupa inicialização, condição e incremento em uma linha só.

início: i=0 │ ┌────▼────┐ │ i < N? │ ──NÃO──▶ sai do loop └────┬────┘ │SIM executa corpo │ incrementa i++ │ volta ao topo
c — sintaxe 
for (int i = inicio; i < fim; i++) {
    // corpo do loop
}
c — contar de 1 a 10 
for (int i = 1; i <= 10; i++) {
    printf("%d ", i);
}
// Saída: 1 2 3 4 5 6 7 8 9 10
c — for inverso (countdown) 
for (int i = 10; i >= 1; i--) {
    printf("%d ", i);
}
// Saída: 10 9 8 7 6 5 4 3 2 1
🧪 Simulador — for
de até passo
♾️ while — Loop com condição ▼
loop C

Quando usar?

Use while quando você não sabe quantas vezes vai repetir — só sabe quando parar. A condição é testada antes de cada iteração.

c — sintaxe 
while (condição) {
    // executa enquanto for verdadeiro
}
c — somando até digitar 0 
int num, soma = 0;
scanf("%d", &num);

while (num != 0) {
    soma += num;           // soma = soma + num
    scanf("%d", &num);    // lê o próximo
}

printf("Soma: %d\n", soma);
⚠️ Cuidado: Se a condição nunca se tornar falsa, o loop é infinito! Sempre garanta que a variável da condição seja alterada dentro do loop.
🧪 Simulador — while (tabuada)
número =
🔁 do-while — Executa ao menos uma vez ▼
loop C

Diferença do while?

No do-while o corpo executa primeiro e a condição é testada depois. Garante pelo menos uma execução, mesmo que a condição já seja falsa de início.

executa corpo ◀──────┐ │ │ ┌────▼─────┐ │ │condição? │ ──SIM─────────┘ └────┬─────┘ │NÃO sai do loop
c — sintaxe 
do {
    // executa pelo menos uma vez
} while (condição); // note o ponto-e-vírgula!
c — menu de opções 
int opcao;

do {
    printf("1 - Novo Jogo\n");
    printf("2 - Carregar\n");
    printf("0 - Sair\n");
    scanf("%d", &opcao);
} while (opcao != 0); // repete até o usuário digitar 0
🧪 Simulador — do-while (fatorial)
n =
🛑 break e continue ▼
loop C

break

break encerra imediatamente o loop ou switch mais interno. O programa continua após o fechamento do bloco.

continue

continue pula o restante da iteração atual e vai direto para o próximo ciclo do loop. O loop não encerra.

c — break e continue 
// break: para ao encontrar o 5
for (int i = 1; i <= 10; i++) {
    if (i == 5) break;
    printf("%d ", i);
}
// Saída: 1 2 3 4

// continue: pula os números pares
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) continue;
    printf("%d ", i);
}
// Saída: 1 3 5 7 9

Switch / Case

Selecione entre múltiplas opções de forma limpa e eficiente

🎛️ switch — Estrutura base ▼
condicional C

Quando usar?

Use switch quando quiser comparar uma variável com vários valores possíveis. É mais legível que vários else if encadeados. Funciona com int e char.

c — sintaxe 
switch (variável) {
    case valor1:
        // código para valor1
        break;
    case valor2:
        // código para valor2
        break;
    default:
        // nenhum case bateu
}
c — menu de operações 
int op = 2;
float a = 10, b = 4;

switch (op) {
    case 1:
        printf("%.2f\n", a + b); break;
    case 2:
        printf("%.2f\n", a - b); break;
    case 3:
        printf("%.2f\n", a * b); break;
    case 4:
        printf("%.2f\n", a / b); break;
    default:
        printf("Opção inválida!\n");
}
⚠️ Não esqueça o break! Sem break, o código cai para o próximo case (fall-through). Isso pode ser bug ou recurso — depende da intenção.
🧪 Simulador — calculadora com switch
🔤 switch com char — dia da semana ▼
condicional C

Switch com char

O switch também funciona com caracteres. O valor do case deve estar entre aspas simples: 'A', 'b'.

c — vogal ou consoante 
char letra = 'a';

switch (letra) {
    case 'a': case 'e': case 'i':
    case 'o': case 'u':
        printf("É vogal!\n");
        break;
    default:
        printf("É consoante!\n");
}
c — dia da semana 
int dia = 3;

switch (dia) {
    case 1: printf("Segunda\n"); break;
    case 2: printf("Terça\n");   break;
    case 3: printf("Quarta\n");  break;
    case 4: printf("Quinta\n");  break;
    case 5: printf("Sexta\n");   break;
    case 6: printf("Sábado\n");  break;
    case 7: printf("Domingo\n"); break;
    default: printf("Dia inválido\n");
}
🧪 Simulador — dia da semana
dia (1-7) =

Funções em C

Modularize o código em blocos reutilizáveis com parâmetros e retorno

📦 Funções — estrutura básica ▼
função C

O que é uma função?

Uma função é um bloco de código com nome que executa uma tarefa específica. Evita repetição, melhora a legibilidade e facilita manutenção. Em C, toda função tem um tipo de retorno, um nome e uma lista de parâmetros.

c — anatomia da função 
/*  tipo_retorno  nome   parâmetros  */
int              soma  (int a, int b) {
    return a + b;  // valor devolvido
}

// Chamando a função
int resultado = soma(3, 7);  // resultado = 10
c — função void (sem retorno) 
void saudacao(void) {
    printf("Olá, mundo!\n");
    // não retorna nada
}

int main() {
    saudacao();  // chamada
    return 0;
}
c — protótipo (declaração antecipada) 
#include <stdio.h>

float media(float a, float b);  // protótipo

int main() {
    printf("%.2f\n", media(8.0, 6.0));
    return 0;
}

float media(float a, float b) {
    return (a + b) / 2.0;
}
🧪 Simulador — função média
🌀 Recursão — função que chama a si mesma ▼
função C

O que é recursão?

Uma função recursiva chama ela mesma para resolver um problema menor. Toda recursão precisa de um caso base (condição de parada) para evitar loop infinito.

c — fatorial recursivo 
int fatorial(int n) {
    if (n == 0 || n == 1)
        return 1;         // caso base
    return n * fatorial(n - 1); // recursão
}

// fatorial(5) = 5×4×3×2×1 = 120
🧪 Simulador — fatorial recursivo
n =

Arrays (Vetores)

Armazene e manipule coleções de dados com vetores unidimensionais e matrizes

📋 Array — declaração e acesso ▼
array C

O que é um array?

Um array é uma sequência de elementos do mesmo tipo armazenados em posições contíguas de memória. Os índices começam em 0.

int v[5] = {10, 20, 30, 40, 50}; índice: [0] [1] [2] [3] [4] valor: 10 20 30 40 50
c — declaração 
int v[5];                         // sem inicializar
int n[5] = {10, 20, 30, 40, 50}; // com valores
float f[] = {1.1, 2.2, 3.3};     // tamanho automático

n[0] = 99;    // modifica o 1º elemento
printf("%d\n", n[2]); // exibe o 3º: 30
c — percorrer com for 
int v[5] = {3, 7, 1, 9, 5};
int soma = 0;

for (int i = 0; i < 5; i++) {
    soma += v[i];
}
printf("Soma: %d\n", soma); // 25
🧪 Simulador — encontrar maior elemento
🔢 Matriz — array bidimensional ▼
array C

O que é uma matriz?

Uma matriz é um array de arrays — como uma tabela com linhas e colunas. Acesso por dois índices: m[linha][coluna].

int m[3][3] col0 col1 col2 lin0 [ 1 ] [ 2 ] [ 3 ] lin1 [ 4 ] [ 5 ] [ 6 ] lin2 [ 7 ] [ 8 ] [ 9 ] m[1][2] = 6
c — matriz 3x3 
int m[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Percorrer com for aninhado
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        printf("%d ", m[i][j]);
    }
    printf("\n");
}

Ponteiros

Manipule memória diretamente com o poderoso sistema de ponteiros do C

📍 Ponteiros — conceito fundamental ▼
ponteiro C

O que é um ponteiro?

Um ponteiro é uma variável que armazena o endereço de memória de outra variável. Use & para pegar o endereço e * para acessar o valor apontado (desreferenciar).

int x = 42; int *p = &x; Memória: endereço 0x100 → x = [ 42 ] endereço 0x200 → p = [ 0x100 ] (aponta para x) *p == 42 (valor de x via ponteiro)
c — operadores & e * 
int x = 42;
int *p = &x;  // p recebe o endereço de x

printf("%d\n", x);    // 42
printf("%d\n", *p);   // 42 (via ponteiro)
printf("%p\n", p);    // endereço de x

*p = 100;  // altera x através do ponteiro
printf("%d\n", x);    // 100
c — passagem por referência 
void dobrar(int *n) {
    *n = *n * 2;  // modifica o original
}

int valor = 5;
dobrar(&valor);
printf("%d\n", valor); // 10
💡 Dica: int *p declara um ponteiro para int. O * na declaração é diferente do * de desreferenciamento usado depois!
🔗 Ponteiros e Arrays ▼
ponteiro array C

Relação especial

Em C, o nome de um array é automaticamente um ponteiro para seu primeiro elemento. Aritmética de ponteiros avança pelo array elemento por elemento.

c — ponteiro percorrendo array 
int v[5] = {10, 20, 30, 40, 50};
int *p = v;  // aponta para v[0]

for (int i = 0; i < 5; i++) {
    printf("%d\n", *(p + i));
    // equivalente a v[i]
}