Como usar este guia

Leia os capítulos na ordem: cada um usa o que foi aprendido no anterior. Em cada capítulo você vai encontrar sempre a mesma estrutura: uma ideia central explicada com analogias, programas completos para testar, um resumo e exercícios com dicas.

1. Digite os exemplos. Digitar treina o olho e a mão, e os erros de digitação ensinam mais do que parece. Se estiver com pressa, use o botão Copiar de cada bloco de código e cole no seu ambiente de desenvolvimento.
2. Mude o código. Troque números, textos, condições. Quebre de propósito e veja a mensagem de erro. Programar é experimentar.
3. Erre sem medo. O computador não se ofende. Todo programador passa o dia corrigindo erros.
4. Faça os exercícios antes de olhar as dicas. A dica só existe para desemperrar.

Como ler os blocos

O código aparece em janelas escuras com número de linha e um botão para copiar. As linhas mais claras são as que estão sendo explicadas naquele momento. A saída do programa aparece em uma janela preta, parecida com a do Windows, e o que a pessoa digita fica destacado.

Os avisos coloridos em cinza seguem um padrão fácil de reconhecer:

Mapa do curso

Clique em qualquer capítulo para começar por ele. Você também pode marcar capítulos como concluídos para acompanhar seu progresso.

O que é um programa?

Um programa é uma lista de instruções que o computador executa uma por uma, na ordem. O computador é rapidíssimo, mas totalmente literal: ele não tem bom senso e não adivinha o que você quis dizer. Só faz exatamente o que está escrito.

Veja um algoritmo para preparar macarrão instantâneo. Repare que cada passo é simples e que a ordem importa:

As peças principais

Todo computador, do celular ao servidor de um jogo online, tem as mesmas peças básicas trabalhando juntas:

Quando você abre um jogo, ele é copiado do SSD para a RAM, e a CPU passa a executá-lo lendo instruções da RAM:

Tudo é 0 e 1

Um computador é feito de bilhões de minúsculos interruptores que só têm dois estados: ligado ou desligado. Cada interruptor é um bit (do inglês binary digit), que vale 0 ou 1. Um grupo de 8 bits forma um byte.

Com 1 bit temos 2 combinações. Com 2 bits, 4. Com 8 bits, 2 × 2 × 2 × 2 × 2 × 2 × 2 × 2 = 256 combinações, ou seja, um byte pode guardar valores de 0 a 255. Cada posição vale o dobro da anterior, da direita para a esquerda:

No exemplo, somamos apenas as posições ligadas: 64 + 1 = 65. Experimente você mesmo. Clique nos bits e observe o número mudar:

Repare que o valor 65 aparece como a letra A. Isso não é coincidência: o computador guarda letras como números, seguindo uma tabela chamada ASCII. Imagens, músicas e vídeos também são apenas números muito longos. Para o computador, tudo é número.

Memória: uma rua com milhões de casas

A RAM é uma sequência enorme de bytes, e cada byte tem um endereço, como o número de uma casa em uma rua. Quando o programa precisa guardar algo, ele reserva algumas dessas casas e dá um nome a elas. Esse nome é o que chamaremos de variável.

Uma pequena parte da memória. Os endereços aqui são inventados, só para ilustrar.

Você não precisa decorar endereços: escolhe o nome (idade) e o computador cuida do resto. Nos capítulos 4 e 12 você vai ver isso na prática.

Da ideia ao programa: o compilador

A CPU só entende instruções em código de máquina, sequências de 0 e 1 que ninguém quer escrever à mão. Por isso criamos linguagens mais próximas do nosso jeito de pensar, como o C. Mas o processador não entende C, então precisamos de um tradutor: o compilador.

Existem dois tipos de erro que você vai encontrar:

• Erros de compilação: o compilador não consegue traduzir (faltou um ponto e vírgula, um nome está errado). O .exe nem chega a ser criado, e o compilador diz onde está o problema.
• Erros de lógica: o programa compila e roda, mas faz a coisa errada (calculou uma média errada, por exemplo). Esses são os mais traiçoeiros, porque ninguém avisa.

Por que aprender C?

O C foi criado por Dennis Ritchie nos laboratórios Bell, no começo da década de 1970, e continua em uso mais de cinquenta anos depois. Há bons motivos:

• É rápido e enxuto. Programas em C usam pouca memória e rodam muito depressa.
• Mostra como o computador funciona. Em C você lida diretamente com memória, tipos e endereços. Quem aprende C entende melhor qualquer outra linguagem.
• Aparece em todo lugar. O núcleo do Linux, partes dos sistemas operacionais, motores de jogos, o interpretador do Python e o firmware de microcontroladores (como os de Arduino) têm muito C ou C++ por baixo.
• Abre portas. C++, C#, Java e JavaScript herdaram muita coisa da sintaxe do C.

