#include <stdio.h>


#include <stdlib.h>


#include <string.h>


typedef struct _agendainfo


{


  char nome[80];


  char rua[80];


  char cidade[40];


  char estado[40];


  char cep[11];


  char datanasc[11];


  char email[100];


  int sexo;                            // utilizaremos 0 para feminino e 1 para masculino


}  agenda_info;






typedef struct _agenda


{



  agenda_info *entrada;



  struct _agenda *next;


} agenda;



void creditos (void);



void insereItem(agenda **head);


void listaAgenda(agenda *head);

  agenda_info *entrada;

  struct _agendainfo *entrada;

  struct _agenda *next;

void creditos (void);

void insereItem(agenda **head);


void listaAgenda(agenda *head);

Nenhum mistério nesse main.c: usamos nosso cabeçalho personalizado agenda.h para importar todos os cabeçalhos que precisamos e também trazer os tipos agenda e agenda_info que usaremos no nosso código. Perceba que marcamos em vermelho a declaração de nossa agenda (na variável minhaAgenda) e em seguida, passamos o endereço aonde está essa informação com o comando insereItem(&minhaAgenda). Perceba que utilizamos o operador de de-referenciamento (&) para obtermos o endereço onde o C irá guardar o endereço para o ponteiro da nossa estrutura da agenda. Isso permitirá que possamos alterar o conteúdo desse ponteiro dentro da nossa função. O resto do código não tem muito mistério, e em geral não deve ser de maior complexidade se você estudou corretamente nosso “curso” até aqui e também fez com calma todos os exemplos que já mostramos.

OK… E como é feita a inserção dos dados? Para isso, utilizamos os códigos de nosso arquivo insert.c:

#include “agenda.h”

void limpandoDados(agenda_info *dados)

{

  memset(dados->nome,”,sizeof(dados->nome));

  memset(dados->rua,”,sizeof(dados->rua));

  memset(dados->cidade,”,sizeof(dados->cidade));

  memset(dados->estado,”,sizeof(dados->estado));

  memset(dados->cep,”,sizeof(dados->cep));

  memset(dados->datanasc,”,sizeof(dados->datanasc));

  memset(dados->email,”,sizeof(dados->email));

  dados->sexo=0;

}

void insereItem (agenda **head)

