Aulas de C

Aprendizado continuo. Linguagem antiga e moderna

Matrizes e Ponteiros – Parte 3 – Ponteiros e Funções

Olá!

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);

que irá exibir o endereço de memória onde a função está armazenada.

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);

É dessa forma. Usamos uma escrita similar à da declaração do ponteiro, mas agora indicando os parâmetros desejados.

AQUI MORA DRAGÕES!!!
O C não faz checagem de cabeçalho de função e das tipagens envolvidas em um ponteiro de função. Isso passa a ser responsabilidade do programador, tomar os cuidados de passar os parâmetros da forma correta. Portanto, devemos ter muito cuidado quanto à parametrização das funções a serem passadas via poibteiros de função. Em geral, quando precisamos desse recurso, utilizamos algum tipo de padronização dos parâmetros. Mesmo assim, vale a ressalva de que se tome muito cuidado com isso.
Perceba uma coisa: o retorno da função executada pelo ponteiro é armazenado na variável int c. Se o retorno para o ponteiro de função fosse void, não teríamos necessidade de guardar retorno nenhum. Os retornos continuam sendo resolvidos normalmente e warnings e erros são retornados por devolver retornos errados. Mas temos que tomar cuidado também quanto a isso: imagine que você declare a função divisao como retornando float. Embora o compilador retorne um warning relacionado à passagem de tipo incompatível, ainda assim ele irá gerar o código binário (você consegue evitar isso usando as opções de compilação pedântica do seu compilador – consulte a documentação do mesmo para maiores informações).
De resto, o código não possui muitos mistérios: uma vez que o switch escolha a função a ser executada, baseada na entrada do usuário, o ponteiro funcPointer recebe o endereço da mesma. Em seguida, é feita a execução da mesma, como dissemos anteriormente, e o valor é retornando para a varável c. Por fim, os comandos printf ao final de main exibira os resultados e o endereço onde a função alocada se encontra. Como “brincadeira”, para você entender melhor, mexa a seqüência nas quais as funções estão dispostas no código fonte. Essa seqüência meio que determina qual função ficará primeiro no código binário. Assim você poderá perceber que o código é manipulado não importa onde.
Bem, brinque um pouco com esse programa para entender ponteriros de função.

Passagem de ponteiros (Passagem por referência e por valor):

Até agora, todas as nossas funções tem passado seus parâmetros por valor, ou seja, passamos uma cópia da informação armazenada na variável que passamos. Isso permite um certo isolamento entre a função chamada e a que chama, o que garante uma segurança quanto aos conteúdos da variável “local”.
Porém, em muitas situações em C, precisamos manipular diretamente a informação das variáveis em uma função. Um exemplo de função que faz isso é a função da biblioteca STDIO scanf. Ela precisa saber onde está a variável cujo conteúdo será alterado para fazer a leitura da informação via teclado (utilizando-se do sistema operacional) e gravando o conteúdo no mesmo local apontado pela varíavel em questão. Isso é chamado tecnicamente de Passagem de parâmetros por referência e com isso o conteúdo no endereço apontado pela variável pode ser manipulado.
O C oferece, através dos ponteiros, formas de passarmos parâmetros por referência. Veremos isso no nosso próximo programa, que é uma brincadeira similar ao programa de TV Roda-a-Roda (antigo Roletrando):

#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! Você acertou!\n”);
          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=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;
}

int contaFaltantes(const char* letrasCertas)
{
  char *letras=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)
    return(1);
  else
    {
      printf(“Que pena, voce errou!\n”);
      (*tentativasErradas)++;
      return(0);
    }
}

Existe pouca coisa nova aqui, à exceção do uso que faremos de passagem de ponteiros a funções e suas idiossincrásias. Inicialmente fazemos algumas inclusões e criamos duas constantes: NUM_TENTATIVAS e TAMANHO_PALAVRAS. Ambas são usadas para evitarmos “números mágicos”. Em especial, nós estamos incluindo a biblioteca padrão string.h, que define funções especiais para strings, além de ter a função malloc(), que precisaremos para alocar dinamicamente algum espaço de memória. Também declaramos quatro funções por meio de seus protótipos:

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);