Exercícios

O que é uma IDE?

IDE significa Ambiente de Desenvolvimento Integrado. É um programa que reúne, em um só lugar, o editor onde você escreve o código, o compilador que o traduz e, geralmente, um depurador que ajuda a achar erros. Existem várias IDEs para C, todas fazendo essencialmente a mesma coisa por baixo: chamar um compilador (na grande maioria das vezes, o GCC ou algo compatível com ele) para transformar seu código em um programa executável.

Instalação em resumo

Os detalhes mudam de ferramenta para ferramenta, mas o caminho costuma ser parecido:

1. Baixe o instalador na página oficial da ferramenta escolhida. Baixe apenas de fontes confiáveis.
2. Execute o instalador. Se o sistema pedir permissão, confirme.
3. Escolha o idioma, se disponível (muitas têm Português Brasileiro), e avance nas telas com as opções padrão.
4. Ao abrir pela primeira vez, o programa pode pedir tema e fonte. Escolha o que for mais confortável para os olhos.

A maioria dessas IDEs já traz o compilador embutido ou o instala junto, então normalmente você não precisa instalar mais nada à parte.

Um passeio pela interface

As IDEs têm aparências diferentes, mas quase todas organizam a tela nas mesmas áreas. O desenho abaixo é um resumo genérico; a sua pode ter os nomes em outro lugar ou com outro visual, mas o papel de cada área costuma ser este:

• Menus: Arquivo, Editar, Executar (ou nomes parecidos, onde estão compilar e rodar)...
• Barra de ferramentas: atalhos com ícones, geralmente incluindo compilar, executar e compilar+executar.
• Painel lateral: lista de arquivos do projeto e, em algumas IDEs, classes e depuração.
• Editor: onde você escreve o código. É aqui que você passa a maior parte do tempo, em qualquer ferramenta.
• Painel de mensagens: mostra erros e avisos do compilador. Fique de olho nele, seja qual for o nome que sua IDE dá a ele!

Criando e salvando o primeiro arquivo

1. Crie uma pasta curta para seus programas, por exemplo C:\programacao no Windows (ou ~/programacao no Linux/macOS). Evite espaços e acentos no caminho.
2. No seu editor, vá em Arquivo > Novo > Arquivo Fonte (ou similar) ou pressione Ctrl+N.
3. Pressione Ctrl+S para salvar. Na janela, escolha sua pasta e, no tipo de arquivo, selecione algo como C source files (*.c).
4. Dê um nome sem espaços nem acentos, como ola.c.

Compilar e executar

Toda IDE tem alguma forma de compilar (traduzir o código) e executar (rodar o programa gerado), muitas vezes combinadas em um único botão de "play" ou "executar". O nome e o atalho variam de ferramenta para ferramenta; a tabela abaixo mostra alguns exemplos comuns só para você ter uma referência — procure o equivalente na sua:

Outros atalhos costumam se repetir em quase toda ferramenta de edição de texto ou código:

Ao compilar e executar, sua ferramenta salva o arquivo (se ainda não salvou), traduz o código e abre uma janela de console (às vezes chamada de terminal), onde seu programa roda. Muitas IDEs acrescentam uma mensagem extra ao final, parecida com esta, para a janela não fechar antes de você ler o resultado:

Essa mensagem extra não é do seu programa: quem escreve é a IDE, e o texto exato varia de uma para outra. O código de retorno é o número que o programa devolveu ao sistema operacional com o return 0; que você conhecerá no próximo capítulo. Zero significa "terminei sem problemas".

Lendo as mensagens do compilador

Quando algo está errado, o painel de erros da sua IDE (a área 5 do diagrama acima, ou a saída do terminal, se você estiver compilando por linha de comando) lista os problemas. Uma mensagem típica, para um ; esquecido, parece com isto, praticamente igual em qualquer ferramenta baseada em GCC:

Leia assim: arquivo ola.c, linha 6, coluna 5, error (erro): "esperava um ponto e vírgula antes de return". Regras de ouro para lidar com erros:

1. Comece pelo primeiro erro da lista. Um único erro costuma provocar vários outros em cascata.
2. Clique (ou dê duplo clique) na mensagem, se sua IDE permitir. Na maioria delas, o cursor pula direto para a linha indicada.
3. Olhe também a linha de cima. No exemplo acima, o ponto e vírgula esquecido estava na linha 5, mas o compilador só percebeu na 6.
4. Avisos (warning) não impedem o programa de rodar, mas geralmente apontam bugs de verdade. Leia todos.

Alternativa: compilando pelo terminal

Se preferir (ou se sua turma trabalhar assim), você não precisa de uma IDE completa: pode escrever o código em qualquer editor de texto simples e compilar diretamente no terminal (o Prompt de Comando ou PowerShell no Windows; o terminal no Linux e no macOS), desde que o compilador esteja instalado e configurado no sistema.