{

  agenda_info *dados=(agenda_info*)malloc(sizeof(agenda_info));

  agenda *entrada=(agenda*)malloc(sizeof(agenda)), *hook;

  char sexo=’M';

  if ((!entrada) || (!dados))

    exit(1);

  limpandoDados(dados);

  printf(“Digite o nome da pessoa, ou então FIM se entrou por engano: \n”);

  fgets(dados->nome,sizeof(dados->nome),stdin);

  if(strncmp(dados->nome,”FIM”,strlen(“FIM”))==0)

    {

      free(dados);

      return;

    }

  printf(“Digite a rua onde essa pessoa mora: “);

  fgets(dados->rua,sizeof(dados->rua),stdin);

  printf(“Digite a cidade onde essa pessoa mora: “);

  fgets(dados->cidade,sizeof(dados->cidade),stdin);

  printf(“Digite o estado onde essa pessoa mora: “);

  fgets(dados->estado,sizeof(dados->estado),stdin);

  printf(“Digite o cep onde essa pessoa mora: “);

  fgets(dados->cep,sizeof(dados->cep),stdin);

  printf(“Digite o email dessa pessoa: “);

  fgets(dados->email,sizeof(dados->email),stdin);

  printf(“Digite a data de nascimento dessa pessoa: “);

  fgets(dados->datanasc,sizeof(dados->datanasc),stdin);

  do

    {

      printf(“Digite o sexo [M/F]: “);

      scanf(“%c”,&sexo);

      getchar();

      sexo=((sexo>=’a')&&(sexo<=’z'))?sexo+’A'-’a':sexo;

      printf(“%c\n”,sexo);

      if (sexo!=’M'&&sexo!=’F') printf (“sexo inválido\n”);

    } while (sexo!=’M'&&sexo!=’F');

  dados->sexo=(sexo==’F')?0:1;

  /**

   *  Checa se já existem itens dentro da agenda

   */

  if (!*head)

    {

      *head=entrada;

      (*head)->next=NULL;

    }

  else

    {

      hook=*head;

      while (hook->next!=NULL) hook=hook->next;

      hook->next=entrada;

    }

  entrada->entrada=dados;

  return;

}

Perceba que aqui temos alguns segredos que irão nos ajudar a montar nossa lista de dados:

Primeiro, perceba que alocamos memória para uma entrada de dados de agenda, na variável dados, e uma entrada para a agenda, chamada entrada, além de declararmos uma terceira variável de agenda, chamada hook (gancho, em inglês). Essa variável irá ser usada para fazer uma “corrida” para achar o final da agenda e colocar nela os dados necessários. O preenchimento de dados não possui grandes mistériosd, exceto que utilizamos, ao invés do operador . (ponto), utilizamos o operador -> (que chamaremos de operador seta, e é composto por um hifen e um sinal de maior). Também não precisamos usar o * para indicar que você quer alterar a informação apontada, como em, dados->rua. Lemos essa entrada como “o elemento rua da estrutura apontada por dados“. O resto é como já vimos anteriormente. Usamos uma função utilitária para inicializar corretamente a estrutura como se deve. Agora, vamos falar sobre o código abaixo… 

  if (!*head)

    {

      *head=entrada;

    }

  else

    {

      hook=*head;

      while (hook->next!=NULL) hook=hook->next;

      hook->next=entrada;

    }

  entrada->entrada=dados;

  entrada->next=NULL;

É bem simples… Lembra da “corrida” que fazemos na entrada de dados? Basicamente fazemos exatamente a mesma coisa: seguimos o seguinte procedimento até acharmos o último item da nossa lista:

1. Armazenamos em registro o ponteiro para os dados que iremos exibir;
2. Exibimos os dados utilizando printf (como de costume);
3. E associamos o ponteiro next e atribuímos a ela o valor de item;

Esse procedimento irá se repetir até que o valor de item seja NULL…

Antes de encerrarmos, vamos falar de uma rotina importante que é uma boa prática no desenvolvimento de qualquer sistema com alocação dinâmica de memória, mas especialmente em programas como nosso, onde usamos intensivamente esse procedirmento. Esse procedimento ocorre no nosso programa apenas no encerramento do mesmo. Observe o seguinte código em main.c:

void limpaDados (agenda *minhaAgenda)

{

  agenda *next,*now;

  next=minhaAgenda;

  while(next!=NULL)

    {

      now=next;

      next=next->next;

      free(now->entrada);

      free(now);

    }

}

Essa função é chamada apenas no final do programa Note que ele segue a mesma idéia de sempre quando falamos na fila, portanto guarde esse procedimento na mente:

1. Ele atribui o valor de next para um ponteiro temporário now (importante fazer isso para que não haja erros de lógica onde o sistema “pire”).
2. Em seguida, como vamos usar apenas o ponteiro now na liberação de memória, podemos passar  para next o valor do próximo item (next);
3. Após isso, liberamos primeiro os dados (com free(now->entrada)) e em seguida, liberamos a entrada (free(now));
4. E então repetimos o processo, enquanto o next não for NULL;

É uma boa prática desalocar toda a memória usada durante o uso do programa. A maioria dos sistemas operacionais modernos conseguem detectar a memória usada pelo programa (incluse do heap, onde é armazenada toda a informação alocada dinamicamente) e eliminá-la, principalmente porque em geral cada programa recebe uma determinada quantidade de memória no momento em que ele executar. Ainda assim, existe a possibilidade de memória alocada não ser liberada no momento do encerramento do programa, formando o que se chama de memory leakage (vazamento de memória), pois para o SO essa memória ainda está alocada, só não sabendo-se por quem. Ao desalocar explicitamente a memória, você diminiu e muito a chance de um memory leakage. Lermbre-se sempre dessa máxima em C:

Com essa máxima, terminamos nossa “aula”. Guarde esse código, pois o usaremos em nossa próxima aula, onde falaremos de arquivos em disco.

Como brincadeiras, sugiro:

1. Se você reparar, não removemos o ENTER na entrada dos dados. Tente criar uma função que remova os terminadores ‘\ n‘ das entradas de dados;
2. Quando falamos que não iríamos organizar os dados, há um jeito: lembre-se que você pode apontar informações de ponteiros e estrururas dentro de outras estruturas. Tente criar um código que permita que você “ordene” os dados armazenados. Procure informações sobre a função strcomp para algumas idéias;

A boa é que terminaremos o tópico que começamos na “aula” passada, quando falamos sobre o conceito de projeto, separação de códigos fonte e compilação individual.
Como vimos, é possível dividir um programa em arquivos fontes individuais (que formam, em conjunto, um projeto) e compilar os mesmos individualmente, de modo que no caso de uma modificação pontual não seja necessário recompilar totalmente os fontes para obter-se o executável. Isso deve-se ao fato de os compiladores modernos na verdade executarem duas funções simultaneamente: a compilação (transformação de códigos fontes em códigos objetos) e a linkedição ou ligação (a união de vários códigos objetos em binários que possam ser executados pela máquina).
Até aqui nenhuma novidade.
Mas lembremos novamente do que mostramos na aula passada. Programas “reais”, como pacotes Office e navegadores possuem milhões de linhas de código, que, por sua vez, podem estar espalhadas em milhares de arquivos de código fonte. Mesmo com essa divisão, a tarefa de gerar um novo código-objeto para cada fonte alterado e ligar todos os objetos em um executável seria MUITO enfadonha e propensa a erros.
Para resolver esse problema, antigamente usavam-se scripts específicos para cada plataforma de desenvolvimento e uso. Porém, isso ainda assim era ineficiente, pois a adição ou remoção de novos arquivos e a mudança na estrutura do projeto demandava a total modificação dos scripts, sendo que os próprios scripts tinham que ser mantidos, e eram enfadonhos de se manter.
Em 1977, porém, Stuart Feldman criou o primeiro sistema de automação para a compilação de programas, o make. A função do make é, construir todas as dependências descritas em um arquivo especial chamado Makefile. Makefiles seguem um padrão razoavelmente simples de construção. Embora o formato Makefile original seja um “padrão de facto“, muitos compiladores trazem consigo o seu próprio make, e IDEs, como a Code::Blocks, o Eclipse e o Netbeans também possuem suas próprias regras e mecanismos, usando ou não e baseado ou não no make UNIX.
Para explicarmos o conceito geral e demonstrarmos o funcionamento, utilizaremos o GNU Make. GNU Make é parte dos utilitários incluídos no GCC (GNU Compiler Chain), que é incluído em quase todas as distribuições Linux e está disponível em várias plataformas, como Windows, MacOS/X, etc…

Um Makefile simples:

Sem muitas delongas, vamos mostrar como o Make trabalha e como criar um Makefile:
Basicamente, make funciona em um sistema de alvos e dependências. Ou seja, make precisa saber quais são os arquivos que ele irá processar (dependências) para realizar alguma tarefa e obter alguma outra coisa (alvo). Por exemplo, vamos fazer um Makefile simples.

all:
    echo “Hello, Make!”

Aqui dizemos que queremos obter “all“, ou seja, tudo (é o default do GNU Make. Se não encontrado, executa o primeiro alvo de cima para baixo dentro do Makefile). Depois dos dois-pontos (:) indicaríamos qualquer dependência que precisássemos. Porém, como não temos nenhuma, deixamos em branco mesmo.
Em seguida, colocamos a tarefa a ser executada. Ela pode ser quaisquer seqüências de comandos válidos para o sistema operacional em questão. No nosso caso, utilizamos um comando echo “Hello, Make!”, que é usado no Linux para emitir uma mensagem na tela (no Windows também funciona). Uma coisa importante: os comandos da tarefa devem ser espaçados do início da linha por uma tabulação (tecla TAB). Embora algumas ferramentas make modernas consiga reconhecer espaços no lugar do TAB para efeito de indicação da tarefa, é melhor manter o padrão para não incorrer em problemas em outras plataformas.
Bem, digitado esse arquivo, salve-o com o nome de Makefile. Esse nome é o nome default que o GNU make (e a maioria dos demais) irá procurar. Em várias ferramentas make, é possível que você defina, por meio de uma opção de linha de comando, qual o Makefile a ser usado. Consulte o manual de sua ferramenta Make para maiores informações.
Bem, voltando: uma vez salvo o mesmo (no momento não interessa onde você irá o jogar), digite o comando “make” na linha de comandos de seu sistema operacional, no diretório onde você salvou o seu arquivo Makefile. A saída resultante será algo mais ou menos como a seguinte:

$ make
echo “Hello, Make!”
Hello, Make!

Não muito útil, mas já mostra resultados. Uma vez que você disparou o comando, ele procurou um alvo-padrão (all) e verificou se suas dependências estavam resolvidas (no momento nenhuma, então ok). Estando tudo OK, ele executou a tarefa determinada (no caso, o comando echo “Hello, Make!”) e se encerrou.
Exemplo bobo…

Um Makefile útil

Bem, pelo menos sabemos como ele funciona. Agora vamos fazer algo realmente útil:
Vá ao diretório onde você guardou o seu projeto do Roletrando que mostramos na “aula” passada. Vamos criar um Makefile um pouco mais interessante:

#
# Primeira tentativa de Makefile
#

all: roletrando
   
roletrando: main.o regras.o letras.o
    gcc -o roletrando main.o regras.o letras.o

main.o: main.c roletrando.h
    gcc -o main.o -c main.c

regras.o: regras.c roletrando.h
    gcc -o regras.o -c regras.c

letras.o: letras.c roletrando.h
    gcc -o letras.o -c letras.c

Agora temos um Makefile realmente útil. Primeira coisa que você deve ter notado é que, de certa forma, colocamos todos os comandos que usaríamos em uma compilação parcial normal, como vimos anteriormente:

Sobre arquivos de código-fonte, arquivos de cabeçalhos e projetos « Aulas de C

No nosso caso, utilizaremos primeiro os comandos:

gcc -o letras.o -c letras.c
gcc -o regras.o -c regras.c
gcc -o main.o -c main.c

Para gerarmos os arquivos .o (os códigos-objeto) de cada um dos código-fonte e, após isso, utilizaremos o comando:

gcc -o roletrando letras.o regras.o main.o

Para fazermos o link das funções e obtermos o executável.

São apenas comentários. No caso do make, os comentários utilizam o símbolo sustenido, ou sharp, ou qualquer outro nome que você já ouviu falar (vale até lasanha… ). Como no C e em qualquer outra linguagem ou ferramenta, os comentários são simplesmente ignorados.

Outra coisa: repare que esse alvo não possui tarefas. O que fizemos aqui é criar uma espécie de alvo “nulo”, ou phony. Simplesmente fizemos isso para “chamar a atenção” do make para cá. Normalmente ele executa o primeiro alvo de cima para baixo dentro do Makefile por padrão se ele não encontrar um alvo all. Em alguns casos, porém, você pode querer que o make gere vários alvos ao mesmo tempo (por exemplo, se você desenvolver um sistema composto por vários programas). Nesse caso, basta listar outros alvos como dependências em all.
Seguindo adiante, vemos uma entrada “completa” de um alvo (chamado também de regra):

roletrando: main.o regras.o letras.o
    gcc -o roletrando main.o regras.o letras.o

Uma regra é composta pelo nome da regra (o alvo), uma ou mais dependências, e comandos que permita ao sistema obter essa dependência. O make precisa dessa informação para fazer suas tarefas. No caso acima:

• O nome da regra (alvo) é roletrando;
• As dependências são main.o regras.o letras.o;
• O comando a ser executado é gcc -o roletrando main.o regras.o letras.o;

Perceba como a coisa está construída: quando usamos várias dependências, elas são separadas por espaço. Além disso, normalmente o nome da regra (ou alvo) é o nome do arquivo final a ser obtido por aquela regra (no nosso caso, o binário roletrando). O comando (ou comandos) devem seguir após a linha com a descrição do alvo e das dependências. Uma regra é separada da outra por uma linha em branco.
OK… Aqui vemos que o make sabe que, para obter o arquivo roletrando, ele precisa ter as dependência (ou seja, os arquivos) main.o, regras.o e letras.o. Além disso, ele sabe que, tendo esses arquivos, ele precisará executar o comando gcc -o roletrando main.o regras.o letras.o para obter o seu alvo e, portanto, cumprir a regra.
Mas até aqui, o Makefile não sabe como obter nenhuma das dependências em questão.
Para isso, incluímos as linhas seguintes:

main.o: main.c roletrando.h
    gcc -o main.o -c main.c

regras.o: regras.c roletrando.h
    gcc -o regras.o -c regras.c

letras.o: letras.c roletrando.h
    gcc -o letras.o -c letras.c

Aqui, vemos que colocamos as diversas regras para gerar cada um dos arquivos .o (objetos) necessários como dependência em roletrando. Perceba que as dependências são os nomes dos arquivos de fonte .c e (no nosso caso), o arquivo de cabeçalho roletrando.h. Isso visa garantir que o arquivo de cabeçalho exista e, no caso de ele ser modificado (por exemplo devido a uma função modificada) o código seja reconstruído de maneira adequada. Claramente isso vai depender de como funciona seu código fonte: haverá situações onde adicionar muitos arquivos fonte ou cabeçalhos gerará inconvenientes (como compilações desnecessárias). Mas isso não vem ao caso agora.
O make checará se (1) os arquivos indicados nas dependências existem ou se (2) eles são alvos resolvidos por outras regras. Se ambas as coisas não forem possíveis, ele irá dar uma mensagem de erro como a seguinte (No caso, renomeei o roletrando.h, exigido por main.o, para outro nome qualquer):

make: *** Sem regra para processar o alvo `roletrando.h’, necessário por `main.o’.  Pare.

Estando tudo OK, ao rodar-se o comando make (por via das dúvidas, antes apague todos os arquivos .o e o arquivo roletrando), ele irá mostrar algo como abaixo:

1. make foi executado, procurou a regra default all e a encontrou. Viu que ela demandava um alvo chamado roletrando. Então foi para a regra roletrando;
2. Em roletrando, ele viu que precisava dos arquivos (ou alvos) main.o, regras.o e letras.o. Antes de fazer qualquer coisa, ele irá verificar se ele tem uma regra que explique como obter esses arquivos.
3. O make percebe que existe uma regra para main.o. Ela demanda os arquivos main.c e roletrando.h. Verificando que os dois existem, ele verifica se o arquivo indicado no alvo existe e é mais novo que os arquivos de dependência (o que indica que nenhum deles foi alterado). Caso contrário, ele irá executar as regras para obter-se uma nova versão do arquivo main.o (ou obtê-lo, caso não exista).
4. Se houver alguma falha (por exemplo, um erro de sintaxe), o make irá abortar sua execução, não gerando nenhum binário e não criando o roletrando.
5. Em caso de sucesso no passo 3 para main.o, o sistema repetirá o processo dos passos 3 e 4 para os demais arquivos de dependência regras.o e letras.o. Se algum deles exigisse um outro arquivo gerado por um outro alvo, os passos 3 e 4 seriam repetidos para tal arquivo e assim sucessivamente. make realiza uma pesquisa recursiva para ver se cada alvo necessáriao como dependência de cada outro alvo (incluindo all) foi obtido com sucesso.
6. O passo 5 tendo sido realizado com sucesso para TODOS os alvos e suas dependências (incluindo outros alvos), o make irá executar os comandos indicados na regra roletrando para obter o arquivo roletrando, resolvendo a dependência all;
7. Resolvida todas as dependências de all (roletrando e suas dependências), make irá se encerrar com sucesso;

Agora, após rodar make, você terá o arquivo roletrando. Se tentar rodar make novamente, verá que ele não fará absolutamente NADA, pois ele sabe que nenhuma das dependências de roletrando foi modificada (nehum dos .o), pois todas existem e são mais atuais que qualquer modificação em quaisquer um dos arquivos .c.
Vamos simular uma alteração em um dos arquivos .c (no caso, o arquivo regras.c). Para isso:

• em Windows, abra o arquivo em um editor e o salve sem alterar nada;
• no Linux, na linha de comando, dê o comando touch regras.c;

Execute então o comando make. Sua saída deve ser como a seguinte:

$ make
gcc -o regras.o -c regras.c
gcc -o roletrando main.o regras.o letras.o

Por que isso aconteceu?
Make analisa o timestamp do arquivo (o registro de quando o mesmo foi alterado pela última vez) de todas as dependências necessárias e, caso o timestamp de uma dependência seja maior que o do arquivo do alvo (ou seja, a dependência em questão foi alterada), ele executa novamente a regra para ele e para todas as regras que tenha o alvo como dependência e assim sucessivamente. Portanto:

1. O sistema identificou que a dependência regras.c de regras.o mudou e reconstruiu regras.o;
2. Então o make percebeu que a dependência regras.o de roletrando mudou e, portanto, reconstruiu roletrando;

Ou seja, você não precisa se preocupar com re-executar manualmente os comandos em questão. Estando tudo OK, o próprio make irá executar e processar os arquivos adequados para gerar um binário.

Varíaveis e Macros no Makefile

Bem, agora temos um Makefile útil…
Mas agora pense em uma coisa…
Aqui colocamos regras, alvos e dependências para CADA arquivo fonte. Isso em sistemas pequenos é bem útil, mas conforme o sistema aumenta de tamanho e funcionalidades, obviamente aumenta o número de arquivos de código fonte. Ou seja, teríamos que fazer mais entradas de regras, mais dependências…
Além disso, imagine que você deixa de usar o gcc como compilador. Você provavelmente teria que modificar todos os alvos e regras para usar os padrões do novo compilador, o que seria um pesadelo!
O make, porém, salva a nossa vida, oferecendo variáveis e macros que nos ajudam a fazer com que o make realize tarefas “genéricas” (como gerar um objeto .o a partir de um fonte .c), além de embutir alguma inteligência para que ele descubra se existem novos arquivos .c no local e coisas do gênero. No caso, digite o seguinte Makefile e o salve no diretório do roletrando com o nome Makefile-1:

#
# Segunda tentativa de Makefile
#

C_COMP=gcc
FONTES=$(wildcard *.c)    # equivale a dizer FONTES=main.c regras.c letras.c
HEADERS=$(wildcard *.h)

all: roletrando
   
roletrando: $(FONTES:.c=.o)
    $(C_COMP) -o $@ $^

%.o: %.c $(HEADERS)
    $(C_COMP) -c $< -o $@

Aqui estamos criando três variáveis: C_COMP, FONTES e HEADERS. A primeira variável, C_COMP, indica o compilador que estamos usando. O nome poderia ser qualquer um (à exceção de alguns nomes que o make reserva para uso próprio, que não detalharemos aqui), e abaixo veremos o porque. No nosso caso atual, definimos que C_COMP=gcc, o que lembra uma atribuição em C. Estamos atribuindo à variável do Makefile C_COMP esse valor.
A variável seguinte, FONTES, é atribuída com $(wildcard *.c).
“O que isso quer dizer, afinal de contas?“.
Quando você usa o símbolo de $, quer dizer que você está usando uma macro do make. As macros são certos recursos embutidos no make que estão disponíveis para facilitar sua vida na criação de um Makefile. Quando usamos $() cercando algo, estamos indicando uma macro de expansão, ou seja, vamos fazer com que o make entenda que o valor que está ali equivale ao de um comando ou variável previamente definido. No nosso caso, usamos o comando wildcard para pedir que o make realize uma busca no diretório onde o Makefile se encontra e localize todos os arquivos que seguem o padrão indicado. No nosso caso, $(wildcard *.c), pode ser lido como “procure todos os arquivos .c no diretório onde você está e os dê como valor onde você está”. Colocamos em seguida um comentário:

# “equivale” a dizer FONTES=main.c regras.c letras.c

para dizer o nosso resultante. No fim das contas, usar:

FONTES=$(wildcard *.c)

equivale a dizer, na situação atual

FONTES=main.c regras.c letras.c

Em seguida, criamos uma varíavel HEADERS, com o mesmo tipo de conteúdo de FONTES.
Uma coisa importante de dizer aqui, que não foi dita, é que as variáveis podem conter um valor só (como em C_COMP), ou vários valores separados entre si por espaço (como no caso da “expansão” de FONTES). Isso é importante em alguns casos, como veremos adiante.
Após estipularmos o alvo all, com dependência roletrando (igual ao nosso primeiro Makefile), definimos nosso alvo roletrando.
roletrando: $(FONTES:.c=.o)
    $(C_COMP) -o $@ $^
“Que coisa maluca é essa pelamordeus?!”
Calma. Aqui estamos usando várias macros para resumir nosso serviço.
Primeiro, vamos olhar a parte das dependências: $(FONTES:.c=.o)
O que isso quer dizer?
O make possui alguma inteligência para saber que determinados arquivos geram outros determinados arquivos. Por isso, ele é capaz de “traduzir” nomes por substituição simples se corretamente indicado. No caso, estamos usando o :.c=.o na frente de FONTES. Isso indica ao make para entender que, ao expandir FONTES ali, ele deve substituir todas as extensões .c para .o. Ou seja, ele será capaz de montar uma lista dos arquivos objetos necessários a partir da lista de arquivos fontes (que colocamos na variável FONTES, lembra).
Em seguida, temos a regra para obtermos os alvos: $(C_COMP) -o $@ $^
Temos a expansão de C_COMP, o que já deve ser claro, e um -o que é parâmetro do gcc (aqui fica uma sugestão: o ideal aqui é que outra variável contivesse todos os parâmetros da compilação, uma vez que eles podem mudar de compilador para compilador). Em seguida temos duas macros novas: $@ e $^. No caso, $@ deve ser lido como “o alvo a ser alcançado” e $^ indica “a lista de dependências passadas”.
Como tudo isso então se comporta, no fim das contas?

1. make irá expandir a lista de dependências. Para isso, irá olhar o valor de FONTES, pegar qualquer valor listado em FONTES que termine com .c e modificará o valor dele nessa expansão para .o. Considerando que FONTES equivale, nesse momento a main.c regras.c letras.c, ele expadirá FONTES como main.o regras.o letras.o nas dependências de roletrando;
2. Em seguida, ele irá montar a regra para atingir-se o alvo roletrando. Primeiro irá expandir a variável C_COMP (valendo gcc), colocará o -o na frente do mesmo (que, como não é uma macro ou variável é deixado como está), após isso inserindo o nome do alvo (no caso, roletrando) e a lista de dependências do mesmo! O valor final para a regra expandida será gcc -o roletrando main.o regras.o letras.o (ou valor similar: na realidade normalmente será gcc -o roletrando letras.o main.o regras.o, pois a expansão com wildcard em FONTES gera um lista em ordem alfabética dos arquivos cujo nome casem com o padrão desejado);

OK, então temos o comando para gerar o executável a partir dos objetos… Mas e quanto a geração dos objetos a partir dos fontes?
O make tem outra boa inteligência que é permitir que um alvo seja estabelecido a partir de um padrão, ou melhor, que haja uma regra padrão para alvos de um determinado tipo. Um exemplo de alvo assim está no final do nosso novo Makefile:

%.o: %.c $(HEADERS)
    $(C_COMP) -c $< -o $@

O símbolo de porcento (%) serve para indicar um padrão genérico que pode ser usado na regra como um todo. Colocando no alvo, ele diz ao make que ele sabe o que fazer para qualquer arquivo que obedeça o padrão em questão. No nosso caso, o alvo passa a ser “qualquer arquivo que termine em .o“. O bom é que esse valor passa a ser “salvo” e pode ser usado na dependência, como fizemos aqui: nossa dependência é %.c $(HEADERS), ou seja, “qualquer arquivo que tenha o mesmo nome do alvo, mas termine em .c” e o valor da variável HEADERS (que é um wildcard de arquivos .h).
A linha de regra tem algumas similaridades com o que temos na linha de regra para roletrando: primeiro expandimos C_COMP para gcc e temos um -c que é mantido como está (lembrando que -c apenas compila o arquivo oferecido como entrada, sem fazer link, gerando um arquivo objeto).
Em seguida, temos a macro $<. Essa macro pega o primeiro valor listado na lista de dependências e o usa como valor. Perceba que, se analisarmos a lista de dependências, teremos normalmente o arquivo .c e um ou mais header files. Por isso, usamos apenas o primeiro item da lista (é bom deixar o header file como dependência, para o caso de alteração, mas o que precisamos usar mesmo é o arquivo de fonte .c) como parâmetro aqui. Em seguida, temos a montagem do resto da regra, que é idêntica a como fizemos no alvo roletrando: -o como está e o $@ sendo expandido para o nome do alvo.
Como então se dá a execução passo a passo do Makefile desde que mandamos o comando make, nesse caso?
Ele irá expandir a regra roletrando e ver se todos os arquivos .o existem. Caso algum deles não exista ou seja mais antigo que o seu  .c, ele perceberá isso e, usando o alvo genérico %.o, irá gerar o .o necessário a partir do .c. Em seguida irá gerar o alvo roletrando.
Apague todos os arquivos .o e mande executar nosso Makefile com make -f Makefile-1. Sua saída provavelmente será algo como abaixo:

gcc -c letras.c -o letras.o
gcc -c main.c -o main.o
gcc -c regras.c -o regras.o
gcc -o roletrando letras.o main.o regras.o

Ou seja, ele fará todo o serviço necessário sem você criar regras individuais e aumentar muito a complexidade do seu Makefile.
Um efeito colateral importante do uso de wildcards é que qualquer arquivo pego pelo padrão é usado como valor de variável (e como dependência, em geral). Isso pode acarretar problemas. Por exemplo, mantendo nosso Makefile como está, crie um arquivo .c em branco no diretório do roletrando. Não interessa o nome, apenas crie (para usuários de Linux, use o comando touch o_nome_do_meu_arquivo_aleatório.c), sem conteúdo nenhum. Após isso, execute o Makefile-1 como fizemos anteriormente. Você perceberá que ele irá achar o arquivo random.c na lista de fontes e colocará o arquivo random.o como parte das dependência de roletrando (devido à expansão), compilando random.c com a regra genérica.
Isso parece bobagem, uma vez que random.c está vazio… Mas tente, por exemplo, copiar um arquivo que tenha uma função main() para dentro de roletrando. Ao usar wildcards, você pode incorrer no risco de, cedo ou tarde, provocar erros de compilação e ligação devido à inclusão inadvertidade de um arquivo .c que contenha um código para uma função similar a uma que já exista em seu código. Tome muito cuidado quanto a isso.
Uma sugestão seria não utilizar as expansões com wildcards e apenas incluir os nomes de arquivo fontes, separados por espaço, em FONTES. Ainda demandaria alguma edição no Makefile após a inclusão de um novo arquivo, mas isso permitiria uma melhor administração dos fontes a serem compilados. Além disso, o resto das regras e macros do Makegile continuariam com sua utilidade mantida.
No caso de a pessoa tentar isso, ela não poderia normalmente dar ENTER e em seguida colocar o nome de um arquivo (considera-se que o valor da variável termina de ser lido em um caracter nova-linha). Porém, é possível “enganar” o sistema para que ele ache que um ENTER não é o iniício de uma nova linha. Para isso, coloque “\” antes de dar ENTER e siga em frente. O ENTER dado não será lido pelo make (será “escapado”) e o valor na linha de baixo será acrescentado aos demais normalmente. Por exemplo,

FONTES=fonte1.c fonte2.c fonte3.c
       fonte4.c

Faria com que você recebesse a mensagem de erro “Makefile:2: *** faltando o separador.  Pare.“. Mas:

FONTES=fonte1.c fonte2.c fonte3.c \
       fonte4.c

Seria correto e retornaria a expansão para fonte1.c fonte2.c fonte3.c fonte4.c.

Na verdade, phony targets são alvos que não vão gerar algum arquivo de saída. Um alvo assim tem como objetivo facilitar atividades que o desenvolvedor necessita fazer, como limpar os arquivos objeto antigos, empacotar um tarball (um arquivo compactado .tar.gz ou .tar.bz2), entre outros.
Uma coisa importante é que o mesmo não irá gerar arquivos, mas é bom por via das dúvidas indicar que esses alvos são Phony Targets para que o make não exija um arquivo com o nome do Phony Target ou para evitar que a existência de um arquivo com o mesmo nome do alvo faça com que a regra pare de funcionar. Para isso, utilizamos o alvo especial .PHONY para isolar todos os Phony Targets por meio dele. Caso contrário, podemos receber mensagens de erros como a seguinte, ao utilizar uma Phony Target clean, por exemplo:

make: *** Sem regra para processar o alvo `clean’.  Pare.

Abra seu arquivo Makefile-1 e adicione as seguintes linhas ao final do mesmo:

clean:
    rm -f *.o roletrando *~

tar:
    tar cvjf roletrando.tar.bz2 $(FONTES) $(HEADERS)

Seu arquivo Makefile-1 deverá estar parecendo algo assim:

Perceba que ainda não definimos clean e tar como Phony Thargets. Agora, vamos definir nossas Phony Thargets. Antes de all, inclua a seguinte regra:

.PHONY: all clean tar

Perceba que agora definimos eles como Phony Targets, perceba que incluimos all. Essa é uma boa prática, incluir all como Phony Target para evitar problema maiores no caso da existência de uma arquivo all. Teste as regras clean e tar, lembrando de usar -f Makefile-1 para indicar o arquivo de Makefile desejado (se você colocar essas regras no arquivo Makefile padrão, não precisará do -f). Muitos softwares livres incluem em seus makefiles Phony Targets como clean, install, package, etc… Tente criar vários Phony Targets para fazer operações de instalação, remoção, limpeza dos objetos antigos, compactação, e por aí afora.
O nosso Makefile “genérico” deve ficar como o abaixo. Esse é um ótimo Makefile padrão para ser adotado no dia a dia:

C_COMP=gcc
FONTES=$(wildcard *.c) 
HEADERS=$(wildcard *.h)

.PHONY: all clean tar

all: roletrando
   
roletrando: $(FONTES:.c=.o)
    $(C_COMP) -o $@ $^

%.o: %.c $(HEADERS)
    $(C_COMP) -c $< -o $@

clean:
    rm -f *.o roletrando *~

tar:
    tar cvjf roletrando.tar.bz2 $(FONTES) $(HEADERS)

Para saber mais

Não pretendo falar por um bom tempo mais sobre Makefiles. Essa introdução deve ser o suficiente para o dia a dia e para o que precisaremos por um LONGO TEMPO no nosso “curso”. Se você desejar maiores informações, abaixo alguns links úteis:

• Artigo sobre make da Wikipedia: http://en.wikipedia.org/wiki/Make_%28software%29;
• Manual do GNU Make: http://www.gnu.org/s/hello/manual/make/index.html#Top;
• Especificação do make segundo o OpenGroup: http://pubs.opengroup.org/onlinepubs/009695399/utilities/make.html;

Além dos seguintes tutoriais, onde me baseei para escrever esse artigo:

• http://www.opussoftware.com/tutorial/TutMakefile.htm
• http://ubuntuforum-pt.org/index.php/topic,21155.0.html
• http://www.eng.hawaii.edu/Tutor/Make/
• http://www.cs.umd.edu/class/fall2002/cmsc214/Tutorial/makefile.html
• http://www.metalshell.com/view/tutorial/120/
• http://developers.sun.com/solaris/articles/make_utility.html#5

Bem, agora chega de falarmos de ferramentas. Prometo na próxima “aula” voltar à programação em C, com estruturas e tipos do usuário. Até lá!

“Como assim?“, você deve estar pensando.
Se pararmos para pensar e compararmos com programas como os que usamos no dia a dia, o nosso “roletrando” é extremamente tosco e rudimentar. Não precisamos pegar leve, pois essa é a verdade. Programas comuns do dia a dia, como um navegador web, o próprio sistema operacional ou um compilador, são programas muito mais complexos e, portanto, com muito mais código. Por exemplo: o Windows XP, segundo a Wikipedia, possui em torno de 45 milhões (sim, MI-LHÕ-ES) de linhas de código. No mesmo artigo, mostra-se que o kernel (a parte mais fundamental do sistema operacional) do Linux 2.6.35 possui 13,5 milhões de linhas de código. Em Julho de 2011, quando esse artigo foi escrito, segundo o site Ohloh.net, o LibreOffice (uma suite de produtividade livre) possuia mais de 7,5 milhões de linhas de código. Pelo mesmo site, e na mesma época, constava que o Mozilla Firefox (um popular navegador Web) possuia em torno de 5 milhões de linhas de código.
Usar tal estatística é problemático, uma vez que o número de linhas de código para descrever-se um programa pode mudar de linguagem de programaçÂão para linguagem de programaçÂão: as linguagens podem incorporar em sua infraestrutura uma maior ou menor quantidade de bibliotecas e funções utilitárias, permitindo que o programador desenvolva programas mais “enxutos” ao utilizar-se de funcionalidades já previstas na linguagem de programaçao. Porém, o caso aqui não é comparar a complexidade no desenvolvimento ou coisas do gênero. Isso não vêem ao caso, pois meu objetivo aqui não é tentar determinar a linguagem que permite produzir mais programa com menos código. Meu objetivo aqui é fazer você pensar: imagine ter que carregar em um editor todos os, por exemplo, 5 milhões de linhas de código do Mozilla Firefox para uma manutenção. Tériamos sérios problemas para localizar o que desejamos corrigir, editar e compilar esse código novo, além do tempo gasto para tais procedimentos.
Entretanto, esses programas existem. “Como?”, você deve se perguntar?
No caso, graças à possibilidade de compilação parcial.
Quando falamos, lá no início do curso, que um compilador compila todo o código e gera o código binário, eu disse apenas meia-verdade. Realmente, o compilador gera UM código binário a partir do código fonte. Pòrém, quem realmente cria o binário esxecutável baseado no código binário gerado pelo compilador é um programa ou rotina do compilador chamado linkeditor (ou linker).
Por que isso é necessário?
O tempo todo, desde o início do curso, temos citado funções. Temos visto funções o tempo todo, desde os printf() até nossas funções personalizadas. Porém, no momento em que o sistema operaciona executa um programa, ele vai apenas lendo e lendo códigos até chegar ao fim do mesmo. Ele pode ter execuções condicionais, baseadas em if, while, etc… (na verdade, tudo vai a um nível ainda mais baixo no fim das contas, mas não vamos entrar nesses detalhes), mas na verdade mesmo com esses saltos cedo ou tarde o programa volta para onde ele estava, até chegar ao fim dele.

#include “roletrando.h”

Esse #include por trazer o nome do arquivo de inclusão entre aspas duplas, ao invés de cercada por sinais de maior e menor (como em #include <stdio.h>). “Qual é a diferença?”, você deve se perguntar.
A diferença está relacionada com a idéia de “biblioteca padrão”:
Toda linguagem de programação (e C não é exceção), tem sua biblioteca padrão de funções. Essa biblioteca representa conjuntos de funções que o programador pode esperar que um ambiente de desenvolvimento inclua, embora isso não seja obrigatório (em ambientes de pouca memória ou com usos específicos, pode-se implementar C sem várias das bibliotecas padrão). Somada à biblioteca padrão, toda linguagem de programação permite que o desenvolvedor a expanda, incluindo bibliotecas para as mais diversas finalidades.
Em C, quando um arquivo de cabeçalho no #include vem cercado de sinais de maior e menor, o compilador procura o arquivo com o nome em questão não apenas nos diretórios do projeto em questão, mas em diretórios adicionais normalmente definidos em uma variável de ambiente chamada INCLUDE (isso não é obrigatório, mas tem se tornado um “padrão de fato” devido ao intensivo uso desse procedimento). Esses diretórios contêm diversos arquivos de cabeçalho para diversas bibliotecas, tanto padrão do C quanto para as bibliotecas adicionadas pelo desenvolvedor. Além disso, o próprio compilador tem certa “inteligência” para localizar bibliotecas padrão. Por exemplo, no Linux e na grande maioria dos ambientes Unix padronizados, os arquivos de cabeçalho da biblioteca padrão estão em /usr/include, e caminhos como /usr/local/include são reservados para bibliotecas adicionais.
Quando, porém, no C, a diretiva de compilação #include é cercada por aspas duplas, o C compreende que o cabeçalho em questão é parte específica desse projeto e não utiliza os caminhos em INCLUDE para procurar por ele, procurando-o dentro do diretório no qual o projeto está sendo compilado.
Essa é a diferença básica nesses dois casos: existem mais detalhes, mas iremos nos restringir no momento a essa explicação básica.
Bem, dito isso, o resto do código não possui mistérios: continua sendo o main() do “jogo de roletrando” que fizemos na última aula,  sem modificação alguma no código. Porém, se você tentar compilar ele “agora”, você receberá mensagens de erro como as a seguir (no caso, se você usar GCC):

main.c:5:24: error: roletrando.h: Arquivo ou diretório não encontrado
main.c: In function ‘main’:
main.c:13: error: ‘TAMANHO_PALAVRAS’ undeclared (first use in this function)
main.c:13: error: (Each undeclared identifier is reported only once
main.c:13: error: for each function it appears in.)
main.c:26: error: ‘NULL’ undeclared (first use in this function)
main.c:30: warning: incompatible implicit declaration of built-in function ‘malloc’
main.c:30: warning: incompatible implicit declaration of built-in function ‘strlen’
main.c:34: warning: incompatible implicit declaration of built-in function ‘printf’
main.c:38: warning: incompatible implicit declaration of built-in function ‘memset’
main.c:42: error: ‘NUM_TENTATIVAS’ undeclared (first use in this function)
main.c:47: warning: incompatible implicit declaration of built-in function ‘printf’
main.c:48: warning: incompatible implicit declaration of built-in function ‘scanf’

/tmp/ccrd9zr4.o: In function `main’:
main.c:(.text+0x32c): undefined reference to `explicarRegras’
main.c:(.text+0x4c7): undefined reference to `checaLetra’
main.c:(.text+0×509): undefined reference to `contaFaltantes’
main.c:(.text+0x53f): undefined reference to `contaFaltantes’
main.c:(.text+0×558): undefined reference to `testaCerto’
collect2: ld returned 1 exit status

Se você parar para pensar, vai notar que realmente não implementamos nenhuma das funções mostradas na mensagem de erro e, embora o compilador “saiba da existência” das mesmas (devido aos arquivos de cabeçalho), não sabe onde elas estão (elas não estão aí mesmo) e, portanto, não consegue gerar o código fonte em questão.
Portanto, vamos implementar as funções que faltam por meio dos dois arquivos que faltam, que são regras.c:

/*
 * regras.c
 */

#include “roletrando.h”

void explicarRegras (void)
{
  // Explicando as regras do jogo para o jogador
  printf (“Okay, vamos explicar as regras!\n”);
  printf (“Eu conheco algumas palavras, e vou escolher aleatoriamente uma delas.\n”);
  printf (“Voce vai me dizer qual letra voce acha que essa palavra tem!\n”);
  printf (“Se voce errar, vou considerar uma tentativa errada!\n”);
  printf (“Se voce acertar, vou te mostrar onde as letras estao!\n”);
  printf (“Quando voce tiver acertado metade das palavras, vou te dar “);
  printf (“a chance de dizer qual palavra e essa. \n”);
  printf (“Se voce errar, vou considerar uma tentativa errada!\n”);
  printf (“Se voce acertar antes de acabar as tentativas, voce vence!\n\n\n”);
  printf (“Algumas observacoes:\n”);
  printf (“Voce tem %d tentativas que voce pode errar.\n”,NUM_TENTATIVAS);
  printf (“Nenhuma palavra possui acentos, cedilha ou trema.\n”);
  printf (“Nao estou diferenciando maisculas e minusculas. \n\n”);
}

int testaCerto (const char* palavraEscolhida, int *tentativasErradas)
{
  char *minhaResposta;

  minhaResposta=(char*)malloc(strlen(palavraEscolhida)+1);
  memset(minhaResposta,”, strlen(palavraEscolhida)+1);

  if (!minhaResposta)
    {
      printf(“Nao consegui alocar memoria!\n”);
      return(1);
    }

  char *conversao=minhaResposta;
  printf(“Qual palavra voce acha que e essa? “);
  fgets(minhaResposta,strlen(palavraEscolhida)+1,stdin);

  // Convertendo para minusculas e eliminando os caracteres de nova linha – \n
  while (*conversao)
    {
      *conversao=((*conversao>=’A')&&(*conversao<=’Z'))?*conversao-’A'+’a':*conversao;
      conversao++;
    }

  minhaResposta[strlen(minhaResposta)]=”;

  if(strncmp(minhaResposta,palavraEscolhida,strlen(palavraEscolhida))==0)
    {
       free(minhaResposta);
       return(1);
    }
  else
    {
      printf(“Que pena, voce errou!\n”);
      (*tentativasErradas)++;
      free(minhaResposta);
      return(0);
    }
}

E letras.c:

/*
 * letras.c
 */

#include “roletrando.h”

int checaLetra (const char* palavra, const char* letrasCertas, char letra)
{
  // Acertos obtidos (0 indica que nao tem a letra em questao na palavra)
  int acertos=0;

  // Ponteiros a serem inicializados
  char *palavraAnalisada, *certas;

  // Inicialidando os ponteiros com os valores recebidos
  palavraAnalisada=(char*)palavra;
  certas=(char*)letrasCertas;

  char letraComparada=((letra>=’A')&&(letra<=’Z'))?letra-’A'+’a':letra;

  while (*palavraAnalisada)
  {
    if (*palavraAnalisada==letraComparada)
      {
    acertos++;
    *certas=letraComparada;
      }
    palavraAnalisada++;
    certas++;
  }

  return acertos;
}

int contaFaltantes(const char* letrasCertas)
{
  char *letras=(char*)letrasCertas;
  int faltantes=0;

  while (*letras) if (*(letras++)==’-') faltantes++;

  return faltantes;
}

OK, você deve estar pensando…
E agora, como compilar esse programa?
Se você tentar compilar apenas um dos dois últimos códigos, você receberá uma mensagem de erro como a seguinte:

/usr/lib/gcc/i386-redhat-linux/4.1.2/../../../crt1.o: In function `_start’:
(.text+0×18): undefined reference to `main’
collect2: ld returned 1 exit status

Isso quer dizer que o compilador compilou corretamente o código, mas o linker não encontrou nenhuma função main(). Portanto, o comando padrão de compilação que usamos desde o começo do curso, que vimos lá atrás:
O primeiro programa: HelloWorld.c « Aulas de C

Entre no mesmo diretório onde você gravou o seu HelloWorld.c e digite o seguinte comando:
gcc -o HelloWorld HelloWorld.c

Já não serve mais.
Existem duas formas de compilar-se o código fonte com arquivos individuais e obter-se o binário. A primeira é utilizar-se o comando:

gcc -o roletrando main.c regras.c letras.c

Perceba que a única diferença aqui entre isso e o que temos feito desde sempre é que adicionamos os arquivos .c adicionais após o main(). Entretanto esse método não oferece grandes vantagens: você ainda gastará muito tempo compilando código-fonte pois, embora o código esteja separado, o compilador precisará reuní-lo antes de compilar e ligar o código. Desse modo, ao menos um dos benefícios da separação dos códigos em arquivos individuais terá sido perdida (você ainda gastará muito tempo compilando todo o código, inclusive os trecho que não mudaram).
O método que nos permite os melhores benefícios é aquele em dois passos, onde (1) o compilador gera cada um dos arquivos binários de cada código fonte e (2) o linker gera o binário final a partir do código binário gerado pelo compilador previamente. Cada compilador tem sua metodologia para gerar esse processo, e você deve ler cuidadosamente a documentação do seu compilador.
No GCC, primeiro iremos gerar o código binário (que chamaremos de código-objeto para distingüir do binário final, ou executável), por meio do comando:

gcc -o nome_do_codigo_objeto.o -c meu_arquivo_fonte.c

A opção -c do compilador GCC apenas faz a compilação do código, sem tentar fazer o link, conforme dito na documentação do mesmo:

-c  Compile or assemble the source files, but do not link.  The linking stage simply is not done.  The ultimate output is in the form of an object file for each source file.
By default, the object file name for a source file is made by replacing the suffix .c, .i, .s, etc., with .o.
Unrecognized input files, not requiring compilation or assembly, are ignored.

Ou seja, ele não gerará o o executável.

É interessante notar que, no caso específico do GCC, ele possui alguma inteligência e é capaz de distinguir código-fonte de código-objeto. Portanto, a última linha do nosso primeiro passo:

gcc -o main.o -c main.c

Poderia ser substituída por:

gcc -o roletrando letras.o regras.o main.c

Sem problemas. Normalmente, porém, fazemos o passo da geração de arquivos objetos para cada arquivo-fonte.
“E onde está o ganho? Até agora, gastei mais tempo lançando comandos!” você deve estar se perguntando.
Imagine que você está traduzindo o jogo do roletrando para um outro idioma e tem que, portanto, mexer na função explicarRegras(), em regras.c. Se você tiver com todos os códigos-objetos gerados, tudo o que você precisará fazer é gerar novamente o código-objeto de regras.c (regras.o) e refazer o executável com o comando para fazer o link das funções.
Existem muitas outras vantagens em usarmos esse método, mas não vem ao caso agora. Falaremos sobre outras vantagens no futuro.
Como “brincadeira”, tente visualizar os programas que criamos até agora e que usam funções, e tente recriá-los, separando as funções em arquivos fontes individuais e criando arquivos de cabeçalho para esses códigos. Esse processo é algo padrão no desenvolvimento de software e é algo muito comum.
Na nossa próxima “aula”, continuaremos esse assunto, aprofundando um pouco na automação da construção de binários a partir de arquivos de código fonte individuas e outras estratégias para organização de projetos.

Esse tópico será um pouco diferenciado, portanto vou avisando que será BEM MAIS LONGO e complexo do que os anteriores. Isso porque iremos ver como as funções em C são afetadas pelos ponteiros. É um tópico bem avançado em teoria, mas é interessante mencioná-lo agora, enquanto os conceitos relacionados a ponteiros estão “frescos” na memória. Na verdade, esse tópico será dividido em dois subtópicos:

• Ponteiros de função, ou seja, usar um ponteiro para chamar diferentes funções decididas em tempo de programação. Isso é muito usado, por exemplo, em plugins de programas. Dizendo de maneira bem simplista, poderíamos carregar para a memória o conteúdo de um arquivo e fornecer o endereço onde esse conteúdo carregado se localiza para um ponteiro de função que o sistema executaria esse código dinamicamente (na verdade, existem mais complicadores, mas em termos gerais podemos dizer isso);
• Passagem de ponteiros para funções: existem detalhes a serem mencionados quando passamos um ponteiro para uma função. Isso ocorre com muita freqüencia, uma vez que muitos “tipos” que um programador pode esperar de uma linguagem de programação (como strings, filas, listas, etc…) são resolvidas em C pelo uso de ponteiros;

Bem, vamos começar com o primeiro de nossos subtópicos:

Ponteiros de Função

Como já cansamos de dizer nesse “curso”, ponteiros são variáveis que armazenam um endereço no qual está um determinado conteúdo. Se pensarmos dessa forma, podemos imaginar que isso possa se aplicar a trechos de código.
“Por que?”, você deve se perguntar. Porque, embora o código não fique no heap ou em outros pontos de memória como os dos dados, ele PRECISA ESTAR na memória para funcionar. Ou seja, se um código não estiver carregado na memória RAM (ao menos no momento da execução), ele não pode ser executado. De fato, quando chamamos um programa binário, a primeira coisa que o sistema operacional faz é chamar uma rotina chamada LOADER para copiar os conteúdos do arquivo onde o binário se encontra para um espaço de memória específico (programas podem eles próprio solicitarem ao SO para carregarem partes de si que ficaram de fora da memória em tempo de execução – isso se chama carga dinâmica e é um tópico mais avançado, que não iremos tratar em um futuro próximo). Em seguida, são feitos procedimentos para iniciar a execução do programa que mudam conforme a arquitetura do sistema operacional e do hardware, mas em geral envolve inicializar uma série de variáveis de baixo nível do sistema operacional e algumas informações no nível dos registradores de hardware (um registrador é um espaço de memória muito pequeno que é usado diretamente pela CPU para coordenar as operações de sistema. Fundamentalmente são eles que carregam as informações e códigos “para dentro” da CPU e “devolvem” o resultado). De qualquer modo, o programa é carregado em memória e em seguida inicializado sua execução.
Quando um programa encontra uma chamada a uma função, ele “salta” para o local de memória onde o código daquela função está e começa a executar o código da função (existem certos procedimentos internos para impedir que a execução da função afete de maneira indesejada o funcionamento do código que a chamou, mas não entraremos em detalhes aqui). Ao terminar essa execução, ele “volta” para o comando seguinte ao qual a função foi chamado. Para isso, obviamente o sistema armazena antes as informações sobre onde ele estava antes de a função ser chamada.
Se pensarmos bem, vamos ver que o tempo todo existe manipulação de endereços no momento da execução de código. E se há endereços, há ponteiros!
Chega de papo! Nosso programa exemplo da vez é uma “calculadora” simples. O código é o seguinte:

#include <stdio.h>
#include <stdlib.h>

int soma (int, int);
int subtracao (int, int);
int multiplicacao (int, int);
int divisao (int, int);

int main(void)
{
  int (*funcPointer)(); // o meu ponteiro de funcao vem aqui

  int a=0,b=0,c=0,oper=0;

  printf (“Entre com dois numeros inteiros separados por espaco: “);
  scanf (“%d %d”, &a, &b);

  do
    {
      printf (“Escolha uma operação a se realizar com esses numeros:\n”);
      printf (“1-) Soma\n”);
      printf (“2-) Subtracao\n”);
      printf (“3-) Multiplicacao\n”);
      printf (“4-) Divisao\n”);
      scanf(“%d”, &oper);
    } while (!((oper>=1) && (oper<=4)));

  switch(oper)
    {
    case 1:
      {
        funcPointer=soma;
        break;
      }
    case 2:
      {
        funcPointer=subtracao;
        break;
      }
    case 3:
      {
        funcPointer=multiplicacao;
        break;
      }
    case 4:
      {
        funcPointer=divisao;
        break;
      }
    }

  c=(*funcPointer)(a,b);

  printf(“O resultado da operacao desejada com os valores %d e %d e %d\n”,a,b,c);

  printf(“A funcao usada para executar a operacao desejada localiza-se em %p\n”,funcPointer);

  return(0);

}

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

int subtracao (int a, int b)
{
  return a-b;
}

int multiplicacao (int a, int b)
{
  return a*b;
}

int divisao (int a, int b)
{
  if (b==0)
    {
      printf(“Nao posso dividir nada por zero!\n”);
      return 0;
    }
  return a/b;
}

Bem, se observarmos bem, não existem grandes novidades aqui. Portanto, vamos nos restringir às explicações sobre os ponteiros de função. A primeira coisa importante a se notar está na declaração do ponteiro de função:

  int (*funcPointer)(); // o meu ponteiro de funcao vem aqui

Se você reparar, lembra levemente um protótipo de uma função. Porém, perceba que você tem o (*funcPointer)(), que indica que é um ponteiro de função. Poderíamos ler esse código como “funcPointer é um ponteiro que aponta para o código de uma função que devolve int“. Outra coisa a se notar é que aqui não tentamos resolver a parte da parametrização. Isso é importante de ser lembrado pois em teoria você pode usar funcPointer para executar qualquer função que retorne int. No momento em que usarmos o ponteiro de função, porém, é o momento no qual teremos que “resolver” a parte da parametrização. No momento, basta saber que aqui na realidade declaramos uma varíavel, ponteiro, que irá apontar para o código de uma função que irá retornar um valor int.
Em seguida, temos um switch…case que se baseia em um valor que passamos para ele como um int para decidir qual a operação a ser feita. Cada número possui um código similar ao abaixo:

        funcPointer=multiplicacao;

Se olharmos no início, veremos que declaramos funções que irão retornar valores int (ou seja, do tipo que é aceito por funcPointer):

int soma (int, int);
int subtracao (int, int);
int multiplicacao (int, int);
int divisao (int, int);

OK. Mas a sua pergunta deve ser “como o C sabe tratar as coisas nesse caso?”. Para o C, se você passa o nome de uma função sem os seus parâmetros, você está na realidade passando uma variável, ponteiro, para uma função cujo retorno será o tipo que a função retorna. Se pegarmos o nosso caso:

        funcPointer=multiplicacao;

Veremos que na nossa lista de funções declaradas existe uma função int multiplicacao (int, int);. Desse modo, o C trata o multiplicacao nesse caso não como um comando, mas como uma variável. Portanto, ele devolverá o endereço da posição de memória onde essa função começa. Isso é comprovado pelo comando:

  printf(“A funcao usada para executar a operacao desejada localiza-se em %p\n”,funcPointer);

Voltando ao programa: já sabemos como declarar um ponteiro de função (algo como tipo (*nomeDoPonteiroDeFuncao)()) e sabemos como passar o endereço para um ponteiro de função (como para qualquer outro). E para executarmos esse comando, como fazemos?

  c=(*funcPointer)(a,b);

AQUI MORA DRAGÕES!!!

Aqui é importante clarificar uma coisa: quando você manda um ponteiro para uma função, ela tem, digamos assim, poder total sobre ele. Isso inclui trocar o endereço de memória para o qual o ponteiro aponta. Se você lembrar de quando usamos ponteiros para executar a função de Fibonacci, utilizamos dois ponteiros apontando para o mesmo lugar, sendo que um deles é que “se deslocaria” através do local alocado para armazenarmos os valores.
Para garantirmos que um ponteiro que estamos passando não vai ter seu endereço alterado, usamos a palavra-chave const antes do char*, para indicarmos ao sistema que esse ponteiro é constante (ou seja, irá apontar SEMPRE para o mesmo lugar enquanto em uso), o que oferecerá uma garantia de que, mesmo que o CONTEÚDO do endereço apontado seja alterado, o ENDEREÇO não o seja. Por segurança, a não ser que você precise manipular os endereços apontados, sempre coloque const quando usar ponteiros em parâmetros de função.
Indo para a função checaLetra, encontramos o seguinte código:

int checaLetra (const char* palavra, const char* letrasCertas, char letra)
{
  // Acertos obtidos (0 indica que nao tem a letra em questao na palavra)
  int acertos=0;

  // Ponteiros a serem inicializados
  char *palavraAnalisada, *certas;
 
  // Inicialidando os ponteiros com os valores recebidos
  palavraAnalisada=palavra;
  certas=letrasCertas;

  char letraComparada=((letra>=’A')&&(letra<=’Z'))?letra-’A'+’a':letra;

  while (*palavraAnalisada)
  {
    if (*palavraAnalisada==letraComparada)
      {
    acertos++;
    *certas=letraComparada;
      }
    palavraAnalisada++;
    certas++;
  }

  return acertos;
}

Vamos analisar essa função. Para começar, temos a declaração de três variáveis: um int onde guardaremos a quantidade de vezes que a letra escolhida “casou” com alguma na palavra (0 se nenhuma), dois ponteiros de caracter (char*) que serão quem realmente fará o trabalho sujo, e um char que irá conter uma versão em minúscula do caracter digitado (isso deve-se ao fato de todas as palavras estarem em minúsculas, o que provocaria problemas na comparação entre os caracteres em caso de maiúsculas). A função não tem muito mistério: iremos correr os ponteiros de palavraAnalisada (que recebe a palavra que o sistema escolheu) e certas (onde serão gravados os acertos). Se o caracter que for apontado por palavraAnalisada “casar” com a letra a ser comparadas, será somado um ao número de acertos e a letra será gravada na posição apontada em certas. Como ambas se movem ao mesmo tempo (no fim do loop de comparação), a posição de certas onde a letra será gravada corresponderá à posição em que a letra fica em palavraAnalisada. Parece estranho no while não haver nenhuma condição de saída aparente, mas lembre-se que para C, qualquer valor 0 ou equivalente é considerado falso e provoca a saída do loop. No caso de strings, o terminador nulo da string é considerado um valor equivalente a 0 e portanto falso. Por isso, não precisamos especificar uma condição de saída. Esse tipo de construção é comum em programas C de alto nível e faz parte do “modo C de pensar” não declarar uma condição de saída explícita aqui. Após o loop, a função retornará quantos acertos ocorreram.
Vejamos agora uma coisa: é necessário criar os dois ponteiros de char?
SIM!
Usando const, garantimos que os endereços armazenados nos ponteiros que passaram os mesmos para o sistema não terão seus valores alterados. Porém, pela própria lógica que usamos, precisaremos de ponteiros que “se movam” através das strings, comparando os caracteres um a um e obtendo os acertos. Não teríamos como fazer isso usando o ponteiro const que passamos, pois ele é constante e portanto não pode ser manipulado. Porém, ao declararmos dois ponteiros e copiarmos os endereços de memória apropriados para eles, podemos “deslocar” esses segundo ponteiros, sem interferir nos ponteiros originais (constantes). Lembre-se que const nesse caso apenas impede que o endereço do ponteiro seja trocado, não seu conteúdo. Por meio dos ponteiros que declaramos dentro da função, podemos modificar os conteúdos das strings apontadas pelos mesmos e deslocar-nos através dos locais apontados, operando por meio de aritmética de ponteiros.
OK, acho que devemos estar claros quanto a isso. Voltemos ao nosso programa.
Lembra que dissemos que a função checaLetra retorna o número de acertos e 0 se nenhum? Isso tem um motivo:

      if (!checaLetra(palavraEscolhida,letrasCertas,minhaLetra))

Esse if explica nossa escolha. Assim como no caso do while em checaLetra, o if aqui é uma “boa prática” de C: ao invés de retornarmos um número arbitrário como falso, usamos o próprio mecanismo de “booleanos” em C (0 ou equivalente igual a falso, qualquer outro valor verdadeiro). Desse modo, o programa fica mais enxuto e rápido por dispensar comparações que seriam “desnecessárias”. Mas atenção: BOAS PRÁTICAS NÃO SÃO OBRIGAÇÕES! Se em algum código você precisar fazer comparações exijam o valor 0 como um valor verdadeiro, não se exime de usar o 0 como verdadeiro e comparar valores com operadores relacionais normalmente. O fato de você se ater a boas práticas ajuda na legibilidade e manutenção do código, mas não deve ser um grilhão para você.
Esse if irá apenas exibir uma mensagem de que o jogador errou e adicionará um ao número de tentativas, e iniciará uma nova interação do while pelo comando continue.
Caso o jogador tenha acertado a letra, ele verá a palavra com as letras que ele já acertou e com traços nas posições onde ainda têm letras que o jogador ainda não acertou. Em seguida chamamos outra função que usa parâmetros por referência, que é a contaFaltantes:

int contaFaltantes(const char* letrasCertas)
{
  char *letras=letrasCertas;
  int faltantes=0;

  while (*letras) if (*(letras++)==’-') faltantes++;

  return faltantes;
}

Basicamente ela conta quantos traços ainda existem em letrasCertas (ou seja, quantas letras ainda precisam ser descobertas). Novamente declaramos um int para armazenar o total de faltantes (com 0 caso não haja nenhuma faltante) e um char* para ser usado para “nos deslocarmos” através da string e contarmos os caracteres faltantes. O while dessa função é estranho:

  while (*letras) if (*(letras++)==’-') faltantes++;

O que queremos dizer aqui é que: enquanto *letras não apontar um terminador nulo, se o valor apontado por letras no momento do if for um traço, adicione um aos faltantes. Após a comparação, mova uma posição adiante o ponteiro letras (perceba a pós-fixação do ponteiro). Esse é outro tipo de construção característica que o C permite e muitas vezes ela é vista em programas profissionais C.
Depois de contadas as faltantes, comparamos esse total com a metade das letras da palavra escolhida. Se isso for verdade, uma nova contagem é feita para ver se todas as letras foram acertadas:

      if((contaFaltantes(letrasCertas)==0)||testaCerto(palavraEscolhida,&tentativasErradas))

Caso contrário, será chamada a função testaCerto. No caso, o C garante que, caso contaFaltantes retorne 0, testaCerto não será chamada (é a short-fuse logic – lógica de curto-circuito, que faz com que, uma vez uma comparação lógica seja irrefutavelmente verdadeira ou falsa, o resultado seja considerado sem necessidade de realizar os demais processamentos, poupando tempo). Perceba que aqui usamos a comparação contaFaltantes(letrasCertas)==0. Embora aqui pudessemos usar !contaFaltantes(letrasCertas), aqui a boa prática não contribuiria, e sim atrapalharia a legibilidade. É importante ter isso em mente ao escrever seus códigos.
Vejamos agora a função testaCerto, que é chamada no caso de ainda haver letras a serem descobertas em uma palavra com mais de metade de seus caracteres descobertos:

int testaCerto (const char* palavraEscolhida, int *tentativasErradas)
{
  char *minhaResposta;

  minhaResposta=(char*)malloc(strlen(palavraEscolhida)+1);
  memset(minhaResposta,”, strlen(palavraEscolhida)+1);
     
  if (!minhaResposta)
    {
      printf(“Nao consegui alocar memoria!\n”);
      return(1);
    }

  char *conversao=minhaResposta;
  printf(“Qual palavra voce acha que e essa? “);
  fgets(minhaResposta,strlen(palavraEscolhida)+1,stdin);

  // Convertendo para minusculas e eliminando os caracteres de nova linha – \n
  while (*conversao)
    {
      *conversao=((*conversao>=’A')&&(*conversao<=’Z'))?*conversao-’A'+’a':*conversao;
      conversao++;
    }

  minhaResposta[strlen(minhaResposta)]=”;
 
  if(strncmp(minhaResposta,palavraEscolhida,strlen(palavraEscolhida))==0)
    return(1);
  else
    {
      printf(“Que pena, voce errou!\n”);
      (*tentativasErradas)++;
      return(0);
    }
}

Quando chamamos testaCerto, passamos a palavra em um ponteiro const char* e um int*.
“Por que esse int não é const?“.
O int aqui não é const pois, vamos dizer assim, o original não era um ponteiro. A validade do que dissemos sobre a alteração potencial do endereço só vale para quando passamos ponteiro-para-ponteiro. Quando derreferenciamos uma variável comum e passamos sua referência, mesmo que haja uma alteração no endereço dentro do código da função, não haverá outros impactos na variável de retorno (além de possíveis crashes de sistema e, na melhor das hipóteses, erros de lógica). Colocar um const como precaução a mais é errado? Não. Mas como o código aqui não vai alterar essa posição (apenas o conteúdo do endereço), não há tanta necessidade assim de colocar const nesse momento.
É imporante aqui dizer que o retorno é 1 para o caso de você acertar a palavra e 0 se errar. A passagem por referência de tentativasErradas é importante pois precisaremos, no caso de erro aqui, adicionar 1 ao número de tentativas erradas (não haveria como fazer uma segunda chamada, uma vez que a entrada do usuário é feita nessa função, e armazenar o valor de retorno dessa função antes da comparação no if que a chama no programa principal, ainda que possível, é complexo e propenso a erros). Inicialmente alocamos o mesmo tanto de memória que usamos na palavraEscolhida para o usuário entrar sua tentativa usando malloc e colocamos um segundo ponteiro chamado conversao para esse endereço. Usamos fgets para aceitar a resposta dada pelo usuário e colocamos o terminador nulo ao fim da entrada do usuário. Usando o ponteiro conversao, convertemos a palavra para minúscula (uma conversão que fazemos usando o fato de que variáveis char podem ser entendidas como int e podemos subtrair um char de outro – mais exatamente, o valor ASCII de um do valor ASCII de outro – e somá-los com um terceiro char).
Em seguida, usamos a função strncmp da biblioteca string.h, para comparar a resposta dada com a palavraEscolhida. Essa função compara um determinado trecho de uma string com o trecho de mesmo tamanho da outra string. Para evitar que o jogador use um cheat e digite apenas a parte que ele sabe da palavra, determinamos que o tamanho a ser usado é o de palavraEscolhida, não da tentativa do jogador. Isso porque strncmp devolve 0 se os dois pedaços forem exatamente iguais, -1 se o primeiro for alfabeticamente anterior ao segundo e 1 se o primeiro for alfabeticamente posterior ao segundo (e aqui você deve ter entendido porque disse que o jogador poderia cheatar aqui). Se o resultado for 0, ou seja, as duas palavras forem iguais, a função retorna 1, o que vai fazer o if no código principal ser verdadeiro. Caso contrário, retornará 0, tornando o if falso (lembrando que pelo short-fuse logic, a primeira função deve ser falsa – senão essa nem seria executadas). Antes de devolver o 0 no caso de erro, porém, ele mostra uma mensagem de erro e soma um ao número de tentativasErradas (atente que o ++ fora do parênteses em (*tentativasErradas)++ indica que o valor a ser alterado é o que está armazenado no endereço apontado por *tentativasErradas, não o próprio *tentativasErradas.).
Se você notar, caso o if seja falso, ele acaba no final do loop. Uma nova iteração será aberta obviamente, se o número de tentativasErradas ainda for menor que o NUM_TENTATIVAS. Caso contrário, o programa sairá do loop e se encerrará.
Algumas “brincadeiras”:

1. Descubra o bug na instrução que escolhe as palavras;
2. Aumente o número de palavras e veja se isso altera alguma coisa no funcionamento do código e se ele não chega a escolher alguma das palavras novas ou antigas. Coloque palavras grandes e veja o que acontece. Modifique o código para corrigir tal circunstância;
3. Uma coisa que não foi considerada propositalmente nesse código: no jogo normal, você não pode pedir uma letra já pedida. Além disso, a qualquer momento você pode pedir uma lista das letras já usadas. Crie uma lógica que trate dessas condições;
4. Em algumas versões desse jogo, uma tentativa errada de informar a palavra completa acaba com o jogo de uma vez. Tente criar uma lógica assim;
5. Em algumas versões, existe uma regra que, caso um determinado número de tentativas erradas consecutivas seja alcançada, o jogo acaba. Tente adaptar o jogo para essa regra;

Bem, com esse tópico, encerramos (ao menos por agora) o tópico Matrizes e Ponteiros. Ainda existe um tema dentro dela que falta, que é o de ponteiros de ponteiros, mas veremos ele no futuro, quando tratarmos de estruturas de dados complexas em C. Por agora é só e tenho só que agradecer por vocês terem aguentado tanto.
[Atualização - Dia 13/06/2011] O leitor André Caldas fez uma série de correções que realmente foram muito esclarecedoras. Ao invés de interferir no texto, prefiro que leiam os comentários do mesmo, pois são conceitos que eu mesmo tinha alguma confusão.. Com isso, algumas correções são necessárias nos códiogs dos dois programas que publicamos aqui. Em especial, devo me corrigir quanto à declaração do ponteiro de função: é possível sim fazer uma declaração de um ponteiro de função indicando os parâmetros. Não só é possível, como é o correto, uma vez que o sistema irá então fazer a checagem correta da função, no quesito de parâmetros e retorno. Ou seja, o código é mais bem escrito uma vez que utilize-se tipos. No caso do nosso primeiro código, ao invés de:

  int (*funcPointer)(); // o meu ponteiro de funcao vem aqui

o correto é:

  int (*funcPointer)(int,int); // o meu ponteiro de funcao vem aqui

Além disso, uma outra correção, essa um erro crasso meu, é o fato de que, no nosso jogo no segundo código, na função testaCerto, existe um sérissimo vazamento de memória (memory leakage) que deixei para trás. Se você leitor não percebeu, eu não faço uma desalocação de memória antes das saídas do código, tanto no caso do acerto quanto de erro. Isso pode parecer pouco, mas esses pequenos erros são os que geram maus hábitos de programação e que acabam redundando em programas mau-feitos e com falhas sérias que podem, inclusive, comprometer todo um ambiente computacional.
No caso, o problema era no código abaixo:

  if(strncmp(minhaResposta,palavraEscolhida,strlen(palavraEscolhida))==0)
    return(1);
  else
    {
      printf(“Que pena, voce errou!\n”);
      (*tentativasErradas)++;
      return(0);
    }

Se você reparar bem, irá notar que tanto no acerto quanto no erro, saio da função sem executar a devida limpeza da memória alocada em minhaResposta. No caso, o código correto é:

  if(strncmp(minhaResposta,palavraEscolhida,strlen(palavraEscolhida))==0)
    {
       free(minhaResposta);
       return(1);
    }
  else
    {
      printf(“Que pena, voce errou!\n”);
      (*tentativasErradas)++;
      free(minhaResposta);
      return(0);
    }

Repare nos free colocados aqui, que têm como objetivo liberar a memória utilizada. Além disso, não estava desalocando a memória antes de encerrar o programa para os ponteiros palavraEscolhida e letrasCertas. Embora possa-se dizer que essa é uma falha que não compromete, uma vez que esses dois espaços são desalocados pelo próprio SO ao final da execução do programa, novamente fica a questão do mau-hábito de programação. O ideal é que, mesmo ao final do programa, você libere todos os recursos usados pelo mesmo.
Dito isso, segue abaixo as novas versões de ambos os programas, caso você ainda tenha alguma dúvida sobre as correções feitas  (que serão marcadas em cores para que você analise e aprenda com o meu erro. )
Calculadora (ponteiro de função):

#include <stdio.h>
#include <stdlib.h>

int soma (int, int);
int subtracao (int, int);
int multiplicacao (int, int, int);
int divisao (int, int);

int main(void)
{
  int (*funcPointer)(int,int); // o meu ponteiro de funcao vem aqui

  int a=0,b=0,c=0,oper=0;

  printf (“Entre com dois numeros inteiros separados por espaco: “);
  scanf (“%d %d”, &a, &b);

  do
    {
      printf (“Escolha uma operação a se realizar com esses numeros:\n”);
      printf (“1-) Soma\n”);
      printf (“2-) Subtracao\n”);
      printf (“3-) Multiplicacao\n”);
      printf (“4-) Divisao\n”);
      scanf(“%d”, &oper);
    } while (!((oper>=1) && (oper<=4)));

  switch(oper)
    {
    case 1:
      {
    funcPointer=soma;
    break;
      }
    case 2:
      {
    funcPointer=subtracao;
    break;
      }
    case 3:
      {
    funcPointer=multiplicacao;
    break;
      }
    case 4:
      {
    funcPointer=divisao;
    break;
      }
    }

  c=(*funcPointer)(a,b);
  printf(“O resultado da operacao desejada com os valores %d e %d e %d\n”,a,b,c);
  printf(“A funcao usada para executar a operacao desejada localiza-se em %p\n”,funcPointer);
  return(0);
}

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

int subtracao (int a, int b)
{
  return a-b;
}

int multiplicacao (int a, int b, int c)
{
  return a*b;
}

int divisao (int a, int b)
{
  if (b==0)
    {
      printf(“Nao posso dividir nada por zero!\n”);
      return 0;
    }
  return a/b;
}

Roda-a-Roda (parâmetro por referência):

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

#define NUM_TENTATIVAS 6
#define TAMANHO_PALAVRAS 20

int checaLetra (const char* palavraEscolhida, const char* letrasCertas, char letra);
void explicarRegras (void);
int contaFaltantes (const char* letrasCertas);
int testaCerto (const char* palavraEscolhida, int* tentativasErradas);

int main (void)
{

  // Declarando variaveis

  // Biblioteca de palavras
  char palavras[][TAMANHO_PALAVRAS]={“rotina”, “retina”, “palhaco”, “lembranca”,
                                     “sistema”, “musica”,”curioso”, “fantasia”,
                     “malabares”,”sonhador”,”atitude”,”pacoca”};

  // Ponteiros necessarios
  char *palavraEscolhida, *letrasCertas;

  // Algumas variaveis de apoio
  int tentativasErradas=0,i;

  explicarRegras();

  srand(time(NULL)); // Serve para modificar a tabela de números pseudo-aleatórios

  palavraEscolhida=palavras[rand()%((sizeof(palavras)/TAMANHO_PALAVRAS)-1)];

  letrasCertas=malloc(strlen(palavraEscolhida)+1);
           
  if (!letrasCertas)
    {
      printf(“Nao consegui alocar memoria!\n”);
      return(1);
    }

  memset(letrasCertas,”, strlen(palavraEscolhida)+1);
  memset(letrasCertas,’-', strlen(palavraEscolhida));

  int tentativaAtual=0;
  while(tentativasErradas
    {
      char minhaLetra;
      tentativaAtual++;
     
      printf (“Okay, tentativa no %d (%d tentativas erradas):”, tentativaAtual, tentativasErradas);
      scanf (“%c”, &minhaLetra);
      getchar();
      if (!checaLetra(palavraEscolhida,letrasCertas,minhaLetra))
    {
      printf(“Que pena, essa letra nao aparece!\n”);
      tentativasErradas++;
      continue;
    }

      printf(“A palavra ate agora e: %s\n”,letrasCertas);

      if (contaFaltantes(letrasCertas)<=(strlen(palavraEscolhida)/2))
    {
      if((contaFaltantes(letrasCertas)==0)||testaCerto(palavraEscolhida,&tentativasErradas))
        {
          printf(“Muito bem! Voce acertou!\n”);
          free(palavraEscolhida);
          free(letrasCertas);
          return(0);
        }
    }
    }
}

void explicarRegras (void)
{
  // Explicando as regras do jogo para o jogador
  printf (“Okay, vamos explicar as regras!\n”);
  printf (“Eu conheco algumas palavras, e vou escolher aleatoriamente uma delas.\n”);
  printf (“Voce vai me dizer qual letra voce acha que essa palavra tem!\n”);
  printf (“Se voce errar, vou considerar uma tentativa errada!\n”);
  printf (“Se voce acertar, vou te mostrar onde as letras estao!\n”);
  printf (“Quando voce tiver acertado metade das palavras, vou te dar “);
  printf (“a chance de dizer qual palavra e essa. \n”);
  printf (“Se voce errar, vou considerar uma tentativa errada!\n”);
  printf (“Se voce acertar antes de acabar as tentativas, voce vence!\n\n\n”);
  printf (“Algumas observacoes:\n”);
  printf (“Voce tem %d tentativas que voce pode errar.\n”,NUM_TENTATIVAS);
  printf (“Nenhuma palavra possui acentos, cedilha ou trema.\n”);
  printf (“Nao estou diferenciando maisculas e minusculas. \n\n”);
}

int checaLetra (const char* palavra, const char* letrasCertas, char letra)
{
  // Acertos obtidos (0 indica que nao tem a letra em questao na palavra)
  int acertos=0;

  // Ponteiros a serem inicializados
  char *palavraAnalisada, *certas;
 
  // Inicialidando os ponteiros com os valores recebidos
  palavraAnalisada=(char*)palavra;
  certas=(char*)letrasCertas;

  char letraComparada=((letra>=’A')&&(letra<=’Z'))?letra-’A'+’a':letra;

  while (*palavraAnalisada)
  {
    if (*palavraAnalisada==letraComparada)
      {
    acertos++;
    *certas=letraComparada;
      }
    palavraAnalisada++;
    certas++;
  }

  return acertos;
}

int contaFaltantes(const char* letrasCertas)
{
  char *letras=(char*)letrasCertas;
  int faltantes=0;

  while (*letras) if (*(letras++)==’-') faltantes++;

  return faltantes;
}

int testaCerto (const char* palavraEscolhida, int *tentativasErradas)
{
  char *minhaResposta;

  minhaResposta=(char*)malloc(strlen(palavraEscolhida)+1);
  memset(minhaResposta,”, strlen(palavraEscolhida)+1);
     
  if (!minhaResposta)
    {
      printf(“Nao consegui alocar memoria!\n”);
      return(1);
    }

  char *conversao=minhaResposta;
  printf(“Qual palavra voce acha que e essa? “);
  fgets(minhaResposta,strlen(palavraEscolhida)+1,stdin);

  // Convertendo para minusculas e eliminando os caracteres de nova linha – \n
  while (*conversao)
    {
      *conversao=((*conversao>=’A')&&(*conversao<=’Z'))?*conversao-’A'+’a':*conversao;
      conversao++;
    }

  minhaResposta[strlen(minhaResposta)]=”;
 
  if(strncmp(minhaResposta,palavraEscolhida,strlen(palavraEscolhida))==0)
    {
       free(minhaResposta);
       return(1);
    }
  else
    {
      printf(“Que pena, você errou!\n”);
      (*tentativasErradas)++;
      free(minhaResposta);
      return(0);
    }
}

Quando, na primeira parte do assunto matrizes e ponteiros, falamos sobre os ponteiros, nós dissemos que “existem situações onde precisamos utilizar uma posição de memória que não conhecemos previamente. Na realidade, isso é mais comum do que se imagina: não fosse assim, todo programa deveria ser artificialmente limitado em suas capacidades baseado em números arbitrários de informação a ser processada. Por exemplo: um programa teria que criar previamente 500 variáveis de notas para processar o boletim escolar de uma classe de 20 alunos, sendo inútil para uma classe de 501 alunos. Isso também aumentaria o custo de desenvolvimento e manutenção de um programa de computador, além de utilizar os recursos de um computador de maneira pouco eficiente.” Isso acontece porque pelas regras do padrão ANSI C Original (seguida pela maior parte dos compiladores), o compilador não pode gerar código que utilize-se de matrizes de tamanho varíavel (em uma versão atualizada do padrão, C-99, os compiladores já passaram a dar suporte a esse recurso, porém nos focaremos ao C padrão ANSI.). Por exemplo, em C padrão ANSI, o código abaixo:

printf (“Quantos elementos precisamos?”);
scanf (“%d”,&nElementos);
int elementos[nElementos];

É considerado errado e gera um erro similar (PS: se você colocar esse tipo de código em um compilador com suporte ao C-99, em geral ele irá compilar, mas irá dar alertas. Será necessário fazer o compilador enxergar o código como C-99, não ANSI C Original. verifique o manual do compilador para maiores informações).
Para “escaparmos” a esse tipo de problema, a solução é fugir das matrizes e recorrermos aos ponteiros. Mas como?
O C Original prevê funções de alocação de memória dinâmica. Com o uso dessas funções, podemos obter, em tempo de execução, qualquer quantidade de memória que precisarmos (claro, imaginando que ela esteja disponível), normalmente de um espaço conhecido como heap e gerenciado pelo sistema operacional. Com isso, não precisamos artificalmente definirmos o uso de memória em um programa C (PS: várias outras linguagens, como Pascal, possuem também mecanismos de alocação dinâmica de memória), podendo aproveitar os recursos do sistema com maior eficiência.
Bem, chega de papo! Vamos ao que interessa.

O código

Vamos refazer um programa similar a algo que fizemos anteriormente, que é o programa da seqüência de Fibonacci (fãs de Código Da Vinci, regozijem-se). Porque disse similar? Pois a seqüência de Fibonacci é calculada de maneira muitíssimo parecida com a do Fatorial, que vimos quando falamos de recursividade. Para não recorrermos à recursão e mostrarmos a seqüência de Fibonacci resultante, utilizaremos alocação dinâmica de memória para reservamos o espaço adequado e aritmética de ponteiros para realizar os cálculos. Abaixo está o código:

#include <stdio.h>
#include <sdtlib.h>

int main(void)
{
  unsigned long int i=0,numeroFib=0,*sequenciaFib,*operFib;

  do
    {
      printf(“Indique o tamanho da sequencia Fibonacci (a partir do 3): “);
      scanf(“%d”,&numeroFib);
    }while (numeroFib<3);

  sequenciaFib=(unsigned long int *)malloc(sizeof(unsigned long int)*numeroFib);
  if(!sequenciaFib)
    {
      printf(“Sem memoria!\n”);
      return(1);
    }

  operFib=sequenciaFib;

  *operFib=1;
  ++operFib;
  *operFib=1;
  ++operFib;

  for (i=0;i<<numeroFib-2;i++)
    {
      *operFib=*(operFib-1)+*(operFib-2);
      operFib++;
    }

  operFib=sequenciaFib;

  for (i=0;<numeroFib;i++)
    {
      printf(“%do. numero Fibonacci e %u e esta armazenado no endereco %p\n”,i+1,*operFib,operFib);
      ++operFib;
    }

  free(sequenciaFib);

  return(0);
}

Bem, não precisamos comentar o início, à exceção que precisamos incluir a stdlib.h (STanDard LIBrary, se você não se lembra bem), pois ela é quem fornece a função malloc (Memory ALLOCation) que precisaremos. Logo falaremos sobre ela. Em seguida declaramos quatro variáveis unsigned long int… Na realidade, duas unsigned long int e dois ponteiros unsigned long int (unsigned long int *). Fizemos a opção de usar o unsigned long int pois podemos com isso executar um número muito alto de interações e, ao mesmo tempo, não precisamos nos preocupar com valores negativos de Fibonacci (que não existem). Para não termos problemas, fazemos com que o sistema só aceite um valor mínimo de 3 (ou seja, para mostrar até o terceiro número de Fibonacci).

Alocação dinâmica de memória – os comandos malloc e free:

Continuando o programa, encontramos o comando:

  sequenciaFib=(unsigned long int *)malloc(sizeof(unsigned long int)*numeroFib);

Essa linha é que faz todo o truque de alocação dinâmica de memória com o uso do comando malloc (Memory ALLOCation). malloc aloca uma determinada quantidade de bytes para um ponteiro do tipo void (void *). É importante lembrar disso pois podemos provocar sérios erros senão lembrarmos constantemente disso. Para que possamos usar corretamente malloc, devemos obter o número de bytes necessários para armazenarmos as informações necessárias. Nesse caso, utilizamos o operador sizeof para obter o tamanho de bytes de um unsigned long int (lembrando que esse valor pode mudar conforme a plataforma) e multiplicamos pelo número de elementos que precisaremos (no caso, o tamanho da seqüência de Fibonacci que desejamos desenvolver). Depois disso, devemos dar um typecast para indicar ao sistema que vamos transformar o ponteiro void retornado por malloc em um ponteiro unsigned long int (unsigned long int *). Desse modo, temos como saída um ponteiro do tipo unsigned long int pronto para nosso uso.
Antes de usarmos o ponteiro, é interessante de, por via das dúvidas, ver se realmente temos a memória alocada. Isso pode não parecer válido agora, mas qualquer pequena falha ao lidar com alocação dinâmica de memória pode comprometer o uso do sistema. O comando malloc nos oferece um bom mecanismo para isso: ele retorna null quando a alocação de memória falhou. Portanto, podemos testar isso com o seguinte código:

  if(!sequenciaFib)
    {
      printf(“Sem memoria!\n”);
      return(1);
    }

Provocando uma saída do sistema caso a memória que precisemos não seja alocada. Isso nos garante que não vamos operar sobrescrevendo memória apontada por um “ponteiro desgarrado” (ponteiro não-inicializado corretamente).
Agora, e essa é uma regra importante: sempre que você alocar memória, desaloquea-a assim que não for mais necessária. Isso vai garantir que não só seu programa, mas qualquer programa no computador onde o seu estiver executando, irá encontrar memória sempre que precisar. Caso não desaloque memória, você pode entrar em uma situação conhecida como “memory leakage” (Vazamento de memória), onde o sistema irá dar falha após várias alocações de memória seguirem-se sem a devida desalocação (o C não possui os sistemas de coletor de lixo – Garbage Collector – existente em outras linguagens devido à sua filosofia de trabalhar com o mínimo possível de complexidade). Para desalocar-se memória é usado o comando free. No nosso caso, o último comando do programa é:

  free(sequenciaFib);

Que avisa ao sistema operacional que desejamos desalocar o espaço de memória que alocamos para sequenciaFib, devolvendo esses recursos ao sistema operacional.

Aritmética de ponteiros:

Bem, agora vamos continuar analisando o código, vendo um tópico que causa muiita confusão e portanto deve ser clareado totalmente, que é a aritmética de ponteiros.
Nós já vimos na aula anterior que existem formas de fazer um ponteiro “correr” pela memória vendo seus conteúdos, somando e subtraindo elementos do ponteiro em questão. Para isso, usa-se a aritmética de ponteiros, que nada mais é que usarmos os operandos matemáticos mais simples (+, -, ++ e –) para que eles alterem a informação de que endereço deve ser apontado por um ponteiro.
Vamos analisar então como o programa irá usar a aritmética de ponteiros:

  operFib=sequenciaFib;

  *operFib=1;
  ++operFib;
  *operFib=1;
  ++operFib;

  for (i=0;i<<numeroFib-2;i++)
    {
      *operFib=*(operFib-1)+*(operFib-2);
      operFib++;
    }

O primeiro comando é simples: salvamos em operFib o endereço apontado por sequeciaFib. Perceba que ambos estão sem o operador de derreferenciamento (sim, o nome é confuso) *. Nesse caso, é o que queremos: aqui estamos atribundo o endereço apontado por sequenciaFib como o endereço a ser apontador operFib.
A pergunta que você deve estar se fazendo é: “por que usar dois ponteiros?“
Na realidade aqui é importante fazer uma consideração MUITO SÉRIA: o C NÃO POSSUI “LEMBRANÇA” do endereço apontado por um ponteiro. Ele trabalha sempre no “instante”, por assim dizer. Se você modificar o endereço de sequenciaFib, ele será usado em tudo o mais por esse novo valor, INCLUSIVE NA DESALOCAÇÃO. Isso pode gerar problemas sérios, pois o sistema operacional, no momento de alocar memória, também armazena a informação de quanta memória foi alocada, mas não a posição inicial-final. Se você “mover o ponteiro” e mandar desalocar a memória, você pode muito bem tentar desalocar memória de programas que não o seu, incluindo aí programas do sistema operacional. Desse modo, você pode comprometer o funcionamento do sistema como um todo ao fazer esse tipo de desalocação. Por via das dúvidas, é muito mais interessante fazer todas as operações por um segundo ponteiro, esse sim “livre” para ser usado à vontade e modificado como necessário. Você pode, obviamente, fazer o “movimento” do ponteiro usando sequenciaFib, se você souber como “recuar” o ponteiro de volta para o início de tudo, mas o nível de complexidade que isso vai gerar, em especial se você precisar modificar a memória alocada ou amarrá-la a outras coisas por meio de ponteiros de ponteiros (veremos esse tópico no futuro) vai mostrar que usar um ponteiro “âncora” representa um gasto de memória muito pequeno e o aumento de complexidade de código não compensará.
Bem, voltando ao nosso código: agora colocamos operFib como ponteiro para traabalharmos. Vamos ver o que ele irá fazer:

  *operFib=1;
  ++operFib;
  *operFib=1;
  ++operFib;

A primeira coisa que fazemos é: pegar os dois primeiros espaços de memória alocados para sequenciaFib (e que vamos alterar usando o ponteiro operFib) e definir eles como 1. Eles são os primeiros dois números de Fibonacci, segundo a definição do mesmo. O que fazemos é repetido então pode-se pensar bem. A primeira linha: *operFib=1, define que queremos armazenar na posição de memória apontada por operFib o valor 1. Aqui estamos tratando a memória apontada, portanto a derreferenciamos usando o operador *. Em seguida, a segunda linha, ++operFib, indica que queremos passar para o próximo elemento de operFib.
AQUI MORA DRAGÕES!!!
Pode parecer que simplesmente somamos 1 ao valor de operFib, como mostramos na outra aula sobre ponteiros. Mas já falamos lá que nesse caso, o C soma o equivalente ao número de bytes ocupados por 1 elemento do tipo apontado pelo ponteiro (no caso, unsigned long int). Normalmente, fazendo as coisas da maneira correta, nem precisamos nos preocupar com isso, mas é muito importante e explica, por exemplo, o porquê da exigência do typecast do ponteiro resultante do malloc de void * para o tipo necessário (além da óbvia mensagem de warning ou erro ao colocar-se um ponteiro void * em um ponteiro unsigned long int *). Com o devido typecast, o compilador, ao gerar o código, faz com que todas as abstrações sejam devidamente configuradas no nível do código de máquina. Sem isso, seria muito fácil o programador provocar erros e bugs devido ao apontamento incorreto de posições.
Dito isso, não há muito mais o que falar nesse momento.
O laço for que se segue, porém, é muito mais interessante:

  for (i=0;i<<numeroFib-2;i++)
    {
      *operFib=*(operFib-1)+*(operFib-2);
      operFib++;
    }

Vamos analisar ele: a primeira coisa é que a condição de saída é o número de elementos de nossa seqüência de Fibonacci-2. Fazemos isso pois os dois primeiros valores já foram estipulados.
Em seguida vem o comando que é mais interessante nesse laço:

      *operFib=*(operFib-1)+*(operFib-2);

Aqui, usando a aritmética de ponteiros, conseguimos declarar normalmente a função para o cálculo de um número de Fibonacci: o valor da posição apontada por operFib será a soma do valor na posição apontada pelo elemento anterior ao atual (*(operFib-1)) e pelo valor anterior a este (*(operFib-2)).
Como ler uma dessas seqüência. A primeira coisa é perceber que temos uma aritmética de ponteiro aí, que é pedir para retornar o endereço corresponte a operFib-1. Nesse caso, lembre-se de que é subtraído o número de bytes do tamanho do tipo indicado pelo ponteiro operFib. Por exemplo, imagine que operFib aponte no momento o endereço 1000 (no caso, para facilitar a compreensão, trate como decimal – normalmente os endereços são apresentados pelo C em Hexadecimal) e que o tamanho de um unsigned long int seja 64 bits (ou seja, 8 bytes). Ao pedirmos para obtermos o elemento anterior (operFib-1), ele irá nos apresentar o valor que está na posição de memória 1000-8, ou seja, na posição 992. Por sua vez, o elemento anterior a esse (operFib-2) estará na posição de memória 1000-16, ou seja, 984.
“Isso não afeta operFib?“, você deve estar se perguntando?
Na verdade não. Ao usarmos os operadores aritméticos na aritmética de ponteiros, seus comportamentos são similares aos dos mesmos na aritmética “convencional”, ou seja, quando fazemos contas. Isso é importante ressaltar pois os comportamentos dos operando ++ e — é similar, assim como os efeitos de pré e pós-fixação que vimos quando falamos sobre os operadores e lógica em C. Em especial, é importante que você tome muito cuidado com pré e pós-fixação na aritmética de ponteiros. Por exemplo, se eu usar: *(meuPonteiro++), ele me retornará o valor apontado por meuPonteiro no momento em que o comando é executado e logo em seguida irá executar a soma de uma posição de memória do tipo apontado pelo ponteiro. Porém, se eu usar *(++meuPonteiro), ele irá avançar uma posição de memória antes de efetuar a leitura da memória. Particularmente não uso esse tipo de construção pois pode gerar confusão. Na dúvida, não a use: prefira escrever um código mais claro e limpo. Quando ganhar experiência poderá escrever código mais avançado.
Bem, em seguida o program irá executar o comando operFib++;, que irá avançar uma posição de memória dentro dos valores apontados. Isso afetará a próxima interação, inclusive o cálculo acima mostrado, onde a posição operFib-1 representará a posição de operFib antes dessa soma, ou seja, o valor calculado nessa iteração.
Bem, isso mostra como iremos calcular a nossa seqüência de Fibonacci.
Em seguida temos o código que irá exibir nosso:
  operFib=sequenciaFib;

  for (i=0;<numeroFib;i++)
    {
      printf(“%do. numero Fibonacci e %u e esta armazenado no endereco %p\n”,i+1,*operFib,operFib);
      ++operFib;
    }
Primeira coisa que fazemos é “resetar” operFib, sobrescrevendo o endereço dele com o de sequenciaFib. Perceba que manipulamos o endereço, não o conteúdo do mesmo que continuará intacto.
Em seguida, um laço irá apresentar para nós o número Fibonacci recuperado de operFib, seu valor e o endereço onde ele está armazenado, adicionando uma posição de memória a cada vez que a iteração for for executada. A saída apresentada será algo como (para 12 números de Fibonacci):
1o. numero Fibonacci e 1 e esta armazenado no endereco 0x9a91008
2o. numero Fibonacci e 1 e esta armazenado no endereco 0x9a9100c
3o. numero Fibonacci e 2 e esta armazenado no endereco 0x9a91010
4o. numero Fibonacci e 3 e esta armazenado no endereco 0x9a91014
5o. numero Fibonacci e 5 e esta armazenado no endereco 0x9a91018
6o. numero Fibonacci e 8 e esta armazenado no endereco 0x9a9101c
7o. numero Fibonacci e 13 e esta armazenado no endereco 0x9a91020
8o. numero Fibonacci e 21 e esta armazenado no endereco 0x9a91024
9o. numero Fibonacci e 34 e esta armazenado no endereco 0x9a91028
10o. numero Fibonacci e 55 e esta armazenado no endereco 0x9a9102c
11o. numero Fibonacci e 89 e esta armazenado no endereco 0x9a91030
12o. numero Fibonacci e 144 e esta armazenado no endereco 0x9a91034
Aqui, perceba o endereço marcado em vermelho (ele variará na sua máquina conforme as execuções, e dificilmente será o mesmo que estou apresentando aqui). Note que ele vai subindo de 4 em 4 (c em Hexadecima representa o número 12). Isso deve-se ao fato de que na plataforma onde executei esse código, o tamanho de um unsigned long int é de 4 bytes (32 bits). Esse valor pode variar conforme a plataforma, mas o importante aqui é que ele vai almentando de 4 em 4 bytes, ou seja, a cada posição do tamanho de um unsigned long int, enfatizando o que dissemos anteriormente sobre o tamanho do tipo de dado na questão da aritmética de ponteiro. Se você lembrar do código e da saída do programa que fizemos ao começarmos a explorar ponteiros, você verá que lá ele subia de 1 em 1 byte, o tamanho de um char. Se você tivesse usando um tipo cujo tamanho fosse de 20 bytes, a aritmética de ponteiro aumentaria o valor da posição de memória de 20 em 20 bytes (imaginando que eles fossem cotiguos, ou seja, em seqüência, que é uma obrigatoriedade para o malloc funcionar corretamente).
Por fim, antes de terminar o programa, o mesmo libera a memória com o comando free. Embora não seja exatamente obrigatório (a maioria dos sistemas operacionais modernos desalocam completamente qualquer memória utilizada por um programa ao término de sua execução), é uma excelente prática ao sair do programa desalocar qualquer ponteiro que possa vir a estar alocado no momento do encerramento do programa. Na realidade, a melhor prática é desalocar qualquer memória alocada dinâmicamente tão logo o programa não mais precise dela, de modo a aproveitar melhor os recursos do computador. Tenha isso sempre em mente ao desenvolver com ponteiros.
Bem, aqui terminamos essa nossa aula. O próximo tópico ainda envolverá ponteiros: na realidade, ele irá mostrar as complexidades envolvendo ponteiros e funções, inclusive a técnica de ponteiros de função, muito usada em programação. Até lá, sugiro que brinque um pouco. Tente “remover” as limitações que impedem o ponteiro de “desgarrar” e veja as conseqüências (PS: não faça isso em produção. Vou repetir: NÃO FAÇA ISSO EM PRODUÇÃO. NEM PENSE EM FAZER ISSO EM PRODUÇÃO!!!). Analise os códigos aos poucos. Tente implementar outros algoritmos (por exemplo, o algoritmo de Fatorial).
Até a próxima, e lembre-se: os comentários estão abertos para dúvidas e sugestões!

Que irá deslocar o ponteiro palavra2 e mostrar em que lugar da memória cada um dos elementos de palavra2 está armazenado. Para isso, em ambos os caso, utilizamos o modificador de formato %p que faz com que o printf imprima na tela o local na memória onde o ponteiro está apontando, e não o seu valor.
Agora, uma coisa pode ficar confusa no printf dentro do loop: por que quando queremos mostrar o caracter, temos que usar o símbolo * e quando queremos mostrar o string e o endereço apontado não? Isso acontece porque, tanto o modificador %s quanto o %p esperam um endereço de memória, enquanto o modificador %c (para caracteres) espera um conteúdo “real” (no caso, um caracter). Basicamente essa é a diferença e é uma diferença importante em C: em muitos casos, o C espera conteúdos “reais”, discretos, como um número ou um caracter. Nos demais casos, normalmente se trabalhará com ponteiros. Não existem em C conceitos como “strings”, “filas” e “listas” como o de linguagens de maior nível, como PHP, Java ou Python. Na realidade, o C oferece mecanismos para criar-se e manipular-se esses tipos de dados, em especial por meio dos ponteiros, mas a linguagem em si não possui tratativa para tais estruturas de dados mais amplas. Veremos no futuro como criar algumas dessas estruturas de dados.
Vamos destrinchar um pouco mais esse while, pois ele nos oferece dicas interessantes e maiores informações sobre como lidar com ponteiros em geral e com uma string em C em particular. Primeiro, vamos ver a “condição de saída” do while:

  while (*palavra2)

Ou seja, enquanto o valor apontado por palavra2 (*palavra2) for considerado verdadeiro, o laço segue adiante. Agora, a pergunta que deve estar passando na cabeça é: “como ele vai saber se o valor apontado é verdadeiro?” Quem ficou atento ao que dissemos quando falamos sobre os operadores lógicos deve ter se lembrado de que falamos que para o C qualquer valor é verdadeiro, à exceção do número 0, do caracter terminador nulo \ 0 e do valor pré-definido null. Se lembrarmos como as strings são compostas em C, elas são seqüências de caracteres terminadas com o caracter terminador nulo \ 0. Portanto, uma vez que o deslocamento do ponteiro leve-o para o caracter terminador nulo, o valor do ponteiro será falso e o programa sairá do loop que criamos.
“Mas como fazemos o ponteiro avançar nos da string?“. Para isso, usamos um pouco de aritmética de ponteiro. No C, se usarmos os operandos aritméticos mais rudimentares + e -, além do incremento e decremento unitários ++ e –, podemos fazer o ponteiro avançar ou recuar, ou então indicar elementos adiante e anteriores à posição indicada pelo ponteiro. No nosso caso, utilizamos o incremento unitário:

      palavra2++;

No endereço em palavra2 (perceba a ausência do asterisco). Nesse caso, estamos indicando que queremos passar para o próximo elemento de palavra2. Quando o C executar essa operação, ele irá somar o equivalente ao número de bytes do tipo apontado por palavra2 ao valor de palavra2. Essa No nosso exemplo, não muda muita coisa, pois em quase todas as plataformas, um char tem o tamanho de 1 byte, mas esse é um conceito que é importante ficar claro: quando usamos operadores aritméticos para modificar o endereço apontado por um ponteiro, ele sempre trabalha somando ou subtraindo em bytes o número de elementos do mesmo tipo vezes o tamanho do tipo. Isso ficará mais claro no próximo post, quando iremos usar ponteiros para valores inteiros.
Isso nos dá como o programa funcionará conceitualmente, mas para melhor entendermos o que aconteceu, vamos analisar a saída do mesmo:

Analisando a saída do programa

OK, e como será a saída disso tudo?
O que iremos ter de saída do programa aparentará ser algo como a seguir:

O texto Hello World! esta armazenado no endereco 0xbffc5eb0
O caracter H da palavra Hello World! esta no endereco 0xbffc5eb0
O caracter e da palavra Hello World! esta no endereco 0xbffc5eb1
O caracter l da palavra Hello World! esta no endereco 0xbffc5eb2
O caracter l da palavra Hello World! esta no endereco 0xbffc5eb3
O caracter o da palavra Hello World! esta no endereco 0xbffc5eb4
O caracter   da palavra Hello World! esta no endereco 0xbffc5eb5
O caracter W da palavra Hello World! esta no endereco 0xbffc5eb6
O caracter o da palavra Hello World! esta no endereco 0xbffc5eb7
O caracter r da palavra Hello World! esta no endereco 0xbffc5eb8
O caracter l da palavra Hello World! esta no endereco 0xbffc5eb9
O caracter d da palavra Hello World! esta no endereco 0xbffc5eba
O caracter ! da palavra Hello World! esta no endereco 0xbffc5ebb

Os valores ao final de cada linha são os endereços onde estão armazenados os conteúdos em questão. Com certeze eles irão aparecer diferentes para você no momento em que você executar o programa, mas o importante é entendê-lo.
A primeira coisa é que todos os endereços são indicados no formato numérico de base 16, chamado hexadecimal. Essa é uma convenção antiga adotada no mundo da informática para indicar endereços de memória. Não importa para nós as posições em questão, pois esses valores poderão (e provavelmente irão) mudar de execução em execução.
Na primeira linha, é indicado o endereço da string “Hello World!”, pego pelo endereço do início da matriz que armazena o vetor de dados. Repare bem que o endereço de “Hello World!” e do caracter “H” são os mesmos, e depois o endereço onde ficam armazenados cara caracter aumenta de um em um byte (que é o tamanho do tipo char).
Como “brincadeira”, uma sugestão é tentar fazer com que a string seja “corrida” ao contrário. Isso pode ser feito utilizando o decremento unitário na aritmética de ponteiros e usando os endereços para comparar o momento em que o ponteiro palavra2 chegar no início da string palavra (lembre-se que deverá fazer comparações com o endereço armazenado em ambos os casos, e não com seus conteúdos). É algo mais difícil, e portanto ressalto que qualquer dúvida os comentários estão abertos para que elas sejam tiradas.
Bem, esse é apenas o início do caminho nos ponteiros em C. Na próxima “aula”, veremos mais sobre a aritmética de ponteiros e alocação dinâmica de memória, um tópico muito importante em C.
Até lá, bom estudo!

Bem, vamos começar com o primeiro tópico, que é o de protótipos. No caso, teremos um programa em cada tópico. Para o nosso tópico, usaremos o programa abaixo:

#include <stdio.h>

int soma(int a, int b);
int subtracao(int a, int b);
int multiplicacao(int a, int b);
int divisao(int a, int b);

void main(void)
{
  /**
   * No GCC, esse cabecalho para main retorna o seguinte warning:
   *
   * warning: return type of ‘main’ is not ‘int’
   */
  int val1=0, val2=0, opt=0, res=0;

  do
    {
      printf(“Digite um valor:”);
      scanf(“%d”,&val1);

      printf(“Digite outro valor:”);
      scanf(“%d”,&val2);

      printf(“Escolha a operação a ser realizada…\n\n”);
      printf(“1 – Soma\n”);
      printf(“2 – Subtracao\n”);
      printf(“3 – Multiplicacao\n”);
      printf(“4 – Divisao”);
      printf(“0 – Sair do Programa\n\nDigite os operadores e a operacao separados por espaco:”);

      scanf(“%d”,&opt);

     switch(opt)
      {
      case 1:
        res=soma(val1,val2);
        break;
      case 2:
        res=subtracao(val1,val2);
        break;
      case 3:
        res=multiplicacao(val1,val2);
        break;
      case 4:
        res=divisao(val1,val2);
        break;
      case 0:
        break;
      default:
        printf(“Opcao invalida\n”);
        continue;
      }
      if (opt!=0) printf (“O resultado da sua operacao para %d e %d e %d\n\n”,val1,val2,res);
    } while (opt!=0);

  /**
   * No GCC, a linha abaixo provoca o seguinte warning:
   *
   * warning: ‘return’ with a value, in function returning void
   */

  return(0);
}

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

int subtracao(int a, int b)
{
  return a-b;
}

int multiplicacao(int a, int b)
{
  return a*b;
}

int divisao(int a, int b)
{
  return a/b;
}

Agora, vamos a algo importante antes de entrarmos no nosso tópico. Olhe o código em verde:

    switch(opt)
    {
      case 1:
        res=soma(val1,val2);
        break;
      case 2:
        res=subtracao(val1,val2);
        break;
      case 3:
        res=multiplicacao(val1,val2);
        break;
      case 4:
        res=divisao(val1,val2);
        break;
      case 0:
        break;
      default:
        printf(“Opcao invalida\n”);
        continue;
    }

Esse comando de controle de fluxo, o switch, é muito usado como substituto para cadeias monstruosas de if…elseif…else, em especial quando existem códigos que serão usados em uma ou mais opções. O switch…case compara o valor da variável dada como entrada (no nosso caso, opt) com o valor inserido em cada uma das linhas case. Caso o valor da variável em questão seja igual ao valor de um dos case, o programa irá seguir a execução desse ponto até o final do bloco switch…case ou até encontrar um comando break, o que acontecer primeiro. No caso de nenhum dos case case com o valor da variável a ser comparada, nada será feito, a não ser que exista uma cláusula default estipulada no bloco. Nesse caso, o programa irá continuar a execução a partir desse ponto, valendo as mesmas regras para os demais case. No nosso caso, por exemplo, se opt for igual a 7, o default será executado e exibirá na tela Opcao Invalida, e retornará ao início do laço do…while. Caso, por exemplo, opt estivesse em 2, o resultado da função subtracao(val1,val2) seria associado à variavel res e em seguida o switch…case seria interrompido.
Bem, agora que falamos desse comando de controle de fluxo que “passou batido” até agora, vamos falar sobre o nosso tópico atual.
Como vimos na aula anterior, as funções devem, na teoria, vir antes de serem usadas por um programa. Na realidade, isso não é bem verdade. O que o compilador normalmente precisa é saber como trabalhar com uma função, ou seja, os valores que ele precisa passar para a mesma como parâmetros e o tipo de retorno da mesma. O código em si não precisa sequer ser descrito como parte do seu programa, podendo estar (o código em si) em qualquer outro lugar. (lembram das bibliotecas, como stdio.h, string.h e stdlib.h? Na realidade eles são úteis para o compilador saber como usar as funções que eles “representam”. Os códigos estão armazenados em outras bibliotecas e arquivos dentro do sistema operacional ou do compilador). Como exemplo, podemos pensar em um conector para celular. Cada celular usa um conector específico e, desde que o conector siga o tipo de conexão que o celular exige, pode ser usado conectores de quaisquer marcas (vide a quantidade de carregadores “genéricos” que existem por aí) e com qualquer tipo de entrada de energia (não importa se é de tomada ou de carro, por exemplo).
No C, chamamos esses “padrões” de protótipos de função. Um protótipo de função nada mais é que um informativo que o compilador usa para saber como “chamar” uma função. A idéia é que os protótipos representam a seqüência de parâmetros e o tipo de retorno das funções a serem usadas no nosso código. Lembram-se de quando falamos que existe a idéia de “caixa preta” no código? Os protótipos são o que permitem a existência dessa “caixa preta”: o que o programador e o compilador precisa saber é o que a função precisa de entrada e o que ela devolve como resultado. O programador não precisa como saber como a função foi construída (imaginando que não tenha sido ele que a construiu) e o compilador só precisa saber se as chamadas de função são “encaixáveis” corretamente ao código.
Quando o programa é compilado, as funções que não fazem parte do programa e que estão em biblotecas são “encaixadas” ao programa de várias formas em um passo chamado de linkedição (em alguns livros mais atuais, usa-se o termo ligação). Um binário sem ser linkeditado é chamado ocasionalmente de código-objeto e, embora não seja útil para ser executado, eles são muito úteis (veremos no futuro compilação de programas com múltiplos fontes), inclusive podendo conter funções que possam ser ligadas a posteriori a outros programas (nessa situação, o código-objeto é chamado também de biblioteca). Uma vez que o ou os programas-fontes sejam compilados e linkeditados, o binário executável está pronto.
Voltando ao assunto, é por meio dos protótipos que o compilador sabe como “encaixar” cada função nas partes onde as funções são chamadas (na realidade, são colocados endereços para onde o programa vai e segue a execução). Além disso, por meio dos protótipos que o compilador, até certo ponto, consegue “perceber” se o código está corretamente construído, pois ele tem todas as informações da entrada de dados (parâmetros) e da saída (retorno).
Para o protótipo da função, a construção é igual ao do nome da função no início da mesma (que alguns chamam de cabeçalhos), com a diferença do ; no fim do protótipo. Na realidade, para o protótipo, você não precisa colocar nenhum nome de variável. uma vez que nesse momento, o que ele precisa saber é quais os tipos de parâmetro a serem recebidos, e não seu nome. No caso, embora tenhamos usado:

int soma(int a, int b);

que seria tão útil quanto o protótipo que o colocamos. De qualquer forma, aconselho que mantenha as declarações com “nomes de variáveis” como uma boa prática, para aumentar a legibilidade sobre quais são os parâmetros a serem passadas.
Não existe o que falar mais: uma vez que o protótipo tenha sido colocado de alguma forma à disposição, o compilador pode buscar funções em qualquer lugar, seja dentro do código objeto equivalente ao fonte compilado, em um arquivo de biblioteca ou no próprio sistema operacional e “encaixá-las” ou “ligá-las” ao programa do usuário.
De resto, existe pouco o que falar desse programa, pois ele não tem mistérios quanto ao que cada função faz. Para as “brincadeiras”, sugerimos:

1. Tente remover os protótipos (comentando-os, por exemplo) e compilar os programas. Alguns compiladores irão dar alertas mas irão compilar o seu fonte, enquanto outros simplesmente se recusarão a compilar o fonte;
2. Para comprovar que o “nome de variável” no protótipo não faz diferença, modifique o “nome de variável” de alguma das funções no protótipo, mas não na função;
3. Para entender bem a idéia dos protótipos de função, uma boa forma é ler a documentação da biblioteca-padrão do C. Existem muitas funções interessantes nela, em especial em bibliotecas como stdlib.h, string.h, stdio.h, time.h e math.h. Nesse link você encontra a documentação completa das bibliotecas-padrão (em inglês). Procure ler com calma e tentar entender o que cada função faz. Obviamente você não compreendará tudo no presente momento, pois muitas funções lidam com conceitos avançados que ainda falaremos, mas com calma você verá algumas funções interessantes. Se possível, tente construir seus próprios programas e funções a partir dos códigos que mencionamos no momento;

Bem, com isso terminamos a parte de protótipos de função. Vamos a um tópico mais interessante: recursividade.

Recursividade – Chamando a si próprio:

Existem certos algoritmos (formas de descrever-se algo para um computador) que são mais facilmente representáveis quando eles usam de algum modo a si próprio. Dois exemplos clássicos são os cálculos de Fatorial e do número Fibonacci. Para relembrar, um número N fatorial (representado N!) é representado pela multiplicação de todos os inteiros até N (sendo que os fatoriais de 0 e 1 são definidos como 1). No caso, esse é o algoritmo que iremos ver em C, pois pe um exercício clássico de programação recursiva.

#include <stdio.h>

unsigned int fatorial (unsigned int a)
{
  if ((a==0) || (a==1))
    return 1;
  else
    return a*fatorial(a-1);
}

int main(void)
{
  unsigned int numeroFatorial=0;

  printf(“Digite o numero ao qual deseja-se obter fatorial (apenas positivos): “);
  scanf(“%d”, &numeroFatorial);
 
  printf(“%d! = %d\n”,numeroFatorial,fatorial(numeroFatorial));

  return(0);
}

Esse código é bem básico e tem pouco mistérios. O importante é atentar ao código da função fatorial:

unsigned int fatorial (unsigned int a)
{
  if ((a==0) || (a==1))
    return 1;
  else
    return a*fatorial(a-1);
}

A primeira coisa que ele define é que, caso o valor passado na execução da função seja 0 ou 1, o valor a ser devolvido pela execução é 1. Caso contrário, ele irá devolver o valor passado vezes o valor devolvido pela execução da mesma função com um valor igual ao valor passado-1.
Como funcionaria então, por exemplo, para o fatorial 5? Vejamos em um teste de mesa:

• main começa executando fatorial(5);
• Como 5 não é igual a 0 ou 1, ele deveria retornar 5*o resultado de fatorial(5-1), ou seja, fatorial(4). Como não sabe o valor de fatorial(4), ele executa fatorial(4);
• Como 4 também não é igual a 0 ou 1, ele deveria retornar 4*o resultado de fatorial(4-1), ou seja, fatorial(3). Como não sabe o valor de fatorial(3), ele executa fatorial(3);
• Como 3 também não é igual a 0 ou 1, ele deveria retornar 3*o resultado de fatorial(3-1), ou seja, fatorial(2). Como não sabe o valor de fatorial(2), ele executa fatorial(2);
• Como 2 também não é igual a 0 ou 1, ele deveria retornar 2*o resultado de fatorial(2-1), ou seja, fatorial(1). Como não sabe o valor de fatorial(1), ele executa fatorial(1);
• Como 1 é igual a 1, a função fatorial retorna 1;
• Agora ele volta para a execução de fatorial(2), pois obteve o valor de fatorial(1), que ele precisava. Ele faz 2*fatorial(1), ou seja, 2*1, retornando 2;
• Em seguida, retoma a execução de fatorial(3), pois obteve o valor de fatorial(2), que ele precisava. Ele faz 3*fatorial(2), ou seja, 3*2, retornando 6;
• Em seguida, retoma a execução de fatorial(4), pois obteve o valor de fatorial(3), que ele precisava. Ele faz 4*fatorial(3), ou seja, 4*6, retornando 24;
• Por fim, retoma a execução de fatorial(5), pois obteve o valor de fatorial(4), que ele precisava. Ele faz 5*fatorial(4), ou seja, 5*24, retornando 120 para main;

Atenção para a questão de:

  if ((a==0) || (a==1))
    return 1;

Todo algoritmo recursivo deve ter uma situação de “escape”, caso contrário provocará um loop infinito. No caso do fatorial, é o fato que os fatoriais de 0 e 1 são definidos por padrão como 1 (no link da Wikipedia mostrado anteriormente há uma explicação dos motivos desses valores serem pré-definidos). Somando-se isso e o fato de que a chamada recursiva é sempre equivalente ao valor da chamada atual-1, o resultado é que cedo ou tarde, o valor vai ser 0 ou 1 (valores negativos são negados já na tipagem unsigned int), ou seja, a “escada” de chamadas irá ser desfeita, com cada chamada devolvendo os valores esperados pela anterior. Caso isso não ocorra, haverá um loop “infinito” que se encerrará com um estouro de memória (uma vez que cada chamada de função armazena localmente valores e portanto precisa de espaço de memória).
Bem, não existe mais o que se falar sobre recursividade. Como “brincadeiras” quanto recursividade, sugiro:

1. Uma circunstância a ser levada em consideração ao se construir algoritmos com recursividade é sobre o uso dos operadores unários de incremento e decremento (++ e –). Para observar seu impacto, no return a*fatorial(a-1), tente substituir por return a*(a–) e verifique o que acontece. Lembre-se que os operadores unários de incremento e decremento atuam como operadores de incremento/decremento e atribuição;
2. Edite o código da chamada recursiva e elimine a “condição de escape” da recursão. Coloque algum código que permita você visualizar os valores recebidos a cada chamada recursiva e seus impactos e analise o resultado final;
3. Tente implementar o algoritmo para determinar-se um número Fibonacci. Lembrando que um número de Fibonacci equivale à soma de todos os números naturais antecessores a ele, predefinido que o 0° Fibonacci é 0 e o 1° Fibonacci é 1. Se você reparar bem, não é muito diferente do cálculo de um número Fatorial;

Com isso, acabamos o básico de Funções. Ainda existem tópicos a serem cobertos. Em especial, um tópico importante que estamos deixando para trás é o de tipos de passagem de parâmetro, um tópico importante que cobriremos quando falarmos de ponteiros, nosso próximo assunto.
Vamos ter algum tempo até começarmos o assunto de ponteiros. Enquanto isso, existem muitos sites e apostilas na internet com exercícios de programação em C que poderão ajudar você a fixar o conteúdo que vimos até agora. Enquanto a mim, vou ficar um tempo sem uma Internet de boa qualidade, mas prometo que, assim que voltar estarei postando o início do tópico de ponteiros, com a parte de matrizes, ponteiros e a correlação entre os dois. Esse será um tópico bastante complexo, mas que se lido com calma irá ser bem fixado.
Então, nos vemos em 2011, pessoal. Até lá, boas festas e muita programação C para todo mundo!

Agora, vamos pensar um pouco no programas que fizemos lá atrás, quando falamos de Entrada de Dados e Variáveis. Aquele foi um programa razoavelmente grande. Agora imagine que você crie um programa realmente complexo, que realize atividades similares em diversos pontos do mesmo. Se você escrever esse programa como criamos o programa de exemplo de Entrada de Dados e Variáveis, você teria um grande programa com vários pontos repetidos. Desse modo, caso precisasse alterar o modo como essas atividades similares seriam executadas, você teria que mexer em vários pontos similiares, o que mesmo o melhor dos programadores não conseguirá com facilidade e sem a possibilidade de provocar erros.
Por isso, o C (como toda boa linguagem de programação) prevê formas de dividir o programa em “pedaços” que executem a mesma tarefa. Chamamos esses pedaços de funções.
Na realidade, já usamos muitas funções até aqui. Todo comando que mostramos até agora, à exceção de palavras chaves como if ou do…while, são funções. A vantagem de dividir-se o programa em funções é que podemos isolar determinadas atividades nelas, o que permite:

1. Programas escritos de maneira mais legível;
2. Melhor manutenção do código, em especial em projetos complexos; você foca só no que está dando errado e uma vez que tudo esteja OK as melhorias se refletem apenas no que está dando errado;
3. Reutilização de código: por meio das funções podemos criar bibliotecas de funções (lembra do que falamos anteriormente sobre isso?) que englobem funções que usamos constantemente em um (ou mesmo em vários programas) e com isso reaproveitar esse código em muitos casos;

Claro que uma função deve ser criada para ser suficientemente genérica, mas feito isso ela pode ser aproveitada nos mais diversos momentos.
Bem, dito essa teoria, vamos ao nosso programa exemplo: um programa de médias escolares.

#include <stdio.h>

/**
* Essa função de média irá acrescentar os valores adicionados à média
* anterior e devolverá a média no momento
*/
float media(float nota)
{
   static float mediaAtual=0.0;
   mediaAtual=(mediaAtual==0)?nota:(mediaAtual+nota)/2;
   return mediaAtual;
}

int main(void)
{
    float nota=0.0;
    int notas=0;

    do
    {
        printf(“Digite a próxima nota ou -1 para sair:”);
        scanf(“%f”,&nota);

        if (nota!=-1)
        {
             notas++;
            printf(“Com essa nota, a média total é de %9.2f\n”,media(nota));
        }
    } while (nota!=-1);

    return 0;
}

Na parte do main() fica a ressalva de que mudamos um pouco o início: de int main (int argc, char** argv), estamos usando int main(void). Como dissemos no Hello World, essa construção (sobre a qual aproveitaremos para falar a seguir) pode ser mudada, embora o compilador possa gerar um aviso de que você está fugindo do padrão do C. No nosso caso, colocamos void nos parâmetros para indicar que não receberemos parâmetros (void é uma palavra reservada do C que indica algo “vazio” – veremos mais sobre isso adiante), ou melhor, que não utilizaremos parâmetros que sejam passados. De resto, o nosso main() engloba coisas que já vimos nas últimas semanas e que você deve estar afiado caso tenha seguido as sugestões que fizemos para mexer no código e compreendido o que fizemos até agora. Na verdade, tem algo que iremos falar, mas apenas depois que vermos nossa função:

float media(float nota)
{
   static float mediaAtual=0.0;
   mediaAtual=(mediaAtual==0)?nota:(mediaAtual+nota)/2;
   return mediaAtual;
}

Já falamos anteriormente sobre o conceito de blocos de código. Basicamente, um bloco de código é uma parte do programa que é isolada logicamente e considerada como um comando único. Para “isolar-se” um bloco de código em C, usa-se as chaves ({}). De maneira “rápida e suja”, podemos definir uma função como um “bloco de código com nome”. Na realidade, uma função pode estar em um outro ponto do programa ou até mesmo em um arquivo totalmente isolado. A única regra para uma função é que ela tem que vir de alguma forma “antes” de qualquer ponto do programa onde ele seja usado (na próxima semana, quando encerrarmos o assunto Funções, veremos que não é bem assim e existem técnicas simples que permitem ao programador colocar sua função onde deseejar).
Uma função na realidade é caracterizada por realizar alguma tarefa e retornar algum valor. Para facilitar a vida do programador e desobrigá-lo de saber o que a função realmente faz, toda linguagem de programação parte do princípio de que uma função é uma “caixa preta”: você coloca determinados parâmetros na entrada da mesma, ele realiza algum processamento (que o programador não precisa realmente saber do que se trata) e devolve ao usuário alguma saída. Porém, embora seja uma “caixa preta”, é sempre necessário a uma função indicar o que ela espera receber de parâmetros para trabalhar e o que o usuário irá receber de volta. No C isso é feito no momento em que se nomeia a função.
Como dissemos acima, podemos pensar em uma função como um “bloco de código com nome”. Em C, chamamos o “nome da função” de protótipo ou assinatura (esse último é mais usado em documentos focando C++ e tem a ver com certas propriedades da mesma). O protótipo de uma função costuma seguir o formato:

Onde:

• retorno indica o tipo de varíavel que a função retorna. Esse tipo pode ser qualquer tipo básico do C, ponteiros (veremos isso quando entrarmos nesse assunto) ou void: void pode ser entendido como um nulo, ou seja, quando C executar uma função cujo retorno seja void ele não deve esperar nenhum retorno do mesmo (na realidade, alguns compiladores costumam provocar erros de compilação);
• nome é o nome pelo qual a função é chamada. Os nomes de função seguem as mesmas regras que vimos quanto aos nomes de variável que vimos quando falamos de Entrada de Dados e Variáveis.  Além disso, não podem ter o mesmo nome de funções que tenham sido importadas por meio de #includes. Uma coisa: mesmo para as funções da biblioteca padrão vale a mesma regra. Por exemplo: se eu não importar a stdio.h, posso incluir minha própria versão de printf sem problemas. Veremos o motivo disso adiante;
• Dentro dos parênteses incluímos uma série de indicações sobre os parâmetros da função, tipoPar1 par1[=init1],tipoPar2 par2[=init2],…,tipoParN parN[=initN]. Elas são distrinchadas assim: tipoPar é o tipo da variável em questão, que pode ser de qualquer tipo básico do C, tipos do usuário ou ponteiros (veremos os dois últimos no futuro). A ele pode ser agregado um modificador const, que indica que, não importa o que aconteça, esse valor não deve ser modificado (esse modificador só é útil quando usamos ponteiros – explicaremos o porque quando alcançarmos esse tópico); par é o nome do parâmetro. Opcionalmente, você tem init, que permite que você defina um valor default para inicialização, que será colocado caso esse parâmetro não seja passado (isso é feito ao deixar o espaço desse parâmetro vazio, sem nenhuma váriavel ou valor, mesmo null – para o compilador, passar null é passar um valor, ainda que nulo).
• Uma ressalva sobre parâmetros: se você não esperar nenhum parâmetro em uma função, é uma boa prática inserir void dentro dos parênteses, ainda que parênteses em branco (()) seja igualmente suficiente para indicar uma função sem parâmetros. Essa boa prática ajuda na leitura do que a função faz e em muitas documentações você verá ela sendo adotada;

Bom, após vermos como é nomeada uma função, vamos ver o nome de nossa função e destrinchá-la:

Na nossa última “aula”, vimos um pouco sobre os operadores, em especial operadores matemáticos, lógicos e relacionais. Mas na verdade o C é composto por uma enorme gama de operadores, capazes de realizar muitas atividades. Aprender bem como usar operadores é algo importantíssimo para construir bons programas em C. Portanto, vamos dar uma pausa e reforçar essa teoria antes de seguirmos em frente.
A primeira coisa a entender é que temos vários tipos de operadores em C, que podemos dividir  em “grupos” para facilitar a compreenção:

• Operadores de atribuição – são operadores usados para atribuir-se valores a variáveis;
• Operadores aritméticos – com ele realizamos operações matemáticas simples usando dois valores, os operandos;
• Operadores relacionais – comparam os valores de dois operandos, verificando se eles representam verdades ou falsidades lógicas naquele momento;
• Operadores lógicos – comparam os valores de dois operandos em termos lógicos, ou seja, comparações baseadas na lógica booleana (E, OU e NÃO);
• Operadores de bits – Permitem realizar operações diretamente nos bits de um determinado valor (em geral, inteiro);
• Operadores compostos – são operadores complexos que podem combinar as funções de dois operadores do tipos acima;
• Operadores especiais -são operadores usados no desenvolvimento da aplicação;

Além disso, existe uma ordem de prioridade dos operadores que iremos mostrar no final desse post. Você não precisa decorar essa tabela: você pode utilizar esse post como referência ou então facilmente pegar uma “cola” dessa tabela na Internet em vários sites de referência.
Bem, vamos começar então com o Operador de Atribuição.

Operador de atribuição – =

O operador de atribuição = serve para indicar ao C que desejamos armazenar (ou atribuir) a uma determinada variável um valor. Já vimos nos programas anteriores vários exemplos de atribuições, em especial quando inicializamos variáveis como fizemos no programa de Entrada de Dados. Uma coisa, porém, que é importante dizer é que o C permite fazer-se múltiplas atribuições, desde que os tipos sejam compatíveis. Por exemplo, o trecho de código abaixo:

int a,c;
float b,d;
a = b = c = d = 0;

É válido, uma vez que b e d, ainda que sejam do tipo float, podem receber valores inteiros (por causa do autocast – lembra que vimos quando mostramos o programa de Entrada de Dados?). Basicamente, esse comando faz a seguinte salada na atribuição:

• Atribui 0 a d – como d é float, dá o autocast do 0 (que nesse caso é tratado como inteiro) para float;
• Em seguida, atribui a c o valor de d – d está inicializado como 0.0 (0 no tipo float). Ao receber o valor para c, o sistema faz o autocast do valor, truncando-o para 0 (inteiro);
• Após isso, atribui a b o valor de c – repete-se o caso da atribuição para d;
• E por fim, atribui a a o valor de b – repetindo o que aconteceu quando atribui-se a c o valor de d;

Importante notar que os autocasts são sempre executados no momento da atribuição do valor a uma variável. Por isso que, se dividimos dois inteiros e precisamos de um valor float, mesmo atribuindo o resultado, precisamos forçar o cast de um dos inteiros para float antes: se usarmos a divisão normalmente, ele irá tratá-la como divisão entre dois inteiros e dará um resultado inteiro, que será convertido depois da operação em float. Ao forçar um deles como float, indicamos que precisamos de um resultado em ponto flutuante e, dando o autocast no outro operando, o programa realizará uma divisão em ponto flutuante e retornará um valor float.
Aproveitando que entramos no assunto typecast, existe uma prioridade nos autocasts: isso é feito com o objetivo de impedir que os resultados percam valor (por exemplo, ao converter-se um valor de um tipo para um outro tipo cujo tamanho seja menor em bits e, portanto, capaz de representar uma gama inferior de valores). Tenha isso em mente ao recorrer ao autocast: prefira, se possível, fazer você mesmo o typecast, pois isso irá garantir que você sabe qual será o tipo resultante.
Dito isso, vamos para o próximo conjunto de operadores.

Operadores aritméticos

Já falamos sobre eles antes: são operadores que realizam contas matemáticas simples entre dois operandos (valores), “devolvendo” um deles como valor da expressão aritmética (em C, uma expressão aritmética tem o mesmo significado que na matemática, e o termo expressão é extrapolado a partir daí como a representação de uma operação lógico-matemática que será resolvida em um determinado momento). Esse valor pode ser usado em uma atribuição ou em qualquer lugar onde exija-se um valor. Isso é interessante pois pode-se executar operações matemáticas, por exemplo, antes de operações lógicas, obviamente respeitando as prioridades determinadas pelo C (veremos abaixo as prioridades e como alterar a ordem de execução das operações).
Basicamente, as operações matemáticas são:

Operador * / % - +

Operação Multiplicação Divisão Resto da Divisão Inteira (mod) Subtração Soma

Prioridade 1 1 1 2 2

Além disso, vamos reenfatizar outra coisa: nunca confunda o operador relacional de igualdade (==) com o de atribuição (=). Isso irá provocar erros de lógica de aplicação que são de difícil depuração.
Pois bem, esses três primeiros tópicos, falando de operadores de atribuição, aritméticos e relacionais são apenas uma revisão do que vimos anteriormente. A partir de agora iremos ver operadores que vimos por alto ou não vimos anteriormente, a começar pelos…

Operadores lógicos são basicamente operadores que realizam comparações. De certa forma, são um subgrupo dos operadores relacionais, mas que trabalham apenas com valores segundo a lógica booleana. De uma forma rápida, podemos dizer que eles podem comparar se dois valores são verdadeiros ao mesmo tempo (E/AND), se pelo menos um entre dois valores pode ser considerado verdadeiro (OU/OR) e se um determinado valor é falso naquele momento (NÃO/NOT). A vantagem de usar-se operadores lógicos é que, combinando-os com os operadores relacionais, podemos construir condições complexas, em especial em situações de controle de fluxo. Por exemplo, vamos relembrar um trecho de código de nossa última “aula”:
      do
        {
          printf(“Quantas tentativas você acha que precisa para descobrir ele? “);
          scanf(“%d”,&maximoTentativas);

          if (maximoTentativas<1)
             printf(“Você precisa tentar ao menos uma vez! \n”);
          if (maximoTentativas>limiteTentativas)
             printf(“%d tentativas? Tá querendo demais também! \n”,maximoTentativas);
        } while (maximoTentativas<1 || maximoTentativas>limiteTentativas);

Relembrando: o do…while executa enquanto a condição indicada no final do bloco de código for considerada verdadeira. No caso, nossa intenção foi garantir que o usuário não entrasse com nenhum número negativo e nem fosse além de um limite de tentativas estipulado previamente. Para isso, utilizamos duas condições relacionais (maximoTentativas<1 e maximoTentativas>limiteTentativas), cada uma atuando em uma das situações que determinamos. Para “unirmos” as duas situações, usamos o operador lógico OU (|| em C) que indica que, enquanto pelo menos uma dessas condições relacionais for verdadeira, a condição lógica será verdadeira e, portanto, o programa permanecerá executando esse bloco de código.
C implementa os principais operadores relacionais, que são o E (AND), OU (OR), e NÃO (NOT), conforme representado abaixo:

Operador ! && ||

Operação NÃO Lógico E Lógico OU Lógico

Prioridade 1 2 3

O programa abaixo, também retirado do material do Curso de C da UFMG poderá ilustrar melhor o comportamento de E, OU e NÃO:

#include <stdio.h> <br />int main()<br />{<br />   int i, j;<br />   printf("informe dois números(cada um sendo 0 ou 1): ");<br />   scanf("%d%d", &i, &j);<br />   printf("%d AND %d é %d\n", i, j, i && j);<br />   printf("%d OR %d é %d\n", i, j, i || j);<br />   printf("NOT %d é %d\n", i, !i);<br />}<br />

Na verdade, com o tempo esse conceito ficará bem arraigado na cabeça. Então vamos para os próximos operadores.
Antes, um parênteses: em vários momentos, e em especial quando falamos dos tipos de dados em C, mencionamos que em C, as strings de caracteres possuem um comportamento diferenciado em relação ao que vemos em outras linguagens de programação. Por isso, você NÃO DEVE utilizar os operadores lógicos e relacionais apresentados anteriormente com strings. Isso irá provocar certamente resultados espúrios. Para comparações envolvendo strings, a biblioteca padrão string.h oferece uma série de funções úteis, sobre as quais falaremos no futuro.

Operadores de bit (bitwise)

O C oferece um conjunto de operadores lógicos voltados exclusivamente para o “acesso direto” aos bits. Mais exatamente, para realizar operações lógicas com bits. Chamamos esses operadores de operadores de bit, bit-a-bit ou bitwise, dependendo do autor do livro.
C foi uma linguagem originalmente projetada para facilitar o desenvolvimento de aplicações em baixo nível, como sistemas operacionais, firmware (software de baixo nível para dispositivos eletrônicos, como celulares e players de DVD), compiladores, com o objetivo de substituir o Assembler e oferecer um mínimo de portabilidade de código, ainda que mantendo os benefícios do Assembler de acesso direto ao hardware. Como o software de um appliance, o firmware, se comunica com o hardware por pulsos eletrônicos interpretados pela CPU como bits 0s e 1s específicos em determinados locais de memória, é interessante que C possua comandos capazes de trabalhar com esses bits, que chamamos em programação de flags. Para isso, utiliza-se os operadores de bit.
Os operadores de bit lembram um pouco os operadores aritméticos e um pouco os operadores lógicos, pois eles irão realizar a operação lógica em cada bit de um determinado número, usando outro, e retornando um terceiro. Por exemplo, imaginemos que precisamos obter de um conjunto de flags (normalmente representados por um int) se o 5° bit dessa conjunto de flags está ativo. Uma forma é aplicar o bitwise AND (E bit-a-bit) contra o número 8 (representado 00001000). Esse valor (que alguns autores chamam de bitmask – máscara de bits) atua de tal forma que zera todos os outros bits do int em questão: lembrando que ambos os bit tem que ser 1 – verdadeiro – para que o bit na saída seja 1. Como os demais bits no bitmask são 0, o valor de tais bits é zerado. Se o bit na flag estiver zerado, o resultado será 0, caso contrário o valor de saída será 8.
Existem também operadores de movimentação de bits: algumas operações matemáticas e lógicas são resolvidas facilmente quando utilizamos essa movimentação de bits, “empurrando” os bits à esquerda ou direita, com isso aumentando e diminuindo seus valores. Como exemplo: uma forma “rápida e suja” de fazer-se a potência de 2 em um número é “empurrando” seus bits uma casa para a direita. Como em numeração binária um bit é sempre uma potência de 2 acima do bit à direita ao seu, ao empurrar-se os bits à direita temos o efeito da potência de 2. (PS: esse método não faz as checagens matemáticas de casos especiais como potências de 0 e 1 e nem verificam estouros do tamanho de variável). Ao empurrar-se os bits, o último bit na direção para a qual os bits foram “empurrados” é eliminado e o primeiro bit da direção oposta é preenchido com 0.
Os operadores de bit são:

Operador ! << >> & ^ |

Operação NÃO por bit a bit Deslocamento de bits à esquerda Deslocamento de bits à direita E bit a bit OU Exclusivo (um e apena um bit) OU bit a bit

Prioridade 1 2 2 3 4 5

Uma coisa a salientar de diferente entre os operadores bit-a-bit e os operadores lógicos é a existência do OU-Exclusivo (eXclusive OR, XOR) bit-a-bit. Nessa situação, ao comparar-se os dois números bit a bit, um bit na saída só será um se UM E APENAS UM dos bits comparados for 1. Caso contrário (ambos 0 ou ambos 1) o bit será zero.
Bem, esse é um tema complexo e pouco útil para nós. Vamos falar agora de…

Operadores Compostos

Operadores Compostos englobam operadores que atuam ao mesmo tempo como dois tipos diferentes de operadores, em geral uma operação bit-a-bit ou aritmética e uma atribuição. Além desses, existe o operador de atribuição condicional ?.
Vamos englobar em três subgrupos os operadores compostos: os de atribuição “aditiva”, os de incremento e decremento em um e o de atribuição condicional.
Os de atribuição “aditiva” são operadores que realizam uma determinada operação envolvendo um parâmetro com uma variável e atribuem à mesma variável o resultado da operação. Por exemplo, a expressão a+=4 é equivalente em termos de programação a a=a+4. Esses operadores existem para ambientes onde o espaço para a leitura do código fonte é pequeno e determinadas redundâncias de digitação comprometeriam a compilação. Alguns autores consideram que o uso desse tipo de operador torna o programa mais legível, enquanto outros defendem que esse tipo de operador provoca a ofuscação do código (ou seja, torna a leitura do código complexa). A lista dos operandos compostos segue abaixo:

Operador /= *= %= += -= << >> & ^ |

Operação Divisão com atribuição Multiplicação com atribuição Resto da divisão inteira com atribuição Soma com atribuição Subtração com atribuição Deslocamento de bits à esquerda com atribuição Deslocamento de bits à direita com atribuição E bit a bit com atribuição OU Exclusivo (um e apena um bit) com atribuição OU bit a bit com atribuição

Prioridade 1 1 1 2 2 3 3 4 4 4

Esse é um subtipo complexo, e o próximo também demanda atenção, que são os operadores de incremento e decremento em um. Na verdade, esses operadores são indicados por ++ e – e indicam que a variável onde eles estão sendo usados terá seu valor somado ou subtraído em 1. Porém, existe um comportamento que deve ser levado em conta ao usar-se tais operadores, que é o de prefixação e pós-fixação. Para usar-se os operadores desse tipo, você pode colocar o operador antes ou depois da varíavel. A posição onde o colocar, porém, irá afetar o comportamento sobre qual será o valor realmente usado.
Ao prefixar o operador antes da variável (ou seja, colocar ++ ou – antes da variável), o valor será modificando antes de qualquer uso. Por exemplo, se você usar a=++b, e b for 4, acontecerá o seguinte: (1) b será incrementada em 1, para 5 e (2) a receberá o novo valor de b, 5. Ao pós-fixar o operador, acontecerá o contrário: o valor será usada para qualquer outro fim antes de ser modificado. Mantendo o exemplo anterior, imagine que você, ao invés de usar a=++b, utilizou a=b++. Nesse caso (1) a receberá o valor atual de b, 4 e depois é que (2) b será incrementado em 1. Essa diferença é importante de ter-se em mente, pois ela pode provocar bugs (em especial quando utiliza-se esse operador em conjutnto com comparações relacionais), mas é uma ferramenta muito poderosa.
Por exemplo: nas “brincadeiras” da nossa última “aula” sugeri:

• Da mesma forma que existe o operador ++, existe o operador –, que subtrai um da variável que o antecede. Considerando isso e o funcionamento do laço for, tente reconstruir o laço para não ter uma condição no sentido exato da palavra. Dica: lembre-se que C trata 0 como falso;

A forma para fazer isso é lembrar que o for, na comparação, exige um “booleano” verdadeiro (ou seja, qualquer valor diferente de 0). Portanto, se usarmos o operador de decremento em 1 pós-fixado, podemos fazer com que o número de tentativas vá se reduzindo até que, na última tentativa, ele chegue na condição em 0 e, sendo “falso”, saia do laço. Portanto, basta substituir a linha:

for (i=1; i<=maximoTentativas;i++)

no programa da nossa última “aula” por:

Mas, ATENÇÃO: isso só funcionará bem se você usar o decremento pós-fixado. Se tentar prefixar o decremento, ele irá, na prática, tirar uma tentativa do usuário, ao ponto de, se o usuário pedir apenas uma tentativa o sistema nem pedir o número: no caso, ele irá subtrair 1 de maximoTentativas (que será 1), reduzindo-o para 0 e tornando a condição “falsa”.
Bem, aqui podemos dizer que terminamos de falar do incremento e decremento de um. Vamos falar, para acabar com os atributos compostos, da atribuição condicional.
Chamamos de atribuição condicional um operador que funciona como o seguinte tipo de lógica:

if (condicao)
   var=x;
else
   var=y;

O C oferece um operador que permite-nos fazer esse tipo de condição diretamente na atribuição, o operador ?. Esse é um operador ternário (ou seja, exige três operandos), sendo composto por <condicao>?<atr_verdadeiro>:<atr_falso>. Nesse caso, caso condicao seja verdadeira (diferente de 0), o operador irá devolver atr_verdadeiro, enquanto que, caso condicao seja falsa (igual a zero), ele irá devolver o valor de atr_falso. Por exemplo, imagine que você irá precisa do módulo de um número, ou seja, do valor sem sinal do mesmo. Ao invés de construir um if só para isso, você pode usar uma atribuição condicional:

modulo=(numero<0)?numero*-1:numero;

O que quer dizer que modulo irá receber o valor de numero vezes -1 caso numero seja menor que 0; caso contrário, ele irá receber o valor normal de numero.

Os dois primeiros programas, Hello World e o de Entrada de Dados, tinham como ponto comum o fato de serem, vamos dizer assim, diretos. Eles eram executados, realizavam cada instrução em sequencia e se encerravam.
Isso em si não é ruim: muitos programas simples e interessantes podem ser feitos assim. Porém, é perceptível que eles não possuem nenhuma “inteligência”: eles não conseguem executar instruções dependendo das entradas que lhe são oferecidas. Isso se deve ao fato de eles não possuírem nenhum controle de fluxo. Em programação, esse termo é adotado para definir situações onde o programa pode mudar a sequencia de execução do programa conforme condições estipuladas no momento do desenvolvimento da aplicação. Por exemplo: no programa de Entrada de Dados, poderíamos estipular valores limite para primeiro e segundo que não os limites do tipo int.
Pois bem, veremos agora um programa com um pouco mais de “inteligência”, pois iremos falar mais sobre os comandos de controle de fluxo em C e sobre os operadores lógicos, além de questões sobre o tipo booleano (ou melhor, sobre a ausência de um tipo booleano) em C.
No caso, vamos escrever um outro programa comum, o “adivinhe o número”. Mas vamos adicionar alguma “inteligência” a ele e tornar ele um pouco mais desafiador:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* Definindo o número limite para a pessoa tentar descobrir */

#define LIMITE 10
#define ENCERRA printf(“Pressione qualquer tecla para continuar!\n”); while(!getchar());

int main (int argc, char** argv)
{
  const int limiteTentativas=(LIMITE/2)-1;
  int numeroPensado=0, numeroDoUsuario=0, maximoTentativas=0,i;
 
  srand(time(NULL)); // Serve para modificar a tabela de números pseudo-aleatórios
  numeroPensado=rand()%LIMITE+1;

  printf(“OK! Pensei em um número entre 1 e %d e te desafio a achar ele!\n”, LIMITE);
  do
    {
      printf(“Quantas tentativas você acha que precisa para descobrir ele? “);
      scanf(“%d”,&maximoTentativas);

      if (maximoTentativas<1)
         printf(“Você precisa tentar ao menos uma vez! \n”);
      if (maximoTentativas>limiteTentativas)
         printf(“%d tentativas? Tá querendo demais também! \n”,maximoTentativas);
    } while (maximoTentativas<1 || maximoTentativas>limiteTentativas);

  for (i=1; i<=maximoTentativas;i++)
    {
      printf(“Vamos lá! %da. tentativa! “,i);
     
      scanf(“%d”,&numeroDoUsuario);

      if (numeroDoUsuario==numeroPensado)
      {
         printf(“Parabéns! Você acertou!\n”);
         ENCERRA
         return(0);
      }
         else
         {
           printf(“Não pensei em %d. “, numeroDoUsuario);
           if (numeroDoUsuario<numeroPensado)
              printf(“Pensei em um número maior.\n”);
           if (numeroDoUsuario>numeroPensado)
              printf(“Pensei em um número menor.\n”);
         }
    }

    printf(“Que pena! Eu pensei em %d! Melhor sorte da próxima vez! \n”,numeroPensado);
    ENCERRA
    return(0);
}

Como de costume, iremos ignorar algumas coisas que já vimos anteriormente. Portanto, se você ficar com alguma dúvida, dê uma relida nos posts anteriores para fixar bem o conteúdo que já lidamos. No caso, vamos falar sobre os trechos de código que estão com destaque colorido no fonte àcima.

#define e os “números mágicos”

Logo de cara incluímos duas novas bibliotecas em C: stdlib.h – STanDard Library (biblioteca padrão), que contêm uma série de funções cotidianas em C – e time.h, que contem funções para lidar com tempo. Dessas, a stdlib.h em especial é muito importante, pois uma grande quantidade de comandos C muito usados está incluída nela. No caso, estamos muito interessados nas funções relacionadas à geração de números randômicos, mas existe muito mais nela e no futuro falaremos muito sobre essa biblioteca.
Logo após, vemos dois novos comandos do pré-processador (ou macros, como são chamados tecnicamente):

#define LIMITE 10
#define ENCERRA printf(“Pressione qualquer tecla para continuar!\n”); while(!getchar());

A macro #define permite ao programador definir um símbolo que o pré-processador irá substituir por uma informação qualquer no momento da compilação. No caso, definimos dois símbolos:

• LIMITE – um número com valor 10;
• ENCERRA – uma sequencia de comandos C;

No caso, você pode se perguntar sobre a utilidade de definir-se símbolos. Esse sistema de símbolos permite:

1. Criar “comandos” simples (caso do ENCERRA);
2. Criar situações de compilação condicional (um tópico mais avançado, veremos no futuro);
3. Evitar os chamados “números mágicos”;

“Números mágicos?! Virou Hogwarts agora?”
Na verdade não. Em programação, chamamos de números mágicos determinados números ou expressões que são colocadas no código para realizar determinadas funções. No nosso caso, precisamos limitar o maior número no qual nosso programa irá “pensar”. Poderíamos simplesmente escrever ele no nosso programa de maneira direta, mas como esse número iria se repetir várias vezes em vários trechos de código aparentemente sem relação um com o outro, com certeza a leitura e análise de erros do programa (que em programação é chamada de depuração) seria complicada. Por isso chamamos tais números de números mágicos: uma vez que ele entra, temos dificuldades para entender o que eles fazem.
No caso, ao criarmos um símbolo (LIMITE), podemos usar ele no nosso código que o próprio compilador (através do pré-processador) irá substituir todas as entradas do símbolo LIMITE pelo valor desejado (no caso, 10). Isso torna o programa mais legível e mais simples de ser modificado.
O mesmo vale para ENCERRA. Com ENCERRA, criamos um “pseudo-comando”, um símbolo que será substituído por uma série de comandos C. No caso, o comando escrito em ENCERRA ajuda alguns usuários de IDEs (em especial no Windows) a visualizarem os resultados dos seus programas.
Existe mais sobre #define que ainda iremos ver, em especial na questão dos “pseudo-comandos”, mas esse básico deve ajudar a compreender melhor as coisas até termos uma oportunidade de nos aprofundarmos nele (em especial, quando falarmos no futuro de outras macros de pré-processador, quando revisitaremos #include e #define).

Variáveis Constantes:

Após as macros temos uma declaração de variáveis: logo de cara, temos uma que é um pouco diferente do que o que vimos quando falamos dos tipos de variáveis e como as declaramos:

  const int limiteTentativas=(LIMITE/2)-1;

A principal diferença está na palavra reservada const antes da declaração do tipo int da variável limiteTentativas. O que essa palavra faz é indicar ao compilador que essa variável na verdade é uma constante do tipo desejado, portanto não poderá mais ser modificada uma vez que seja inicializada, o que acontece em seguida. No caso, a variável constante limiteTentativas tem seu valor inicializado com o resultado de (LIMITE/2)-1, ou seja, na divisão do valor do nosso símbolo LIMITE por 2, menos 1 (no caso atual, o valor final é 4).
Você deve estar se perguntando: “usar um símbolo com #define não seria mais interessante?”
Bem, nesse caso não. Perceba que o limite de tentativas é determinado baseando-se no valor de LIMITE, e o #define não realiza per se contas ou qualquer processamento: tudo o que ele faz é dizer que (1) existe um símbolo e (2) qual seu valor. Se modificarmos o valor de LIMITE, teríamos que modificar o valor desse novo #define manualmente.
Você pode pensar então: “por que não tornar a fórmula um símbolo via #define?”. A ideia parece boa, mas ela cai em um problema: quando você substituir o símbolo, você obrigaria o sistema a repetir várias vezes uma determinada conta. Podemos pensar em desktops com gigas de poder de processamento e isso aparentemente ser uma boa ideia, mas pense em um sistema embarcado e você verá que uma situação como essa iria provocar redução na velocidade do programa.
Já com a variável constante, temos uma situação onde a variável não poderá ser modificada mas ainda assim será calculada apenas uma vez, apenas exigindo uma recompilação no caso de uma mudança de LIMITE (o que iria acontecer de qualquer maneira), pois ao compilar, LIMITE seria substituído pelo seu valor.
“Eu tenho que OBRIGATORIAMENTE inicializar uma variável constante no momento em que a declaro?”, você deve estar se perguntando. Na realidade, da mesma forma que ocorre com as variáveis comuns, as variáveis constantes PODEM ser inicializadas após a declaração. O que é impedido é que uma variável constante receba OUTROS VALORES após a inicialização. Como constantes são normalmente usadas para delimitar de alguma forma o comportamento do programa (no nosso caso, utilizaremos limiteTentativas para delimitar o máximo de tentativas que uma pessoa terá de adivinhar o número “pensado” pelo computador), é uma boa prática inicializá-la antes de qualquer entrada de dados.
Bem, acho que fechamos aqui a questão das variáveis constantes, à exceção de uma coisa: por que logo abaixo vem uma segunda linha de declarações int?
Quando você coloca várias declarações e/ou inicializações de variáveis em uma mesma linha, o compilador irá entender que todas elas tem o mesmo comportamento. Se colocássemos as int em questão junto com a declaração const int de limiteTentativas, essas variáveis também seriam declaradas constantes, o que não é o comportamento desejado. Nesse caso, a regra é clara: declarações de constantes devem ser separadas das declarações de variáveis comuns.
Bem, agora que vimos o bastante sobre constantes para entendermos o programa, sigamos em frente.

rand(), srand() e o gerador de números pseudo-aleatórios:

Vamos dar uma olhada nesse bloco de código:

srand(time(NULL)); // Serve para modificar a tabela de números pseudo-aleatórios
numeroPensado=rand()%LIMITE+1;

A primeira linha utiliza duas funções: a primeira é srand(), da stdlib.h, que recebe um long int como entrada. Essa função serve para modificar a tabela de números pseudo-aleatórios do sistema, usando o long int de entrada como parâmetro para essa modificação. No caso, usamos a função time(NULL), da biblioteca time.h, que devolve o horário do sistema atual em UNIX TimeStamp (o número de segundos passados desde as 0:00 do dia 01/01/1970 até o momento atual). Na verdade, ela retorna o epoch time (outra forma pela qual pode ser chamado o UNIX TimeStamp) para qualquer data passada de maneira correta (não entraremos nesse detalhe aqui).
Por que chamamos os números do sistema de pseudo-aleatórios?
Porque o computador não consegue, pela própria natureza lógica, gerar um padrão 100% aleatório. O que pode ser feito é utilizar-se algoritmos que gerem números, considerando-se a probabilidade de sua ocorrência em sequencia, que se aproximem da aleatoriedade e montar uma tabela com ela. O problema é que, ao se “pegar” um número nessa tabela é que, caso ela não seja “inicializada” de maneiras diferentes entre cada execução, o valor deixará de ser aleatório, ainda que continue sendo não-determinístico (ou seja, você não consegue, a partir das sequencias de números, determinar com precisão as fórmulas matemáticas que as geraram). Para evitar esse problema, utilizamos um comando, o srand(), que irá modificar a semente da tabela de números pseudo-aleatórios, o que irá garantir que, a cada execução, como o Timestamp será diferente, a semente da tabela será diferente e, por sua vez, a saída da mesma será diferente (se quiser saber mais sobre a idéia de geração de números pseudo-aleatórios, dê uma olhada nesse artigo da Wikipedia). De qualquer modo, sabemos que o srand() irá garantir que os números “aleatórios” tenham esse comportamento o mais próximo possível da realidade.
Na linha seguinte, utilizamos rand() para obter um número aleatório. Porém, esse comando não nos permite definir qual o valor máximo a ser obtido, normalmente obtendo qualquer valor entre 0 e uma definição chamada RAND_MAX (normalmente o limite de um unsigned int). A opção padrão é obter o resto da divisão inteira entre o maior número que desejamos e o valor retornado. Nesse caso, obtemos um número que vai de 0 ao limite estipulado menos 1. No nosso caso, queremos um número entre 1 e o LIMITE estipulado, por isso adicionamos 1 ao valor obtido (lembre-se da prioridade de execução da operação de resto em relação à soma).
Bem, acho que já falamos demais sobre rand(), até porque não tem como aprofundar nesse caso sem entrar uma teoria extremamente complexa e totalmente fora do nosso escopo atual (e muito provavelmente futuro). Tudo que é preciso saber é que precisaos usar srand() antes de rand() para garantir o comportamento aleatório e que precisamos utilizar a operação resto para “limitar” o valor de rand().

Laço de repetição condicional – do {…} while e operações relacionais e lógicas:

Em seguida, vemos que ele irá apresentar o desafio ao usuário e entrará no bloco de código abaixo:

  do
    {
      printf(“Quantas tentativas você acha que precisa para descobrir ele? “);
      scanf(“%d”,&maximoTentativas);

      if (maximoTentativas<1)
         printf(“Você precisa tentar ao menos uma vez! \n”);
      if (maximoTentativas>limiteTentativas)
         printf(“%d tentativas? Tá querendo demais também! \n”,maximoTentativas);
    } while (maximoTentativas<1 || maximoTentativas>limiteTentativas);

No nosso caso, nos focaremos nos comandos em ciano. Eles representam um tipo de controle de fluxo que chamamos de repetição (ou iteração, em alguns lugares) condicional. O nome pomposo apenas quer dizer que o laço em questão vai ser executado enquanto uma determinada condição for cumprida. No nosso caso, esse comando funciona assim:

  do
    {
       <…>
    } while (<condicao>);

Mas como construir uma condição lógica? Para isso, C nos fornece os operadores lógicos, que comparam valores e retornam “verdadeiro” ou “falso” conforme a situação.
Aqui cabe um parenteses antes de entrarmos nos operadores: o C não possui um tipo booleano (ou seja, verdadeiro ou falso) específico. Para o C, um valor 0, NULL (que é definido por padrão como 0) ou “” (string vazia) como falso e qualquer outro valor como verdadeiro. Isso é importante pois existe um bug em C muito comum que iremos discutir adiante.
Bem, dito isso, os operadores lógicos em C padrão são: 

Operador   >  >=  <  <=  ==  != && || !

Ação   Maior do que Maior ou igual a Menor do que  Menor ou igual a  Igual a  Diferente de E lógico OU lógico NÃO lógico

(fonte: curso de C da UFMG)
Os operadores lógicos são escritos de maneira similar aos matemáticos, sempre comparando um valor a outro. No caso, por exemplo, do comando acima, temos três expressões:

• primeiro, uma comparação maximoTentativas<1;
• depois, uma comparação maximoTentativas>limiteTentativas;
• e por fim, uma operação lógica ou entre os dois;

Como isso é resolvido no C? Primeiro, o sistema irá analisar se o maximoTentativas<1. Caso seja, ele nem irá fazer a segunda comparação maximoTentativas>limiteTentativas, pois o fato de a comparação lógica ser OU vai fazer o programa aceitar como verdadeira a condição e continuará no laço (chama-se a isso short-circuit logical analysis – análise lógica de curto-circuito, e parte do princípio que uma vez que tenhamos garantido que uma condição é sabidamente verdadeira ou falsa, não há necessidade de continuar-se processando a lógica em questão). Caso contrário, ele irá tentar a segunda comparação, maximoTentativas>limiteTentativas, para verificar se ela é verdadeira ou falsa e, portanto, a condição o será.
Parece meio confuso, mas é só pensar com calma que você irá entender. Procure imaginar valores para maximoTentativas e pense em qual será a resposta (lembre-se: no caso atual, limiteTentativas é 4).
O que acontecerá se o valor não fizer nenhuma das duas condições estipuladas ser verdadeira? Simples: a expressão como um todo será falsa (0) e o laço do…while irá se encerrar normalmente, com o programa seguindo adiante. Ou seja, somente quanto o usuário entrar com um número máximo de tentativas maior que 1 e menor ou igual que o limite de tentativas estipulado (no caso, 4), o laço será interrompido.
Temos uns ifs engraçadinhos dentro desse laço, mas não falaremos sobre ele agora. Vamos então seguir em frente.
Para fecharmos esse tópico, existe uma versão do do…while chamada simplesmente while. Ela é representada assim:

while(<condicao>)
{
    <…>
}

e sua única diferença em relação ao seu “irmão” é que, caso ao chegar na entrada do laço a condição for satisfeita, o sistema sequer irá entrar no bloco de código em questão. O do…while irá executar ao menos uma vez, uma vez que a condição é testada no momento da saída do laço, diferentemente do while, que é executada quando da entrada no laço.

Iterações – o comando for:

Após nosso usuário ter determinado quantas tentativas ele quer ter para acertar o número mágico, vamos então dar a chance a ele.

  for (i=1; i<=maximoTentativas;i++)
    {
      printf(“Vamos lá! %da. tentativa! “,i);
     
      scanf(“%d”,&numeroDoUsuario);

      if (numeroDoUsuario==numeroPensado)
      {
         printf(“Parabéns! Você acertou!\n”);
         ENCERRA
         return(0);
      }
         else
         {
           printf(“Não pensei em %d. “, numeroDoUsuario);
           if (numeroDoUsuario<numeroPensado)
              printf(“Pensei em um número maior.\n”);
           if (numeroDoUsuario>numeroPensado)
              printf(“Pensei em um número menor.\n”);
         }
    }

Aqui temos um número delimitado de tentativas por máximo de tentativas. Desse modo, podemos utilizar um outro comando de laço, o for, que é um outro caso de laço de repetição ou iteração. Diferentemente do do…while, porém, o for é uma iteração não-condicional. Na verdade, ele é condicional, mas ele é mais usado em situações na qual se espera que ele se execute um determinado número de vezes (pode-se usar ele até como um while diferente, mas não é boa prática e não falaremos sobre isso aqui).
O for tem como estrutura a seguinte:
  for (<inicializacao>; <condicao>; <iteracao>)
    {
       <…>
    }
No caso, ele é um pouquinho complexo, portanto vamos dar uma olhada no seu comportamento:

• no momento em que o programa chega no for, a primeira coisa que é feita é executar os comandos em <inicializacao>. No nosso caso, ele inicializa a variável i em 1. Essa inicialização pode ser feita como desejado, mas restringindo-se a um comando (ou bloco de código);
• Em seguida, o bloco de código do for será executado;
• Ao terminar de executar-se o bloco de código do for, ele executa o comando que está em <iteracao>. No nosso caso, utilizamos um operador matemático ++, que é utilizado em C para adicionar-se um ao valor da variável ao qual ela sucede. Na verdade ele se comporta de uma maneira mais complexa, mas para o momento basta entender que i++ seria o equivalente a i=i+1;
• Depois de executar a <iteracao>, o sistema irá verificar se a <condicao> colocada é verdadeira. Caso o seja, ele irá interromper o laço for da mesma forma que o while, caso contrário ele entrará e executará uma nova iteração. No nosso caso, testamos se i ainda é menor ou igual ao número de limiteTentativas. Lembrando que C não possui tipo booleano e que basta que o valor seja 0 ou “” para ser considerado falso e, portanto, o laço for seja interrompido;

Bem, acho que isso deve ter deixado claro como o for funciona. O primeiro printf do programa deve deixar claro que você vai passando por várias iterações até acertar o “número mágico” “pensado” pelo nosso programa (o do rand() do início do programa). Mas como o programa saberá quando fomos bem-sucedidos?
Para isso existe o nosso próximo comando.

Execução condicional – o comando if:

OK… Paramos falando sobre como o nosso programa saberá que fomos bem sucedido. Veja que temos um scanf lendo o que o personagem entrou naquela tentativa. Precisamos de um comando para decidir fomos bem sucedidos ou não em acertar a descoberta do número “mágico”  “pensado” pelo programa. Quem cuida disso é comando if do bloco abaixo:

      if (numeroDoUsuario==numeroPensado)
      {
         printf(“Parabéns! Você acertou!\n”);
         ENCERRA
         return(0);
      }
      else
      {
         printf(“Não pensei em %d. “, numeroDoUsuario);
         if (numeroDoUsuario<numeroPensado)
            printf(“Pensei em um número maior.\n”);
         if (numeroDoUsuario>numeroPensado)
            printf(“Pensei em um número menor.\n”);
      }

Agora, vamos tentar ler esse trecho de código. A primeira coisa que ele testa é se numeroDoUsuario==numeroPensado, ou seja, se o número que o usuário entrou é igual ao número “pensado” pelo sistema. Caso seja, ele indica que foi bem sucedido e encerra o mesmo (perceba que temos um return(0) dentro do if. Isso é permitido pelo C). Perceba que o operador de relação de igualdade é ==. NUNCA CONFUNDA COM O OPERADOR DE ATRIBUIÇÃO, =. Esse é um bug (falha de programação) muito comum que é provocado por falta de atenção na programação. No caso de colocar =, o valor de numeroDoUsuario seria substituído pelo de numeroPensado. A não ser que numeroPensado fosse 0 (o que é impossível, devido à lógica do programa) o programa acusaria verdadeiro independentemente do valor realmente ser (lembre-se, qualquer valor diferente de 0 ou “” ou NULL é considerado pelo C como verdadeiro em relações lógicas).
Bem, dito isso, vamos continuar a analisar nosso programa. Caso a condição acima não seja verdadeira, ele irá ignorar o bloco abaixo de if e irá ver que temos um else com um bloco de código. Ele então entrará nesse bloco de código. A primeira coisa que ele irá fazer é dizer que não pensou no numeroDoUsuario e testar se numeroDoUsuario<numeroPensado. Caso seja verdadeiro, ele irá imprimir na tela uma mensagem dizendo que pensou em um número maior que o que o usuário entrou. Caso contrário, irá verificar se numeroDoUsuario>numeroPensado. Se verdadeiro (provavelmente será, se tudo mais deu errado), irá imprimir que pensou em um número menor que o que o usuário pensou.
Os ifs dessas linhas possuem uma característica interessante que é o fato de terem comandos diretamente abaixo deles, e não dentro de blocos de código. Na realidade isso deve-se ao fato que if, while, for e afins, todos eles possuem uma característica de executar na realidade apenas um comando. A diferença é que, para o compilador C, um bloco de código (lembre-se: blocos de código são comandos isolados pelos colchetes {}) são considerados comandos isolados. Portanto, um bloco de código == um comando.
Lendo com calma o código você irá compreender muito bem o mesmo. Leia e releia o códigoo e faça exercícios mentais para entender o código do if.

Quando tudo dá errado – considerações:

OK… Mas e caso o usuário não acerte mesmo depois de ter tentado o número de vezes que ele desejou (maximoTentativas).
Isso ocorre quando a variável i, após a iteração do for, ficar com um valor maior que maximoTentativas, tornando a condição  i<=maximoTentativas falsa e saindo do laço for (ao atingir o limite de iterações estipulado). Para encerrar o programa, nós fazemos o sistema imprimir uma mensagem dizendo qual o número no qual ele pensou e saindo do mesmo.
Antes de irmos para as “brincadeiras” finais, algumas considerações:

• Os operadores relacionais que mostramos anteriormente só servem para valores numéricos ou para o tipo char. Em especial para strings, a biblioteca string.h traz funções que nos permite testar igualdade entre textos. Veremos eles melhor no futuro;
• Ainda não esgotamos o assunto controle de fluxo. Em especial falaremos ainda sobre um tipo de execução condicional para múltiplos valores e sobre como “quebrar” laços como o for e o while;
• É possível aninhar ifs ccom múltiplos else if e afins. Porém, tome cuidado ao usá-los: além de tornar o código de difícil leitura, você pode ter problemas dependendo do compilador (normalmente o C exige no mínimo 8 “níveis” de ifs aninhados, mas esse valor não é obrigatório);

Bem, dito isso, vamos fazer algumas sugestões para “brincadeiras” com o nosso código:

• Comente ou remova o srand() e veja o comportamento do gerador de números pseudo-aleatórios;
• Tente reescrever o código para tornar maximoTentativas uma constante. Lembre-se que não é necessário inicializar o valor imediatamente, podendo ser inicializado em um momento futuro;
• No caso de quando o usuário erra o número “pensado”, você pode ter percebido que os dois ifs são redundantes. Tente reescrever o código usando apenas um if;
• Da mesma forma que existe o operador ++, existe o operador –, que subtrai um da variável que o antecede. Considerando isso e o funcionamento do laço for, tente reconstruir o laço para não ter uma condição no sentido exato da palavra. Dica: lembre-se que C trata 0 como falso;
• Para ter uma idéia do problema que pode ocorrer quando se confunde o operador de igualdade com o de atribuição, modifique o código removendo um dos sinais de igual de if (numeroDoUsuario==numeroPensado) e veja o que acontece com o programa. Para maior clareza, coloque um printf que apresente o número “pensado” antes do usuário entrar o seu número e digite outro completamente diferente. Coloque também um printf mostrando o numeroDoUsuario após o bug;
• Para entender a questão das definições, altere o valor de LIMITE e veja como o programa se comporta. Como dica, o cálculo do limiteTentativas baseia-se na idéia de buscar-se o número sempre indo na metade do que é válido. Por exemplo: computador escolhe 6. Na primeira interação, tento 5, e ele me fala que pensou um maior. Tento 7 (metade do bloco “acima de cinco”) e ele me diz que pensou um menor. Tento 6 e acerto;

Bem, semana que vem iremos reeforçar a teoria dos operadores (lista completa e exemplos) e daremos uma terminada na questão dos controles de fluxo. Até lá, divirtam-se!