As funções checaLetra, contaFaltantes e testaCerto são as funções que nos interessam. explicarRegras não faz nada, exceto exibir algum texto informativo explicando o funcionamento do nosso jogo. Não vou me ater a explicar o jogo, pois o jogo mesmo irá se explicar.😉
No main, começamos declarando todas as variáveis úteis:

  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;

Declaramos uma matriz bidimencional de caracteres (ou, para ser mais exato, uma matriz de strings), onde uma das dimensões está em branco e a outra tem como tamanho TAMANHO_PALAVRAS. Isso é permitido para no máximo uma dimensão: se uma dimensão estiver em branco, o C irá alocar o espaço suficiente para conter os elementos nela, mas APENAS se a inicialização acontecer no momento da declaração, como no nosso código. Em seguida, declaramos dois ponteiros de caracteres, palavraEscolhida e letrasCertas, e algumas variáveis de apoio.
Em seguida, o sistema chama explicarRegras para explicar como funciona nosso jogo. Em seguida, usamos a função srand(time(NULL)) para gerarmos uma nova raiz de números pseudo-aleatórios (já vimos isso anteriormente, lembra?) e, usando

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

escolhemos uma das palavras.
Aqui tem uma pegadinha de programação: se você se lembra bem, mencionamos anteriormente que para o C, matrizes e ponteiros são estruturas similares. Isso porque em C uma matriz nada mais é que uma quantidade de memória alocada pelo sistema e declarada em ponteiro. Isso vale também para matrizes quaisquer dimensão. Podemos, desse modo, utilizar uma técnica para apontar diretamente a matriz de maneira “correta” (na realidade, existe um pequeno bug aqui, que vou deixar como uma “brincadeira” para você, leitor, identificar. A pista é: tem a ver com o tamanho. Você vai entender a seguir). No caso, o que fazemos é fazer com que o sistema escolha uma posição no começo de uma palavra. Para isso, existe alguma matemática com a função rand, usando o tamanho da matriz palavras e o TAMANHO_PALAVRAS de modo que rand retorne um valor entre 0 e o número de palavras-1, devolvendo o endereço do início dessa palavra para palavraEscolhida. Você pode se perguntar “e porque não copiar a palavra escolhida”. Isso é possível, mas é mais complexo e consome memória e tempo de processamento. Novamente: não pense em programação apenas para PCs, com seus gigas de memória e processamento. Pense, por exemplo, em um celular com alguns KB de espaço útil e poucos megahertz de processamento. Aproveitar a palavra que JÁ ESTÁ NA MEMÓRIA é uma idéia melhor. Nós veremos como usar essa informação de maneira segura já já.
Em seguida usamos malloc para alocar um espaço de tamanho igual ao tamanho da palavra escolhida. Fazemos uma checagem para ver se a alocação foi bem sucedida (NUNCA SE ESQUEÇA DISSO!) e usamos a função memset para preencher a memória alocada com terminadores nulos e, em seguida, com hifens. Essa segunda variável irá armazenar aonde você já acertou na escolha das palavras.
Entramos então no loop principal. Declaramos um caracter e adicionamos um a cada tentativa. O caracter é só declarado, sem ser inicializado. Aqui podemos “quebrar” a boa prática de C de inicializar uma variável assim que declará-la, pois aqui não iremos fazer mais nada que ler um caracter. Não há problema imediato nesse caso, pois é uma leitura rápida e o endereço usado será sempre o mesmo (não estamos alocando dinamicamente esse caracter). O jogador recebe uma informação sobre o número de tentativas que ele fez e quantas ele já errou (o laço compara o valor de tentativasErradas com o de NUM_TENTATIVAS). Foi colocado um getchar() para “limpar” qualquer caracter espúrio que tenha sobrado (em especial o ENTER).
E agora entramos em nossa primeira checagem: o jogador escolheu uma letra certa?
Para isso, temos a função:

int checaLetra (const char* palavraEscolhida, const char* letrasCertas, char letra);

Que recebe dois ponteiros e a letra a ser comparada.
Aqui existe um detalhe: os dois ponteiros são declarados como const.
Por que? Não queremos manipular o conteúdo deles?”, você deve estar se perguntando.

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. :P)
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);
    }
}

8 Respostas para “Matrizes e Ponteiros – Parte 3 – Ponteiros e Funções

  1. André Caldas 10/06/2011 às 9:22

    Tenho alguns comentários a fazer sobre ponteiros pra funções.

    Primeiramente, não é comum usar (*f)(a) pra chamar a função apontada pelo ponteiro f. O mais comum é usar simplesmente f(a)!!!🙂

    Note que você já faz isso quando escreve funcPointer=soma;. Note que se não fosse o caso de ponteiro pra função, o correto seria funcPointer = &soma;!!! Assim o código fica mais bonito, um pouco.😛

    Em segundo lugar, acho que é muito importante chamar a atenção quanto à tipagem dos ponteiros para função. Da mesma forma que você não usa o tipo void* no lugar de int*, não vejo um bom motivo para usar int (*f)() no lugar de int (*f)(int). Se o código em questão permite que se qualifique corretamente o tipo da função e deixar que o compilador faça as checagens pra você, então não se deve usar a versão não tipada! Quanto menos coisas você tiver que se preocupar, melhor! Pra isso foi criado o conceito de tipos!! Por outro lado, se o código foi feito de modo que não dá pra usar as versões corretamente tipadas, então é porque o código provavelmente está mal desenhado. Essas observações valem para qualquer tipo de variável, não apenas ponteiros para funções.

    Ah… se eu uso o g++, ao invés do gcc, o seu código dá erro:

    error: invalid conversion from ‘int (*)(int)’ to ‘int (*)()’ [-fpermissive]
    error: too many arguments to function

    Em terceiro, eu só queria dizer que na minha opinião, se você se vê em uma situação onde precisa ficar usando muito ponteiro pra função, então deveria estar usando polimorfismo em uma linguagem orientada para objeto. Acho que é importante saber quando se está abusando dos ponteiros para funções…😉

  2. André Caldas 10/06/2011 às 10:14

    Sobre ponteiros const…

    Primeiramente, gostaria de parabenizá-lo pela preocupação com os tipos const. Informar ao compilador exatamente quais são as suas intenções é a melhor maneira de evitar erros. Talvez você pudesse fazer um post falando só sobre as consequências/benefícios de se utilizar o “const”. Quando você começa a usar o “const” começa a perceber o tanto de lugares onde a coisa poderia dar problema.🙂

    Só que tem um detalhe… você usa corretamente mas explica o contrário… apesar de que a observação ao final está correta!?!?

    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.

    O “const” antes do “char*” NÃO faz com que o ponteiro seja constante e o conteúdo apontado seja variável. É exatamente o contrário!!! A expressão const char* deve ser entendida como um ponteiro para um const char. O que você está explicando seria um char* const.

    No entando, você está correto em dizer que sempre que se supõe que uma função não vai alterar o conteúdo apontado por um ponteiro, devemos declará-lo como sendo um ponteiro PARA const. No caso específico do seu post, como você também não tem a intensão de alterar o valor de palavra faria sentido (e seria muito melhor) declará-la como const char* const palavra. Mas o importante mesmo é o “primeiro” const. Isso porque é o primeiro const que garante para quem está chamando a função que é seguro passar um endereço QUALQUER! Sem correr o risco de o conteúdo desse endereço ser modificado. Por exemplo, se tivesse um BUG no programa e no lugar de if (*palavraAnalisada==letraComparada) o programador tivesse esquecido um dos sinais de “=” e escrito if (*palavraAnalisada=letraComparada), o compilador avisaria. Aliás, já está avisando… o seu código emite o seguinte aviso:

    warning: assignment discards ‘const’ qualifier from pointer target type [enabled by default]

    Isso porque ao fazer palavraAnalisada = palavra você está eliminando o “const” que colocou lá no protótipo da variável palavra. O correto seria fazer com que palavraAnalisada TAMBÉM seja um ponteiro para const. Afinal de contas, você deu a garantia de que não iria alterar o conteúdo apontado por palavra.

    Analisando um pouco mais o código da função checaLetra, você vai perceber que const char* letrasCertas deveria de fato ser declarada SEM O CONST! A final de contas, sua função ALTERA o conteúdo apontado por letrasCertas. Neste caso, o melhor seria char* const letrasCertas. Se você quisesse ser bem chato… (e eu recomendo!), o melhor protótipo para a função checaLetra seria

    int checaLetra (const char* const palavra, char* const letrasCertas, const char letra)

    Experimente fazer um código realmente “const correct”… você vai perceber como o compilador AJUDA!!!

    Referência (em inglês): Const-Correctness na wikipedia.

    • André Caldas 10/06/2011 às 10:44

      “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.

      Bom… nem preciso dizer que o parágrafo acima está TOTALMENTE incorreto. Agora entendi como é que você está interpretando o significado de const char*. Está totalmente incorreto. Não existe o conceito do que você chama de “alteração no endereço”. Você está falando como se alteração no valor da variável palavra fosse de alguma forma relocar o conteúdo ou coisa do tipo. Sei lá… parece que você tá dizendo que sem o “const”, se eu escrever palavra = palavra + 1 então as variáveis vão sair do lugar ou algo do tipo. Não é nada disso!

      Só um último comentário:

      Use ++variavel, a menos que você realmente queira o efeito colateral retardado causado por variavel++.

  3. André Caldas 10/06/2011 às 13:00

    Ah… o código tem vazamento de memória em toda alocação dinâmica feita!!!

    • Fábio Emilio Costa 13/06/2011 às 16:59

      Origado pelas suas informações e pelas correções, André.

      Como eu disse no momento em que comecei o Blog, embora goste muito de C, não sou um especialista. Desenvolvo em diversas linguagens e, corretamente, posso ter problemas em compreender conceitos em algumas. Mas suas observações são muito válidas e testei todas nos códigos comentados. Estarei publicando ASAP os códigos corretos.

      Quanto a polimorfismo e OOP como substituto de ponteiros de função, concordo. MAS, aqui ainda estamos focando-nos em Czinho (chamarei assim para evitar má compreensões, OK?). De qualquer modo, quando chegarmos a ver C++, aí será realmente o momento de tentar aprofundar no polimorfismo.

      Agradeço realmente os comentários e correções. Qualquer um que desejar me corrigir em qualquer coisa que tenha deixado de errado, por favor, FAÇA-O! Não sou perfeito, portanto fico feliz quando me corrigem onde estou errado.

  4. André Caldas 13/06/2011 às 22:30

    Olá, Fábio!!

    Fiquei muito impressionado como você encarou bem meus comentários. Eu fui muito duro… você está realmente de parabéns por ter feito algo tão alto-nível aqui. Eu fiquei um pouco incomodado pela questão da responsabilidade. É que tem uma galera aprendendo com você, aqui… acho que seria bacana tratar das questões de modo um pouco mais “conceitualmente correto”. Digo, pra não acontecer de propagar certos problemas e perpetuar essa coisa de amadorismo ao extremo. Principalmente no que se refere a ponteiros, já que estes são a maior causa de falhas de segurança de toda a história da informática.

    Quando fizer as correções, fique à vontade para apagar meus comentários.🙂

    Eu, pra dizer a verdade, não manjo tanto de C, não. Mas sempre que quiser uma opinião, fique à vontade pra entrar em contato:
    andre.em.caldas@gmail.com

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

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: