Guia Didático C do Zero

Prévia do material em texto

C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 1
C DO ZERO
Resumo didático fiel à sequência do livro
Introdução à programação em C - os primeiros passos de um desenvolvedor
Objetivo: Transformar o livro enviado em um material de estudo mais curto e mastigado, sem trocar a 
ordem dos assuntos nem substituir a abordagem do autor por uma trilha diferente. Os três jogos 
continuam sendo o fio condutor: Adivinhação, Forca e Foge-foge.
Este material é um resumo explicativo. Ele não reproduz o livro integralmente: condensa as explicações, 
mantém os conceitos, os nomes das funções e a progressão dos projetos, e usa apenas pequenos trechos 
de código necessários para acompanhar o raciocínio.
A recomendação do próprio livro é estudar em sequência, porque cada capítulo evolui o código construído 
antes. Aqui faremos exatamente isso.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 2
Sumário fiel ao livro
1 Introdução
2 Jogo de adivinhação
3 Variáveis
4 Controle de fluxo com ifs e fors
5 Tipos de dados e operações matemáticas
6 Finalizando o jogo de adivinhação
7 Exercícios
8 Jogo de forca
9 Arrays
10 Números binários
11 Funções e ponteiros
12 Entrada e saída (I/O)
13 Finalizando o jogo de forca
14 Exercícios
15 Jogo Foge-foge
16 Matrizes
17 Structs
18 Programando como um profissional
19 Recursividade
20 Outras diretivas de compilação
21 Exercícios
22 O que fazer agora?
23 Apêndice: compilador e códigos finais
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 3
1. Introdução
O livro começa com uma ideia simples: programar é aprender a dizer à máquina, de forma precisa, o que 
ela deve fazer. A máquina não completa intenções por conta própria; por isso, aprender programação 
envolve aprender a pensar em passos e expressá-los em uma linguagem que o computador possa 
processar.
A linguagem escolhida é C. A justificativa do livro é que C é antiga, popular, poderosa e permite trabalhar 
em níveis diferentes de abstração: em alguns momentos podemos ignorar os detalhes da memória; em 
outros, podemos manipulá-la diretamente.
A proposta dos três jogos
• Jogo de adivinhação: introduz entrada e saída, variáveis, operações matemáticas, decisões, loops e 
números randômicos.
• Jogo de forca: introduz arrays, strings, funções, ponteiros, leitura e escrita de arquivos e organização do 
código.
• Foge-foge: introduz matrizes, alocação dinâmica, structs, ponteiros de ponteiros, recursividade, 
organização em vários arquivos e diretivas de compilação.
Como estudar: O livro recomenda seguir os capítulos na ordem, porque o código cresce passo a 
passo. O objetivo não é ver apenas a solução final, mas acompanhar as mudanças e entender por que 
elas são feitas.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 4
2. Jogo de adivinhação
Primeiro projeto do livro e ponto de partida para os fundamentos da linguagem.
O computador escolhe um número e o jogador tenta adivinhar. A cada erro, o jogo informa se o chute foi 
maior ou menor que o número secreto. Mais tarde entram nível de dificuldade, limite de tentativas e 
pontuação.
O que esse jogo vai ensinar
• Ler do teclado e escrever na tela.
• Guardar valores na memória e manipulá-los.
• Fazer operações matemáticas.
• Diferenciar tipos inteiros e tipos com ponto flutuante.
• Tomar decisões com base na entrada do usuário.
• Repetir trechos de código com loops.
Ideia central: O livro apresenta primeiro o comportamento desejado do jogo e só depois começa a 
construir cada peça. Essa forma de trabalhar continua nos outros projetos.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 5
3. Variáveis
Base no livro: Conteúdo reorganizado e condensado a partir do capítulo correspondente do livro 
enviado, preservando a sequência e os conceitos apresentados pelo autor.
3.1 Nosso primeiro programa
O código C fica em um arquivo com extensão .c. O livro cria adivinhacao.c, recomenda nomes 
significativos e evita espaços e acentos no nome do arquivo. O primeiro objetivo é apenas imprimir uma 
mensagem de boas-vindas.
#include 
int main() {
 printf("Bem-vindo ao Jogo de Adivinhação\n");
}
A função printf() imprime na saída padrão. O arquivo stdio.h contém declarações de funções de entrada e 
saída. A função main() é o ponto de entrada do programa, e as chaves delimitam seu corpo. O livro 
também introduz \n como quebra de linha e lembra que, após mudar o código-fonte, é preciso compilar 
novamente.
Compilação com GCC
gcc adivinhacao.c -o adivinhacao.exe
O compilador verifica se o código segue as regras da linguagem e o transforma em código de máquina. O 
executável gerado é específico da plataforma em que foi compilado, embora o mesmo código-fonte 
padrão possa ser recompilado em outros sistemas.
3.2 Declarando variáveis
Variáveis são lugares usados para guardar informações. Em C, uma variável precisa de um tipo e de um 
nome. Para o número secreto, o livro começa com um inteiro.
int numerosecreto;
numerosecreto = 42;
Para imprimir um inteiro dentro de uma frase, o livro introduz a máscara %d no printf(). Também 
aparecem comentários iniciados por //, que são ignorados pelo compilador.
3.3 Lendo do teclado
int chute;
printf("Qual é o seu chute? ");
scanf("%d", &chute);
printf("Seu chute foi %d\n", chute);
A função scanf() lê a entrada. Neste ponto do livro, o & ainda não é explicado em profundidade; ele é 
guardado como regra prática e será retomado no capítulo de ponteiros.
3.5 O que o livro resume
• Escrever a função main e um primeiro programa em C.
• Usar printf e scanf.
• Declarar variáveis inteiras.
• Entender o papel do compilador.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 6
4. Controle de fluxo com ifs e fors
Agora o jogo precisa decidir se o chute acertou, foi maior ou foi menor. É aqui que o programa deixa de 
executar sempre o mesmo caminho.
if, else e comparações
if(chute == numerosecreto) {
 printf("Parabéns! Você acertou!\n");
} else {
 if(chute > numerosecreto) {
 printf("Seu chute foi maior!\n");
 } else {
 printf("Seu chute foi menor!\n");
 }
}
O livro chama atenção para ==, usado para comparar, em contraste com =, usado para atribuir. Também 
sugere colocar condições em variáveis com nomes claros, como acertou e maior, para aumentar a 
legibilidade. Nesse contexto, 0 representa falso e 1 representa verdadeiro.
4.1 Escopo de variáveis
Uma variável é válida no escopo em que foi declarada e nos escopos internos. Uma variável criada dentro 
de um else, por exemplo, não pode ser usada fora daquele bloco. A orientação do livro é declará-la no 
escopo adequado ao uso.
4.2 Loops e for
Para não copiar o mesmo código três vezes, o livro introduz loops. Como a quantidade de tentativas é 
conhecida, começa pelo for. O for possui inicialização, condição e incremento.
for(int i = 1; isua condição nunca deixa de ser verdadeira, como while(1).
Resumo do capítulo: Decisões com if/else if/else, repetição com for e while, controle com 
break/continue, escopo e constantes com #define.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 7
5. Tipos de dados e operações matemáticas
5.1 Pontuação e operações
O jogo passa a ter pontos. O jogador começa com 1000 e perde pontos de acordo com a distância entre o 
chute e o número secreto. O livro usa +, -, * e / e mostra que parênteses podem controlar a precedência.
double pontos = 1000;
double pontosperdidos = (chute - numerosecreto) / 2.0;
pontos = pontos - pontosperdidos;
5.2 Outros tipos numéricos
Além de int, o livro apresenta double, long, short e float. A motivação prática é que inteiros não preservam 
casas decimais em uma divisão inteira. Também alerta que uma variável local não inicializada pode conter 
“lixo” de memória.
Atenção: O livro enfatiza: inicialize suas variáveis antes de usá-las.
5.3 Conversões e casting
int a = 3;
int b = 2;
double resultado = (double)a / (double)b;
Casting força o compilador a tratar um valor como outro tipo naquele momento. Converter para um tipo 
com menor capacidade pode perder informação; o exemplo do livro converte 3.1415 para int e fica apenas 
com 3.
5.4 Funções matemáticas
Para impedir que uma diferença negativa faça o jogador ganhar pontos, o livro usa abs() e inclui stdlib.h.
double pontosperdidos = abs(chute - numerosecreto) / 2.0;
5.5 Números randômicos
rand() gera números pseudorrandômicos. Para variar a sequência entre execuções, o livro usa time(0) 
como semente de srand(). Depois usa o resto da divisão para limitar o número secreto ao intervalo de 0 a 
99.
#include 
#include 
srand(time(0));
int numerosecreto = rand() % 100;
Resumo do capítulo: Tipos numéricos, operações, double, casting, abs(), srand(), rand() e operador % 
para limitar intervalos.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 8
6. Finalizando o jogo de adivinhação
Níveis de dificuldade
O jogador escolhe fácil, médio ou difícil. O número de tentativas muda para 20, 15 ou 6. Primeiro isso é 
feito com if/else if; depois o livro apresenta switch/case como alternativa adequada quando comparamos 
uma mesma variável inteira com opções fixas.
switch(nivel) {
case 1:
 totaldetentativas = 20;
 break;
case 2:
 totaldetentativas = 15;
 break;
default:
 totaldetentativas = 6;
 break;
}
Vitória, derrota e escopo
A variável acertou precisa sobreviver ao fim do for para que o programa saiba se deve mostrar a 
mensagem de vitória ou derrota. Isso retoma a discussão de escopo do capítulo 4.
Interface no console
Com a lógica pronta, o livro melhora a apresentação usando ASCII Art. Aqui aparecem sequências de 
escape: \ para imprimir uma barra invertida e \" para imprimir aspas dentro de uma string.
Fim do primeiro projeto: O jogo de adivinhação consolida entrada, saída, variáveis, tipos, 
matemática, decisões, loops, constantes, aleatoriedade e switch.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 9
7. Exercícios do primeiro bloco
O livro propõe melhorias no jogo e pequenos programas separados. Para manter o material fiel sem 
reproduzir a lista inteira, aqui estão os tipos de desafio que aparecem:
• Deixar o usuário escolher o intervalo do número secreto.
• Trocar números mágicos por #define.
• Perguntar se deseja jogar novamente usando outro loop.
• Evitar o mesmo chute em sequência.
• Imprimir números pares de 2 a 50.
• Somar os números de 1 a 100.
• Gerar uma tabuada até 10.
• Criar uma calculadora com operação escolhida pelo usuário.
• Calcular fatorial.
• Ordenar três números em ordem crescente.
Prática recomendada: Faça pelo menos os desafios de pares, soma, tabuada, calculadora e fatorial 
antes de seguir. Eles usam exatamente as ferramentas dos capítulos anteriores.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 10
8. Jogo de forca
O segundo projeto escolhe uma palavra aleatória de um arquivo. O jogador chuta letras e perde após cinco 
erros. Ao final, o programa também poderá inserir novas palavras no banco de dados.
O que esse jogo introduz
• Arrays de diferentes tipos.
• Arrays de char e strings.
• Funções com parâmetros e retorno.
• Leitura e escrita de arquivos.
• Extração de funções para evitar repetição.
• Header files.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 11
9. Arrays
char e arrays
Uma única letra pode ser guardada em char. Para uma palavra, o livro mostra que precisamos de várias 
letras e apresenta arrays: vários elementos do mesmo tipo armazenados em sequência e acessados por 
índice.
char letra = 'M';
int notas[5];
notas[0] = 10;
notas[1] = 5;
Índices: Um array de 5 posições usa índices de 0 a 4. A primeira posição é 0, não 1.
9.1 Strings e array de chars
char palavrasecreta[20];
sprintf(palavrasecreta, "MELANCIA");
printf("%s", palavrasecreta);
Strings em C usam um caractere especial de término, \0. O printf com %s lê o array até encontrar esse 
terminador.
9.2 Varrendo o array e do-while
O jogo precisa pedir pelo menos um chute. O livro introduz do-while, que executa o corpo antes de testar a 
condição. strlen(), de string.h, fornece o tamanho da palavra.
do {
 char chute;
 printf("Qual letra? ");
 scanf(" %c", &chute);
} while(!acertou && !enforcou);
O espaço antes de %c é importante no exemplo do livro porque faz scanf ignorar o enter que ficou no 
buffer.
9.3 Laços encadeados
Os chutes são guardados em char chutes[26]. Para cada letra da palavra, o programa percorre os chutes 
já dados e decide se mostra a letra ou um underscore. Isso cria um for dentro de outro for.
for(int i = 0; iA motivação é que uma main com muitas linhas fica difícil de 
entender. O livro começa a dividir o jogo em partes menores e, a partir disso, chega naturalmente a 
parâmetros, passagem por cópia, ponteiros e retorno.
11.1 Escrevendo funções
void abertura() {
 printf("/****************/\n");
 printf("/ Jogo de Forca */\n");
 printf("/****************/\n\n");
}
int main() {
 abertura();
}
Uma função encapsula um bloco de código que pode ser chamado pelo nome. Quando main chama 
abertura(), sua execução é suspensa, a outra função executa e depois o fluxo volta ao ponto da chamada.
11.2 e 11.3 Extração e parâmetros
Ao extrair chuta(), surge um problema: variáveis locais de main não existem dentro da nova função. A 
solução inicial é passar dados como parâmetros.
void abertura(int multiplicador) {
 printf("Tabuada do %d\n", multiplicador);
}
abertura(2);
O livro explica passagem por cópia: o valor do argumento é copiado para o parâmetro. Mudar o parâmetro 
não altera automaticamente a variável original.
11.4 e 11.5 Ponteiros e passagem por referência
Quando a função precisa alterar a variável original, o livro passa seu endereço. & obtém o endereço; um 
ponteiro é declarado com *; e * também permite acessar o conteúdo do endereço apontado.
int c = 10;
int* ponteiro = &c;
printf("%d", *ponteiro);
No jogo, tentativas precisa ser alterada dentro de chuta(). Então a função recebe int* e main passa 
&tentativas.
void chuta(char chutes[], int* tentativas) {
 char chute;
 scanf(" %c", &chute);
 chutes[*tentativas] = chute;
 (*tentativas)++;
}
chuta(chutes, &tentativas);
Mapa mental: &variavel = endereço; int* p = ponteiro para int; *p = conteúdo no endereço apontado.
11.6 Arrays e ponteiros
O livro mostra que arrays já se comportam como ponteiros para a primeira posição. Os elementos ficam 
lado a lado na memória, e a aritmética de ponteiros permite navegar entre eles.
int numeros[3] = {10, 20, 30};
int* ponteiro = numeros;
printf("%d", *(ponteiro + 1)); // 20
11.7 Funções com retorno
int quadrado(int n) {
 return n * n;
}
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 14
void é usado quando nada precisa ser devolvido. Se a função produz um resultado, o tipo de retorno 
substitui void e return devolve o valor e encerra a função naquele ponto.
11.8 e 11.9 Mais funções e variáveis globais
O jogo é dividido em funções como desenhaforca(), chuta(), jachutou() e escolhepalavra(). Depois o livro 
experimenta variáveis globais para reduzir a quantidade de parâmetros. A vantagem é a simplicidade das 
assinaturas; a desvantagem é perder controle sobre quem pode modificar os dados.
Resumo do capítulo: Funções, chamadas, parâmetros, passagem por cópia, ponteiros, passagem por 
referência, arrays como ponteiros, retorno, extração de funções e prós/contras de variáveis globais.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 15
12. Entrada e saída (I/O)
Com funções bem separadas, o jogo passa a implementar de verdade as condições de vitória e derrota e, 
depois, troca a palavra fixa por um banco de palavras em arquivo.
ganhou() e enforcou()
enforcou() conta chutes errados e retorna se o limite foi atingido. ganhou() percorre a palavra secreta e 
retorna falso assim que encontra uma letra ainda não chutada. O do-while principal passa a depender 
diretamente dessas funções.
do {
 desenhaforca();
 chuta();
} while(!ganhou() && !enforcou());
12.1 Header files
Em C, a ordem das declarações importa. O livro mostra que as assinaturas das funções podem ser 
declaradas antes e depois movidas para um arquivo .h. O forca.c inclui esse header com aspas porque ele 
pertence ao próprio projeto.
// forca.h
int enforcou();
void abertura();
void chuta();
int jachutou(char letra);
int ganhou();
void desenhaforca();
void escolhepalavra();
// forca.c
#include "forca.h"
12.2 Lendo arquivos
FILE* representa o arquivo aberto. fopen("palavras.txt", "r") abre para leitura. Como I/O pode falhar, o 
retorno precisa ser verificado. fscanf() lê dados do arquivo de maneira sequencial e fclose() libera o 
recurso.
FILE* f = fopen("palavras.txt", "r");
if(f == 0) {
 printf("Banco de dados indisponível\n");
 exit(1);
}
int qtddepalavras;
fscanf(f, "%d", &qtddepalavras);
fclose(f);
12.3 Escrevendo no arquivo
O jogo pergunta se o usuário deseja inserir uma palavra. O livro apresenta fprintf(), os modos de abertura 
e fseek(). O modo a acrescenta ao fim; w escreve em um arquivo novo/sobrescreve; r+ permite ler e 
alterar o arquivo existente.
f = fopen("palavras.txt", "r+");
fscanf(f, "%d", &qtd);
qtd++;
fseek(f, 0, SEEK_SET);
fprintf(f, "%d", qtd);
fseek(f, 0, SEEK_END);
fprintf(f, "\n%s", novapalavra);
fclose(f);
12.4 Mais sobre I/O
O livro menciona retornos de fscanf(), feof(), fgetc(), fread() e fwrite() e reforça que a biblioteca é extensa. 
A orientação é consultar a documentação quando precisar entender parâmetros e retornos.
Regra recorrente: Abra o recurso, verifique se abriu, use-o e feche-o. O livro insiste em fclose(), 
especialmente na escrita, porque dados podem estar em buffer.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 16
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 17
13. Finalizando o jogo de forca
13.1 Evitando repetição
Repetição de código aumenta o custo de mudança e favorece bugs. O livro volta às duas ferramentas já 
conhecidas: funções para trechos reutilizáveis e constantes para valores repetidos. O tamanho máximo da 
palavra vira TAMANHO_PALAVRA no header.
#define TAMANHO_PALAVRA 20
13.2 Extraindo funções
A função enforcou() é dividida. chuteserrados() passa a calcular a quantidade de erros; letraexiste() isola a 
busca de uma letra. O resultado são funções menores e reaproveitáveis.
int enforcou() {
 return chuteserrados() >= 5;
}
13.3 If ternário
Para desenhar a forca sem repetir vários blocos de printf, o livro introduz o operador ternário: condição ? 
valor_verdadeiro : valor_falso.
printf(" | %c%c%c \\n",
 (erros >= 1 ? '(' : ' '),
 (erros >= 1 ? '_' : ' '),
 (erros >= 1 ? ')' : ' '));
13.4 Últimos detalhes
chuta() passa a informar se a letra existe; ao final, o jogo mostra mensagens diferentes para vitória e 
derrota. A lógica principal fica composta por funções pequenas e com nomes que descrevem as ações.
Resumo do capítulo: Quebrar funções, evitar números mágicos repetidos e usar if ternário quando a 
escolha é curta e inline.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 18
14. Exercícios do segundo bloco
Os exercícios retomam os dois jogos e avançam um pouco em arquivos e funções. Entre os desafios do 
livro estão:
• Trocar o loop do jogo de adivinhação por do-while.
• Aceitar apenas letras maiúsculas na forca.
• Impedir palavra duplicada no arquivo.
• Adicionar palavra apenas em determinadas condições.
• Criar níveis de dificuldade para a forca.
• Reaproveitar jachutou() para reduzir repetição.
• Corrigir o formato da contagem de palavras usando %04d.
• Salvar nome e pontuação em ranking.txt.
• Criar função de potência, tabuada em arquivo, soma de pares, teste de primo e soma de primos em 
intervalo.
• Criar função que soma os elementos de um array de inteiros.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 19
15. Jogo Foge-foge
O terceiro projeto é semelhante a Pac-Man. O herói anda por um mapa, evita fantasmas e pode usar uma 
pílula para explodi-los. O livro usa esse projeto para introduzir os tópicos mais avançados da obra.
• Matrizes / arrays bidimensionais.
• Alocação dinâmica de memória.
• Structs e tipos próprios.
• Funções recursivas.
• Funções de manipulação de strings e memória.
• Ponteiros de ponteiros.
• Outras diretivas de compilação.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamenteno livro enviado | 20
16. Matrizes
Mapa como linhas e colunas
O mapa contém paredes, espaços livres e o herói. Em vez de criar um array separado para cada linha, o 
livro usa uma matriz, isto é, uma estrutura de linhas e colunas.
char mapa[5][10];
mapa[0][0] = '|';
printf("%c", mapa[2][3]);
16.1 Ponteiros de ponteiros
Cada linha da matriz pode ser vista como um array. O livro então apresenta a ideia de um ponteiro que 
aponta para ponteiros e usa int** como representação conceitual de “ponteiro de ponteiro”.
int** matriz;
16.2 Alocação dinâmica de memória
Para mapas de tamanhos diferentes, o tamanho não deve ficar fixo no código. malloc() reserva a 
quantidade de bytes em tempo de execução e devolve um ponteiro. sizeof() fornece o tamanho do tipo na 
plataforma.
int linhas = 5;
int colunas = 10;
int** matriz = malloc(sizeof(int*) * linhas);
for(int i = 0; i como forma simplificada de (*m).campo.
void alocamapa(MAPA* m) {
 m->matriz = malloc(sizeof(char*) * m->linhas);
}
O projeto passa a compilar múltiplos arquivos C juntos.
gcc fogefoge.c mapa.c -o fogefoge.out
17.3 Introdução à análise de algoritmos
A primeira versão de move() procura o herói percorrendo a matriz inteira. O livro observa que o pior caso 
cresce com linhas × colunas. Depois guarda a posição do herói em uma struct POSICAO, evitando a busca 
a cada movimento e tornando essa parte independente do tamanho da matriz.
struct posicao {
 int x;
 int y;
};
typedef struct posicao POSICAO;
Resumo do capítulo: Agrupar dados relacionados com struct, typedef, separar arquivos, passar 
structs por referência, usar -> e começar a pensar no custo dos algoritmos.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 22
18. Programando como um profissional
O título do capítulo resume sua intenção: pegar um jogo que funciona e melhorar sua organização. A 
função move() está grande, então o livro volta a discutir responsabilidades, legibilidade, reutilização e 
contratos de funções.
18.1 Novamente, responsabilidades
move() fazia tarefas demais: validar direção, calcular posição, validar mapa e alterar a matriz. O livro 
extrai funções como ehdirecao(), ehvalida(), ehvazia() e andanomapa(). O objetivo é que cada função 
tenha uma responsabilidade mais clara.
int ehdirecao(char direcao) {
 return direcao == 'a' || direcao == 'w' ||
 direcao == 's' || direcao == 'd';
}
Ideia do capítulo: Um nome de função bem escolhido permite entender a intenção sem ler todos os 
detalhes da implementação.
18.2 Novamente, constantes
Os “chars mágicos” do mapa e das direções viram constantes em mapa.h e fogefoge.h.
#define HEROI '@'
#define VAZIO '.'
#define PAREDE_VERTICAL '|'
#define CIMA 'w'
#define BAIXO 's'
18.3 Estruturas auxiliares
Para mover fantasmas sem processar novamente um fantasma que acabou de andar, o livro cria uma 
cópia do mapa. strcpy() copia strings. Também são apresentadas memcpy(), para copiar blocos de 
memória, e memset(), usada no exemplo para inicializar uma struct com zeros.
memcpy(&destino, &origem, sizeof(CONTATO));
memset(&contato, 0, sizeof(CONTATO));
18.4 Um pouco de inteligência artificial
Os fantasmas passam a escolher aleatoriamente uma entre quatro direções possíveis. Uma matriz auxiliar 
guarda as opções e a função tenta até dez vezes encontrar uma direção válida. O livro apresenta isso 
como um exemplo muito simples de tomada de decisão, não como um estudo aprofundado de IA.
18.5 Acoplamento, encapsulamento e assinaturas
Ao mudar uma assinatura, todos os lugares que chamam a função podem precisar mudar. Por isso, o livro 
chama atenção para o “contrato” de uma função: nome, parâmetros e retorno. A implementação pode 
evoluir sem quebrar o restante se o contrato permanecer estável.
Resumo do capítulo: Funções menores, estruturas auxiliares, strcpy/memcpy/memset, contratos de 
função, encapsulamento e variáveis auxiliares para tornar o código mais legível.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 23
19. Recursividade
A pílula dá ao herói uma bomba que explode casas ao redor. O livro primeiro resolve uma direção com 
loop e depois reescreve o problema de forma recursiva para ensinar o conceito.
19.1 Entendendo recursão
Uma função recursiva chama a si mesma. Se não houver uma condição de parada, a chamada continua 
até esgotar a pilha de execução. O livro chama a condição de parada de ponto de fuga.
void explodepilula(int x, int y, int qtd) {
 if(qtd == 0) return;
 m.matriz[x][y+1] = VAZIO;
 explodepilula(x, y+1, qtd-1);
}
Fibonacci aparece como outro exemplo clássico: F(n) = F(n-1) + F(n-2), com casos de parada em 0 e 1.
int fib(int n) {
 if(n == 0) return 0;
 if(n == 1) return 1;
 return fib(n-1) + fib(n-2);
}
19.2 Tornando o algoritmo genérico
A explosão passa a receber somax e somay, permitindo reutilizar a mesma função nas quatro direções. 
Outros pontos de fuga interrompem a recursão quando a posição é inválida ou há uma parede.
Custo: O livro observa que recursão pode ser simples de ler, mas cada chamada precisa preservar o 
estado das chamadas anteriores na pilha. Em alguns problemas, um loop pode consumir menos 
memória.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 24
20. Outras diretivas de compilação
A interface do mapa é movida para ui.c. Isso aumenta o número de arquivos e cria um problema: o mesmo 
header pode ser incluído mais de uma vez, causando redefinições.
20.1 #ifdef e #ifndef
Essas diretivas são condicionais de compilação. #ifdef inclui um trecho se um símbolo estiver definido; 
#ifndef faz o contrário. O livro usa isso para criar proteções nos headers.
#ifndef _MAPA_H_
#define _MAPA_H_
// structs, constantes e assinaturas
#endif
Assim, uma segunda inclusão do mesmo header não repete suas declarações. O capítulo também comenta 
que diretivas desse tipo podem selecionar trechos específicos para plataformas diferentes.
Resumo do capítulo: Entender redefinições em projetos com vários arquivos e usar #ifdef/#ifndef 
para controlar o que é compilado.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 25
21. Exercícios do Foge-foge
O último conjunto de exercícios pede melhorias diretamente ligadas ao que foi estudado. Os desafios 
incluem:
• Aceitar comandos em maiúsculas e minúsculas.
• Fazer fantasmas se aproximarem do herói por caminhos melhores.
• Controlar por quantos turnos o herói pode comer fantasmas.
• Impedir fantasmas de comerem pílulas.
• Reescrever explodepilula() sem recursão, usando loops.
• Melhorar move() para reduzir repetição.
• Desenhar a árvore de chamadas de fib(5) e perceber cálculos repetidos.
• Guardar valores já calculados de Fibonacci em um array (memorização, como o livro chama).
• Criar função para verificar palíndromos.C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 26
22. O que fazer agora?
O livro encerra a trilha principal dizendo que a base de programação foi construída, mas ainda existe 
muito a estudar. As sugestões do autor incluem:
• Orientação a Objetos e linguagens como Java e C#.
• Desenvolvimento web: HTML, CSS, JavaScript e tecnologias de servidor.
• Desenvolvimento mobile.
• Testes automatizados, em vez de depender apenas de testes manuais.
• Boas práticas, padrões de projeto e arquitetura de software.
• Participar de comunidades, fóruns e eventos e continuar pesquisando.
Mensagem final do livro: A vida do desenvolvedor envolve aprendizado contínuo. Pesquisar, ler erros 
do compilador com calma e continuar praticando fazem parte do trabalho.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 27
23. Apêndice: compilador e códigos finais
Instalando/testando o GCC
O apêndice original orienta usuários de Windows a instalar MinGW/GCC e configurar o PATH; em Linux e 
Mac, considera provável que GCC já esteja disponível. Como esse material é antigo, o ponto conceitual 
mais importante é testar o compilador com um programa mínimo.
#include 
int main() {
 printf("Meu compilador funciona!");
}
gcc teste.c -o teste.exe
Apêndice B: códigos completos
O livro termina reunindo os códigos completos dos três projetos: adivinhação, forca e Foge-foge. Eles são 
úteis para conferir o estado final, mas a aprendizagem proposta pelo livro está na evolução feita ao longo 
dos capítulos, não apenas em copiar o código pronto.
Como revisar: Quando seu código quebrar, compare primeiro a parte do capítulo que você está 
estudando. Use o código final apenas como referência de chegada.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 28
Mapa final dos conceitos - na ordem em que o livro constrói
Projeto Progressão de conceitos
Adivinhação printf/scanf → int → if/else → escopo → for → break/continue 
→ while → #define → tipos → casting → abs → rand/srand → 
switch.
Forca char → arrays → strings → strlen → do-while → loops 
aninhados → binário/hexadecimal → funções → parâmetros → 
ponteiros → referência → retorno → globais → headers → 
FILE* → fopen/fscanf/fprintf/fseek/fclose → refatoração → 
ternário.
Foge-foge matrizes → ponteiro de ponteiro → malloc/sizeof/free → 
structs → typedef → ponteiros de structs e -> → vários .c → 
análise de algoritmos → responsabilidades → constantes → 
strcpy/memcpy/memset → contratos → recursividade → 
#ifdef/#ifndef.
Se você dominar esta sequência: Você terá percorrido o mesmo caminho conceitual do livro, só que 
em uma versão condensada. Quando algum ponto não estiver claro, volte ao capítulo correspondente 
no original e acompanhe a evolução completa do jogo.
C DO ZERO - GUIA FIEL AO LIVRO
Resumo didático baseado exclusivamente no livro enviado | 29
Checklist de domínio
• Explicar o papel de main, #include, printf, scanf e do compilador.
• Declarar e inicializar variáveis e escolher entre int, double, float, long, short e char no contexto 
apresentado pelo livro.
• Usar if/else if/else, switch, for, while e do-while.
• Explicar escopo, break, continue e #define.
• Manipular arrays e strings e lembrar que os índices começam em 0.
• Explicar por que strings precisam de terminador nulo.
• Escrever funções com parâmetros e retorno.
• Diferenciar passagem por cópia de passagem por referência.
• Explicar &, *, int* e a relação entre arrays e ponteiros.
• Criar e usar um header .h.
• Abrir, ler, escrever, reposicionar e fechar arquivos.
• Declarar matrizes e entender a motivação para ponteiro de ponteiro.
• Usar malloc, sizeof e free no modelo do livro.
• Criar structs, typedef e usar . e ->.
• Explicar por que separar responsabilidades melhora legibilidade e reúso.
• Entender, em nível introdutório, custo proporcional ao tamanho da entrada versus tempo constante.
• Explicar recursão e ponto de fuga.
• Usar include guards com #ifndef/#define/#endif.
Critério prático: Não basta reconhecer a sintaxe. Tente escrever pequenos trechos sem olhar, 
compile, provoque erros e explique o que cada linha faz.
	Sumário fiel ao livro
	1. Introdução
	A proposta dos três jogos
	2. Jogo de adivinhação
	O que esse jogo vai ensinar
	3. Variáveis
	3.1 Nosso primeiro programa
	Compilação com GCC
	3.2 Declarando variáveis
	3.3 Lendo do teclado
	3.5 O que o livro resume
	4. Controle de fluxo com ifs e fors
	if, else e comparações
	4.1 Escopo de variáveis
	4.2 Loops e for
	4.3 break, 4.6 continue e 4.7 while
	4.4 #define e números mágicos
	4.5 else if e 4.8 loops infinitos
	5. Tipos de dados e operações matemáticas
	5.1 Pontuação e operações
	5.2 Outros tipos numéricos
	5.3 Conversões e casting
	5.4 Funções matemáticas
	5.5 Números randômicos
	6. Finalizando o jogo de adivinhação
	Níveis de dificuldade
	Vitória, derrota e escopo
	Interface no console
	7. Exercícios do primeiro bloco
	8. Jogo de forca
	O que esse jogo introduz
	9. Arrays
	char e arrays
	9.1 Strings e array de chars
	9.2 Varrendo o array e do-while
	9.3 Laços encadeados
	10. Números binários
	Binário e bytes
	10.1 Letras e ASCII
	10.2 8, 16, 32 e 64 bits
	10.3 Ponto flutuante
	10.4 Hexadecimal e 10.5 imagens
	11. Funções e ponteiros
	11.1 Escrevendo funções
	11.2 e 11.3 Extração e parâmetros
	11.4 e 11.5 Ponteiros e passagem por referência
	11.6 Arrays e ponteiros
	11.7 Funções com retorno
	11.8 e 11.9 Mais funções e variáveis globais
	12. Entrada e saída (I/O)
	ganhou() e enforcou()
	12.1 Header files
	12.2 Lendo arquivos
	12.3 Escrevendo no arquivo
	12.4 Mais sobre I/O
	13. Finalizando o jogo de forca
	13.1 Evitando repetição
	13.2 Extraindo funções
	13.3 If ternário
	13.4 Últimos detalhes
	14. Exercícios do segundo bloco
	15. Jogo Foge-foge
	16. Matrizes
	Mapa como linhas e colunas
	16.1 Ponteiros de ponteiros
	16.2 Alocação dinâmica de memória
	17. Structs
	17.1 Definindo uma struct
	17.2 Ponteiros para structs
	17.3 Introdução à análise de algoritmos
	18. Programando como um profissional
	18.1 Novamente, responsabilidades
	18.2 Novamente, constantes
	18.3 Estruturas auxiliares
	18.4 Um pouco de inteligência artificial
	18.5 Acoplamento, encapsulamento e assinaturas
	19. Recursividade
	19.1 Entendendo recursão
	19.2 Tornando o algoritmo genérico
	20. Outras diretivas de compilação
	20.1 #ifdef e #ifndef
	21. Exercícios do Foge-foge
	22. O que fazer agora?
	23. Apêndice: compilador e códigos finais
	Instalando/testando o GCC
	Apêndice B: códigos completos
	Mapa final dos conceitos - na ordem em que o livro constrói
	Checklist de domínio