endereço i: 0x7ffe26476b20
endereço j: 0x7ffe26476b24

• Podemos ter vários apontadores para um mesmo objeto

Atribuição de apontadores

• Atenção: não confundir as atribuições
  
  q = p;
  
  com
  
  *q = *p;
  
  
• A primeira é uma atribuição entre apontadores
• A segunda modifica o valor apontado por q (ver figura seguinte)

Atribuição de apontadores

p = &i; q = &j; i = 1;

*q = *p;

Apontadores como argumentos

• Os argumentos de funções em C são passados por valor
• Isto implica que as modificações dos argumentos não são visíveis depois do retornar da função
• Passar apontadores a uma função permite modificar os objetos apontados
• Isto podem também ser usado quando queremos retornar mais do que um resultado de uma função

Exemplo: trocar duas variáveis

• A seguinte função não funciona
• As variáveis a, b são locais à função
• Logo a troca não tem efeito depois do retorno da função

/* Trocar duas variáveis; versão errada */
void trocar(int a, int b) {
    int temp;
    temp = a;
    a = b;
    b = temp;
}

Versão usando apontadores

void trocar(int *pa, int *pb) {
   int temp;
   temp = *pa;
   *pa = *pb;
   *pb = temp;
}

• Para invocar temos de passar apontadores para as variáveis a trocar:

   int a, b;
   ...
   trocar(&a, &b);  // trocar `a' com `b'

Programação com apontadores

Introdução

• A linguagem C permite usar apontadores para processar variáveis indexadas
• Mais geralmente: podemos usar apontadores para processar sequências em memória (e.g. cadeias)
• Este tipo de processamento é essencial para programação de baixo-nível (e.g. sistemas operativos)

Apontadores para elementos

• Podemos usar o operador & para obter um apontador para um elemento de uma variável indexada
• Se a é uma variável indexada, então &a[i] é um apontador para o i-ésimo elemento de a:

   int a[10], *p;
   p = &a[0];

Modificar um elemento

• Podemos usar o apontador para modificar o elemento:

   *p = 21;

Aritmética de apontadores

Aritmética de apontadores

• Se p aponta para um elemento de uma variável indexada, outros elementos podem ser obtidos usando aritmética de apontadores sobre p:
• A linguagem C suporta três operações aritméticas sobre apontadores:
  • somar um inteiro a um apontador;
  • subtrair um inteiro a um apontador;
  • subtrair dois apontadores

Somar um inteiro

• Se p aponta o elemento a[i], então p+j aponta o elemento a[i+j]

p = &a[2];

q = p + 3;

Subtrair um inteiro

• Se p aponta o elemento a[i], então p-j aponta o elemento a[i-j]

p = &a[2];

q = p - 2;

Processamento de vetores

Processamento de vetores

• Podemos usar aritmética de apontadores para processar elementos de uma variável indexada
• Exemplo: somar todos os elementos

int soma_vec(int vec[], int n) {
  int *p, soma;
  soma = 0;
  for(p = &vec[0]; n>0; n--) {
    soma += *p;
    p++;
  }
  return soma;
}

Apontadores e variáveis indexadas

• O nome de uma variável indexada pode ser usado como um apontador para o primeiro elemento:

   int a[10];
   *a = 7;      // coloca 7 em a[0] 
   *(a+1) = 12; // coloca 12 em a[1]

Em geral:

Apontadores e variáveis indexadas (cont.)

Podemos re-escrever a inicialização do ciclo

  for(p = &vec[0]; n>0; n--) {
   ...
  }

como:

  for(p = vec; n>0; n--) {
    ...
  }

Argumentos de funções

• Quando passamos uma variável indexada a uma função esta é tratada como um apontador:

  int soma_vec(int vec[], int n) {
     ...
  }
  ...
  int a[N];
  ...
  s = soma_vec(a, N);  

• A chamada soma_vec(a, N) passa um apontador à função — não copia os elementos do vetor

Consequências

• Quando passamos uma variável usual o seu valor é copiado; a função não pode alterar a variável original
• Passar uma variáveis indexada corresponde a passar um apontador para o primeiro elemento
  • não é necessário copiar
  • a função pode modificar os seus elementos
• Podemos passar uma variável indexada a uma função declarada com apontador ou vice-versa
• Vamos ver dois exemplos deste uso

Exemplo 1

• Podemos declarar soma_vec usando um apontador como argumento:

   int soma_vec(int *vec, int n) {
     ...
   }

• Isto é equivalente à declaração original:

   int soma_vec(int vec[], int n) {
     ...
   }

Exemplo 2

