Programação em C – Fundamentos ao Projeto Prático 💻

Desenvolva uma base sólida em programação utilizando a linguagem C. Aprenda desde a lógica fundamental até a manipulação de memória e organização de projetos profissionais.

Foco do Curso

Metodologia: Aprendizado prático baseado em terminal, compilação manual e construção de algoritmos eficientes, preparando você para sistemas de baixo nível e alto desempenho.

🎯 O Que Você Vai Aprender

Lógica e Memória --- Compreenda como o computador armazena dados, o uso de ponteiros e a gestão eficiente de memória. Ver Módulo 3
Terminal e Compilação --- Domine o uso do GCC e MinGW, entenda o processo de pré-processamento, compilação e linkedição. Ver Compilação
Estruturação de Projetos --- Aprenda a organizar códigos complexos usando headers, múltiplos arquivos fonte e automatização com Makefile. Ver Organização
Persistência de Dados --- Saiba como salvar e carregar informações de arquivos, criando sistemas que mantêm os dados após o fechamento. Ver Projetos

📚 Jornada de Aprendizado (16 Aulas)

O curso é estruturado em quatro fases de evolução técnica.

Plano de Ensino 📅

Curso: Programação em C – Fundamentos ao Projeto Prático

Ementa

Módulo 1: Fundamentos e Lógica: Introdução à lógica de programação, sintaxe básica de C, tipos de dados e operadores.
Módulo 2: Estruturas de Controle e Dados: Controle de fluxo, laços de repetição, vetores e manipulação de cadeias de caracteres (strings).
Módulo 3: Modularização e Memória: Criação de funções, entendimento de endereçamento de memória através de ponteiros e estruturas de dados personalizadas (structs).
Módulo 4: Persistência e Projetos Profissionais: Manipulação de arquivos, organização de múltiplos arquivos, compilação automatizada e desenvolvimento de um sistema completo.

Cronograma (16 Aulas)

Módulo 1: Fundamentos e Lógica

Aula 01: Introdução à Programação e Hello World
Aula 02: Estrutura de um Programa e Compilação (GCC/MinGW)
Aula 03: Variáveis, Tipos de Dados e IO (printf/scanf)
Aula 04: Operadores Aritméticos, Relacionais e Lógicos

Módulo 2: Estruturas de Controle e Dados

Aula 05: Estruturas Condicionais (if, else, switch)
Aula 06: Estruturas de Repetição (while, for, do-while)
Aula 07: Vetores (Arrays Unidimensionais)
Aula 08: Strings (Arrays de caracteres e string.h)

Módulo 3: Modularização e Memória

Aula 09: Funções, Parâmetros e Escopo
Aula 10: Ponteiros (Conceito de Memória e Operadores & e *)
Aula 11: Ponteiros, Vetores e Passagem por Referência
Aula 12: Structs (Estruturas de Dados Personalizadas)

Módulo 4: Persistência e Projetos Profissionais

Aula 13: Manipulação de Arquivos (Leitura e Escritria)
Aula 14: Organização Profissional de Projetos (src, include, Makefile)
Aula 15: Projeto Prático Integrador (Sistema de Cadastro)
Aula 16: Boas Práticas, Debug e Encerramento

Avaliação

Exercícios: 16 listas de exercícios (5 por aula).
Projetos: 16 mini-projetos práticos de fixação.
Quizzes: 16 testes de conhecimento (10 perguntas por aula).
Projeto Integrador: Desenvolvimento de um sistema de cadastro modularizado com persistência em arquivos.

Aulas

Aula 01 – Introdução à Programação e à Linguagem C 🚀

Bem-vindo ao início da sua jornada na programação! Nesta aula, vamos entender o "porquê" da linguagem C ser tão fundamental e daremos nossos primeiros passos no terminal.

🧐 O que é Programação?

Programar é o ato de dar instruções precisas para um computador resolver um problema ou executar uma tarefa. O computador é extremamente rápido, mas "burro": ele só faz exatamente o que mandamos através de uma Linguagem de Programação.

📜 História e Importância da Linguagem C

Criada na década de 70 por Dennis Ritchie nos laboratórios Bell, a linguagem C revolucionou a computação. Ela foi usada para escrever o sistema operacional Unix, que é a base para o Linux, macOS e Android que usamos hoje.

[!NOTE] Conceito: C é considerada uma linguagem de "médio nível" porque une a facilidade de leitura humana com o poder de manipular o hardware diretamente.

🌍 Onde C é Utilizada Hoje?

Apesar de ser uma linguagem veterana, C está em todo lugar: - Sistemas Operacionais: Windows, Linux, macOS. - Sistemas Embarcados: Micro-ondas, carros, satélites, Arduinos. - Motores de Jogos: A base de muitos motores gráficos de alto desempenho. - Bancos de Dados: MySQL, PostgreSQL e muitos outros.

🏗️ Fluxo de Funcionamento de um Programa

Abaixo, veja como transformamos texto em algo que o processador entende:

graph LR
    A["Código Fonte (.c)"] --> B["Compilador (GCC/MinGW)"]
    B --> C["Binário Executável (.exe)"]
    C --> D["Processador"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style C fill:#00ff00,stroke:#333,stroke-width:2px

💻 Primeiro Programa: Hello, World!

Vamos criar nosso primeiro código. Abra seu editor e digite:

#include <stdio.h> // Biblioteca padrão de entrada e saída

int main() {
    // A função main é o ponto de partida de todo programa C
    printf("Olá, Mundo! Bem-vindo ao curso de C.\n");
    return 0; // Indica que o programa terminou com sucesso
}

🛠️ Compilando no Terminal

Para transformar esse código em um programa real, usamos o terminal:

$ gcc hello.c -o hello
$ ./hello
Olá, Mundo! Bem-vindo ao curso de C.

[!CAUTION] Atenção: Se você ainda não instalou o compilador, siga o Guia de Instalação.

🚀 Mini-Projeto da Aula: "Cartão de Visitas"

Objetivo: Criar um programa que imprima seu nome, idade e sua principal motivação para aprender C, formatado em um quadro de caracteres.

Exemplo de Saída:

******************************
* Nome: Ricardo              *
* Idade: 25 anos             *
* Foco: Sistemas Embarcados  *
******************************

📝 Exercícios de Fixação

Explique com suas palavras por que a linguagem C é importante para entender o hardware.
O que acontece se você esquecer o ; no final do printf? Teste e observe o erro no terminal.
Modifique o "Hello World" para imprimir duas mensagens em linhas diferentes usando \n.

Próxima Aula: Estrutura & Compilação

Aula 02 – Estrutura de um Programa em C 🏗️

Na aula anterior, rodamos nosso primeiro código. Hoje, vamos desmontar um programa C para entender cada uma de suas peças e como elas se encaixam durante o processo de compilação.

🧩 Anatomia de um Código C

Todo programa em C possui elementos fundamentais que garantem seu funcionamento. Observe o exemplo abaixo:

#include <stdio.h> // 1. Diretiva do Pré-processador

/*
   2. Comentário de múltiplas linhas:
   Este programa imprime uma saudação.
*/

int main() { // 3. Ponto de Entrada (Função Principal)
    // 4. Instrução ou Comando (Statement)
    printf("Entendendo a estrutura do C!\n"); 

    return 0; // 5. Valor de Retorno
}

Explicação dos Componentes:

#include <stdio.h>: Avisa ao compilador que usaremos funções de entrada e saída (como o printf).
Comentários: Texto ignorado pelo compilador, usado para explicar o código (// para uma linha ou /* ... */ para blocos).
int main(): A "chave de ignição". Todo código C começa a ser executado aqui.
Chaves { }: Delimitam o início e o fim de um bloco de código.
Ponto e vírgula ;: Indica o final de uma instrução. Omiti-lo é o erro mais comum de iniciantes!

⚙️ O Ciclo de Vida do Código (Compilação)

Não escrevemos algo que o processador entende diretamente. O código passa por 3 etapas principais:

graph TD
    A["Código Fonte (.c)"] --> B["Pré-processador"]
    B -- "Código Expandido" --> C["Compilador"]
    C -- "Código de Máquina (.o / .obj)" --> D["Linker"]
    D -- "Bibliotecas Externas" --> E["Executável (.exe / .out)"]
    style A fill:#e1f5fe
    style E fill:#c8e6c9

Pré-processador: Trata as linhas que começam com # (inclui arquivos e substitui macros).
Compilador: Traduz o código C para linguagem de montagem (assembly) e depois para código de objeto.
Linker: Une seu código com as bibliotecas do sistema (como a stdio) para criar o executável final.

💻 Prática: Compilando com Nome Personalizado

No terminal, podemos dar qualquer nome ao nosso programa usando a flag -o (output).

$ gcc aula02.c -o meu_programa
$ ./meu_programa
Entendendo a estrutura do C!

⚠️ Erros Comuns e Como Corrigi-los

[!WARNING] Syntax Error: Geralmente causado por falta de ; ou fechar chaves } incorretamente. O compilador indicará a linha aproximada do erro.

[!TIP] Dica: Sempre indente seu código (use espaços/tabs no início das linhas). Isso ajuda a visualizar onde começam e terminam as funções.

🚀 Mini-Projeto da Aula: "O Calculador de Área"

Objetivo: Criar um arquivo chamado area.c que use múltiplos printf para exibir a fórmula de cálculo da área de um quadrado (\(A = L^2\)) acompanhado de um desenho do quadrado feito com caracteres.

Exemplo de Saída:

CÁLCULO DE ÁREA
---------------
      ____
     |    |
     |    | L=5
     |____|
Area = 25
---------------

📝 Exercícios de Fixação

Qual a função das bibliotecas (headers) terminadas em .h?
Crie um programa com um erro proposital (tire o ;) e observe a mensagem do GCC. O que ela diz?
Escreva um programa que use comentários para explicar o que cada linha do seu código faz.

Próxima Aula: Variáveis & Tipos

Aula 03 – Variáveis e Tipos de Dados 📊

Computadores servem para processar informações. No entanto, para processar algo, primeiro precisamos guardá-lo. É aqui que entram as Variáveis.

📦 O que é uma Variável?

Pense na variável como uma caixa na memória RAM do seu computador. Cada caixa tem: 1. Tipo: O que ela pode guardar (números, letras, etc). 2. Nome: Como chamamos essa caixa (identificador). 3. Valor: O que está dentro da caixa.

🔢 Tipos de Dados Primitivos em C

Em C, precisamos dizer exatamente que tipo de dado vamos guardar:

Tipo	Descrição	Espaço (Bytes)	Formatador
`int`	Números inteiros (ex: 10, -5)	4	`%d` ou `%i`
`float`	Números decimais (ex: 3.14)	4	`%f`
`double`	Decimais de alta precisão	8	`%lf`
`char`	Um único caractere (ex: 'A')	1	`%c`

✍️ Declaração e Inicialização

#include <stdio.h>

int main() {
    int idade = 25;       // Declara e atribui valor
    float altura = 1.75;  // Note o uso de ponto, não vírgula!
    char inicial = 'R';   // Caractere usa aspas simples

    printf("Eu tenho %d anos e meço %.2f de altura.\n", idade, altura);
    return 0;
}

[!IMPORTANT] Ponto Flutuante: Em programação, usamos o padrão americano. Logo, decimais usam ponto (1.75) e não vírgula.

📥 Lendo Dados com `scanf`

Para interagir com o usuário, usamos o scanf. Ele "escaneia" o que foi digitado no teclado.

$ gcc aula03.c -o entrada
$ ./entrada
Digite sua idade: 20
Você digitou: 20 anos.

Exemplo de Código:

int idade;
printf("Digite sua idade: ");
scanf("%d", &idade); // O & (ampersand) é obrigatório aqui!

[!CAUTION] Atenção: O símbolo & indica o endereço da variável. Sem ele, o scanf não sabe onde guardar o valor e seu programa vai travar.

🚀 Mini-Projeto da Aula: "Conversor de Idade"

Objetivo: Criar um programa que peça a idade do usuário e calcule quantos dias ele já viveu aproximadamente (Idade * 365).

📝 Exercícios de Fixação

Crie variáveis para guardar seu peso, altura e a primeira letra do seu nome. Imprima-as formatadas.
O que acontece se você tentar guardar um número com vírgula (ex: 3.9) em uma variável do tipo int? Teste e descubra.
Pesquise: O que é o tipo unsigned int e quando devemos usá-lo?

Próxima Aula: Operadores

Aula 04 – Operadores e Expressões ➗

Agora que sabemos como guardar dados, precisamos aprender a manipulá-los. Os Operadores são símbolos que dizem ao C para realizar cálculos ou comparações.

➕ 1. Operadores Aritméticos

Usados para cálculos matemáticos básicos:

Operador	Operação	Exemplo (`a=10, b=3`)	Resultado
`+`	Adição	`a + b`	13
`-`	Subtração	`a - b`	7
`*`	Multiplicação	`a * b`	30
`/`	Divisão	`a / b`	3 (se for `int`)
`%`	Resto (Módulo)	`a % b`	1

[!WARNING] Divisão Inteira: Se você dividir dois números inteiros (10 / 3), o C vai ignorar o resto e dar o resultado 3. Para ter 3.33, pelo menos um dos números deve ser float.

⚖️ 2. Operadores Relacionais

Usados para comparar dois valores. O resultado é sempre 1 (Verdadeiro) ou 0 (Falso).

Operador	Significado	Exemplo
`==`	Igual a	`5 == 5` (1)
`!=`	Diferente de	`5 != 3` (1)
`>`	Maior que	`10 > 20` (0)
`<`	Menor que	`7 < 10` (1)
`>=`	Maior ou igual	`5 >= 5` (1)
`<=`	Menor ou igual	`3 <= 2` (0)

🧠 3. Operadores Lógicos

Usados para combinar várias comparações:

&& (E / AND): Verdadeiro apenas se ambos forem verdadeiros.
|| (OU / OR): Verdadeiro se pelo menos um for verdadeiro.
! (NÃO / NOT): Inverte o valor (se era 1 vira 0, e vice-versa).

⬆️ 4. Incremento e Decremento

Atalhos muito usados em contagens: - x++ é o mesmo que x = x + 1. - x-- é o mesmo que x = x - 1.

💻 Exemplo Prático: Validação de Nota

#include <stdio.h>

int main() {
    float nota;
    printf("Digite sua nota: ");
    scanf("%f", &nota);

    // Verifica se a nota é válida (entre 0 e 10)
    int valida = (nota >= 0) && (nota <= 10);

    printf("A nota inserida é válida? %d (1=Sim, 0=Não)\n", valida);
    return 0;
}

🏗️ Precedência de Operadores

Assim como na matemática, o C segue uma ordem: 1. Parênteses ( ) 2. Multiplicação e Divisão *, /, % 3. Adição e Subtração +, -

🚀 Mini-Projeto da Aula: "Calculadora de Médias"

Objetivo: Criar um programa que peça 3 notas de um aluno, calcule a média aritmética e mostre se ele foi aprovado (média >= 7.0).

📝 Exercícios de Fixação

Qual o resultado da expressão 10 % 3? Explique por quê.
Escreva um programa que peça um número e informe se ele é par ou ímpar (Dica: use o operador %).
Crie uma expressão lógica que verifique se uma idade está entre 18 e 65 anos.

Próxima Aula: Estruturas Condicionais

Aula 05 – Estruturas Condicionais 🚦

Até agora, nossos programas eram lidos como uma linha reta, do topo até o fim. Porém, na vida real, precisamos tomar decisões. As Estruturas Condicionais permitem que o programa escolha caminhos diferentes.

🛣️ 1. O Desvio Simples: `if` e `else`

O if (se) testa uma condição. Se ela for verdadeira, o bloco de código dentro dele é executado. Caso contrário, o else (senão) assume o controle.

#include <stdio.h>

int main() {
    int idade;
    printf("Digite sua idade: ");
    scanf("%d", &id);

    if (idade >= 18) {
        printf("Você é maior de idade. Acesso liberado!\n");
    } else {
        printf("Acesso negado. Você é menor de idade.\n");
    }

    return 0;
}

🚦 2. Múltiplas Condições: `else if`

Quando temos mais de dois caminhos possíveis, usamos o else if.

if (nota >= 7.0) {
    printf("Aprovado!\n");
} else if (nota >= 5.0) {
    printf("Recuperação!\n");
} else {
    printf("Reprovado!\n");
}

🎚️ 3. A Escolha Múltipla: `switch`

O switch (chaveador) é ideal para quando temos uma variável que pode assumir vários valores discretos (como um menu).

int opcao;
printf("1. Café\n2. Chá\nEscolha: ");
scanf("%d", &opcao);

switch (opcao) {
    case 1:
        printf("Saindo um café quentinho...\n");
        break; // Omitir o break faz o código continuar para o próximo caso!
    case 2:
        printf("Preparando seu chá...\n");
        break;
    default:
        printf("Opção inválida!\n");
}

[!CAUTION] Atenção: O comando break é essencial no switch. Sem ele, o C executará todos os casos abaixo do escolhido!

⚡ 4. Operador Ternário (Atalho)

Uma forma rápida de escrever um if-else simples em uma única linha: condicao ? valor_se_verdade : valor_se_falso;

Exemplo: int maior = (a > b) ? a : b;

💻 Exemplo Prático: Par ou Ímpar

$ gcc parimpar.c -o parimpar
$ ./parimpar
Digite um número: 7
O número 7 é ÍMPAR.

int num;
scanf("%d", &num);
if (num % 2 == 0) {
    printf("É PAR!\n");
} else {
    printf("É ÍMPAR!\n");
}

🚀 Mini-Projeto da Aula: "O Jogo de Adivinhação"

Objetivo: Criar um programa que defina um "número secreto" (ex: 42) e peça para o usuário tentar adivinhar. O programa deve dizer se ele acertou, se o chute foi alto demais ou baixo demais.

📝 Exercícios de Fixação

Escreva um programa que receba dois números e imprima o maior deles.
Crie uma calculadora simples: Peça dois números e um símbolo de operação (+, -, *, /). Use switch para realizar o cálculo.
O que acontece se você usar if (x = 10) em vez de if (x == 10)? Teste e explique o comportamento bizarro que ocorrerá.

Próxima Aula: Estruturas de Repetição

Aula 06 – Estruturas de Repetição 🔁

Imagine ter que imprimir "Olá Mundo" 1.000 vezes. Escrever o código manualmente seria impossível. As Estruturas de Repetição (ou laços/loops) permitem que o computador execute a mesma tarefa várias vezes automaticamente.

🔄 1. O Laço `while` (Enquanto)

O while repete um bloco de código enquanto uma condição for verdadeira.

#include <stdio.h>

int main() {
    int contador = 1;

    while (contador <= 5) {
        printf("Número: %d\n", contador);
        contador++; // Importante: Incrementa para a condição um dia ser falsa!
    }

    return 0;
}

🔁 2. O Laço `for` (Para)

O for é ideal quando sabemos exatamente quantas vezes queremos repetir algo. Ele agrupa a inicialização, a condição e o incremento em uma única linha.

for (int i = 1; i <= 5; i++) {
    printf("Contagem: %d\n", i);
}

🔄 3. O Laço `do-while` (Faça-Enquanto)

Diferente dos outros, o do-while garante que o código será executado pelo menos uma vez, pois a condição só é checada no final.

int num;
do {
    printf("Digite um número positivo (ou 0 para parar): ");
    scanf("%d", &num);
} while (num > 0);

🛑 4. `break` e `continue`

break: Sai imediatamente do laço, interrompendo a repetição.
continue: Pula o resto do código dentro do laço e volta para o início da próxima repetição.

💻 Exemplo Prático: Tabuada

$ gcc tabuada.c -o tabuada
$ ./tabuada
Qual tabuada deseja? 5
5 x 1 = 5
5 x 2 = 10
...
5 x 10 = 50

int tab;
scanf("%d", &tab);
for (int i = 1; i <= 10; i++) {
    printf("%d x %d = %d\n", tab, i, tab * i);
}

🚀 Mini-Projeto da Aula: "Contagem Regressiva"

Objetivo: Criar um programa que peça um número ao usuário e faça uma contagem regressiva até zero, com um intervalo visual (use vários prints ou apenas a lógica).

📝 Exercícios de Fixação

Escreva um programa que imprima todos os números pares de 1 a 20 usando um laço for.
Crie um programa que peça 5 números ao usuário e, ao final, exiba a soma de todos eles.
O que é um "Loop Infinito"? Crie um propositalmente (ex: while(1)) e aprenda a pará-lo no terminal usando Ctrl + C.

Próxima Aula: Vetores (Arrays)

Aula 07 – Vetores (Arrays) 📏

Até agora, cada variável guardava apenas um valor. Mas e se quisermos guardar as 10 notas de um aluno ou os nomes de 50 produtos? Criar 50 variáveis seria um caos. Para isso, usamos os Vetores (ou Arrays).

📦 O que é um Vetor?

Um vetor é uma coleção de variáveis do mesmo tipo, colocadas lado a lado na memória. Imagine um prédio onde cada apartamento tem o mesmo tamanho, mas um endereço (índice) diferente.

📐 Declaração e Acesso

#include <stdio.h>

int main() {
    // Declara um vetor de inteiros com 5 posições
    int notas[5] = {8, 7, 10, 6, 9};

    // Acessando valores (O índice começa sempre em 0!)
    printf("A primeira nota é: %d\n", notas[0]);
    printf("A última nota é: %d\n", notas[4]);

    return 0;
}

[!IMPORTANT] Índice Zero: No C, o primeiro elemento está na posição 0. Se um vetor tem tamanho 5, os índices válidos são de 0 a 4.

🔁 Percorrendo um Vetor com `for`

A maior vantagem dos vetores é que podemos usar laços de repetição para processar todos os dados de uma vez.

int valores[5];

// Lendo 5 valores do teclado
for (int i = 0; i < 5; i++) {
    printf("Digite o valor %d: ", i + 1);
    scanf("%d", &valores[i]);
}

// Imprimindo os valores
for (int i = 0; i < 5; i++) {
    printf("Vetor[%d] = %d\n", i, valores[i]);
}

📊 Aplicações Reais

Vetores são a base para: - Listas de Compras: Armazenar preços. - Sensores: Guardar as últimas 100 leituras de temperatura. - Imagens: Uma imagem digital é, na verdade, um grande vetor de pixels. - Sons: Ondas sonoras digitalizadas em pequenos pedaços.

🚫 Perigos: Acesso Fora do Limite

C não avisa se você tentar acessar uma posição que não existe.

int teste[3];
teste[10] = 50; // PERIGO! Isso pode travar seu programa ou corromper outros dados.

🚀 Mini-Projeto da Aula: "Média de Turma"

Objetivo: Criar um programa que peça a nota de 5 alunos, guarde-as em um vetor, calcule a média da turma e diga quantos alunos ficaram acima da média.

📝 Exercícios de Fixação

Crie um vetor que armazene os 10 primeiros números pares e os imprima na ordem inversa.
Escreva um programa que encontre o maior valor dentro de um vetor de 5 números digitados pelo usuário.
Tente criar um vetor de float para armazenar preços de produtos e faça a soma total do "carrinho".

Próxima Aula: Strings

Aula 08 – Strings em C 🔡

Diferente de linguagens como Python ou Java, o C não possui um tipo "String" nativo. Em C, um texto é simplesmente um Vetor de Caracteres (char).

🧵 1. O que é uma String em C?

É um array de char que termina obrigatoriamente com o caractere especial \0 (null terminator). Esse caractere avisa ao computador: "O texto acaba aqui!".

Declaração e Inicialização

#include <stdio.h>

int main() {
    // Declaração de string com 20 posições
    char nome[20] = "Ricardo"; 

    // O C adiciona o '\0' automaticamente no final de strings entre aspas duplas
    printf("Olá, %s!\n", nome); // %s é o formatador de String

    return 0;
}

📥 2. Lendo Strings com Espaços

O scanf("%s", ...) para de ler assim que encontra um espaço. Para ler um nome completo ou uma frase, usamos o comando fgets.

$ gcc strings.c -o strings
$ ./strings
Digite seu nome completo: Ricardo Pires
Bem-vindo, Ricardo Pires!

Exemplo de Código:

char nomeCompleto[50];
printf("Digite seu nome: ");
fgets(nomeCompleto, 50, stdin); // Nome, tamanho, entrada padrão (teclado)

📚 3. A Biblioteca `<string.h>`

Para manipular textos, usamos funções prontas desta biblioteca:

strlen(): Retorna o tamanho da string (quantidade de letras).
strcpy(): Copia uma string para outra.
strcat(): Junta (concatena) duas strings.
strcmp(): Compara se duas strings são iguais (retorna 0 se forem iguais).

💻 Exemplo Prático: Comparação de Senha

#include <stdio.h>
#include <string.h>

int main() {
    char senha[20] = "segredo123";
    char tentativa[20];

    printf("Digite a senha: ");
    scanf("%s", tentativa);

    if (strcmp(senha, tentativa) == 0) {
        printf("Acesso Garantido!\n");
    } else {
        printf("Senha Incorreta.\n");
    }

    return 0;
}

🚀 Mini-Projeto da Aula: "Criptografia Simples"

Objetivo: Criar um programa que receba uma palavra e a "criptografe" somando 1 ao valor ASCII de cada caractere (ex: 'A' vira 'B', 'B' vira 'C').

📝 Exercícios de Fixação

Crie um programa que peça o nome do usuário e imprima quantas letras esse nome tem.
Escreva um programa que receba duas palavras e as junte em uma única variável usando strcat.
Desafio: Como você faria para imprimir uma string de trás para frente usando um laço for e o strlen?

Próxima Aula: Funções

Aula 09 – Funções e Modularização 📦

Até agora, escrevemos todo o nosso código dentro da função main. Para programas pequenos, isso funciona. Mas para sistemas grandes, o código se tornaria impossível de ler. As Funções permitem dividir o programa em pequenas peças reutilizáveis.

🧩 1. O que é uma Função?

Uma função é um bloco de código que realiza uma tarefa específica e pode ser "chamado" a qualquer momento. Elas funcionam como pequenos programas dentro do programa principal.

Estrutura Base:

tipo_retorno nome_da_funcao(parametros) {
    // Código da função
    return valor; 
}

Tipo de Retorno: O tipo de dado que a função envia de volta (ex: int, float, void se não enviar nada).
Parâmetros: Dados que a função recebe para trabalhar.

🛠️ 2. Exemplo Prático: Função de Soma

#include <stdio.h>

// 1. Protótipo da Função (Avisa ao C que a função existe)
int somar(int a, int b);

int main() {
    int resultado = somar(10, 5); // Chamada da função
    printf("A soma é: %d\n", resultado);
    return 0;
}

// 2. Definição da Função
int somar(int a, int b) {
    return a + b;
}

🌐 3. Escopo de Variáveis

Onde uma variável "vive"? - Variáveis Locais: Criadas dentro de uma função. Elas só existem lá dentro e "morrem" quando a função termina. - Variáveis Globais: Criadas fora de todas as funções. Elas podem ser vistas e alteradas por qualquer parte do programa (use com muito cuidado!).

🔘 4. Funções sem Retorno (`void`)

Muitas vezes queremos apenas que a função execute algo, como imprimir um menu, sem devolver nenhum cálculo.

void imprimirCabecalho() {
    printf("====================\n");
    printf("   SISTEMA C-STORE  \n");
    printf("====================\n");
}

💻 Modularização: Por que usar?

Reutilização: Escreva uma vez, use mil vezes.
Organização: O main fica limpo e fácil de entender.
Manutenção: Se houver um erro no cálculo, você só precisa consertar em um lugar.

🚀 Mini-Projeto da Aula: "Biblioteca de Desenhos"

Objetivo: Criar funções para desenhar diferentes formas geométricas (quadrado, linha, triângulo) usando caracteres, e chamá-las no main conforme a escolha do usuário.

📝 Exercícios de Fixação

Crie uma função chamada ehPar que receba um inteiro e retorne 1 se for par e 0 se for ímpar.
Escreva uma função que receba a temperatura em Celsius e retorne o valor em Fahrenheit.
Crie uma função void que receba um número e imprima a tabuada dele de 1 a 10.

Próxima Aula: Ponteiros (Introdução)

Aula 10 – Ponteiros (Introdução) 🧠

Ponteiros são considerados o "terror" de muitos estudantes de C, mas na verdade eles são ferramentas extremamente simples e poderosas. Um Ponteiro é apenas uma variável que guarda o Endereço de Memória de outra variável.

📍 1. Endereço de Memória vs Valor

Toda variável que você cria ocupa um lugar físico na memória RAM do computador. Esse lugar tem um número de identificação, chamado de Endereço.

Valor: O que está dentro da "caixa" (ex: 42).
Endereço: Onde a "caixa" está na prateleira (ex: 0xFF01).

🏗️ 2. Operadores de Ponteiro

Existem dois símbolos fundamentais que você deve decorar:

& (E comercial / Ampersand): Significa "Endereço de". Usado para descobrir onde a variável mora.
* (Asterisco): Quando usado na declaração, indica um ponteiro. Quando usado no código, significa "Conteúdo de" (aponta para o valor dentro do endereço).

Exemplo Base:

#include <stdio.h>

int main() {
    int v = 10;
    int *p; // Declarando um ponteiro para inteiro

    p = &v; // p agora guarda o ENDEREÇO de v

    printf("Valor de v: %d\n", v);
    printf("Endereço de v: %p\n", &v); // %p para endereços
    printf("Valor apontado por p: %d\n", *p);

    return 0;
}

🛠️ 3. Por que usar Ponteiros?

Você pode se perguntar: "Por que não usar a variável direto?". Ponteiros são essenciais para: - Passagem por Referência: Permitir que uma função mude o valor de uma variável que está fora dela. - Alocação Dinâmica: Criar vetores que crescem ou diminuem durante o programa. - Estruturas Complexas: Como listas encadeadas e árvores (base de grandes softwares).

💻 Exemplo Prático: Trocando Valores

Lembram do exercício de trocar A por B? Com funções e ponteiros, podemos fazer isso de forma elegante:

void trocar(int *a, int *b) {
    int aux = *a;
    *a = *b;
    *b = aux;
}

int main() {
    int x = 5, y = 10;
    trocar(&x, &y); // Enviamos o endereço!
    printf("x=%d, y=%d", x, y); // Saída: x=10, y=5
    return 0;
}

🚀 Mini-Projeto da Aula: "Inspetor de Memória"

Objetivo: Criar um programa que peça para o usuário digitar um valor, e o programa mostre um relatório completo: o valor, o endereço de memória e o tamanho em bytes que aquela variável ocupa (use sizeof).

📝 Exercícios de Fixação

Crie um ponteiro para um float, atribua um valor a uma variável e use o ponteiro para dobrar esse valor original.
O que acontece se você tentar imprimir p em vez de *p no printf? Teste e observe o resultado.
Desafio: Tente criar um "Ponteiro para Ponteiro" (int **pp) e veja se consegue acessar o valor original através dele.

Próxima Aula: Ponteiros e Arrays

Aula 11 – Ponteiros e Arrays 🎭

Você sabia que, em C, um vetor é na verdade apenas um ponteiro disfarçado? Entender essa relação é a chave para escrever códigos extremamente rápidos e eficientes.

🎭 1. O Nome do Vetor é um Ponteiro

Quando você declara int v[5], o nome v funciona como um ponteiro constante para o primeiro elemento do array (&v[0]).

#include <stdio.h>

int main() {
    int v[3] = {10, 20, 30};

    printf("Endereço de v[0]: %p\n", &v[0]);
    printf("Valor de v (como ponteiro): %p\n", v); // São o mesmo endereço!

    return 0;
}

➕ 2. Aritmética de Ponteiros

Diferente de números comuns, somar 1 a um ponteiro não pula 1 byte, mas sim 1 elemento. O C sabe o tamanho do tipo de dado e pula a quantidade exata de bytes.

p + 1: Aponta para o próximo elemento do vetor.
*(p + 1): É exatamente o mesmo que v[1].

int v[3] = {10, 20, 30};
int *p = v;

printf("Primeiro: %d\n", *p);       // v[0]
printf("Segundo: %d\n", *(p + 1));  // v[1]
printf("Terceiro: %d\n", *(p + 2)); // v[2]

🔁 3. Percorrendo Arrays sem Colchetes

Podemos usar a aritmética de ponteiros para varrer um vetor de forma muito performática.

int v[5] = {1, 2, 3, 4, 5};
int *p = v;

for (int i = 0; i < 5; i++) {
    printf("Elemento %d: %d\n", i, *(p + i));
}

🏗️ 4. Por que isso importa?

Em sistemas embarcados, drivers de hardware e motores de jogos, acessar a memória via aritmética de ponteiros costuma ser levemente mais rápido que usar a notação de colchetes [], pois evita cálculos extras do compilador.

🚀 Mini-Projeto da Aula: "O Varredor de Memória"

Objetivo: Criar um programa que peça 5 números para um vetor, mas que realize a leitura e a impressão de todos os valores sem usar colchetes [], utilizando apenas ponteiros e aritmética.

📝 Exercícios de Fixação

Crie um vetor de 5 double e use um ponteiro para percorrê-lo e calcular a média.
Tente somar 2 a um ponteiro para int. Quantos bytes o endereço mudou? (Use %p para verificar).
Desafio: Escreva uma função que receba um ponteiro para o início de uma string e conte quantos caracteres ela tem sem usar a função strlen.

Próxima Aula: Estruturas (Structs)

Aula 12 – Estruturas (Structs) 🏗️

Até agora, aprendemos a agrupar dados do mesmo tipo em Vetores. Mas e se quisermos agrupar dados de tipos diferentes relacionados ao mesmo objeto? Por exemplo, um Aluno tem Nome (string), Idade (int) e Nota (float). Para isso, usamos as Structs (Estruturas).

🏛️ 1. O que é uma Struct?

Uma Struct é um tipo de dado personalizado que funciona como uma "ficha" ou "formulário". Ela agrupa várias variáveis (chamadas de membros) sob um único nome.

Definição e Uso:

#include <stdio.h>
#include <string.h>

// Definindo a estrutura
struct Aluno {
    char nome[50];
    int idade;
    float nota;
};

int main() {
    struct Aluno a1; // Criando uma variável do tipo Aluno

    // Acessando membros com o ponto (.)
    strcpy(a1.nome, "Ricardo");
    a1.idade = 20;
    a1.nota = 9.5;

    printf("Aluno: %s | Idade: %d | Nota: %.1f\n", a1.nome, a1.idade, a1.nota);

    return 0;
}

📑 2. O comando `typedef`

Para não ter que escrever struct Aluno toda vez, podemos dar um "apelido" ao tipo usando typedef.

typedef struct {
    char marca[20];
    float preco;
} Carro;

int main() {
    Carro c1 = {"Fiat", 45000.00};
    printf("Carro: %s\n", c1.marca);
}

📚 3. Vetores de Structs

Podemos criar um array onde cada posição é uma ficha completa. Isso é a base para pequenos bancos de dados em memória.

Carro estoque[10]; // Um vetor capaz de guardar 10 fichas de carros!

for (int i = 0; i < 2; i++) {
    printf("Marca do carro %d: ", i + 1);
    scanf("%s", estoque[i].marca);
}

🏹 4. Ponteiros para Structs e o Operador `->`

Quando usamos ponteiros para manipular estruturas, usamos o operador de seta (->) para acessar os membros.

struct Aluno a1 = {"Joao", 18, 7.0};
struct Aluno *p = &a1;

printf("Nome: %s", p->nome); // O mesmo que (*p).nome

🚀 Mini-Projeto da Aula: "Cadastro de Produtos"

Objetivo: Criar um sistema que cadastre 3 produtos (Nome, Preço e Quantidade) usando um vetor de structs, e ao final exiba o valor total do inventário (Preço * Quantidade de todos os itens).

📝 Exercícios de Fixação

Defina uma struct Ponto com coordenadas x e y (float). Peça ao usuário os dados de dois pontos e calcule a distância entre eles.
Crie uma struct Livro com título, autor e número de páginas. Peça ao usuário para cadastrar um livro e exiba os dados formatados.
Desafio: Crie um vetor de 5 structs Funcionario (Nome, Salário). Encontre e imprima o nome do funcionário que tem o maior salário.

Próxima Aula: Arquivos (I/O)

Aula 13 – Arquivos (Gerenciamento de Dados) 💾

Até agora, todos os dados que digitamos sumiam assim que o programa era fechado. Para criar sistemas reais, precisamos salvar as informações no disco rígido. Em C, fazemos isso usando o ponteiro especial FILE.

📂 1. Abrindo e Fechando Arquivos

Para trabalhar com um arquivo, primeiro devemos "abri-lo" e, ao terminar, "fechá-lo" obrigatoriamente para garantir que os dados sejam salvos.

#include <stdio.h>

int main() {
    FILE *arquivo;

    // fopen(nome_do_arquivo, modo)
    arquivo = fopen("dados.txt", "w"); // "w" = write (escrever)

    if (arquivo == NULL) {
        printf("Erro ao abrir o arquivo!\n");
        return 1;
    }

    // ... realizar operações ...

    fclose(arquivo); // SEMPRE feche o arquivo!
    return 0;
}

🚦 2. Modos de Abertura

Modo	Descrição
`"r"`	Read: Abre para leitura (o arquivo deve existir).
`"w"`	Write: Abre para escrita (cria novo ou sobrescreve o existente).
`"a"`	Append: Abre para adicionar ao final (não apaga o que já existe).

✍️ 3. Escrevendo no Arquivo (`fprintf`)

É quase igual ao printf, mas o primeiro parâmetro é o ponteiro do arquivo.

fprintf(arquivo, "Nome: %s | Idade: %d\n", "Ricardo", 20);

📖 4. Lendo do Arquivo (`fscanf` e `fgets`)

fscanf: Lê dados formatados (para no espaço).
fgets: Lê uma linha inteira do arquivo.

char linha[100];
while (fgets(linha, 100, arquivo) != NULL) {
    printf("%s", linha);
}

💻 Exemplo Prático: Diário Simples

FILE *arq = fopen("notas.txt", "a");
char texto[50];

printf("Escreva algo para o arquivo: ");
fgets(texto, 50, stdin);

fprintf(arq, "%s", texto);
fclose(arq);

🚀 Mini-Projeto da Aula: "Gerador de Log"

Objetivo: Criar um programa que peça o nome do usuário e registre em um arquivo chamado acessos.log o nome dele seguido da frase "Acessou o sistema". O programa deve usar o modo "a" para não apagar os acessos anteriores.

📝 Exercícios de Fixação

Crie um programa que abra um arquivo de texto, leia o conteúdo e o imprima em letras maiúsculas no terminal.
Escreva um programa que peça 5 números ao usuário e os salve em um arquivo chamado numeros.txt, um por linha.
Desafio: Crie uma função que conte quantas linhas existem em um arquivo de texto específico.

Próxima Aula: Organização de Projetos

Aula 14 – Organização de Projetos 📂

Até agora, todos os nossos programas tinham apenas um arquivo .c. Em projetos profissionais, o código é dividido em dezenas ou centenas de arquivos para facilitar a organização. Em C, usamos arquivos de Cabeçalho (.h) e arquivos de Implementação (.c).

🏗️ 1. A Divisão do Trabalho

Arquivo de Cabeçalho (.h): Contém as "promessas" (protótipos das funções, definições de structs e constantes). É o manual de instruções.
Arquivo de Implementação (.c): Contém o código real das funções.

🛡️ 2. Header Guards

Para evitar que o compilador inclua o mesmo arquivo várias vezes (causando erros), usamos os "Guardiões de Cabeçalho":

// util.h
#ifndef UTIL_H
#define UTIL_H

void saudar();

#endif

🛠️ 3. Exemplo Prático: Projeto Modular

Imagine um projeto com 3 arquivos:

calculos.h (Protótipos)
calculos.c (Lógica das funções)
main.c (Ponto de entrada que usa as funções)

No main.c:

#include <stdio.h>
#include "calculos.h" // Aspas "" indicam arquivos locais ao projeto

int main() {
    printf("Resultado: %d", somar(10, 20));
    return 0;
}

⚙️ 4. Compilando Múltiplos Arquivos

Para gerar o programa final, precisamos compilar todos os arquivos .c juntos:

$ gcc main.c calculos.c -o meu_projeto
$ ./meu_projeto

📜 5. Introdução ao Makefile (Básico)

O Makefile é um script que automatiza o processo de compilação. Em vez de digitar um comando gigante no terminal, você apenas digita make.

# Exemplo simplificado de Makefile
all:
    gcc main.c calculos.c -o meu_projeto

🚀 Mini-Projeto da Aula: "Calculadora Modular"

Objetivo: Criar um projeto onde as funções matemáticas (somar, subtrair, multiplicar) fiquem em arquivos separados do main.c. O desafio é compilar tudo junto e garantir que os headers funcionem.

📝 Exercícios de Fixação

Crie um header geometria.h com constantes para PI e protótipos para área de círculo. Implemente no geometria.c e use no main.c.
O que acontece se você esquecer as aspas "" e usar < > para um arquivo que você criou? Teste e observe o erro do compilador.
Desafio: Tente criar um Makefile que compile seu projeto e também tenha um comando clean para apagar o executável.

Próxima Aula: Projeto Integrador

Aula 15 – Projeto Prático Integrador 🚀

Chegamos ao ponto alto do nosso curso! Nesta aula, não aprenderemos um conceito novo, mas sim como Integrar tudo o que vimos até aqui: Variáveis, Condicionais, Laços, Vetores, Funções, Structs e Arquivos.

🏗️ 1. O Desafio: Sistema de Gestão de Biblioteca

Vamos construir um sistema que permita: 1. Cadastrar Livros em uma struct. 2. Salvar os livros em um arquivo .txt para não perdê-los. 3. Listar os livros cadastrados lendo diretamente do disco. 4. Organizar o código em funções para manter o main limpo.

🗂️ 2. A Estrutura do Dado

typedef struct {
    char titulo[50];
    char autor[30];
    int ano;
} Livro;

🛠️ 3. A Lógica de Persistência

Nosso programa terá uma função void salvarLivro(Livro l) que abre o arquivo em modo "a" (append) e grava os dados, e uma função void listarLivros() que lê o arquivo até o fim (feof).

void salvarLivro(Livro l) {
    FILE *f = fopen("biblioteca.db", "a");
    if (f == NULL) return;
    fprintf(f, "%s;%s;%d\n", l.titulo, l.autor, l.ano);
    fclose(f);
}

O main funcionará como um maestro, apenas direcionando o usuário para as funções corretas.

int main() {
    int opcao;
    do {
        printf("1. Cadastrar | 2. Listar | 0. Sair: ");
        scanf("%d", &opcao);
        // ... switch case chamando as funções ...
    } while (opcao != 0);
    return 0;
}

💻 Desenvolvimento Passo a Passo

Criação da Struct: Definir quais dados são necessários.
Interface CLI: Criar o loop principal com o menu.
Implementação das Funções: Começar pela escrita e depois a leitura.
Testes: Cadastrar, fechar o programa, abrir de novo e listar.

🚀 O que vem a seguir?

Este projeto é o protótipo do que você encontrará no mercado: sistemas que recebem dados, processam regras de negócio e salvam em algum lugar.

📝 Atividade da Aula

Siga o roteiro acima e construa o seu MinosSGB (Sistema de Gestão de Biblioteca). Sinta-se livre para adicionar novos campos, como "Preço" ou "Gênero".

Próxima Aula: Boas Práticas e Encerramento

Aula 16 – Boas Práticas e Encerramento 🎓

Parabéns! Você chegou ao final da nossa jornada pelos fundamentos da linguagem C. Nesta aula, vamos aprender como elevar o nível do seu código, tornando-o profissional, e quais são os próximos passos na sua carreira de programador.

💎 1. Convenções de Nomenclatura

Código limpo é código fácil de ler. Use nomes que expliquem o que a variável ou função faz.

Variáveis: Use camelCase (ex: notaFinal) ou snake_case (ex: nota_final). Evite nomes como x, y, a1.
Constantes: Siga o padrão UPPER_CASE (ex: PI, MAX_BUFFER).
Funções: Devem ser verbos no infinitivo (ex: calcularMedia, salvarDados).

📝 2. Comentários Úteis (≠ Óbvios)

Ruim (Comenta o óbvio):

int x = 10; // Declara x igual a 10

Bom (Explica o porquê):

// Tempo de espera em milissegundos para evitar sobrecarga no servidor
#define TIMEOUT 5000

🌐 3. Portabilidade (Linux vs Windows)

O C é uma linguagem que roda em tudo, mas certas bibliotecas são específicas: - conio.h (uso de getch() ou system("pause")) é comum no Windows, mas não existe nativamente no Linux. - Tente usar sempre bibliotecas padrão (stdio.h, stdlib.h, string.h) para que seu código rode em qualquer lugar do mundo.

🚀 4. Próximos Passos na Programação

O que estudar agora? 1. Estruturas de Dados Avançadas: Listas Encadeadas, Pilhas, Filas e Árvores. 2. Alocação Dinâmica (malloc/free): Gerenciar a memória manualmente em tempo de execução. 3. C++: Uma evolução do C que traz a Programação Orientada a Objetos. 4. Sistemas Embarcados: Programar microcontroladores (Arduino, ESP32) usando C.

🏁 5. Mensagem Final

A linguagem C é a "mãe" das linguagens modernas. Dominá-la deu a você um entendimento profundo de como o computador funciona por baixo de todas as camadas de abstração. O caminho é longo, mas você já deu o passo mais difícil.

🚀 Desafio de Formatura

Crie um programa final (pode ser o SGB da Aula 15) mas aplique todas as boas práticas: use nomes claros, modularize em arquivos .h e .c, adicione um Makefile e documente suas funções com comentários explicativos.

Parabéns, Programador C! ✨

Exercícios

Índice de Exercícios 📝

Pratique seus conhecimentos com atividades divididas por níveis de dificuldade para cada aula.

🚀 Módulo 01: Fundamentos

Aula 01: Introdução e Hello World - Primeiro contato e compilação.
Aula 02: Estrutura e Compilação - Anatomia do código e erros comuns.
Aula 03: Variáveis e Tipos - Manipulação de dados e I/O.
Aula 04: Operadores - Cálculos e lógica.

🔀 Módulo 02: Estruturas de Controle

Aula 05: Condicionais - Tomada de decisão.
Aula 06: Repetição - Loops e automação.
Aula 07: Vetores - Coleções de dados.
Aula 08: Strings - Manipulação de textos.

📦 Módulo 03: Modularização e Memória

Aula 09: Funções - Divisão em blocos reutilizáveis.
Aula 10: Ponteiros (Introdução) - Endereços de memória.
Aula 11: Ponteiros e Arrays - Aritmética de ponteiros.
Aula 12: Structs - Tipos personalizados.

🏗️ Módulo 04: Sistemas e Persistência

Aula 13: Arquivos - Salvando dados no disco.
Aula 14: Organização de Projetos - Múltiplos arquivos e Headers.
Aula 15: Projeto Integrador - Desenvolvimento de sistemas.
Aula 16: Boas Práticas - Refatoração e Portabilidade.

[!TIP] Dica: Tente resolver os exercícios sem olhar a solução primeiro. O erro é parte fundamental do aprendizado em C!

Exercícios: Aula 01 – Introdução à Programação em C 📝

Pratique os conceitos iniciais de instalação, compilação e saída de dados.

🟢 Nível: Básico

1. Mensagem Personalizada

Crie um programa que imprima três frases diferentes, cada uma em uma linha, sobre suas expectativas para este curso. Use a biblioteca <stdio.h> e o comando printf.

2. Linhas em Branco

Modifique o programa anterior para que haja uma linha em branco entre cada frase, utilizando apenas um único comando printf (dica: use \n\n).

🟡 Nível: Intermediário

3. Desenho de Personagem

Crie um programa que utilize caracteres (como #, *, |, -) para "desenhar" um boneco palito ou uma casa simples no terminal usando vários comandos printf.

4. Compilação Manual

Abra o seu terminal e compile o programa do exercício 3 manualmente usando o comando gcc arquivo.c -o executavel. Em seguida, execute-o e tire um print do terminal. (Documente os comandos usados em um comentário no topo do seu código).

🔴 Nível: Desafio

Crie um programa que imprima um menu de sistema fictício. O menu deve ser centralizado e usar bordas feitas de caracteres especiais.

Exemplo de Saída Esperada:

=================================
|        SISTEMA DE GESTÃO      |
=================================
| 1. Cadastrar Aluno            |
| 2. Listar Notas               |
| 3. Configurações              |
| 0. Sair                       |
=================================

[!TIP] Dica: Lembre-se sempre de incluir o #include <stdio.h> e a função int main() { ... } com o return 0; no final.

Exercícios: Aula 02 – Estrutura e Compilação 📝

Aprofunde seus conhecimentos sobre como um programa C é organizado e como o processo de compilação funciona.

🟢 Nível: Básico

1. Identificando Erros

Abaixo está um código com 3 erros de sintaxe. Identifique-os e escreva a versão corrigida:

include stdio.h

int main() (
    printf("Olá Mundo")
    return 0;
}

2. Comentários Didáticos

Crie um programa que imprima o seu nome e, acima de cada linha de código, coloque um comentário explicando o que aquela linha está fazendo (ex: "Incluindo biblioteca de entrada e saída").

🟡 Nível: Intermediário

3. Compilação via Terminal

Crie um programa simples chamado test.c. Use o terminal para compilá-lo gerando um executável com o nome meu_teste. Teste a execução e descreva o comando exato que você usou.

4. Várias Funções de Saída

Crie um programa que utilize 5 comandos printf para contar uma história curta (uma frase por comando). Use \n para organizar as linhas.

🔴 Nível: Desafio

5. O Fluxograma Visual

Crie um programa que, ao ser executado, imprima no terminal um "mapa" visual do processo de compilação (Pré-processador -> Compilador -> Linker). Use setas feitas de caracteres (-->) e caixas feitas de hifens e barras (|, -).

Exemplo de Saída Esperada:

[ FONTE.C ] --(Pré-processador)--> [ EXPANDIDO ]
[ EXPANDIDO ] --(Compilador)-----> [ OBJETO.O ]
[ OBJETO.O ] --(Linker)----------> [ EXECUTÁVEL ]

[!IMPORTANT] Lembrete: A indentação não é obrigatória para o compilador, mas é ESSENCIAL para você e outros programadores entenderem o código!

Exercícios: Aula 03 – Variáveis e Tipos de Dados 📝

Pratique a declaração de variáveis e a interação com o usuário através do teclado.

🟢 Nível: Básico

1. Ficha Cadastral

Crie um programa que declare variáveis para armazenar seu nome (apenas a primeira letra), sua idade, sua altura e se você gosta de café (use 1 para Sim e 0 para Não). Imprima tudo formatado em uma frase.

2. Leitura Simples

Escreva um programa que peça ao usuário para digitar um número inteiro e, em seguida, imprima o dobro desse número.

🟡 Nível: Intermediário

3. Calculadora de IMC (Simplificada)

Crie um programa que peça o peso (float) e a altura (float) do usuário. Calcule o IMC básico usando a fórmula \(IMC = peso / (altura \times altura)\) e exiba o resultado com 2 casas decimais.

4. Troca de Valores

Declare duas variáveis inteiras, A e B, e peça valores para elas. Em seguida, faça com que o valor de A vá para B e o de B vá para A. Imprima os valores antes e depois da troca. (Dica: você precisará de uma terceira variável "auxiliar").

🔴 Nível: Desafio

5. O Pequeno Inventário

Crie um programa que simule o cadastro de um produto em uma loja. O programa deve pedir: - A letra inicial do produto (char). - A quantidade em estoque (int). - O preço unitário (float). - O código identificador do corredor (int).

Ao final, exiba um relatório formatado em colunas mostrando todos os dados capturados.

[!IMPORTANT] Lembrete: Sempre use o símbolo & no scanf para variáveis numéricas! Ex: scanf("%d", &variavel);

Exercícios: Aula 04 – Operadores e Expressões 📝

Coloque em prática o uso de cálculos matemáticos e lógica booleana em C.

🟢 Nível: Básico

1. As 4 Operações

Crie um programa que peça dois números inteiros ao usuário e exiba a soma, a subtração, a multiplicação e a divisão entre eles.

2. Resto da Divisão

Escreva um programa que peça um número inteiro e exiba o resto da divisão desse número por 2. (Dica: se o resto for 0, o número é par).

🟡 Nível: Intermediário

3. Calculadora de Desconto

Crie um programa que peça o valor de um produto (float). Calcule e exiba o "Valor com Desconto (10%)" e o "Valor Parcelado (3x sem juros)".

4. Verificador de Triângulo

Peça três números que representam os lados de um triângulo. Use operadores lógicos para verificar se eles podem formar um triângulo válido (a soma de dois lados deve ser sempre maior que o terceiro lado). Imprima 1 para Válido e 0 para Inválido.

🔴 Nível: Desafio

5. O Conversor de Tempo

Crie um programa que peça ao usuário um valor em segundos (int). O programa deve decompor esse valor em: Horas, Minutos e Segundos restantes.

Exemplo: 3665 segundos = 1 Hora, 1 Minuto e 5 Segundos. (Dica: Use os operadores / e % sucessivamente).

[!TIP] Dica: No exercício do triângulo, a lógica é: (a + b > c) && (a + c > b) && (b + c > a).

Exercícios: Aula 05 – Estruturas Condicionais 📝

Domine o controle de fluxo do seu programa usando decisões lógicas.

🟢 Nível: Básico

1. Maior de Dois

Escreva um programa que peça dois números inteiros e imprima qual deles é o maior. Se forem iguais, imprima "Os números são iguais".

2. Positivo ou Negativo

Crie um programa que receba um número e diga se ele é Positivo, Negativo ou Zero.

🟡 Nível: Intermediário

3. Classificação de Idade

Peça a idade de uma pessoa e classifique-a: - 0 a 12: Criança - 13 a 17: Adolescente - 18 a 59: Adulto - 60ou mais: Idoso

4. Mini Calculadora (switch)

Crie um programa que peça dois números reais e uma opção de operação (1-Soma, 2-Subtração, 3-Multiplicação, 4-Divisão). Use o switch para exibir o resultado. Não esqueça de tratar a divisão por zero!

🔴 Nível: Desafio

5. O Verificador de Ano Bissexto

Um ano é bissexto se ele for divisível por 4, mas não por 100, exceto se for divisível por 400. Crie um programa que peça um ano e diga se ele é bissexto ou não usando apenas estruturas if e else.

[!TIP] Dica: No exercício do ano bissexto, use o operador % para verificar a divisibilidade. Ex: ano % 4 == 0.

Exercícios: Aula 06 – Estruturas de Repetição 📝

Automatize tarefas repetitivas e aprenda a controlar fluxos cíclicos.

🟢 Nível: Básico

1. Contador de 1 a 10

Escreva um programa que utilize um laço while para imprimir os números de 1 a 10, um em cada linha.

2. Tabuada Fixa

Crie um programa que utilize um laço for para imprimir a tabuada do número 7 (de 1 a 10).

🟡 Nível: Intermediário

3. Soma de Intervalo

Peça ao usuário dois números inteiros (início e fim). O programa deve somar todos os números entre esse intervalo (inclusive) e exibir o resultado final.

4. Média de N Números

Crie um programa que pergunte quantos números o usuário deseja digitar. Em seguida, use um laço para ler esses números e, ao final, exiba a média aritmética deles.

🔴 Nível: Desafio

5. O Gerador de Triângulos

Peça ao usuário um número inteiro N. O programa deve imprimir um triângulo de asteriscos com N linhas.

Exemplo para N=4:

*
**
***
****

(Dica: você precisará usar um laço dentro de outro laço - laços aninhados).

[!IMPORTANT] Cuidado: Sempre verifique se sua condição de parada será atingida. Loops infinitos podem travar seu computador se não forem interrompidos!

Exercícios: Aula 07 – Vetores (Arrays) 📝

Aprenda a manipular coleções de dados de forma eficiente usando índices e laços.

🟢 Nível: Básico

1. Preenchendo o Vetor

Escreva um programa que declare um vetor de inteiros de 5 posições. Peça ao usuário para preencher o vetor e, em seguida, imprima todos os valores na tela.

2. Soma de Vetor

Crie um programa que tenha um vetor de 5 números reais (float) pré-definido. Calcule e exiba a soma de todos os elementos desse vetor.

🟡 Nível: Intermediário

3. Ordem Inversa

Peça ao usuário para digitar 6 números inteiros e guarde-os em um vetor. Em seguida, imprima esses números na ordem inversa (do último para o primeiro).

4. Busca no Vetor

Crie um vetor com 10 números inteiros aleatórios (ou fixos). Peça ao usuário um número e informe se esse número está presente no vetor ou não.

🔴 Nível: Desafio

5. O Maior e a Posição

Escreva um programa que leia 10 números e armazene-os em um vetor. Ao final, o programa deve informar qual foi o maior número digitado e em qual posição (índice) do vetor ele se encontra.

[!IMPORTANT] Dica: Lembre-se que o índice do vetor sempre vai de 0 até tamanho - 1. Acessar vetor[tamanho] causará erros de memória!

Exercícios: Aula 08 – Strings em C 📝

Pratique a manipulação de textos e o uso da biblioteca string.h.

🟢 Nível: Básico

1. Boas-Vindas Personalizada

Escreva um programa que peça o primeiro nome do usuário e imprima uma mensagem personalizada como: "Olá [Nome], você está na aula 08!".

2. Contador de Caracteres

Crie um programa que peça uma palavra ao usuário e, usando a função strlen(), informe quantas letras a palavra possui.

🟡 Nível: Intermediário

3. Comparador de Nomes

Peça para o usuário digitar dois nomes. O programa deve dizer se os nomes são exatamente iguais ou se são diferentes (dica: use strcmp()).

4. Nome em Maiúsculas (Lógica)

Crie um programa que receba uma palavra em minúsculas e a transforme em maiúsculas. (Dica: Na tabela ASCII, a diferença entre 'a' e 'A' é de 32 valores. Tente subtrair 32 de cada caractere).

🔴 Nível: Desafio

5. Inversor de Textos

Escreva um programa que peça uma string ao usuário e a imprima de trás para frente.

Exemplo: Entrada: Roma Saída: amoR (Dica: Use um laço for começando do índice strlen(string) - 1 e decresça até 0).

[!IMPORTANT] Aviso: Ao usar fgets, o C pode incluir o caractere de "Enter" (\n) no final da string. Fique atento a isso ao comparar textos!

Exercícios: Aula 09 – Funções e Modularização 📝

Pratique a criação de blocos de código independentes e reutilizáveis.

🟢 Nível: Básico

1. Mensagem de Boas-Vindas

Crie uma função void saudar(char nome[]) que receba um nome e imprima "Olá, [nome]! Bem-vindo ao sistema de funções.". Chame essa função 3 vezes no main com nomes diferentes.

2. O Dobro do Número

Escreva uma função int dobro(int n) que receba um número inteiro e retorne o seu valor multiplicado por 2. Imprima o resultado no main.

🟡 Nível: Intermediário

3. Calculadora de Áreas

Crie funções separadas para calcular a área de um Quadrado, um Retângulo e um Triângulo. No main, peça ao usuário para escolher uma forma e informe as medidas necessárias para o cálculo.

4. Verificador de Notas

Escreva uma função que receba a média de um aluno e retorne um caractere: - 'A' para média >= 9 - 'B' para média >= 7 - 'C' para média < 7 Exiba o caractere retornado no main.

🔴 Nível: Desafio

5. O Validador de Primos

Crie uma função chamada ehPrimo(int n) que retorne 1 se o número for primo e 0 caso contrário. Use essa função dentro de um laço no main para imprimir todos os números primos entre 1 e 50.

[!IMPORTANT] Dica: No desafio do número primo, lembre-se que um número primo só é divisível por 1 e por ele mesmo. Você terá que testar divisões de 2 até n-1.

Exercícios: Aula 10 – Ponteiros (Introdução) 📝

Explore a manipulação direta da memória e entenda como as variáveis são armazenadas.

🟢 Nível: Básico

1. O Apontador

Crie um programa que declare uma variável inteira e um ponteiro para ela. Imprima o valor da variável acessando-a diretamente e, em seguida, acessando-a através do ponteiro.

2. Endereço Físico

Escreva um programa que peça um número ao usuário e imprima qual o endereço de memória (em hexadecimal) onde esse número foi guardado pelo sistema.

🟡 Nível: Intermediário

3. Alteração Indireta

Crie um programa com uma variável float preco = 100.00;. Declare um ponteiro para essa variável e use o ponteiro para aplicar um desconto de 15% direto na memória. Imprima o preço final acessando a variável original.

4. Tamanho dos Tipos

Use o operador sizeof() para descobrir e imprimir quantos bytes ocupam na memória um int, um float, um double e um char. Mostre também o endereço inicial de cada um deles após declará-los.

🔴 Nível: Desafio

5. Função com Referência

Escreva uma função void atualizarValores(int *a, int *b) que receba dois endereços. A função deve substituir o valor de A pela soma de A+B e o valor de B pela subtração de A-B. Teste a função no main imprimindo os resultados.

Exemplo: Entrada: A=10, B=5 Saída: A=15, B=5 (15-10=-5 ou conforme sua lógica de fluxo).

[!IMPORTANT] Aviso: Trabalhar com ponteiros exige atenção! Tentar acessar um endereço inválido (ponteiro NULL ou não inicializado) resultará no erro Segmentation Fault (Faslha de Segmentação).

Exercícios: Aula 11 – Ponteiros e Arrays 📝

Aprofunde-se na relação entre vetores e aritmética de memória.

🟢 Nível: Básico

1. Acesso Indireto

Crie um vetor de 5 inteiros. Declare um ponteiro para esse vetor e imprima o terceiro elemento usando a notação *(p + 2).

2. Varredura com Ponteiro

Escreva um programa que peça 5 números ao usuário, armazene em um vetor e os imprima usando apenas um ponteiro e um laço for (sem usar colchetes []).

🟡 Nível: Intermediário

3. Soma via Aritmética

Crie um programa que declare um vetor de 10 números inteiros. Use um ponteiro para percorrer o vetor e calcular a soma total dos elementos.

4. Pulando Bytes

Crie um vetor de 4 elementos do tipo double. Imprima o endereço de cada elemento usando aritmética de ponteiros (e.g., p, p+1, p+2). Observe a diferença numérica entre os endereços e explique por que é maior que no caso de int.

🔴 Nível: Desafio

5. Inversão com Ponteiros

Escreva um programa que receba 10 números em um vetor. Use dois ponteiros (um apontando para o início e outro para o final do vetor) para inverter a ordem dos elementos dentro do próprio vetor, sem usar um vetor auxiliar.

[!TIP] Dica: No exercício de inversão, você pode fazer os ponteiros "caminharem" um em direção ao outro (p1++ e p2--) enquanto trocam os valores apontados.

Exercícios: Aula 12 – Estruturas (Structs) 📝

Aprenda a modelar dados do mundo real agrupando diferentes tipos de informações.

🟢 Nível: Básico

1. Ficha de Cadastro

Defina uma estrutura chamada Pessoa que contenha: Nome (string), Idade (int) e Altura (float). No main, peça ao usuário para preencher uma variável dessa estrutura e imprima os dados de forma organizada.

2. Geometria de Pontos

Crie uma struct Ponto com x e y (inteiros). Peça ao usuário as coordenadas de um ponto e diga em qual quadrante do plano cartesiano ele se encontra (ou se está sobre um eixo).

🟡 Nível: Intermediário

3. Gerenciamento de Estoque

Defina uma struct Produto com: Nome, Código (int) e Preço. Crie um vetor de 3 produtos. Peça ao usuário para cadastrá-los e, ao final, aplique um aumento de 10% no preço de todos e exiba a tabela atualizada.

4. Cadastro de Livros

Crie uma estrutura Livro com Título, Autor e Ano. Peça ao usuário para cadastrar um livro. Em seguida, crie uma função void imprimirLivro(struct Livro l) que receba a struct e exiba seus dados.

🔴 Nível: Desafio

5. O Melhor Aluno

Crie um programa que cadastre 5 alunos (Nome, Matrícula e Nota). Ao final do cadastro, o programa deve percorrer o vetor e imprimir o nome e a nota apenas do aluno que obteve a maior nota da turma.

[!TIP] Dica: No exercício 5, use uma variável maiorNota iniciada com zero e uma variável indiceMelhor para guardar a posição do aluno vencedor durante a varredura do laço.

Exercícios: Aula 13 – Gerenciamento de Arquivos 📝

Aprenda a persistir dados no disco e a ler informações externas ao seu programa.

🟢 Nível: Básico

1. Olá Arquivo

Escreva um programa que crie um arquivo chamado ola.txt e escreva dentro dele a frase: "Este é meu primeiro arquivo em C!". Verifique se o arquivo foi criado na pasta do seu projeto.

2. Leitor de Texto

Crie um programa que abra o arquivo ola.txt criado no exercício anterior e exiba o conteúdo dele no terminal.

🟡 Nível: Intermediário

3. Cadastro Persistente

Peça ao usuário seu nome, idade e cidade. Salve essas informações em um arquivo chamado usuario.txt de forma organizada (um dado por linha ou separado por vírgulas).

4. Somador de Arquivo

Crie manualmente um arquivo chamado valores.txt com 5 números inteiros (um por linha). Escreva um programa em C que abra este arquivo, leia os números, calcule a soma e exiba o resultado no terminal.

🔴 Nível: Desafio

5. O Backup de Texto

Escreva um programa que leia um arquivo de texto chamado origem.txt e copie todo o seu conteúdo para um novo arquivo chamado destino.txt.

Dica: Você precisará abrir dois arquivos simultaneamente: um para leitura ("r") e outro para escrita ("w"). Use um laço com fgetc ou fgets para transferir os dados caractere por caractere ou linha por linha.

[!IMPORTANT] Aviso: Sempre verifique se o ponteiro FILE é diferente de NULL após abrir o arquivo. Se for NULL, o arquivo pode estar sendo usado por outro programa ou você não tem permissão de escrita.

Exercícios: Aula 14 – Organização de Projetos 📝

Aprenda a estruturar projetos de larga escala dividindo o código de forma lógica e modular.

🟢 Nível: Básico

1. Meu Primeiro Header

Crie um arquivo chamado saudacao.h com o protótipo de uma função void imprimirOla(). Em seguida, crie saudacao.c com a implementação dessa função. Por fim, crie um main.c que inclua o header e chame a função. Compile ambos os arquivos .c juntos.

2. Header Guards

Adicione os "Header Guards" (#ifndef, #define, #endif) ao arquivo saudacao.h que você criou no exercício anterior.

🟡 Nível: Intermediário

3. Biblioteca Matemática

Crie uma "mini-biblioteca" chamada math_util. - math_util.h: Protótipos para dobro(int), triplo(int) e quadrado(int). - math_util.c: Implementação das funções. - main.c: Peça um número ao usuário e exiba os três resultados usando sua biblioteca.

4. Compilação Manual

Descreva, em um comentário no topo do seu main.c, qual o comando exato que você deve digitar no terminal do VS Code para compilar um projeto que tenha 3 arquivos .c chamados main.c, player.c e enemy.c.

🔴 Nível: Desafio

5. O Pequeno Makefile

Crie um arquivo chamado Makefile (sem extensão) na pasta do seu projeto. Escreva as regras para compilar sua "Biblioteca Matemática" do exercício 3. O comando make no terminal deve gerar um executável chamado app_matematica.

[!IMPORTANT] Dica: No Makefile, a indentação DEVE ser feita com a tecla TAB, não com espaços, caso contrário o comando falhará.

Exercícios: Aula 15 – Projeto Prático Integrador 📝

Este é o momento de consolidar seu aprendizado. Não há novos comandos, apenas a aplicação da sua lógica de engenharia de software.

🟡 Nível: Integrador

1. Robustez no Cadastro

No sistema de biblioteca que estamos criando na aula, adicione uma validação: se o usuário tentar cadastrar um livro com o campo Ano negativo ou maior que o ano atual, o sistema deve exibir um erro e pedir para digitar novamente.

2. Pesquisa por Título

Adicione uma terceira opção ao menu: 3. Pesquisar Livro. O usuário digita o nome de um livro e o programa varre o arquivo (usando strcmp) para informar se o livro está ou não na biblioteca.

🔴 Nível: Desafio de Engenharia

3. O Contador de Acervo

Crie uma função que leia o arquivo da biblioteca e exiba um resumo estatístico: - Total de livros cadastrados. - Qual o livro mais antigo. - Qual o livro mais novo.

4. Remoção de Dados (Lógica)

Pense em como você faria para "deletar" um livro do arquivo. (Dica: como não podemos deletar linhas no meio de um arquivo de texto facilmente, a técnica comum é copiar todos os livros para um arquivo temporário, EXCETO o que você quer deletar, e depois renomear o temporário para o nome original).

[!IMPORTANT] Dica Final: Use funções para tudo! O seu main deve ter apenas a lógica de navegação do menu. Isso tornará seu projeto muito mais profissional.

Exercícios: Aula 16 – Boas Práticas e Refatoração 📝

O objetivo aqui não é criar algo novo, mas sim melhorar o que já existe. Refatorar é a arte de reescrever o código sem mudar o que ele faz, apenas tornando-o "melhor".

🟢 Nível: Analista

1. Detetive de Código

Analise o código abaixo e liste 3 problemas de "Boas Práticas" que ele possui:

int a(int b, int c){
int d = b + c;
return d;
}

2. Comentários Estratégicos

Pegue um dos seus projetos anteriores (ex: Projeto 13 ou 14) e adicione um cabeçalho de comentário padrão no topo de cada função explicando: - O que a função faz. - O que ela recebe como parâmetro. - O que ela retorna.

🟡 Nível: Refatorador

3. De Snake para Camel

Pegue um programa que você escreveu usando snake_case (ex: minha_variavel) e reescreva-o inteiramente usando camelCase (ex: minhaVariavel), seguindo as convenções profissionais.

4. Limpeza de Globais

Se você usou alguma variável global em seus projetos, tente refatorar o código para que essa variável seja passada como parâmetro para as funções, eliminando a dependência global.

🔴 Nível: Arquiteto

5. O Manual do Desenvolvedor

Escreva um pequeno arquivo README.txt para o seu Projeto Integrador (Aula 15) que explique: - Como compilar o projeto. - Quais arquivos compõem o sistema. - Como o usuário deve interagir com o programa.

[!TIP] Dica: No desenvolvimento profissional, o README é tão importante quanto o código, pois ele é a porta de entrada para outros programadores entenderem seu trabalho.

Projetos

Índice de Mini-Projetos 🚀

Aplique o que aprendeu em cenários reais com estes desafios práticos de final de aula.

🛠️ Lista de Projetos

Projeto 01: Cartão de Visitas Digital - Saída formatada.
Projeto 02: Calculadora de Área CLI - Entrada e processamento.
Projeto 03: Conversor de Unidades - Cálculos matemáticos.
Projeto 04: Validador de Notas - Lógica de operadores.
Projeto 05: Jogo de Adivinhação - Estruturas condicionais.
Projeto 06: Tabuada Programável - Laços de repetição.
Projeto 07: Gerenciador de Notas de Turma - Vetores e cálculos.
Projeto 08: Criptografia de César - Manipulação de Strings.
Projeto 09: Biblioteca de Geometria - Modularização com Funções.
Projeto 10: Inspetor de Memória - Manipulação de Ponteiros.
Projeto 11: Varredor de Memória - Aritmética de Ponteiros.
Projeto 12: Sistema de Inventário - Uso de Structs.
Projeto 13: Diário de Bordo C - Persistência em Arquivos.
Projeto 14: Calculadora Modular - Múltiplos Arquivos e Headers.
Projeto 15: Gestão de Biblioteca (SGB) - Projeto Integrador.
Projeto 16: Portfólio Final - Boas Práticas e Refatoração.

[!IMPORTANT] Aviso: Recomenda-se realizar os projetos sequencialmente, pois cada um utiliza conhecimentos das aulas anteriores.

Projeto 01: Cartão de Visitas Digital 📇

Neste primeiro projeto, você aplicará os conceitos de saída de dados (printf) para criar um cartão de visitas formatado no terminal.

🎯 Objetivo

Desenvolver um programa em C que exiba suas informações básicas de forma organizada, utilizando caracteres especiais para criar uma moldura visual.

🛠️ Requisitos

Utilizar o cabeçalho #include <stdio.h>.
Utilizar a função int main().
Exibir pelo menos as seguintes informações:
- Nome Completo
- Idade
- Ocupação/Interesse Principal (ex: Estudante de Engenharia)
- GitHub ou LinkedIn
O texto deve estar contido dentro de uma moldura feita de asteriscos (*) ou hifens (-).

💻 Exemplo de Saída

****************************************
*                                      *
*          CARTÃO DE VISITAS           *
*                                      *
*  Nome: Fulano de Tal                 *
*  Idade: 20 anos                      *
*  Foco: Desenvolvimento de Sistemas   *
*  GitHub: github.com/usuarioteste     *
*                                      *
****************************************

🚀 Passo a Passo

Crie um arquivo chamado projeto01.c.
Escreva a estrutura básica do programa.
Use vários comandos printf para montar a moldura.
Compile no terminal usando: gcc projeto01.c -o projeto01.
Execute e valide se a moldura está alinhada.

[!TIP] Dica: Tente usar espaços em branco dentro do printf para garantir que as bordas laterais fiquem perfeitamente alinhadas!

Projeto 02: Calculadora de Área via CLI 📐

Neste projeto, você colocará em prática o uso de múltiplos printf e a organização de código para criar uma ferramenta de cálculo visual.

🎯 Objetivo

Desenvolver um programa que exiba a fórmula de cálculo da área de um quadrado e um retângulo, utilizando formatação de texto para criar um layout limpo no terminal.

🛠️ Requisitos

Utilizar comentários para separar as seções do código (cabeçalho, corpo e rodapé).
Utilizar a flag de compilação -o para gerar um executável chamado geometria.
Exibir:
- Um título centralizado.
- O desenho de um quadrado e um retângulo (usando caracteres como |, -, #).
- As fórmulas matemáticas correspondentes (\(A = L \times L\) e \(A = b \times h\)).

💻 Exemplo de Saída

=================================
       SISTEMA GEOMÉTRICO
=================================

1. QUADRADO:
   +-------+
   |       |  Lado = 4
   |       |
   +-------+
   Fórmula: Area = L * L

2. RETÂNGULO:
   +-----------+
   |           |  Base = 6
   |           |  Altura = 3
   +-----------+
   Fórmula: Area = b * h

=================================

🚀 Passo a Passo

Crie um arquivo chamado geometria.c.
Organize o código com comentários explicativos.
Experimente alinhar os textos usando espaços dentro do printf.
Compile no terminal: gcc geometria.c -o geometria.
Execute e verifique se o layout está agradável visualmente.

[!IMPORTANT] Desafio Extra: Tente adicionar uma cor ao título usando códigos de escape ANSI (pesquise por "C ANSI colors") se estiver no Linux ou Windows 10+.

Projeto 03: Conversor de Unidades (Idade em Dias) 🗓️

Neste projeto, você aprenderá a capturar dados do usuário, realizar um cálculo matemático simples e exibir o resultado formatado.

🎯 Objetivo

Criar um programa em C que solicite a idade do usuário em anos e exiba o equivalente aproximado em dias, horas e minutos vividos.

🛠️ Requisitos

Utilizar variáveis do tipo int.
Utilizar printf para solicitar os dados e scanf para capturá-los.
Utilizar as seguintes constantes para o cálculo:
- 1 ano = 365 dias.
- 1 dia = 24 horas.
- 1 hora = 60 minutos.
Exibir o resultado de forma organizada.

💻 Exemplo de Saída

=================================
     CONVERSOR DE EXISTÊNCIA
=================================
Digite sua idade em anos: 20

Sua jornada até agora:
> Dias: 7.300
> Horas: 175.200
> Minutos: 10.512.000
=================================

🚀 Passo a Passo

Crie um arquivo chamado conversor.c.
Declare as variáveis idade, dias, horas e minutos.
Peça para o usuário digitar a idade.
Realize as multiplicações.
Exiba os resultados usando os formatadores %d.
Compile e execute!

[!TIP] Dica: No printf, você pode usar pontos para separar os milhares manualmente no texto ou apenas imprimir o número direto. Para números muito grandes (como minutos), considere usar o tipo long int se o resultado ultrapassar 2 bilhões!

Projeto 04: Calculadora de Médias e Validação 🎓

Neste projeto, você utilizará operadores aritméticos para calcular a média de um aluno e operadores lógicos para validar se os dados inseridos são consistentes.

🎯 Objetivo

Desenvolver um programa que receba as notas de dois bimestres, calcule a média e informe se o aluno está aprovado, além de verificar se as notas inseridas são válidas.

🛠️ Requisitos

Solicitar duas notas (tipo float).
Calcular a média aritmética simples.
Utilizar operadores relacionais e lógicos para:
- Verificar se a Nota 1 está entre 0 e 10.
- Verificar se a Nota 2 está entre 0 e 10.
- Verificar se a Média é maior ou igual a 7.0.
Exibir os resultados (0 ou 1) para cada uma dessas validações.

💻 Exemplo de Saída

=================================
      SISTEMA DE APROVAÇÃO
=================================
Digite a nota do 1º Bimestre: 8.5
Digite a nota do 2º Bimestre: 6.0

Relatório de Processamento:
> Média Final: 7.25
> Notas válidas (0-10)? 1 (Sim)
> Aluno aprovado (Média >= 7)? 1 (Sim)
=================================

🚀 Passo a Passo

Crie um arquivo chamado media.c.
Peça as notas ao usuário.
Crie variáveis inteiras (int) para armazenar os resultados das comparações lógicas.
Use expressões como (nota1 >= 0 && nota1 <= 10) para validação.
Imprima a média com duas casas decimais (%.2f).
Compile: gcc media.c -o media e execute.

[!IMPORTANT] Desafio: Tente criar uma única variável chamada tudo_certo que só seja 1 se ambas as notas forem válidas E o aluno estiver aprovado.

Projeto 05: O Jogo de Adivinhação 🎲

Neste projeto, você aplicará os conceitos de estruturas condicionais (if, else if, else) para criar um jogo interativo simples no terminal.

🎯 Objetivo

Desenvolver um programa que armazene um "Número Secreto" e peça para o usuário tentar adivinhá-lo. O programa deve fornecer dicas se o número digitado foi maior ou menor que o segredo.

🛠️ Requisitos

Definir uma variável constante (ou inicializada) chamada numeroSecreto (ex: 42).
Solicitar um valor inteiro do usuário.
Comparar o chute com o segredo e exibir:
- "PARABÉNS! Você acertou!" se os números forem iguais.
- "DICA: O número secreto é MAIOR." caso o chute seja baixo.
- "DICA: O número secreto é MENOR." caso o chute seja alto.

💻 Exemplo de Saída

=================================
      JOGO DE ADIVINHAÇÃO
=================================
Tente adivinhar o número (1 a 100): 30

DICA: O número secreto é MAIOR.
=================================

🚀 Passo a Passo

Crie um arquivo chamado adivinha.c.
Declare as variáveis numeroSecreto e chute.
Use o scanf para ler o palpite do usuário.
Crie uma estrutura if encadeada para as três situações possíveis.
Compile com gcc adivinha.c -o adivinha e execute.

[!IMPORTANT] Aviso: Por enquanto, o jogo roda apenas uma vez. Na próxima aula (Repetição), aprenderemos como fazer o jogo continuar até o usuário acertar!

Projeto 06: Tabuada Programável ➗

Neste projeto, você aplicará o comando for para automatizar a geração de uma tabuada completa com base na escolha do usuário.

🎯 Objetivo

Desenvolver um programa que peça ao usuário um número e gere a tabuada desse número de 1 a 10 de forma automática e organizada.

🛠️ Requisitos

Solicitar um número inteiro do usuário.
Utilizar um laço for para iterar de 1 a 10.
Calcular o resultado da multiplicação dentro (ou durante) o laço.
Exibir cada linha da tabuada formatada como N x i = Resultado.

💻 Exemplo de Saída

=================================
      GERADOR DE TABUADA
=================================
Deseja a tabuada de qual número? 8

8 x 1 = 8
8 x 2 = 16
8 x 3 = 24
...
8 x 10 = 80
=================================

🚀 Passo a Passo

Crie um arquivo chamado tabuada.c.
Declare as variáveis numero e i.
Use o scanf para ler o número desejado.
Escreva a estrutura do for.
Imprima os resultados linha a linha.
Compile com gcc tabuada.c -o tabuada e execute.

[!TIP] Dica: Tente adicionar um cabeçalho visual e um rodapé para deixar o programa com cara de sistema profissional!

Projeto 07: Gerenciador de Médias de Turma 📈

Neste projeto, você utilizará vetores para armazenar as notas de vários alunos e laços de repetição para processar esses dados coletivamente.

🎯 Objetivo

Desenvolver um programa que receba a nota de 5 alunos, armazene-as em um vetor, calcule a média da turma e informe quantos alunos obtiveram nota igual ou superior à média calculada.

🛠️ Requisitos

Declarar um vetor de float com tamanho 5.
Utilizar um laço for para ler as 5 notas.
Utilizar um laço for separado para somar as notas e calcular a média.
Utilizar um terceiro laço (ou integrar no anterior) para contar quantos alunos estão acima da média.
Exibir a média da turma e a contagem de aprovados.

💻 Exemplo de Saída

=================================
      CONTROLE DE NOTAS 1.0
=================================
Digite a nota do Aluno 1: 8.0
Digite a nota do Aluno 2: 6.5
Digite a nota do Aluno 3: 10.0
Digite a nota do Aluno 4: 7.0
Digite a nota do Aluno 5: 9.0

Relatório Final:
> Média da Turma: 8.10
> Alunos acima da média: 2
=================================

🚀 Passo a Passo

Crie um arquivo chamado notas_turma.c.
Declare o vetor notas[5], a variável soma e contAcima.
Preencha o vetor usando um laço for.
Calcule a média total.
Faça uma nova varredura no vetor comparando cada nota com a média.
Imprima os resultados formatados.

[!IMPORTANT] Dica: Ao calcular a média, certifique-se de dividir a soma total por 5.0 (float) para manter a precisão das casas decimais.

Projeto 08: Criptografia de César Simples 🔐

Neste projeto, você aplicará o conceito de strings como vetores de números (Tabela ASCII) para criar um sistema de criptografia básico.

🎯 Objetivo

Desenvolver um programa que receba uma palavra do usuário e gere uma versão "criptografada" onde cada letra é substituída pela próxima letra do alfabeto (ex: 'A' vira 'B', 'c' vira 'd').

🛠️ Requisitos

Solicitar uma palavra ou frase curta (use fgets).
Utilizar um laço for que percorra a string até encontrar o \0.
Dentro do laço, somar 1 ao valor de cada caractere (exceto o \0 e espaços).
Exibir a string original e a string criptografada.

💻 Exemplo de Saída

=================================
      CRIPTOGRAFADOR C-STORE
=================================
Digite a mensagem: Olá Mundo

Original: Olá Mundo
Protegida: Pmc!Nvndo
=================================

🚀 Passo a Passo

Crie um arquivo chamado cripto.c.
Inclua stdio.h e string.h.
Declare um vetor char mensagem[100].
Use fgets(mensagem, 100, stdin) para ler a entrada.
Crie o loop: for(int i = 0; mensagem[i] != '\0'; i++).
Verifique se o caractere não é um espaço antes de somar 1.
Imprima o resultado.

[!TIP] Desafio: Crie a função de "Descriptografar", que faz o caminho inverso (subtrai 1) para recuperar a mensagem original!

Projeto 09: Biblioteca de Geometria Modularizada 📐

Neste projeto, você aplicará o conceito de funções para criar um sistema de desenho e cálculo geométrico organizado e fácil de manter.

🎯 Objetivo

Desenvolver um programa que utilize funções separadas para realizar cálculos e exibir formas geométricas no terminal, modularizando a lógica do sistema.

🛠️ Requisitos

Criar uma função void desenharLinha(int tamanho) que imprima uma linha de hifens (-).
Criar uma função float areaQuadrado(float lado) que retorne a área.
Criar uma função float areaTriangulo(float base, float altura) que retorne a área.
No main, apresentar um menu de opções para o usuário.
Utilizar as funções criadas para exibir os resultados.

💻 Exemplo de Saída

=================================
      GEOMETRIA MODULAR 1.0
=================================
1. Área do Quadrado
2. Área do Triângulo
Escolha: 1

Digite o lado: 5
---------------------------------
Resultado: 25.00
---------------------------------
=================================

🚀 Passo a Passo

Crie um arquivo chamado geo_modular.c.
Escreva os protótipos das funções no topo.
Implemente o main com um switch para o menu.
Escreva a definição de cada função abaixo do main.
Compile com gcc geo_modular.c -o geo e execute.

[!TIP] Dica: A função desenharLinha pode ser usada para criar separadores visuais elegantes em todo o seu programa, evitando repetir vários printf("------\n").

Projeto 10: Inspetor de Memória Interativo 🔍

Neste projeto, você colocará em prática o uso de ponteiros para investigar como o computador armazena os dados que o usuário digita.

🎯 Objetivo

Desenvolver um programa que peça um valor ao usuário, use um ponteiro para alterá-lo e exiba um "Raio-X" da variável na memória RAM.

🛠️ Requisitos

Solicitar um número inteiro do usuário.
Declarar um ponteiro que aponte para essa variável.
Exibir:
- O valor original.
- O endereço de memória (em hexadecimal usando %p).
- O tamanho da variável em bytes (usando sizeof).
Alterar o valor da variável usando apenas o ponteiro (ex: *p = 500;).
Exibir o novo valor da variável original.

💻 Exemplo de Saída

=================================
      INSPETOR DE MEMÓRIA
=================================
Digite um número: 42

RELATÓRIO:
> Valor: 42
> Endereço: 0061FF1C
> Tamanho: 4 bytes

Alterando valor via ponteiro...

> Novo Valor: 500
=================================

🚀 Passo a Passo

Crie um arquivo chamado inspetor.c.
Declare as variáveis num e int *p.
Peça o número ao usuário.
Aponte o ponteiro: p = &num;.
Use printf com os formatadores %d, %p e %zu (para sizeof).
Mude o valor com *p = 500;.
Compile com gcc inspetor.c -o inspetor e execute.

[!IMPORTANT] Explicação: Note que mesmo mudando o valor através do ponteiro p, a variável num original foi alterada. Isso acontece porque p tem a "chave" (o endereço) do apartamento onde num vive.

Projeto 11: O Varredor de Memória 🧹

Neste projeto, você desafiará sua lógica ao manipular um vetor inteiro sem usar os colchetes [], utilizando apenas aritmética de ponteiros para ler e processar os dados.

🎯 Objetivo

Desenvolver um programa que capture 5 valores inteiros do usuário, guarde-os em um vetor e, em seguida, encontre o maior valor e a soma total de todos eles usando apenas ponteiros.

🛠️ Requisitos

Declarar um vetor de int com tamanho 5.
Declarar um ponteiro int *p que aponte para o início do vetor.
Utilizar um laço for para a leitura dos dados usando a notação *(p + i).
Utilizar outro laço para percorrer o vetor via ponteiro e realizar os cálculos (soma e maior valor).
Proibição: O uso de v[i] em qualquer parte do código é proibido para este projeto.

💻 Exemplo de Saída

=================================
      VARREDOR DE MEMÓRIA
=================================
Digite o 1º valor: 10
Digite o 2º valor: 25
Digite o 3º valor: 15
Digite o 4º valor: 30
Digite o 5º valor: 5

RESULTADOS (Via Ponteiros):
> Soma Total: 85
> Maior Valor: 30
=================================

🚀 Passo a Passo

Crie um arquivo chamado varredor.c.
Declare as variáveis necessárias.
Preencha o vetor usando scanf("%d", (p + i));.
Implemente a lógica de soma e comparação usando *(p + i).
Imprima os resultados.
Compile e execute!

[!IMPORTANT] Reflexão: Observe como o código funciona exatamente da mesma forma. A notação de colchetes é apenas uma facilidade que o C nos dá, mas por baixo dos panos, o computador sempre faz aritmética de ponteiros.

Projeto 12: Sistema de Inventário de Loja 🛒

Neste projeto, você modelará um sistema de controle de produtos utilizando structs e vetores para gerenciar o estoque de uma pequena loja.

🎯 Objetivo

Desenvolver um programa que cadastre 3 produtos, cada um contendo Nome, Preço e Quantidade em Estoque. O sistema deve calcular o valor total investido em cada item e o valor total geral do estoque.

🛠️ Requisitos

Definir uma struct Produto usando typedef.
Declarar um vetor de 3 produtos.
Utilizar um laço for para preencher os dados (Nome, Preço e Qtd).
Utilizar outro laço para exibir um relatório formatado em colunas (tabela).
Calcular e exibir o valor total (Preço * Quantidade) de todo o estoque.

💻 Exemplo de Saída

=================================
      CONTROLE DE ESTOQUE
=================================
Produto 1: Teclado
Preço: 150.00
Quantidade: 10

... (Repete para 3 produtos) ...

RELATÓRIO FINAL:
ID   NOME         PREÇO    QTD    TOTAL
---------------------------------------
01   Teclado      150.00   10     1500.00
02   Mouse        80.00    20     1600.00
03   Monitor      900.00   5      4500.00
---------------------------------------
VALOR TOTAL EM ESTOQUE: R$ 7600.00
=================================

🚀 Passo a Passo

Crie um arquivo chamado estoque.c.
Defina a struct Produto fora do main.
No main, declare o vetor Produto lista[3];.
Combine printf e scanf para coletar os dados.
Use formatadores como %10s ou %-15s no printf para alinhar as colunas da tabela.
Compile e execute!

[!IMPORTANT] Dica: Ao ler strings com scanf, lembre-se que ele para no espaço. Se quiser nomes compostos, use fgets (e tenha cuidado com o \n extra!).

Projeto 13: Diário de Bordo Persistente 📓

Neste projeto, você criará um programa que funciona como um diário, permitindo salvar anotações no disco rígido para que elas sejam mantidas mesmo após fechar o programa.

🎯 Objetivo

Desenvolver um programa que peça uma mensagem ao usuário e a grave em um arquivo de texto chamado diario.txt. O programa deve ser capaz de ler e exibir todas as mensagens salvas anteriormente.

🛠️ Requisitos

Apresentar um menu com duas opções: 1. Escrever no Diário e 2. Ler Diário.
Na opção 1, usar o modo "a" (append) para adicionar o novo texto ao final do arquivo sem apagar os registros antigos.
Na opção 2, abrir o arquivo no modo "r" (read), ler linha por linha e imprimir no terminal.
Garantir que o arquivo seja fechado corretamente em ambas as operações.

💻 Exemplo de Saída

=================================
       DIÁRIO DE BORDO C
=================================
1. Escrever nova nota
2. Ver notas anteriores
Escolha: 1

Digite sua nota: Hoje aprendi a manipular arquivos!
Nota salva com sucesso!
=================================

🚀 Passo a Passo

Crie um arquivo chamado diario.c.
Implemente o menu usando switch.
Crie as funções de escrita e leitura separadamente para manter o código limpo.
No main, chame a função correspondente à escolha do usuário.
Compile com gcc diario.c -o diario e execute.

[!TIP] Dica: Adicione uma data ou um separador como -------------------- entre as notas gravadas para facilitar a leitura no modo 2.

Projeto 14: Calculadora Modular (Multi-arquivo) 🛠️

Neste projeto, você aprenderá a estruturar um programa profissional dividindo o código em diferentes arquivos e usando o compilador para uni-los.

🎯 Objetivo

Desenvolver uma calculadora que realize as 4 operações básicas, onde as funções de cálculo residem em arquivos separados do arquivo principal (main.c).

🛠️ Requisitos

operacoes.h: Contém os protótipos das funções somar, subtrair, multiplicar e dividir, protegidos por Header Guards.
operacoes.c: Contém a implementação real de cada função.
main.c: Contém o menu de interação com o usuário e faz o #include "operacoes.h".
Realizar a compilação manual via terminal unindo os dois arquivos .c.

💻 Exemplo de Estrutura

projeto_calc/
├── main.c
├── operacoes.h
└── operacoes.c

🚀 Passo a Passo

Crie a pasta do projeto.
Escreva o arquivo operacoes.h com as defesas #ifndef.
Escreva o arquivo operacoes.c com a lógica matemática.
Escreva o main.c solicitando os números e chamando as funções da sua biblioteca.
No terminal, digite: gcc main.c operacoes.c -o calc.
Execute: ./calc (no Windows) ou ./calc.exe.

[!IMPORTANT] Desafio: Tente criar um arquivo chamado Makefile simples para compilar esse projeto com apenas um comando make.

Projeto 15: Sistema de Gestão de Biblioteca (SGB) 📚

Este é o seu projeto final integrador! Aqui você aplicará quase tudo o que aprendeu ao longo do curso para criar um software de utilidade real.

🎯 Objetivo

Desenvolver um sistema completo de cadastro de livros que salve as informações em um arquivo no disco, permitindo que os dados sejam consultados mesmo após reiniciar o programa.

🛠️ Requisitos

Estrutura: Criar uma struct Livro com: Título (string), Autor (string) e Ano (int).
Persistência: Criar uma função para salvar um novo livro no arquivo biblioteca.dat (use o modo "a").
Leitura: Criar uma função para listar todos os livros lendo o arquivo do início ao fim.
Interface: Criar um menu robusto usando do-while e switch-case.
Modularização: Separar a lógica do menu das funções de manipulação de dados.

💻 Exemplo de Funcionamento

SISTEMA DE BIBLIOTECA 1.0
--------------------------
1. Adicionar Livro
2. Listar Acervo
0. Sair
Escolha: 1

Título: Dom Casmurro
Autor: Machado de Assis
Ano: 1899

Livro salvo com sucesso!

🚀 Passo a Passo

Crie o arquivo sgb.c.
Defina a struct e os protótipos das funções.
Implemente o loop principal no main.
Escreva a função de salvar usando FILE * e fprintf.
Escreva a função de listar usando fgets ou fscanf dentro de um while.
Teste cadastrando 3 livros e verificando se a listagem exibe todos corretamente.

[!IMPORTANT] Desafio Extra: Adicione uma função de "Contagem" que mostre quantos livros existem no acervo sem precisar listá-los um por um.

Projeto 16: Portfólio Final do Aluno 🏆

Chegamos ao fim! Este não é apenas um projeto, mas a consolidação de tudo o que você construiu. O objetivo aqui é aplicar o "Polimento Profissional" em sua obra.

🎯 Objetivo

Refatorar o seu melhor projeto do curso (pode ser o SGB da Aula 15) aplicando TODAS as boas práticas de engenharia de software aprendidas na Aula 16.

🛠️ Requisitos de Excelência

Nomenclatura: Substituir qualquer variável obscura (ex: x, aux) por nomes descritivos.
Identação: Garantir que o código esteja perfeitamente alinhado e legível.
Modularização: O projeto deve estar dividido em pelo menos dois arquivos .c e um .h.
Makefile: Criar um script Makefile funcional para compilar o sistema.
Documentação: Adicionar um arquivo README.md explicando o que o projeto faz e como executá-lo.

💻 Checklist de Verificação

[ ] O código compila sem warnings com o comando -Wall.
[ ] Não existem variáveis globais desnecessárias.
[ ] Todas as funções têm comentários explicando sua utilidade.
[ ] O sistema de arquivos trata o erro de "arquivo não encontrado".
[ ] As strings são lidas de forma segura (usando fgets em vez de scanf).

🚀 Próximos Passos

Após concluir esta refatoração, salve seu código em um repositório no GitHub. Este será o seu primeiro grande marco como desenvolvedor de software de baixo nível.

[!IMPORTANT] Parabéns! Você não apenas aprendeu a programar, você aprendeu a arte de escrever código de qualidade. O mercado de trabalho valoriza profissionais que se preocupam com os detalhes que você aplicou hoje.

Quizzes

Índice de Quizzes ❓

Teste seu conhecimento teórico com perguntas rápidas sobre cada tópico do curso.

🔄 Módulo 2: Fluxo e Controle

Quiz 05: Estruturas Condicionais
Quiz 06: Laços de Repetição
Quiz 07: Vetores e Coleções
Quiz 08: Strings e Caracteres

📍 Módulo 3: Avançado

Quiz 09: Funções e Modularização
Quiz 10: Introdução aos Ponteiros
Quiz 11: Ponteiros e Arrays
Quiz 12: Estruturas (Structs)

💾 Módulo 4: Especialização

Quiz 13: Manipulação de Arquivos
Quiz 14: Organização e Headers
Quiz 15: Projeto Integrador
Quiz 16: Boas Práticas

[!NOTE] Como usar: Clique em um dos links acima para abrir o quiz interativo da aula correspondente. Cada quiz contém 10 perguntas.

Quiz 01 – Introdução à Programação em C ❓

Quiz 02 – Estrutura e Compilação ❓

Quiz 03 – Variáveis e Tipos de Dados ❓

Quiz 04 – Operadores e Expressões ❓

Quiz 05 – Estruturas Condicionais ❓

Quiz 06 – Estruturas de Repetição ❓

Quiz 07 – Vetores (Arrays) ❓

Quiz 08 – Strings em C ❓

Quiz 09 – Funções e Modularização ❓

Quiz 10 – Ponteiros (Introdução) ❓

Quiz 11 – Ponteiros e Arrays ❓

Quiz 12 – Estruturas (Structs) ❓

Quiz 13 – Gerenciamento de Arquivos ❓

Quiz 14 – Organização de Projetos ❓

Quiz 15 – Projeto Prático Integrador ❓

Quiz 16 – Boas Práticas e Futuro ❓

Slides

Índice de Slides 🎞️

Acesse os slides interativos de cada aula.

Slide 01 --- Introdução à Linguagem C.
Slide 02 --- Estrutura e Compilação.
Slide 03 --- Variáveis e Tipos de Dados.
Slide 04 --- Operadores e Expressões.
Slide 05 --- Estruturas Condicionais.
Slide 06 --- Estruturas de Repetição.
Slide 07 --- Vetores (Arrays).
Slide 08 --- Strings em C.
Slide 09 --- Funções e Modularização.
Slide 10 --- Introdução a Ponteiros.
Slide 11 --- Ponteiros e Vetores.
Slide 12 --- Estruturas (Structs).
Slide 13 --- Arquivos em C.
Slide 14 --- Organização de Projetos.
Slide 15 --- Projeto Integrador.
Slide 16 --- Boas Práticas.

Introdução à Programação em C 🚀

Aula 01 - Fundamentos ao Projeto Prático

O que vamos aprender hoje? 📅

O que é programação?
História da Linguagem C
Aplicações modernas
Ambiente de Desenvolvimento
Nosso primeiro programa!

O que é Programar? 🧐

"Programação é a arte de organizar instruções para um computador executar tarefas."

Linguagens de Programação
Algoritmos
Lógica Computacional

Por que aprender C? 🧠

Fundacional: Base para C++, Java, C#, PHP e JavaScript.
Performance: Controle direto sobre memória e hardware.
Portabilidade: "Escreva uma vez, compile em qualquer lugar".
Sistemas Reais: Linux, Windows e Android são feitos em C.

História da Linguagem C 📜

Criador: Dennis Ritchie (1941-2011).
Local: Bell Labs.
Ano: 1972.
Objetivo: Reescrever o kernel do Unix.

Onde C é usada hoje? 🌍

Sistemas Operacionais 💻
Sistemas Embarcados (IoT) 🚗
Drivers de Hardware 🖨️
Bancos de Dados (MySQL, Postgres) 💾

O Processo de Compilação 🏗️

graph LR
    A[Código .c] --> B[Pré-Processador]
    B --> C[Compilador]
    C --> D[Assembler]
    D --> E[Linker]
    E --> F[Executável]

Ambiente de Desenvolvimento ⚙️

Precisamos de duas coisas: 1. Editor de Texto (VS Code) 2. Compilador (GCC / MinGW)

Terminal: Nossa Nova Casa 🏠

Comandos básicos: * gcc source.c -o out (Compilar) * ./out (Executar no Linux/macOS) * out.exe (Executar no Windows)

Estrutura de um Programa C 🧩

#include <stdio.h>

int main() {
    printf("Olá Mundo!\n");
    return 0;
}

#include 📚

#include: Diretiva do pré-processador.
<stdio.h>: Standard Input Output Header.
Necessário para printf e scanf.

int main() 🔑

É o coração do programa.
Toda execução começa aqui.
As chaves { } delimitam o bloco de código.

printf() e Strings 🔡

printf: Função para imprimir texto.
"": Aspas duplas delimitam uma string.
\n: Caractere de nova linha.
;: Termina a instrução (obrigatório!).

return 0; ✅

Indica que o programa terminou com sucesso.
Envia um sinal ao Sistema Operacional.

Erros Comuns ❌

Esquecer o #include.
Esquecer o ;.
Digitar Printf (maiúsculo). C é Case Sensitive!

Mão na Massa! 💻

Configurar o ambiente.
Criar hello.c.
Compilar no terminal.
Celebrar seu primeiro programa! 🥳

Exemplo TermynalJS ⚡

$ gcc hello.c -o hello
$ ./hello
Hello World! 🚀

Desafio da Aula 🚀

Crie um programa que imprima seu nome completo e o nome do seu curso atual, separados por uma linha.

Próxima Aula 🔜

Aula 02 - Estrutura e Compilação

Vamos entender o que acontece "debaixo do capô" quando você aperta o botão de compilar.

Dúvidas? 🤔

Obrigado pela atenção!

FIM DA AULA 01 ✨

Exercícios e Quizzes já disponíveis!

Estrutura e Compilação 🏗️

Aula 02 - Desvendando o código C

O que vamos aprender hoje? 📅

Anatomia do código C
A função main
Comentários: Por que usar?
O Ciclo de Compilação
Erros comuns de sintaxe

Anatomia de um Programa 🧩

#include <stdio.h>

int main() {
    printf("Olá Mundo!\n");
    return 0;
}

1. Diretiva #include 📚

Toda linha com # é para o Pré-processador.
stdio.h: Standard Input/Output Header.
Diz ao computador: "Vou precisar das funções básicas de tela e teclado".

2. A Função main() 🔑

int: O tipo de dado que a função devolve (inteiro).
main: Nome obrigatório da função principal.
( ): Espaço para parâmetros (veremos depois).
{ }: Chaves que delimitam o bloco de código.

3. Instruções e ; 🏁

Cada linha dentro de { } é uma instrução.
O ; (ponto e vírgula) é o "ponto final" da frase.
Omitir o ; é o erro nº 1 de quem começa!

Comentários: A voz do autor 🗣️

// Comentário de uma linha

/* 
   Comentário de 
   múltiplas linhas 
*/

"Código bom é código que você entende daqui a 6 meses."

O Ciclo de Compilação ⚙️

Como o texto vira programa?

graph TD
    A[Código .c] --> B[Pré-processador]
    B --> C[Compilador]
    C --> D[Linker]
    D --> E[Executável]

Etapa 1: Pré-processador 🧹

Limpa os comentários.
Substitui as diretivas #.
Prepara o terreno para o compilador.

Etapa 2: Compilador 🛠️

Verifica a Sintaxe (você escreveu certo?).
Traduz C para Linguagem de Objeto (binário parcial).

Etapa 3: Linker 🔗

Une seu código com as bibliotecas do sistema.
Cria o arquivo final: .exe (Windows) ou .out (Linux).

Compilando no Terminal 💻

Flag -o para dar nome ao seu filho:

$ gcc aula02.c -o meu_app
$ ./meu_app

Case Sensitivity 🔍

C diferencia maiúsculas de minúsculas!

main ✅
Main ❌
printf ✅
Printf ❌

A Importância da Indentação 📑

Qual é mais fácil de ler?

int main(){printf("Oi");return 0;}

OU

int main() {
    printf("Oi");
    return 0;
}

Desafio de Hoje 🚀

Crie o programa area.c que desenha um quadrado usando caracteres e imprime a fórmula da área.

Dúvidas? 🤔

Nos vemos na prática!

FIM DA AULA 02 ✨

Pratique no terminal!

Variáveis e Tipos de Dados 📊

Aula 03 - Guardando informações

O que vamos aprender hoje? 📅

O conceito de Variável
Tipos Primitivos (int, float, char...)
Declaração vs Inicialização
Entrada de dados com scanf
Formatação de saída

O que é uma Variável? 📦

Imagine uma caixa na memória do computador.

Tem um Nome (etiqueta).
Tem um Tipo (tamanho e formato).
Tem um Valor (conteúdo).

Tipos Primitivos: int 🔢

Uso: Números inteiros (sem vírgula).
Exemplos: 10, -5, 1000.
Formatador: %d ou %i.
Espaço: 4 Bytes.

Tipos Primitivos: float 🥧

Uso: Números reais (com casas decimais).
Exemplos: 3.14, 1.75, 0.001.
Formatador: %f.
Precisão: ~6 a 7 dígitos.

Tipos Primitivos: char 🔡

Uso: Um ÚNICO caractere ou símbolo.
Exemplos: 'A', '7', '@', '\n'.
Formatador: %c.
Observação: Usa-se aspas simples ' '.

Tipos Primitivos: double 💎

Uso: Decimais de alta precisão.
Formatador: %lf (Long Float).
Espaço: 8 Bytes (O dobro do float).

Declaração de Variáveis ✍️

int idade;      // Declarou
idade = 20;     // Atribuiu

OU

int idade = 20; // Inicializou

Identificadores (Nomes) 🏷️

Pode: * Começar com letra ou _. * Conter números depois da 1ª letra. * nota1, preco_final, _temp.

NÃO Pode: * Começar com número (1nota). * Ter espaços (preco final). * Ser palavra reservada (int, char, main).

Saída Formatada: printf 📺

Podemos controlar como os dados aparecem:

float pi = 3.1415;
printf("Valor: %.2f", pi); 
// Saída: Valor: 3.14

Entrada de Dados: scanf 📥

Como o programa escuta o usuário?

int valor;
printf("Digite: ");
scanf("%d", &valor);

O perigo do ampersand (&) ⚠️

O scanf precisa do Endereço da variável.
O & aponta para onde a caixa está na RAM.
Sem o &, o programa costuma travar!

Exemplo Completo 🧬

#include <stdio.h>

int main() {
    char inicial;
    printf("Digite sua inicial: ");
    scanf(" %c", &inicial); // Note o espaço antes do %c
    printf("Sua inicial é: %c\n", inicial);
    return 0;
}

Curiosidade: Garbage Value 🗑️

Se você declarar uma variável e não der um valor (inicializar), ela conterá um "lixo de memória".

Sempre inicialize suas variáveis!

Desafio da Aula 🚀

Crie o "Conversor de Idade": Receba a idade em anos e imprima o equivalente em dias.

Próxima Aula 🔜

Aula 04 - Operadores

Vamos aprender a fazer cálculos e comparações com os dados que guardamos hoje.

Dúvidas? 🤔

Pratique agora nos Exercícios!

FIM DA AULA 03 ✨

Guarde bem essas informações!

Operadores e Expressões ➗

Aula 04 - Fazendo o computador trabalhar

O que vamos aprender hoje? 📅

Operadores Aritméticos
Operadores Relacionais
Operadores Lógicos
Precedência (O que vem primeiro?)
Incremento e Decremento

Operadores Aritméticos ➕

Os cálculos básicos do dia a dia:

+ (Soma)
- (Subtração)
* (Multiplicação)
/ (Divisão)
% (Resto / Módulo)

O Módulo (%) 🧱

Retorna o resto da divisão inteira.

10 % 3 = 1
7 % 2 = 1
8 % 2 = 0 (Útil para saber se é par!)

Divisão Inteira vs Real 🥧

10 / 3 (int / int) = 3
10.0 / 3 (float / int) = 3.333

"Se todos são inteiros, o resultado é inteiro."

Operadores Relacionais ⚖️

Usados para fazer perguntas (comparações):

== (Igual?)
!= (Diferente?)
> (Maior?)
< (Menor?)
>= (Maior ou Igual?)
<= (Menor ou Igual?)

Verdadeiro ou Falso? 🚦

Em C padrão: * 0 representa FALSO. * 1 (ou qualquer ≠ 0) representa VERDADEIRO.

Operadores Lógicos 🧠

Combinando perguntas complexas:

&& (AND / E): Tudo deve ser verdade.
|| (OR / OU): Pelo menos um deve ser verdade.
! (NOT / NÃO): Inverte o valor.

Tabela Verdade (AND &&) 🤝

A	B	Result
V	V	V
V	F	F
F	V	F
F	F	F

Tabela Verdade (OR ||) 👐

A	B	Result
V	V	V
V	F	V
F	V	V
F	F	F

Incremento e Decremento ⬆️

Atalhos de economia de código:

x++ -> x = x + 1
x-- -> x = x - 1

Atribuição Combinada 🎯

x += 5 -> x = x + 5
x *= 2 -> x = x * 2
x /= 10 -> x = x / 10

Precedência 🔢

( ) Parênteses
!, ++, --
*, /, %
+, -
>, <, >=, <=
==, !=
&&
||

Exemplo Real: Validação 🛡️

// Aluno aprovado?
int passou = (media >= 7.0) && (presenca >= 75);

Desafio da Aula 🚀

Crie a "Calculadora de Médias": Peça 3 notas, calcule a média e mostre se a média é maior ou igual a 7.

Próxima Aula 🔜

Aula 05 - Estruturas Condicionais

Até agora o código era uma linha reta. Na próxima aula, vamos aprender a criar desvios!

Dúvidas? 🤔

Mãos à obra nos exercícios!

FIM DA AULA 04 ✨

O computador é ótimo em contas!

Estruturas Condicionais 🚦

Aula 05 - Tomando Decisões

O que vamos aprender hoje? 📅

O conceito de Fluxo de Controle
O comando if (Se)
A alternativa else (Senão)
Múltiplas escolhas com else if
Seleção com switch
Operador Ternário

Tomada de Decisão 🧠

Na vida real:

"SE estiver chovendo, levo guarda-chuva. SENÃO, vou sem."

No Código:

if (chuva) {
    levar_guarda_chuva();
} else {
    ir_sem();
}

O comando if 🛣️

if (condicao) {
    // Código se verdade
}

A condição deve estar entre ( ).
As chaves { } são opcionais para uma única linha (mas use sempre!).

if ... else 🚦

O caminho alternativo:

if (idade >= 18) {
    printf("Liberado!");
} else {
    printf("Proibido!");
}

else if 🚦🚦🚦

Quando temos várias opções:

if (nota >= 7) {
    printf("A");
} else if (nota >= 5) {
    printf("B");
} else {
    printf("C");
}

Operadores na Condição ⚖️

Lembre-se da Aula 04: * == (Igual) * != (Diferente) * > (Maior) * && (E) * || (OU)

Ideal para valores fixos (inteiros ou caracteres):

switch (opcao) {
    case 1:
        // Codigo 1
        break;
    case 2:
        // Codigo 2
        break;
    default:
        // Caso nenhum acima
}

Cuidado com o Break! ⚠️

Sem o break, o C executa o próximo case mesmo que a condição não bata.

Isso se chama Fall-through.

Operador Ternário ⚡

Atalho para o if-else:

(nota >= 7) ? printf("Passou") : printf("Dobrou");

Indentação e Estilo 🎨

Mantenha seu código limpo. O if ajuda a ver a hierarquia do programa.

Desafio da Aula 🚀

Crie o "Jogo de Adivinhação": O computador tem um número secreto e você tem que dizer se o chute foi maior, menor ou igual.

Próxima Aula 🔜

Aula 06 - Estruturas de Repetição

E se quisermos que o chute se repita até o usuário acertar? 🔄

Dúvidas? 🤔

Vamos para os exercícios!

FIM DA AULA 05 ✨

Agora você manda no fluxo!

Estruturas de Repetição 🔁

Aula 06 - Automatizando Tarefas

O que vamos aprender hoje? 📅

O que são laços (loops)?
O comando while (Enquanto)
O comando do-while (Faça-Enquanto)
O comando for (Para)
Interrupções: break e continue

Por que repetir? 🤔

Imagine imprimir os números de 1 a 1.000...

Escrever 1.000 vezes printf? NÃO! ❌

Usamos loops para que o computador faça o trabalho sujo. ⚙️

1. O Laço while 🔄

"Enquanto for verdade, repita".

int i = 1;
while (i <= 10) {
    printf("%d ", i);
    i++; // Fundamental!
}

Cuidado: Loop Infinito! ♾️

Se a condição nunca for falsa, o programa nunca para.

while (1) {
    printf("Socorro!");
}

Aperte Ctrl + C para parar no terminal.

2. O Laço for 🔁

Ideal para contagens conhecidas.

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

Tudo em uma única linha! ✨

As 3 partes do for 🧩

Inicialização: int i = 0 (Começa aqui)
Condição: i < 10 (Enquanto isso for verdade...)
Incremento: i++ (Faça isso ao fim de cada volta)

3. O Laço do-while ↩️

"Faça primeiro, pergunte depois".

int senha;
do {
    printf("Senha: ");
    scanf("%d", &senha);
} while (senha != 1234);

Executa pelo menos uma vez!

break: A Saída de Emergência 🛑

Interrompe o laço imediatamente.

while(1) {
    if (acertou) break;
}

continue: O "Pula essa" ⏭️

Pula o resto do bloco e vai para a próxima volta.

for (int i=1; i<=10; i++) {
    if (i == 5) continue; // Pula o 5
    printf("%d ", i);
}

Laços Aninhados 📦📦

Um laço dentro do outro. Comum em tabelas e matrizes.

for (int i=1; i<=3; i++) {
    for (int j=1; j<=3; j++) {
        printf("*");
    }
    printf("\n");
}

Exemplo Real: Tabuada ➗

int n = 5;
for (int i = 1; i <= 10; i++) {
    printf("%d x %d = %d\n", n, i, n*i);
}

Desafio da Aula 🚀

Crie o "Gerador de Triângulos": Peça um número e desenhe um triângulo de asteriscos.

Próxima Aula 🔜

Aula 07 - Vetores (Arrays)

O que fazer quando temos muitos dados do mesmo tipo para guardar? 📏

Dúvidas? 🤔

Bons estudos e pratique muito!

FIM DA AULA 06 ✨

Repetir é o poder do computador!

Vetores (Arrays) 📏

Aula 07 - Coleções de Dados

O que vamos aprender hoje? 📅

O problema das múltiplas variáveis
O que é um Vetor?
Declaração e Inicialização
Acesso via Índices (Base Zero)
Percorrendo Vetores com for

O Problema 😫

Como guardar as notas de 50 alunos?

float n1, n2, n3, n4... n50;

Inviável! ❌

A Solução: Vetores 📦

Um vetor é uma única variável que guarda vários valores do mesmo tipo.

float notas[50]; // 50 caixas de float juntas!

Anatomia do Vetor 📐

Identificador: Nome do vetor.
Tamanho: Quantidade de elementos.
Tipo: Tipo de todos os elementos.
Índice: Endereço de cada "casa".

Declaração e Inicialização ✨

int números[5] = {10, 20, 30, 40, 50};

int: Tipo
números: Nome
[5]: Tamanho
{ ... }: Valores iniciais

A Regra de Ouro: Índice Zero! 0️⃣

O primeiro elemento está SEMPRE na posição 0.

Elemento 1 -> v[0]
Elemento 2 -> v[1]
Elemento N -> v[N-1]

Acessando Valores 🔍

int v[3] = {10, 20, 30};

printf("%d", v[0]); // Saída: 10
v[2] = 100;         // Muda o 30 para 100

Vetores + For = ❤️

A combinação perfeita para processar dados.

int idades[5];

for (int i = 0; i < 5; i++) {
    scanf("%d", &idades[i]);
}

Cuidado: Limites de Memória! ⚠️

O C NÃO verifica se o índice existe.

int v[5];
v[10] = 7; // ERRO SILENCIOSO!

Isso pode causar o famoso Segmentation Fault.

Exemplo Real: Média 📊

float notas[3] = {7.5, 8.0, 6.5};
float soma = 0;

for(int i=0; i<3; i++) {
    soma += notas[i];
}
float media = soma / 3;

Memória RAM 🧠

No hardware, um vetor é um bloco contínuo de memória. Isso o torna extremamente rápido de acessar!

Desafio da Aula 🚀

Crie o "Gerenciador de Notas": Peça 5 notas, guarde no vetor, calcule a média e mostre quem está acima dela.

Próxima Aula 🔜

Aula 08 - Strings

E se o vetor for de caracteres? Como lidar com textos? 🔡

Dúvidas? 🤔

Pratique com os exercícios!

FIM DA AULA 07 ✨

Organização é a alma do código!

Strings em C 🔡

Aula 08 - Manipulando Textos

O que vamos aprender hoje? 📅

O que é uma String?
O Terminador \0
Declaração e Inicialização
Lendo textos com fgets
A biblioteca string.h

String? Em C não existe! 😱

Diferente de Python ou Java, C não tem um tipo string.

Em C, texto é um Vetor de Caracteres.

char nome[10] = "Ana";

O Terminador Null (`\0`) 🛑

Toda string em C DEVE terminar com o caractere especial \0.

A	n	a	\0	?	?
0	1	2	3	4	5

Ele marca o fim do texto na memória.

Aspas Simples vs Duplas ✌️

'A': Um único caractere (char).
"A": Uma string (Vetor com 'A' e '\0').

Lendo Strings: O problema do scanf 📥

scanf("%s", ...) para no primeiro espaço.

Exemplo: "Ricardo Pires" vira apenas "Ricardo".

A Solução: fgets() ✅

Lê a linha inteira, incluindo espaços.

char buffer[50];
fgets(buffer, 50, stdin);

buffer: onde guardar. 50: limite de letras. stdin: origem (teclado).

Biblioteca 📚

As ferramentas essenciais:

strlen(s): Tamanho do texto.
strcpy(dest, orig): Copia texto.
strcat(s1, s2): Junta textos.
strcmp(s1, s2): Compara textos.

Comparando Strings ⚖️

NUNCA use == para comparar strings.

// ERRADO ❌
if (s1 == s2) 

// CERTO ✅
if (strcmp(s1, s2) == 0)

O == compararia o endereço de memória, não o texto!

Exemplo: Criptografia 🔐

Strings são apenas números (Tabela ASCII).

char s[] = "ABC";
s[0] = s[0] + 1; // 'A' vira 'B'

Percorrendo uma String 🔁

for (int i = 0; s[i] != '\0'; i++) {
    printf("%c-", s[i]);
}
// Saída: R-i-c-a-r-d-o-

Desafio da Aula 🚀

Crie o "Inversor de Nomes": Receba um nome e imprima ele de trás para frente.

Próxima Aula 🔜

Aula 09 - Funções

Chega de escrever tudo no main! Vamos aprender a criar nossos próprios comandos. 📦

Dúvidas? 🤔

Pratique nos exercícios!

FIM DA AULA 08 ✨

Domine as strings, domine a CLI!

Funções e Modularização 📦

Aula 09 - Dividindo para Conquistar

O que vamos aprender hoje? 📅

O que são funções?
Anatomia de uma Função
Parâmetros e Retorno
Protótipos (Declaração vs Definição)
Escopo de Variáveis
Boas Práticas: Modularização

O Problema do Main Gigante 😱

Escrever tudo no main() é como guardar tudo em uma única gaveta.

Fica difícil de achar erros.
Não dá para reaproveitar código.
Fica impossível de ler.

A Solução: Funções 🧩

Uma função é um "subprograma" que executa uma tarefa específica.

Exemplo: printf, scanf, strlen são todas funções prontas!

Anatomia da Função 🛠️

tipo_retorno nome(parametros) {
    // Corpo da função
    return valor;
}

int, float, char: Devolve um dado.
void: Não devolve nada.

Parâmetros: As Entradas 📥

Informações que a função precisa para funcionar.

void saudar(char nome[]) {
    printf("Olá %s", nome);
}

Return: A Saída 📤

Devolve o resultado do processamento.

int dobrar(int x) {
    return x * 2;
}

Protótipos 📑

Aviso prévio para o compilador.

#include <stdio.h>

void f1(); // Protótipo

int main() {
    f1();
}

void f1() { // Definição
    printf("Oi");
}

Escopo: Onde eu existo? 🌐

Local: Existe apenas dentro da função { }.
Global: Existe em todo o arquivo (Perigo! Evite!).

Passagem por Valor 💎

Em C, quando passamos uma variável para a função, ela recebe uma COPIA.

Mudar o valor lá dentro não muda o valor aqui fora.

Exemplo: Calculadora ➗

float soma(float a, float b) {
    return a + b;
}

float sub(float a, float b) {
    return a - b;
}

Por que usar funções? 🚀

Reuso: Não repita código.
Organização: main limpo.
Clareza: Nomes de funções explicam o que o código faz.

Desafio da Aula 🚀

Crie a "Biblioteca de Formas": Funções que desenham linhas e quadrados de tamanhos diferentes.

Próxima Aula 🔜

Aula 10 - Ponteiros (Introdução)

Como o C acessa diretamente a memória? O pesadelo e o poder do C! 🧠

Dúvidas? 🤔

Mãos à obra nos exercícios!

FIM DA AULA 09 ✨

Modularize e conquiste o código!

Ponteiros (Introdução) 🧠

Aula 10 - Dominando a Memória

O que vamos aprender hoje? 📅

Valor vs Endereço
O que é um Ponteiro?
Operadores & e *
Declaração e Uso
Passagem por Referência

Memória RAM: O Prédio 🏢

Imagine a memória RAM como um grande prédio.

Cada apartamento tem um Número (Endereço).
Dentro de cada apartamento vive um Dado (Valor).

Exemplo: No endereço 0x1A4 mora o número 42.

O que é um Ponteiro? 📍

É uma variável especial.

Em vez de guardar números ou letras, ela guarda o Endereço de outra variável.

"É como um papel onde você anota onde a chave do tesouro está guardada."

Operador de Endereço: & 🔍

Usamos o ampersand & para perguntar: "Onde você mora?".

int x = 10;
printf("Endereço: %p", &x); 
// Saída: 0061FF1C

Declarando um Ponteiro: * ✨

Para dizer que uma variável é um ponteiro, usamos o asterisco *.

int *p; // p é um ponteiro para inteiro
p = &x; // p recebe o endereço de x

Operador de Conteúdo: * 🗝️

O asterisco também serve para "entrar" no endereço.

printf("Valor: %d", *p); 
// Saída: 10 (O valor que está no endereço de p)

Resumo dos Símbolos 📑

int x: Uma caixa com um valor.
&x: Localização da caixa.
int *p: Uma variável que guarda localizações.
*p: O que tem dentro da localização guardada.

Por que usar? 🛠️

Funções: Mudar valores fora da função.
Performance: Evita copiar dados grandes (envia só o endereço).
Flexibilidade: Alocação dinâmica.

Passagem por Referência 🔗

void dobrar(int *n) {
    *n = (*n) * 2;
}

int main() {
    int x = 5;
    dobrar(&x); // x agora vale 10!
}

Perigo: Segmentation Fault! 💀

Tentar usar um ponteiro que aponta para o lugar errado (ou para o nada) mata o programa.

Sempre inicialize seus ponteiros!

Ponteiro NULL 🚫

Se não sabe para onde apontar ainda, use NULL.

int *p = NULL;

Desafio da Aula 🚀

Crie o "Inspetor de Memória": Receba um valor e mostre seu endereço, seu tamanho em bytes e use um ponteiro para alterá-lo.

Próxima Aula 🔜

Aula 11 - Ponteiros e Arrays

Você sabia que, em C, um vetor é na verdade um ponteiro disfarçado? 🎭

Dúvidas? 🤔

Não se sinta mal, ponteiros levam tempo para "clicar" na mente!

FIM DA AULA 10 ✨

Você agora acessa o hardware!

Ponteiros e Arrays 🎭

Aula 11 - A Relação Secreta

O que vamos aprender hoje? 📅

O array como ponteiro
Aritmética de Ponteiros
Navegando na Memória
Array Notation vs Pointer Notation
Performance e Eficiência

O Segredo do C 🤐

Em C, o nome de um vetor é um ponteiro constante para o seu primeiro elemento.

int v[5];
// v é igual a &v[0]

Aritmética na Prática ➕

Somar 1 ao ponteiro move o endereço para o próximo elemento, não para o próximo byte.

p + 1 -> Próximo int (4 bytes depois)
p + 2 -> Dois ints depois (8 bytes depois)

Notações Equivalentes ↔️

Notação de Array	Notação de Ponteiro
`v[0]`	`*v`
`v[1]`	`*(v + 1)`
`v[i]`	`*(v + i)`
`&v[i]`	`v + i`

Percorrendo um Vetor 🔁

int v[] = {10, 20, 30};
int *p = v;

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

Incremento de Ponteiro ⬆️

Podemos mover o ponteiro em si:

while (p <= &v[2]) {
    printf("%d ", *p);
    p++;
}

Arrays em Funções 📦

Quando passamos um array para uma função, passamos apenas o endereço do primeiro elemento.

void imprimir(int *v, int tam) { ... }

Por isso o sizeof() não funciona dentro da função!

Performance ⚡

Aritmética de ponteiros costuma ser mais rápida em loops críticos, pois evita a multiplicação índice * tamanho_do_tipo a cada passo.

Strings são Arrays... 🔡

...logo, strings são ponteiros!

char *s = "Olá";
printf("%c", *(s + 1)); // Saída: 'l'

Perigos: Out-of-bounds 🚫

A aritmética de ponteiros permite que você "saia" do vetor facilmente.

int v[3];
*(v + 10) = 5; // DESASTRE! 💀

Desafio da Aula 🚀

Crie o "Varredor de Memória": Preencha um vetor e use aritmética de ponteiros para percorrê-lo e encontrar o maior valor.

Próxima Aula 🔜

Aula 12 - Estruturas (Structs)

Como criar nossos próprios tipos de dados complexos? 🏗️

Dúvidas? 🤔

Mantenha a calma e confie na aritmética!

FIM DA AULA 11 ✨

Você agora domina o fluxo da memória!

Estruturas (Structs) 🏗️

Aula 12 - Modelando Dados Reais

O que vamos aprender hoje? 📅

Limitações dos Vetores
O que é uma Struct?
Declaração e Membros
O operador . (ponto)
Uso de typedef
Vetores de Structs

O Desafio 😰

Como guardar os dados de um Aluno? * Nome: "Ricardo" (String) * Idade: 20 (Int) * Média: 8.5 (Float)

Vetores só aceitam o mesmo tipo. ❌

A Solução: Struct 🏛️

Uma Struct agrupa variáveis de tipos diferentes sob um único nome.

struct Aluno {
    char nome[30];
    int idade;
    float media;
};

Declarando Variáveis ✍️

struct Aluno a1;
struct Aluno a2;

Cada variável a1, a2 terá seu próprio nome, idade e média independentes.

Acessando os Membros 🔘

Usamos o ponto . para entrar na estrutura.

strcpy(a1.nome, "Ana");
a1.idade = 19;
a1.media = 9.0;

Facilitando com typedef 🏷️

Cria um apelido para não digitar struct toda hora.

typedef struct {
    int id;
    float preco;
} Produto;

Produto p1; // Muito mais limpo!

Vetores de Structs 📚

Pense em um arquivo excel: * Cada coluna é um membro da struct. * Cada linha é uma posição no vetor.

Produto estoque[100];
estoque[0].preco = 15.50;

Ponteiros e Structs 🏹

Quando usamos ponteiros, o . vira ->.

Produto *ptr = &p1;
ptr->id = 101; 
// Equivalente a (*ptr).id

Estruturas Aninhadas 📦📦

Uma struct pode viver dentro de outra!

struct Nascimento {
    int dia, mes, ano;
};

struct Pessoa {
    char nome[20];
    struct Nascimento data;
};

Exemplo Real: Jogos 🎮

typedef struct {
    float x, y;
    int vida;
    int powerUps;
} Player;

Toda a inteligência do jogo está em manipular essas structs!

Desafio da Aula 🚀

Crie o "Inventário de Loja": Cadastre 3 produtos e mostre o valor total investido no estoque.

Próxima Aula 🔜

Aula 13 - Arquivos (I/O)

Como salvar esses dados para que eles não sumam quando fecharmos o programa? 💾

Dúvidas? 🤔

Structs são a base para a Programação Orientada a Objetos!

FIM DA AULA 12 ✨

Você agora modela o mundo!

Gerenciamento de Arquivos 💾

Aula 13 - Persistindo Dados

O que vamos aprender hoje? 📅

Por que usar arquivos?
O ponteiro FILE
Abrindo (fopen) e Fechando (fclose)
Modos de acesso (r, w, a)
Lendo e Gravando dados

Memória Volátil vs Permanente 🧠

Variáveis: Somem quando o programa fecha (RAM).
Arquivos: Ficam no disco rígido (SSD/HD).

O Fluxo de Trabalho de Arquivos 🔄

Abrir: Pedir permissão ao SO.
Verificar: Deu certo? (FILE != NULL).
Processar: Ler ou Escrever.
Fechar: Salvar tudo e liberar recurso.

O tipo FILE 📂

#include <stdio.h>

FILE *arquivo;

FILE é uma estrutura definida na stdio.h que gerencia toda a comunicação com o disco.

Abrindo o Arquivo 🔑

arquivo = fopen("config.txt", "w");

config.txt: Nome do arquivo.
"w": Modo de abertura.

Modos de Abertura 🚦

"r" (Read): Só leitura. Erro se não existir.
"w" (Write): Sobrescreve. Cria se não existir.
"a" (Append): Adiciona ao final sem apagar.

Escrita Formatada: fprintf ✍️

fprintf(arquivo, "Pontuação: %d\n", score);

É o printf com destino configurável!

Leitura: fgets e fscanf 📖

char buffer[100];
// Lê uma linha inteira do arquivo
fgets(buffer, 100, arquivo);

Verificação de Erro 🛡️

Sempre faça isso:

if (arquivo == NULL) {
    printf("Erro ao abrir!");
    return 1;
}

Fim de Arquivo (EOF) 🏁

while (!feof(arquivo)) {
    // Ler dados...
}

Diz ao programa para parar quando o arquivo acabar.

O Esquecimento Fatal 💀

Sempre feche seu arquivo!

fclose(arquivo);

Se não fechar: * Dados podem não ser gravados. * O arquivo fica "preso" no sistema.

Desafio da Aula 🚀

Crie o "Logger de Acessos": Salve o nome do usuário e a hora em um arquivo de log sem apagar os anteriores.

Próxima Aula 🔜

Aula 14 - Organização de Projetos

Como dividir seu código em múltiplos arquivos .c e .h? 📂

Dúvidas? 🤔

O disco rígido é o limite!

FIM DA AULA 13 ✨

Seus dados agora são eternos!

Organização de Projetos 📂

Aula 14 - Escalando seu Código

O que vamos aprender hoje? 📅

A necessidade da Modularização
Arquivos .h (Cabeçalhos)
Arquivos .c (Implementação)
Header Guards
Compilação Modular
Introdução ao Makefile

O Caos de um Arquivo Só 🤯

1.000, 5.000, 10.000 linhas em um único arquivo...

Impossível de achar funções.
Conflitos entre programadores.
Tempo de compilação gigante.

A Solução: Arquivos Separados 🏗️

Dividimos o código por responsabilidade.

player.c / player.h: Lógica do jogador.
fisica.c / fisica.h: Lógica de gravidade e colisão.
main.c: Onde o jogo começa.

Arquivos de Cabeçalho (.h) 📑

É o Contrato do seu módulo.

Contém: * Protótipos de funções. * Definições de Structs. * Constantes e Macros.

Arquivos de Implementação (.c) 🛠️

É a Fábrica.

Contém o código real de cada função prometida no .h.

O Guardião de Cabeçalho (Header Guard) 🛡️

Evita o erro de "Redefinição".

#ifndef MEU_HEADER_H
#define MEU_HEADER_H

// Seu código aqui...

#endif

#include: < > vs " " 🔍

#include <stdio.h>: Bibliotecas do sistema.
#include "util.h": Meus arquivos locais.

Compilação Modular ⚙️

O GCC precisa de todos os arquivos fonte.

$ gcc main.c funcoes.c util.c -o app

O que é o Makefile? 📜

Um robô que compila tudo para você.

all:
|   gcc main.c player.c -o jogo

No terminal, você só digita: make

Boas Práticas 🌟

Um .h para cada .c.
Nomes de arquivos intuitivos.
Mantenha o main.c focado apenas no fluxo principal.

Desafio da Aula 🚀

Crie a "Calculadora Modular": Divida as operações matemáticas em um arquivo separado e crie um Makefile simples para compilar.

Próxima Aula 🔜

Aula 15 - Projeto Prático Integrador

Vamos unir tudo o que aprendemos em um sistema completo! 🏗️✨

Dúvidas? 🤔

Organizar bem é programar melhor!

FIM DA AULA 14 ✨

Seu código agora é profissional!

Projeto Integrador 🚀

Aula 15 - Criando um Sistema Real

O que vamos fazer hoje? 📅

Unir TUDO o que aprendemos: 1. Variáveis e Tipos 2. Lógica de Decisão 3. Laços de Repetição 4. Modularização (Funções) 5. Estruturas (Structs) 6. Persistência (Arquivos)

O Projeto: Biblioteca C 📚

Um sistema para gerenciar acervos de livros.

Cadastrar: Salvar no disco.
Listar: Ver o que foi salvo.
Pesquisar: Encontrar um título.

Passo 1: Modelagem 🏗️

typedef struct {
    char titulo[50];
    char autor[30];
    int paginas;
} Livro;

A base de todo software é o seu Modelo de Dados.

Passo 2: O Banco de Dados 💾

Usaremos um arquivo .db ou .txt.

void salvar(Livro l) {
    FILE *f = fopen("acervo.txt", "a");
    // fprintf...
    fclose(f);
}

Passo 3: A Interface 📺

Um menu amigável no terminal:

Cadastrar Livro
Listar Acervo
Buscar Livro
Sair

Passo 4: Modularização 📦

biblioteca.h: Definições.
biblioteca.c: Funções.
main.c: Controle do fluxo.

Por que esse projeto importa? 🌟

Você está saindo do "código de brinquedo" e entrando no nível de Sistemas de Informação.

Dicas de Sucesso 💡

Valide os dados: Não deixe salvar anos negativos.
Trate erros: E se o arquivo não abrir?
Use a Seta (->): Lembre-se que structs via ponteiros são mais eficientes.

Demonstração ao vivo 💻

Vamos ver o código ganhando vida!

Desafio Final 🏁

Adicione um campo "Preço" ao seu sistema e crie uma função que mostre o valor total do acervo da biblioteca.

Próxima Aula 🔜

Aula 16 - Boas Práticas e Encerramento

O caminho do programador apenas começou! 🛤️

Mãos à obra! 🛠️✨

Boa sorte no seu projeto integrador!

Boas Práticas e Futuro 🎓

Aula 16 - O Próximo Nível

O que vamos aprender hoje? 📅

Código Limpo (Clean Code)
Convenções de Mercado
Comentários vs Documentação
Portabilidade
Próximos Passos (Carreira)

Nomenclatura Profissional 💎

Use nomes que falam!

Ruim: int n;, float x;, void f();
Bom: int numAlunos;, float precoFinal;, void salvarVenda();

Estilos de Escrita ✍️

snake_case: nota_do_aluno
camelCase: notaDoAluno (Mais comum em C/C++)
UPPER_CASE: VALOR_PI

Dica: Escolha um e seja fiel a ele!

Comentários: Menos é Mais 📝

Não comente o óbvio!

x = x + 1; // Soma 1 em x ❌
// Compensação de taxa de juros anual ✅

Comente o "Porquê", não o "O quê".

Portabilidade 🌐

Evite o "Eu só rodo no Windows".

Use bibliotecas padrão: stdio.h, stdlib.h.
Cuidado com o tamanho dos tipos (long pode mudar entre 32/64 bits).

O Pesadelo das Globais 💀

Fuja das variáveis globais!

Dificultam encontrar bugs.
Tornam a reutilização impossível.
Qualquer função pode estragar seus dados.

Refatoração 🛠️

"Torne o código melhor, sem mudar o que ele faz."

Limpar o código é tão importante quanto escrever código novo.

O Caminho Adiante 🛤️

O que estudar agora? 1. Estruturas de Dados: Listas, Pilhas e Árvores (Onde o C brilha!). 2. Alocação Dinâmica: Gerir memória manualmente. 3. C++: Orientação a Objetos.

O Mercado de Trabalho 💼

Onde se usa C hoje? * Sistemas Operacionais (Linux, Windows). * Motores de Jogos (Unreal Engine). * Sistemas Embarcados (Carros, Satélites). * IoT (Internet das Coisas).

Dica de Ouro 🌟

Nunca pare de codar! Teoria sem prática é apenas papel. Construa coisas.

Fim da Jornada? 🔜

Não, é o Início.

Dúvidas Finais? 🤔

Obrigado por me acompanhar nestas 16 aulas!

PARABÉNS! 🎓✨

Você agora fala a linguagem das máquinas!

Configuração

Ambientes de Desenvolvimento 🛠️

Guias para configurar seu computador para o desenvolvimento mobile.

Android --- Instalação do Android Studio, SDK e emuladores.
- Setup 01 - Android Studio
iOS (Opcional/Referência) --- Configuração básica de Xcode e ferramentas Mac.
- Setup 02 - Xcode Foundation
Ferramentas de Apoio --- Git, Terminais e Postman/Insomnia para testes de API.
- Setup 03 - Tools

Guia de Instalação: Compilador C (GCC/MinGW) 🛠️

Para programar em C, precisamos de um Compilador. Ele é o tradutor que transforma seu código em um programa que o computador entende.

🪟 No Windows (MinGW-w64)

Recomendamos o uso do MSYS2 para instalar o MinGW, que é a versão mais moderna do GCC para Windows.

Download: Acesse msys2.org e baixe o instalador.
Instalação: Siga os passos do instalador padrão.
Terminal MSYS2: Após instalar, abra o terminal "MSYS2 UCRT64" e digite:
```
pacman -S --needed base-devel mingw-w64-ucrt-x86_64-toolchain
```
Variáveis de Ambiente:
- Adicione o caminho C:\msys64\ucrt64\bin ao seu PATH do sistema.
Verificação: Abra um novo terminal (CMD ou PowerShell) e digite:
```
gcc --version
```

🐧 No Linux (Ubuntu/Debian)

No Linux, a instalação é muito simples e direta pelo terminal.

Atualize os repositórios:
```
sudo apt update
```
Instale o build-essential:
```
sudo apt install build-essential
```
Verificação:
```
gcc --version
```

🍎 No macOS

No Mac, o compilador vem junto com as ferramentas de linha de comando do Xcode.

Abra o Terminal e digite:
```
xcode-select --install
```
Verificação:
```
gcc --version
```

[!TIP] Dica: No macOS, o comando gcc muitas vezes aponta para o clang, que é um compilador compatível e excelente.

Configurar o VS Code

Configuração do VS Code para C 💻

O Visual Studio Code é o editor de código mais popular do mundo. Com as extensões certas, ele se torna uma ferramenta poderosa para programar em C.

1. Instalação do VS Code

Se ainda não tem, baixe em: code.visualstudio.com.

2. Extensões Essenciais

Abra o menu de extensões (Ctrl+Shift+X) e instale:

C/C++ (Microsoft): Oferece IntelliSense (autocompletar) e suporte a depuração (debug).
Code Runner: Permite rodar o código com apenas um clique ou um atalho (Ctrl+Alt+N).
C/C++ Compile Run: Alternativa excelente para compilar e rodar no terminal interno automaticamente.

3. Configurando o Code Runner (Opcional)

Para que o Code Runner use o terminal e aceite entradas do teclado (scanf), faça o seguinte:

Vá em File -> Preferences -> Settings.
Procure por Run In Terminal.
Marque a opção Code-runner: Run In Terminal.

4. Testando sua Configuração

Crie um novo arquivo chamado teste.c.

Cole o código do "Hello World":

#include <stdio.h>
int main() {
    printf("Ambiente Configurado com Sucesso!\n");
    return 0;
}

Clique no botão de "Play" no canto superior direito ou use o atalho do Code Runner.

[!IMPORTANT] Atenção: O VS Code não vem com um compilador embutido. Você deve ter seguido o primeiro passo do Guia de Instalação do GCC.

Voltar para Aula 01

Sobre

Sobre o Curso

🎓 Programação em C – Fundamentos ao Projeto Prático

Este curso foi desenhado para jovens e adultos que desejam construir uma base sólida na computação. A linguagem C é a "mãe" das linguagens modernas e o melhor caminho para entender como o computador realmente funciona.

🎯 Objetivos do Curso

Lógica de Programação --- Desenvolver o pensamento algorítmico, resolvendo problemas complexos com soluções simples e eficientes.
Gestão de Memória --- Entender endereçamento de memória, ponteiros e como os dados são organizados no nível do hardware.
Domínio de Terminal --- Aprender a compilar, debugar e executar programas diretamente pelo terminal no Windows e Linux.
Engenharia de Software --- Aprender boas práticas de organização, modularização de código e estruturação profissional de projetos.

📚 O Que Você Vai Aprender

Módulo 1 – Fundamentos e Lógica

Introdução à Linguagem C e História
Estrutura básica de um programa e compilação
Variáveis, Tipos de Dados e IO
Operadores Aritméticos e Lógicos

Módulo 2 – Estruturas de Controle e Dados

Condicionais (if, else, switch)
Laços de Repetição (for, while)
Vetores (Arrays Unidimensionais)
Strings e Manipulação de Texto

Módulo 3 – Modularização e Memória

Funções, Parâmetros e Retornos
Introdução a Ponteiros e Endereços
Ponteiros e Vetores (Passagem por Referência)
Estruturas de Dados Personalizadas (struct)

Módulo 4 – Projeto e Persistência

Manipulação de Arquivos (Leitura/Escrita)
Organização Profissional e Makefiles
Projeto Prático Integrador
Boas Práticas e Próximos Passos (Sistemas Embarcados/C++)

🛠️ Metodologia

O curso foca na prática constante. Cada aula é acompanhada de exercícios progressivos, um quiz para fixação e um mini-projeto. Ao final, o aluno desenvolve um sistema modularizado completo que demonstra domínio dos fundamentos da linguagem.

Pronto para entender a base da computação? Começar Agora

Roadmap do Projeto: Programação em C 🚀

Este documento rastreia a evolução da migração para o novo curso de C.

✅ Fase 1: Planejamento (Concluído)

[x] Definição Syllabus (16 Aulas)
[x] Escolha de Temas (Teal/Amber)
[x] Estrutura de Diretórios Adaptada

✅ Fase 2: Infraestrutura e Base (Concluído)

[x] Atualização mkdocs.yml e pyproject.toml
[x] Configuração CI/CD (GitHub Actions)
[x] Atualização de README.md e index.md
[x] Atualização de documentos pedagógicos (plano-ensino.md)

✅ Fase 3: Desenvolvimento de Conteúdo (Concluído)

[x] Criação das 16 Aulas (Markdown)
[x] Criação dos 16 Quizzes (10 perguntas/aula)
[x] Criação dos 16 Exercícios (5 exercícios/aula)
[x] Criação dos 16 Slides (RevealJS v11 interface)
[x] Criação dos 16 Mini-projetos práticos

🚀 Fase 4: Validação e Finalização (Em Progresso)

[/] Build Strict sem erros
[ ] Validação de Mermaid e MathJax
[ ] Testes de Navegação e UX
[ ] Lançamento Oficial

Status Atual: Validação Final ✅ Última Atualização: 21/02/2026

Materiais Complementares 📚

Bem-vindo à seção de materiais complementares do curso de Programação em C. Aqui você encontra recursos adicionais para apoiar seus estudos e aprofundar seu conhecimento técnico.

Slides
- Acesse os slides interativos em Reveal.js de cada aula.
Exercícios
- Lista de 16 conjuntos de exercícios (Básico ao Desafio).
Quizzes
- Teste seus conhecimentos com 10 questões por tópico.
Projetos
- Guia para os 16 mini-projetos práticos do curso.
Guias de Setup
- Aprenda a instalar o Compilador (GCC/MinGW) e o VS Code.
Bons Hábitos
- Guia de indentação e documentação de código.

Versão para Impressão

Esta página foi gerada automaticamente para impressão.

Programação em C – Fundamentos ao Projeto Prático 💻

🎯 O Que Você Vai Aprender

📚 Jornada de Aprendizado (16 Aulas)

🧱 Fase 1: Fundamentos (Aulas 01-04)

🏗️ Fase 2: Controle e Dados (Aulas 05-08)

🧠 Fase 3: Modularização e Memória (Aulas 09-12)

🚀 Fase 4: Especialização (Aulas 13-16)

Plano de Ensino 📅

Ementa

Cronograma (16 Aulas)

Módulo 1: Fundamentos e Lógica

Módulo 2: Estruturas de Controle e Dados

Módulo 3: Modularização e Memória

Módulo 4: Persistência e Projetos Profissionais

Avaliação

Aulas

Aula 01 – Introdução à Programação e à Linguagem C 🚀

🧐 O que é Programação?

📜 História e Importância da Linguagem C

🌍 Onde C é Utilizada Hoje?

🏗️ Fluxo de Funcionamento de um Programa

💻 Primeiro Programa: Hello, World!

🛠️ Compilando no Terminal

🚀 Mini-Projeto da Aula: "Cartão de Visitas"

📝 Exercícios de Fixação

Aula 02 – Estrutura de um Programa em C 🏗️

🧩 Anatomia de um Código C

Explicação dos Componentes:

⚙️ O Ciclo de Vida do Código (Compilação)

💻 Prática: Compilando com Nome Personalizado

⚠️ Erros Comuns e Como Corrigi-los

🚀 Mini-Projeto da Aula: "O Calculador de Área"

📝 Exercícios de Fixação

Aula 03 – Variáveis e Tipos de Dados 📊

📦 O que é uma Variável?

🔢 Tipos de Dados Primitivos em C

✍️ Declaração e Inicialização

📥 Lendo Dados com scanf

🚀 Mini-Projeto da Aula: "Conversor de Idade"

📝 Exercícios de Fixação

Aula 04 – Operadores e Expressões ➗

➕ 1. Operadores Aritméticos

⚖️ 2. Operadores Relacionais

🧠 3. Operadores Lógicos

⬆️ 4. Incremento e Decremento

💻 Exemplo Prático: Validação de Nota

🏗️ Precedência de Operadores

🚀 Mini-Projeto da Aula: "Calculadora de Médias"

📝 Exercícios de Fixação

Aula 05 – Estruturas Condicionais 🚦

🛣️ 1. O Desvio Simples: if e else

🚦 2. Múltiplas Condições: else if

🎚️ 3. A Escolha Múltipla: switch

⚡ 4. Operador Ternário (Atalho)

💻 Exemplo Prático: Par ou Ímpar

🚀 Mini-Projeto da Aula: "O Jogo de Adivinhação"

📝 Exercícios de Fixação

Aula 06 – Estruturas de Repetição 🔁

🔄 1. O Laço while (Enquanto)

🔁 2. O Laço for (Para)

🔄 3. O Laço do-while (Faça-Enquanto)

🛑 4. break e continue

💻 Exemplo Prático: Tabuada

🚀 Mini-Projeto da Aula: "Contagem Regressiva"

📝 Exercícios de Fixação

Aula 07 – Vetores (Arrays) 📏

📦 O que é um Vetor?

📐 Declaração e Acesso

🔁 Percorrendo um Vetor com for

📊 Aplicações Reais

🚫 Perigos: Acesso Fora do Limite

🚀 Mini-Projeto da Aula: "Média de Turma"

📝 Exercícios de Fixação

Aula 08 – Strings em C 🔡

🧵 1. O que é uma String em C?

Declaração e Inicialização

📥 2. Lendo Strings com Espaços

📚 3. A Biblioteca <string.h>

💻 Exemplo Prático: Comparação de Senha

🚀 Mini-Projeto da Aula: "Criptografia Simples"

📥 Lendo Dados com `scanf`

🛣️ 1. O Desvio Simples: `if` e `else`

🚦 2. Múltiplas Condições: `else if`

🎚️ 3. A Escolha Múltipla: `switch`

🔄 1. O Laço `while` (Enquanto)

🔁 2. O Laço `for` (Para)

🔄 3. O Laço `do-while` (Faça-Enquanto)

🛑 4. `break` e `continue`

🔁 Percorrendo um Vetor com `for`

📚 3. A Biblioteca `<string.h>`

🔘 4. Funções sem Retorno (`void`)

📑 2. O comando `typedef`

🏹 4. Ponteiros para Structs e o Operador `->`

✍️ 3. Escrevendo no Arquivo (`fprintf`)

📖 4. Lendo do Arquivo (`fscanf` e `fgets`)