Esse comando compila ola.c e gera um executável chamado ola (ola.exe no Windows). Para rodar:

Esse é exatamente o mesmo processo que uma IDE faz por trás dos botões: ela só poupa você de digitar o comando toda vez.

Hábitos que poupam dor de cabeça

• Salve com Ctrl+S com frequência (ou lembre de recompilar após salvar, se seu fluxo for pelo terminal).
• Use um arquivo para cada programa e nomes sem espaços ou acentos: media_notas.c.
• Indente o código (4 espaços ou Tab dentro das chaves). Código alinhado é código legível.
• Para projetar em sala, aumente a fonte do editor nas opções da sua ferramenta.

Exercícios

O "Olá, mundo!"

Todo programador começa por aqui. Abra sua IDE (ou o terminal, se for esse o seu caminho), crie um arquivo novo, salve como ola.c e digite:

Compile e execute (use o atalho ou o botão do seu ambiente, como vimos no capítulo anterior). Se tudo deu certo, a janela preta aparece:

Parabéns, você acabou de criar um programa! Vamos entender o que cada linha faz.

Anatomia de um programa em C

O que acontece quando você compila e executa

Por trás do botão (seja ele qual for) existe uma linha de montagem com três etapas:

Mais de uma instrução

Vamos criar uma pequena ficha de apresentação. Note como cada printf aparece em uma linha da tela, na mesma ordem em que foi escrito. Esse programa já usa a linha do setlocale, que explicamos logo adiante:

E os acentos?

O console do Windows usa uma tabela de caracteres antiga, diferente da que o editor usa. Sem uma configuração, palavras como informática podem sair como informática. A solução é avisar ao programa que vamos usar português, com a linha:

Este é o seu modelo padrão: a partir de agora, todo programa do guia começa assim. Guarde uma cópia como modelo.c e comece cada exercício a partir dele.

Caracteres especiais

Dentro das aspas do printf, a barra invertida \ inicia uma sequência de escape: um código que representa algo que não dá para digitar diretamente.

Comentários: notas para humanos

O compilador ignora completamente os comentários, então eles servem para explicar o código para quem for ler (inclusive você daqui a um mês). Também servem para "desligar" uma linha temporariamente.

Desenhando com texto

Um exemplo divertido que junta tudo: um gatinho em arte ASCII. Como a barra invertida é especial, cada uma precisa ser escrita duas vezes (\\).

Erros comuns de quem está começando

Exercícios

Variável é uma caixa com nome

Para usar uma variável, primeiro a declaramos, dizendo o tipo e o nome. Depois damos um valor a ela com o sinal =, que em C significa "recebe" e não "é igual a":

Cada int ocupa 4 bytes, por isso os endereços (inventados) pulam de 4 em 4.

Os tipos básicos

Os números decimais usam ponto no código: 3.14, e não 3,14. Um caractere isolado usa aspas simples: 'G'. Textos com aspas duplas ("Olá") são um assunto para o capítulo 10.

Mostrando variáveis na tela

No printf, cada %d, %f ou %c dentro do texto é um espacinho que será preenchido pelas variáveis listadas depois da vírgula, na mesma ordem. O %.2f mostra o número com 2 casas decimais.

O valor de uma variável pode mudar durante o programa. É por isso que ela se chama "variável":

Aplicação: quantas músicas cabem no pen drive?

Conversões de armazenamento aparecem toda hora. Com variáveis, o programa faz a conta para qualquer tamanho:

Outro exemplo do dia a dia, agora com decimais: o total de uma compra.

Nomes de variáveis

• Podem ter letras, números e o sublinhado _, mas não podem começar com número.
• Sem espaços, acentos ou símbolos: nota_final sim, nota final e média não.
• Maiúsculas importam: Idade e idade são variáveis diferentes.
• Não podem ser palavras reservadas do C, como int, if ou return.
• Prefira nomes que expliquem o conteúdo: preco_unitario diz muito mais do que x.

Constantes

Quando um valor nunca deve mudar (como o valor de π ou o número máximo de estudantes), declare uma constante. Por convenção, usamos letras maiúsculas:

O tamanho de cada tipo

O operador sizeof pergunta ao compilador quantos bytes um tipo ocupa. É uma boa forma de conferir o que você aprendeu no capítulo 1:

Quando os números "estouram"

Uma variável tem um número fixo de bits, então existe um valor máximo. Um unsigned char (byte sem sinal) vai de 0 a 255. O que acontece ao somar 1 em 255?

Volte ao laboratório do capítulo 1: 11111111 mais 1 daria 100000000, que precisa de 9 bits. Como só cabem 8, o bit extra se perde e sobra 00000000. É como o hodômetro de um carro que passa de 999.999 e volta a zero. Esse fenômeno se chama overflow.

Variável sem valor: o "lixo" na memória

Ao declarar int x;, o computador reserva a caixa, mas não a limpa. Ela contém o que sobrou de algum programa anterior, o "lixo". Ler uma variável antes de dar valor a ela mostra números imprevisíveis.

Tabela de especificadores

Exercícios

O ciclo: perguntar, esperar, guardar

Um programa interativo segue quase sempre a mesma receita: mostra uma pergunta com printf, espera a resposta com scanf e guarda o valor em uma variável.

O scanf tem duas partes: o formato entre aspas, que diz que tipo de dado esperar (%d para int, %f para float, %lf para double, %c para char), e o destino, a variável onde guardar.

Nosso primeiro programa interativo

Vamos perguntar o nome da pessoa. Por enquanto, aceite que char nome[50] cria um espaço para guardar um texto de até 49 letras (o capítulo 10 explica). Repare que, para texto, não usamos o &:

Lendo números e fazendo contas

Aqui vai um pequeno spoiler do próximo capítulo: os símbolos + - * / fazem o que você espera. Veja duas leituras, uma para cada número:

Repare que cada valor tem sua própria pergunta e sua própria leitura. Isso deixa claro para quem está usando o programa o que ele deve digitar a cada momento.

Aplicação: conversor de temperatura

Viajando para o Canadá, 25 °C parece pouco ou muito? Vamos converter com a fórmula F = C × 9 / 5 + 32:

Aplicação: quanto tempo até juntar dinheiro?

Sonhando com um celular novo ou um videogame? O programa calcula quantos meses são necessários, guardando uma quantia fixa por mês:

Lendo um caractere

Para ler uma única letra, coloque um espaço antes do %c. Esse espaço manda o scanf ignorar o Enter que sobrou de uma leitura anterior:

Tabela de formatos do scanf

Erros clássicos

• Esquecer o &: scanf("%d", idade); tenta escrever em um endereço inválido e o programa pode fechar de repente.
• Formato errado: usar %d para ler um float guarda lixo. O formato deve combinar com o tipo da variável.
• Digitar letra onde se espera número: o scanf desiste da leitura e a variável fica com o valor antigo. Para programas mais robustos, verifique o retorno: scanf devolve quantos valores conseguiu ler.

Exercícios

Operadores aritméticos

A pegadinha da divisão de inteiros

Se os dois lados da divisão forem inteiros, o resultado também é inteiro: a parte decimal é simplesmente descartada. Isso vale mesmo quando o resultado é guardado em um float! Para obter o resultado correto, ao menos um dos lados precisa ser decimal, e podemos forçar isso com uma conversão (cast): (float)a.

O resto da divisão é muito útil

O operador % parece esquisito no começo, mas resolve muitos problemas: saber se um número é par (n % 2 == 0), fazer ciclos (como os dias da semana) e converter unidades. Veja como transformar segundos em horas, minutos e segundos:

Como funciona: 3725 ÷ 3600 = 1 hora, sobrando 125 segundos (3725 % 3600). Desses 125, 125 ÷ 60 = 2 minutos, sobrando 5 segundos (total % 60).

Precedência: quem calcula primeiro?

Como na matemática, multiplicação, divisão e resto são calculados antes de soma e subtração. Use parênteses para mandar no que acontece primeiro. O erro clássico é calcular uma média sem eles:

Atalhos: incremento e atribuição composta

Somar 1 a uma variável é tão comum que existe um atalho. O mesmo vale para as outras operações:

Operadores de comparação e lógicos

Comparações respondem verdadeiro ou falso. Em C, o falso é o número 0 e o verdadeiro é 1 (na verdade, qualquer valor diferente de zero conta como verdadeiro).

Funções matemáticas: math.h

Para raiz quadrada, potência e outras contas, inclua a biblioteca math.h:

Um uso real: em jogos, é preciso saber a distância entre dois pontos da tela (o jogador e um inimigo, por exemplo). Pelo teorema de Pitágoras, d = √((x₂−x₁)² + (y₂−y₁)²):

Exercícios

A bifurcação

No dia a dia decidimos o tempo todo: se estiver chovendo, levo guarda-chuva; senão, deixo em casa. Em C escrevemos exatamente assim. A condição fica entre parênteses e o que fazer, entre chaves:

          ┌───────────────┐
          │  media >= 7 ? │
          └───────┬───────┘
          sim     │     não
        ┌─────────┴─────────┐
        ▼                   ▼
  "Aprovado!"         "Reprovado."
        └─────────┬─────────┘
                  ▼
           (o programa segue)

Se a condição for verdadeira, o bloco do if executa; se for falsa, executa o bloco do else (que é opcional). Depois disso o programa continua normalmente.

Vários caminhos: else if

Quando há mais de duas possibilidades, encadeamos condições com else if. O computador testa de cima para baixo e executa apenas o primeiro bloco cuja condição for verdadeira:

Combinando condições

Use && (E) e || (OU) para condições mais ricas. Um exemplo clássico: descobrir se um ano é bissexto. A regra é: divisível por 4 e não por 100, ou divisível por 400.

Escolhendo entre opções: switch

Quando você compara uma mesma variável com vários valores fixos (um menu, um operador), o switch fica mais limpo que muitos else if. Cada case é uma possibilidade; o break encerra o caso, e o default cuida de qualquer outra coisa.

Aplicação: cardápio da lanchonete

Um menu numerado é o uso perfeito do switch. Note que dentro do default usamos return 0; para encerrar o programa se a opção for inválida:

Bônus: o operador ternário

Para escolher entre dois valores em uma única linha existe o operador ?:, que lê "condição ? valor se verdadeiro : valor se falso":

Erros comuns em decisões

Exercícios

while: repetir enquanto for verdade

O while testa uma condição; se for verdadeira, executa o bloco e volta a testar. Só para quando a condição fica falsa. Veja uma contagem regressiva:

Teste de mesa: como "ser o computador"

Para entender um laço, faça um teste de mesa: uma tabela onde você acompanha, passo a passo, o valor das variáveis como se fosse o computador executando. É a melhor técnica para achar erros de lógica.

for: quando você sabe quantas vezes

O for reúne em uma linha as três partes de um laço com contador: início, condição e passo.

for ( int i = 1 ;  i <= 10 ;  i++ ) {
      └───┬───┘    └──┬──┘    └─┬─┘
      começa em     repete    depois de cada
          1        enquanto    volta, soma 1
                  for verdade
}

A tabuada é o exemplo perfeito. Escolha o número e o computador mostra a conta inteira:

Contador e acumulador

Dois padrões aparecem o tempo todo dentro de laços. O contador conta quantas vezes algo acontece (cont++). O acumulador vai somando valores (soma += valor). Os dois começam em zero antes do laço.

do-while: faça primeiro, pergunte depois

O do-while executa o bloco pelo menos uma vez e só então testa a condição. É ideal para validar dados: pede-se o valor e repete-se enquanto ele estiver errado.

Todo programa com menu usa esse padrão: mostra as opções e repete até o usuário escolher "Sair".

break e continue

break sai do laço imediatamente. continue pula o resto da volta atual e vai para a próxima. Veja um sistema de senha com três tentativas, um caso real de uso do break:

E um exemplo curto de continue: mostrar só os números ímpares de 1 a 10.

Laços dentro de laços

Um laço pode conter outro. O de dentro roda completo a cada volta do de fora. É assim que desenhamos figuras e percorremos tabelas:

Qual laço usar?

Projeto: jogo de adivinhação

Hora de juntar tudo: variáveis, scanf, if e um laço. O computador "pensa" em um número aleatório e você tenta adivinhar com dicas de maior ou menor. Para sortear, usamos rand(), e srand(time(NULL)) muda a semente a cada execução (senão o número seria sempre o mesmo).

Exercícios

Uma fileira de caixas numeradas

O vetor v depois de v[2] = 99. Embaixo, o endereço (inventado) de cada posição.

Percorrendo com for

Vetores e laços for nasceram um para o outro: o contador do laço serve de índice. Vamos ler as notas de 5 estudantes e calcular estatísticas. Usamos #define TAM 5 para definir o tamanho em um só lugar:

Vetor como contador: lançando dados

Um uso muito esperto: cada posição do vetor conta quantas vezes um valor apareceu. Vamos "rolar" um dado 60 vezes e desenhar um histograma:

O perigo de sair dos limites

O C não verifica se o índice existe. Se você escrever em v[5] em um vetor de 5 posições, o programa escreve na memória vizinha, que pertence a outra variável (ou a outro pedaço do programa!). O resultado pode ser um valor que muda "do nada", ou o programa fechar de repente.

Ordenando: bubble sort

Ordenar dados é uma das tarefas mais comuns da computação. O bubble sort (ordenação por bolhas) compara pares vizinhos e troca se estiverem fora de ordem. A cada rodada, o maior valor "flutua" para o final:

Matrizes: vetores com linhas e colunas

Uma matriz é um vetor de vetores: uma tabela com dois índices, [linha][coluna]. Serve para tabuleiros, imagens (grades de pixels) e planilhas. Vamos desenhar um tabuleiro de jogo da velha:

Exercícios

Caracteres são números

Lembra do capítulo 1? O byte 01000001 vale 65, que a tabela ASCII associa à letra A. Em C, um char é exatamente esse pequeno número, e o printf decide como mostrá-lo: com %c como letra ou com %d como número.

Como as letras são números em sequência, dá para fazer contas com elas. A diferença entre uma letra minúscula e sua maiúscula é sempre 32. Digite qualquer texto abaixo e veja o código de cada caractere:

Uma string é um vetor de char

Não existe um tipo "texto" em C. Uma string é um vetor de char que termina com o caractere especial '\0' (o "terminador", de valor zero). É ele que avisa às funções onde o texto acaba.

O vetor nome. As posições depois do '\0' existem, mas não fazem parte do texto.

Por ser um vetor, você não pode trocar o texto com nome = "Bia";. Para copiar textos existem funções prontas, que veremos a seguir.

Lendo frases com fgets

O scanf("%s") para no primeiro espaço. Para ler uma linha inteira, use fgets. Ele recebe o vetor, o tamanho máximo e stdin (o teclado). Como o fgets também guarda o Enter digitado ('\n'), removemos ele com uma linha padrão:

Ferramentas de string.h e ctype.h

Aplicação: tela de login

O %29s limita a leitura a 29 caracteres para não estourar o vetor de 30 posições (29 letras + o terminador).

Percorrendo uma string: contando vogais

Como a string termina em '\0', podemos percorrê-la com um laço que roda até encontrá-lo:

Palíndromos

Um palíndromo lê-se igual de trás para a frente: arara, radar, ovo. A ideia é comparar o primeiro com o último, o segundo com o penúltimo, e assim por diante, com dois índices caminhando um em direção ao outro:

Projeto: a cifra de César

Há mais de 2000 anos, Júlio César protegia mensagens militares trocando cada letra por outra, três posições à frente no alfabeto: A vira D, B vira E, e assim por diante. Com o que você sabe sobre char como número, dá para programar isso! O % 26 faz o alfabeto "dar a volta" (depois do Z volta ao A):

Como funciona: c - 'a' converte a letra em uma posição de 0 a 25; somamos a chave; o % 26 mantém no alfabeto; e o + 'a' volta para a letra. Para decifrar, use a chave 26 menos a original (para chave 3, decifra-se com 23).

Exercícios

Por que usar funções?

• Reaproveitamento: escreve uma vez, usa muitas.
• Organização: o main fica curto e legível, como um sumário.
• Facilidade de testar e corrigir: cada função faz uma coisa só.

Você já usa funções desde o primeiro capítulo: printf, scanf, sqrt e strlen são funções escritas por outras pessoas. Agora você vai escrever as suas.

Anatomia de uma função

  tipo do retorno   nome     parâmetros
        │             │           │
        ▼             ▼           ▼
       int        quadrado(   int n   ) {
           return n * n;    ◄── devolve o resultado
       }

Se a função não devolve nada, o tipo de retorno é void. Se não recebe nada, os parênteses ficam vazios (ou com void). Veja várias funções pequenas em ação:

O protótipo (a linha com ; no topo) apresenta a função ao compilador antes de ela ser usada. Sem ele, o compilador lê o main de cima para baixo e não sabe o que é quadrado. Se você definir as funções antes do main, os protótipos ficam dispensáveis.

Cada função tem a sua "bancada"

As variáveis criadas dentro de uma função são locais: só existem enquanto ela roda e ninguém de fora as enxerga. Quando você passa um valor como parâmetro, a função recebe uma cópia. Modificar a cópia não altera a variável original:

Essa passagem "por cópia" é segura, mas às vezes queremos que a função altere a variável original. Para isso existem os ponteiros, tema do próximo capítulo.

Aplicação: caixa eletrônico

Um programa com menu, laço e funções: o main mostra o fluxo geral, e cada operação bancária fica em uma função. As funções que alteram o saldo devolvem o novo saldo, e o main guarda o resultado.

Vetores como parâmetro

Para receber um vetor, a função declara o parâmetro com colchetes vazios e recebe o tamanho separadamente (ela não tem como descobrir sozinha):

Recursão: a função que chama a si mesma

Uma função pode chamar ela mesma para resolver um problema menor. O exemplo clássico é o fatorial: n! = n × (n−1)!, e 1! = 1. Toda função recursiva precisa de um caso base (a hora de parar), senão chama a si mesma para sempre.

Cada chamada fica "esperando" a próxima terminar, empilhadas como pratos. Quando o caso base é atingido, a pilha vai se desfazendo e as multiplicações acontecem:

fatorial(5) = 5 * fatorial(4)
                    = 4 * fatorial(3)
                          = 3 * fatorial(2)
                                = 2 * fatorial(1)
                                      = 1        ◄── caso base
  volta:  2*1 = 2  →  3*2 = 6  →  4*6 = 24  →  5*24 = 120

Exercícios

Toda variável mora em um endereço

Lembra da rua com casas numeradas do capítulo 1? Cada variável ocupa uma ou mais "casas" da RAM, e cada casa tem um endereço. O operador & revela onde a variável mora. Para mostrar um endereço, usamos %p:

Ponteiro: uma variável que guarda um endereço

O ponteiro p guarda o número 1000: o endereço de idade. Dizemos que p "aponta para" idade.

Agora o scanf faz sentido

Quando escrevemos scanf("%d", &idade), entregamos ao scanf o endereço da variável. Com o endereço em mãos, ele consegue guardar o valor digitado exatamente lá. Se entregássemos só idade, ele receberia uma cópia e não teria como alterar a original. Por isso o & é obrigatório (e, para textos, o nome do vetor já é um endereço, por isso não usamos &).

Uso 1: funções que alteram variáveis de fora

No capítulo 11, vimos que a função recebe uma cópia. Se passarmos o endereço da variável, a função pode alterar a original. O exemplo clássico é trocar o valor de duas variáveis:

Uso 2: devolver vários resultados

Uma função só pode devolver um valor com return. Com ponteiros, ela pode "devolver" vários pelos parâmetros. Vamos refazer a conversão de segundos do capítulo 6, mas agora com uma função:

Ponteiros e vetores são parentes

O nome de um vetor é, na prática, o endereço do seu primeiro elemento. Por isso um vetor passado a uma função não é copiado: a função recebe o endereço e trabalha no original (foi o que vimos no capítulo 11). Somar 1 a um ponteiro o move para o próximo elemento, e v[i] é o mesmo que *(v + i):

Uso 3: pedir memória quando o programa já está rodando

Até agora, o tamanho de todo vetor era decidido antes de rodar. E se você só souber quantas notas terá depois que o usuário responder? Com malloc o programa pede memória à RAM no momento certo e recebe o endereço do bloco. Depois de usar, devolve com free.

Cuidados com ponteiros

• Ponteiro sem destino: int *p; aponta para um lugar aleatório. Usar *p assim pode derrubar o programa. Inicialize sempre: com um endereço válido ou com NULL (ninguém).
• Teste o NULL: depois de malloc, confira se deu certo, como no exemplo acima.
• Não use memória depois do free. O endereço continua no ponteiro, mas o espaço já não é seu.
• Respeite os limites do bloco alocado, como nos vetores.

Exercícios

Uma ficha de cadastro

O typedef dá um nome curto ao molde, e depois usamos Jogador como qualquer outro tipo (int, float). O ponto (.) escolhe qual campo da ficha acessar.

Aplicação: ranking de jogadores

Combinando struct, vetor e laço, montamos um ranking: lemos os jogadores, mostramos uma tabela e descobrimos o campeão. A formatação %-10s alinha o texto à esquerda em 10 colunas:

Repare em j[i].nome: primeiro escolhemos a ficha do vetor (j[i]) e depois o campo dela (.nome). Como nome já é um vetor de char, o scanf dispensa o &; já pontos precisa dele.

Structs e funções

Passar uma struct por valor copia a ficha inteira. Se a função precisa alterar a original (ou se a struct é grande e queremos evitar a cópia), passamos um ponteiro para ela e usamos a seta -> para acessar os campos: j->pontos é o mesmo que (*j).pontos.

Como uma struct ocupa a memória

Os campos ficam um depois do outro na RAM. Vamos perguntar ao compilador o tamanho de uma ficha de personagem:

Exercícios

Arquivo é como uma fita de texto

Trabalhar com arquivos lembra usar um caderno: você abre, escreve ou lê e fecha. Em C, temos um ponteiro do tipo FILE * que representa o arquivo aberto, e funções muito parecidas com as que você já conhece:

Salvando um placar

Este programa guarda o nome e a pontuação em um arquivo de texto. Como usamos o modo "a", cada execução acrescenta uma linha nova:

Depois de rodar duas ou três vezes com nomes diferentes, abra a pasta do programa: aparece o arquivo placar.txt. Você pode abri-lo no Bloco de Notas para conferir, porque é texto puro.

Lendo o placar de volta

Para ler, abrimos com "r" e repetimos fscanf enquanto ele conseguir ler dois valores (o nome e os pontos). Lembre que o scanf devolve quantos itens leu, e o fscanf também:

Diário com data e hora

Para ler ou escrever frases com espaços, usamos fgets para digitar e fprintf para gravar. A biblioteca time.h fornece a data e a hora atuais:

Para mostrar o diário inteiro, leia linha por linha com fgets, que devolve NULL quando o arquivo acaba:

Aplicação: recorde que nunca se perde

Todo jogo guarda a maior pontuação. Este programa lê o recorde salvo (se existir), compara com a pontuação da partida e só regrava o arquivo se o recorde for batido. Note o uso do modo "w" para substituir o valor antigo:

Exercícios

Projeto 1: Pedra, papel e tesoura

Você joga contra o computador em cinco rodadas. Usa números aleatórios, funções, switch, um laço com validação e placar. A função nomeJogada devolve um texto fixo (o tipo const char * significa "endereço de um texto que não vamos alterar").