• Podemos usar soma_vec para somar apenas uma parte de um vetor:

   int a[100];
   ...
   s = soma_vec(&a[30], 10);
      // somar a[30], a[31], ... a[39]

• Alternativa (equivalente):

   s = soma_vec(a+30, 10);

Retornar apontadores

• Podemos não apenas passar apontadores como argumentos a funções mas também retorná-los como resultados
• Exemplo: retornar um apontador para o maior de dois inteiros (passados também como apontadores)

   int *max(int *pa, int *pb) {
      if(*pa > *pb)
         return pa;
      else
         return pb;  
   } 

Retornar apontadores (cont.)

• Ao chamar max passamos dois apontadores:

   int *p, i, j;
   ...
   p = max(&i, &j);

• Depois de executar max, p aponta para i ou para j

Cuidados ao retornar apontadores

• Podemos retornar apontadores passados como argumentos (como no exemplo anterior)
• Também podemos retornar apontador para um elemento de um vetor passado como argumento
• Contudo: não podemos retornar apontadores para variáveis locais (porque o espaço associado é automaticamente libertado)

char *f( ... ) {
   char tmp[MAX];
   ...
   return &tmp[...]; // ERRO
}

Apontador nulo

• Por vezes temos de retornar um apontador mesmo em situações de erro ou resultado indefinido
• Nessas situações é usual retornar o apontador nulo NULL

Exemplo

Definir uma função

   char *find_alpha(char *str);

• Procura a primeira ocorrência de uma letra numa cadeia
• Retorna um apontador para esse carater
• Se não encontrar nenhuma letra, então retorna NULL

Exemplo (cont.)

#include <stdlib.h>
#include <ctype.h>

char *find_alpha(char *str) {
   while(*str != '\0' && !isalpha(*str)) {
      str ++;
   }
   if (*str != '\0')
      return str;  // encontrou
   else
      return NULL; // não encontrou
}

Apontador nulo

• NULL é uma constante definida no header stdlib.h
• É o apontador nulo
  • diferente de qualquer apontador válido
  • usado para representar a ausência de resultado

   char texto[100], *ptr;
   ...
   ptr = find_alpha(texto);
   if(ptr != NULL) 
     printf("Primeira letra: %c\n", *ptr);
   else 
     printf("Não existem letras!\n"); 

Apontador nulo (cont.)

• Podemos usar NULL para inicializar qualquer apontador
• Contudo: ler ou atribuir a NULL leva a um erro de execução (e.g. “segmentation fault”)

int *p = NULL;

printf("%d", *p); // ERRO

*p = 42;          // ERRO

Processamento de cadeias

Processamento de cadeias

Vamos re-implementar algumas funções sobre cadeias usando apontadores:

• calcular o comprimento
• copiar
• concatenar
• comparar

Comprimento (1)

unsigned comprimento(char *str) {
  unsigned len = 0;
  char *ptr = str;
  while(*ptr != '\0') {
     len ++;
     ptr ++;
  }
  return len;
}

Comprimento (2)

Versão mais “idiomática”: pós-incremento na condição do ciclo.

unsigned comprimento(char *str) {
  unsigned len = 0;
  char *ptr = str;
  while(*ptr++ != '\0')
      len++;
  return len;
}

Comprimento (3)

Não é necessário a variável auxiliar ptr: podemos usar o argumento da função directamente.

unsigned comprimento(char *str) {
  unsigned len = 0;
  while(*str++ != '\0')
      len++;
  return len;
}

Comprimento (4)

unsigned comprimento(char *str) {
  char *ptr = str;
  while(*ptr++ != '\0');
  return ptr-str;
}

Copiar (1)

void copiar(char *dest, char *origem) {
   while(*origem != '\0') {
      *dest = *origem;
      dest ++;
      origem ++;
   }
   *dest = '\0';  // colocar terminador
}

Copiar (2)

Combinando a atribuição com o pós-incremento de apontadores.

void copiar(char *dest, char *origem) {
   while(*origem != '\0') 
      *dest++ = *origem++;
   *dest = '\0';  // colocar terminador
}

Concatenar

void concat(char *dest, char *origem) {
    // advançar até final do destino
   dest += comprimento(dest);
   // copia a origem
   while(*origem != '\0') 
      *dest++ = *origem++;
   *dest = '\0';
}

Comparar cadeias

Resultado 1 se as cadeias são iguais e 0 se são diferentes.

int comparar(char *str1, char *str2) {
  while(*str1 != '\0' && *str1 == *str2) {
    str1++;
    str2++;
  }
  return (*str1 == *str2);
}