Desafios: permita escolher o número de rodadas; mostre a porcentagem de vitórias; jogue "melhor de 3" e pare assim que alguém ganhar duas rodadas.

Projeto 2: Gerador de senhas

Uma aplicação real de vetores de caracteres e números aleatórios: a cada posição da senha, sorteamos um caractere da lista de símbolos permitidos.

Desafios: peça quantos tipos de caracteres usar (só letras, letras e números, tudo); garanta que a senha tenha ao menos um dígito; gere 5 senhas de uma vez.

Projeto 3: Lista de tarefas

O projeto mais completo: usa struct, vetor, funções, ponteiros e arquivos. As tarefas ficam em tarefas.txt: você fecha o programa, abre de novo e elas continuam lá. Repare que as funções que precisam alterar o total de tarefas recebem um ponteiro (int *total).

Desafios: adicione a opção "Remover tarefa"; mostre quantas tarefas estão pendentes; ordene para mostrar as pendentes primeiro.

Projeto 4: Conversor de decimal para binário

Fechando o ciclo com o capítulo 1: como o computador enxerga o número que você digita? Dividindo sucessivamente por 2, os restos formam os bits, do último para o primeiro:

Confira no laboratório do capítulo 1: 01000001 é o número 65, a letra A.

Ideias para continuar

• Jogo da forca: uma palavra secreta em uma string, um vetor com as letras já descobertas e um contador de erros.
• Jogo da velha completo: a matriz do capítulo 9 com jogadas alternadas e verificação de vitória.
• Quiz de conhecimentos: perguntas em um vetor de structs, com pontuação e recorde salvo em arquivo.
• Controle de gastos: registre despesas em arquivo e mostre o total por categoria.
• Batalha por turnos: dois personagens (structs) com vida e ataque aleatório.

Exercícios finais

Mensagens do compilador

Problemas na hora de executar

Método para caçar bugs

1. Leia a mensagem inteira, começando pelo primeiro erro.
2. Reproduza: descubra qual entrada faz o problema aparecer.
3. Faça o teste de mesa no papel para o trecho suspeito.
4. Imprima para investigar: coloque printf temporários para ver o valor das variáveis em cada ponto.
5. Isole: comente partes do código até achar qual delas causa o problema.
6. Explique o código em voz alta para alguém (ou para um objeto). Muitas vezes você acha o erro enquanto explica.

Estrutura e entrada/saída

Controle de fluxo

Funções, ponteiros e structs

Bibliotecas mais usadas

Formatos de printf e scanf

Algoritmo

Sequência finita e ordenada de passos claros que resolve um problema.

ASCII

Tabela que associa um número a cada caractere básico (A = 65, a = 97, espaço = 32).

Bit

Menor unidade de informação do computador: vale 0 ou 1.

Buffer

Área de memória que guarda temporariamente dados, como o que foi digitado no teclado antes de o programa ler.

Byte

Grupo de 8 bits; guarda valores de 0 a 255.

Compilador

Programa que traduz o código-fonte em código de máquina (executável).

Constante

Valor que não muda durante a execução (const ou #define).

Depuração (debug)

Processo de encontrar e corrigir erros (bugs) em um programa.

Endereço

Número que identifica a posição de um byte na memória.

Escopo

A região do programa em que uma variável existe e pode ser usada.

Executável

Arquivo (.exe no Windows) que o computador consegue rodar diretamente.

Função

Bloco de código com nome, que recebe parâmetros e pode devolver um resultado.

Heap

Área da memória usada para alocação dinâmica com malloc.

IDE

Ambiente de desenvolvimento integrado: editor, compilador e depurador juntos (como Dev-C++, Code::Blocks, CLion ou VS Code com as extensões certas).

Índice

Número que indica a posição de um elemento em um vetor; começa em 0.

Laço (loop)

Estrutura que repete um bloco de código: for, while, do-while.

Overflow

Quando um valor ultrapassa o limite do tipo e "dá a volta".

Parâmetro

Variável de uma função que recebe o valor enviado por quem a chamou.

Ponteiro

Variável que guarda o endereço de outra variável.

Protótipo

Declaração de uma função (sem o corpo) que a apresenta ao compilador.

RAM

Memória de trabalho do computador: rápida e volátil.

Recursão

Técnica em que uma função chama a si mesma.

Retorno

O valor que uma função devolve com return.

String

Texto: vetor de char terminado em '\0'.

Struct

Tipo composto que agrupa campos de tipos diferentes sob um nome.

Teste de mesa

Simulação no papel da execução de um código, acompanhando os valores das variáveis.

Tipo de dado

Define o que uma variável pode guardar e quantos bytes ocupa: int, float, char...

Variável

Espaço nomeado da memória que guarda um valor que pode mudar.

Vetor (array)

Conjunto de elementos do mesmo tipo guardados em sequência na memória.