AULA 17 - Programação 1 - Engenharia

Objetivos

Ao final desta aula o aluno deverá ser capaz de:

• conceituar ponteiros no C mostrando um diagrama de memória e a possibilidade de manipular posições de memória com ponteiros;
• saber definir ponteiros para quaisquer tipos de variáveis;
• saber iniciar e manipular o conteúdo de outras variáveis usando ponteiros;
• saber operar sobre arranjos e estruturas usando ponteiros;
• usar ponteiros em parâmetros de funções para implementar passagem por referência;
• operar sobre strings usando ponteiros;
• construir e usar arranjos de ponteiros e, em particular, aplicar em passagem de parâmetros na linha de comando.

Referências

[1]

[2]

[3]

[4]

Site Embarcados

Conceito de Ponteiro

• Vídeo Explicativo de Ponteiros no C

A memória de um computador pode ser vista como um vetor de bytes.

Cada byte possui um endereço. O tamanho da memória é definido pelo tamanho do barramento de endereços usado para acessá-la.

Uma variável ocupa uma área da memória. Tipicamente uma variável to tipo char se utiliza de um byte. Já uma variável do tipo int pode (dependendo do sistema) usar 4 bytes contíguos.

 Uma variável possui um endereço e um conteúdo (dados).

 Uma variável ponteiro tem como conteúdo um endereço. Portanto a variável ponteiro possui um endereço e contém um endereço como conteúdo.

Ponteiro para inteiro

• Vídeo Explicativo desta seção

Observe o programa abaixo. A variável p é um ponteiro para inteiro. Isto significa que ela pode armazenar um endereço de um inteiro. O operador & é usado para capturar o endereço da variável.

#include <stdio.h>

void main()
{
  int x;
  int *p;

  x=5;
  printf("Valor de x antes = %d\n", x);
  
  p = &x;
  *p = 10;

  printf("Valor de x depois = %d\n", x);
  printf("Valor de p = %p\n", p);
}

Observe que para se referenciar o conteúdo da posição de memória apontada por p deve-se usar o asterisco: *p

EXERCÍCIO 1: Considere o programa:

• Vídeo Explicativo Exercício 1

int main(void)
{
  int x=10;
  int y, *p, *w;

}

Faça um código para copiar o conteúdo de x para y, sem que estas variáveis apareçam no lado esquerdo de um sinal de atribuição.

solução Ex. 1
int main(void) { int x=10; int y, *p, *w; p = &x; w = &y; *w = *p; printf("valor copiado para y : %d\n",y); return 0; }

EXERCÍCIO 2: Tente inferir qual seria o valor da variável y no final do programa abaixo.

int main(void)
{
  int x,y,w,*p1,*p2;
  x = 20;
  w = 30;
  p1 = &x;
  p2 = &w;
  y = *p1 + *p2;
  return 0;
}

solução Ex. 2
y = 50

EXERCÍCIO 3: Tente inferir qual seria o valor da variável y no final do programa abaixo.

int main(void)
{
  int x,y,w,*p1,*p2, *p3;
  x = 20;
  w = 30;
  p1 = &x;
  p2 = &w;
  y = *p1 + w;
  p3 = &y;
  *p3 = *p3 + 10;
  y = *p1 + *p2 + *p3;
  return 0;
}

solução Ex. 3
y = 110

Ponteiro para char

Os ponteiro para char são muito utilizados pois permitem apontar para strings. A ideia é que ele aponte para o primeiro caracter da string. Veja o exemplo abaixo.

#include <stdio.h>

int main(void)
{
   char x[10]="ifsc";
   char alfa='X', *p;

   p = &alfa;    /* p aponta para alfa */

   printf("O caracter apontado por p é %c", *p);

   p = &x[2];    /* p aponta para o caracter que está 
                     na posição 2 do vetor x */

   printf("x[2] = %c\n", *p);

   p = x;

   printf("string %s\n", p);

   while (*p!=0) {
       printf("Endereco %p conteúdo %c\n", p,*p);
       p++;
   }
    
   return 0;	
}

Neste foi usado o incremento de um ponteiro, o que implica em adicionar ao endereço armazenado em p uma quantidade relativa ao tamanho do tipo apontado. No caso é 1 (tamanho de um char é um byte).

EXERCÍCIO: Sem executar o programa abaixo, determine o valor de y no final do programa:

int main(void)
{
   char x[10]="ifsc";
   char *p, y;
   
   p = x + 2;
   y = *p;
   return 0;
}

solução
y = 's'

Apontando para um vetor de inteiros

Da mesma forma que usamos um ponteiro para char para apontar uma string, podemos fazer um ponteiro para int apontar para para um elemento de um vetor de inteiros. Notar que o ponteiro na prática deve apontar para um elemento específico do vetor. Se o ponteiro for incrementado ele apontará para o próximo elemento.

#include <stdio.h>

int main()
{
   int x[10]= {0,1,2,3,4,5,6,7,8,9};
   int *p;
   int i;
   
   p = x;

   i=0;
   while (i<10) {
       printf(" endereco %p e conteudo %d\n", p, *p);
       p++;
       i++;       
   }
   return 0;	
}

OBSERVE que p++ incrementa em 4 unidades.

Usando ponteiro na passagem de parâmetros

Observe como podemos usar ponteiros na passagem de parâmetros. O exemplo abaixo mostra a passagem de dois vetores para a função str_cpy. Os dois parâmetros formais da função são ponteiros para char. Pode-se analisar o código da seguinte forma: pdest e pfonte são parâmetros (varíaveis) que recebem os endereços dos vetores destino e fonte. Desta forma, é possível manipular as strings contidas nestes vetores através dos parâmetros pdest e pfonte.

#include <stdio.h>

void str_cpy(char *pdest, char *pfonte)
{
   while (*pfonte!=0) {
        *pdest++ = *pfonte++;
   }
   *pdest = 0;
}


int str_len (char *p)
{
   int i=0;
   while (*p++!=0)
		i++;
   return i;
}

int main(void)
{
   char fonte[10]="ifsc";
   char destino[10];

   str_cpy(destino, fonte);
   printf("string destino = %s\n", destino);

   printf("tamanho de dest = %d\n", str_len(destino));
   return 0;
}

Um ponto interessante é que ponteiros permitem, na chamada de uma função, passar valores por referência (de forma "simulada"):

void alfa(int *p)
{
  *p=10;
}

main()
{
  int x;
  x =5;
  printf("Valor de x antes da chamada de alfa = %d\n", x);
  alfa(&x);
  printf("Valor de x depois da chamada de alfa = %d\n", x);
}

Exercícios

1. Rever a aula da UFMG em Link Aula Ponteiros UFMG e fazer os exercícios de fixação. Obs: Se necessário, ao ler no browser, troque a codificação de UTF8 para Ocidental. Eu tive problemas na leitura da página.
2. Implemente um programa que realize o swap de duas variáveis inteiras passadas como parâmetro. Use ponteiros.
3. Implementar a função str_cat cujo esqueleto é fornecido abaixo, de forma a concatenar duas strings passadas como parâmetro através de ponteiros. A segunda string deve ser colocada no final da primeira string. A função deve retornar um ponteiro para a string concatenada.

   char *str_cat(char *p1, const char *p2)
   {
   
   }
   
   /* exemplo de uso da função */
   int main()
   {
     char vet1[10]="IFSC";
     char vet2[5]="-SC";
     
     p = str_cat(vet1,vet2);
     printf("%s",vet1); /* aqui deveria imprimir "IFSC-SJ" */
     printf("%s",p);    /* aqui também deveria imprimir "IFSC-SJ" */
     return (0);
   }
   

   solução A:

   #include <stdio.h> char *str_cat(char *p1, const char *p2) { char *pdest; pdest = p1; /*salva o ponteiro mpara o inicio */ while (*p1 != '\0') p1++; /* encontra o final da string 1 */ while(*p2 != '\0' ){ /* copia até o final da string apontada por p2 */ *p1++ = *p2++; }; *p1 = '\0'; /* coloca o NULL no final da string concatenada */ return pdest; } /* exemplo de uso da função */ int main(void) { char vet1[30]="IFSC"; char vet2[20]="-SJ"; printf("%s\n",str_cat(vet1,vet2)); return (0); }

   solução B:

   #include <stdio.h> char *str_cat(char *p1, char *p2) { char *pdest = p1; while (*p1) p1++; /* localiza po final da string */ while (*p1++ = *p2++) /* copia, avalia a expressão - se 0 encerra o while - incrementa os ponteiros */ ; return pdest; } /* exemplo de uso da função */ int main(void) { char vet1[30]="IFSC"; char vet2[20]="-SJ"; char *p; p = str_cat(vet1,vet2); printf("%s\n",p); printf("%s\n",vet1); return (0); }

   Solução C:

   #include <stdio.h> /* extraído do site stackoverflow */ char *str_cat(char *p1, char *p2) { int i,j; for (i = 0; p1[i] != '\0'; i++) ; /* Localiza o final da string - no final i contém o índice do NULL */ for (j = 0; p2[j] != '\0'; j++) p1[i+j] = p2[j]; /* faz a cópia - no final j contém o ídnice do NULL*/ p1[i+j] = '\0'; return p1; } /* exemplo de uso da função */ int main(void) { char vet1[30]="IFSC"; char vet2[20]="-SJ"; char *p; p = str_cat(vet1,vet2); printf("%s\n",p); printf("%s\n",vet1); return (0); }

4. Implementar um programa para ler dados para dentro das variáveis x e y e somar o conteúdo das mesmas colocando o resultado em x SEM referenciar estas variáveis no scanf ou na expressão de soma.

   solução Ex. 4
   #include <stdio.h> int main(void) { float x,y; float *p1,*p2; p1=&x, p2=&y; printf("Entre com número 1\n"); scanf("%f",p1); printf("Entre com número 2\n"); scanf("%f",p2); *p1=*p1+*p2; printf("valor de x é %f\n", x); }

5. Implementar uma função que compara duas strings passadas como parâmetro. A função retorna 0 se as strings forem iguais e 1 se diferentes. Usar ponteiros.

   solução Ex. 5

   //Autor:Victor Cesconetto de Pieri #include <stdio.h> int str_cmp(char * p1, char * p2) { while ( * p1 != 0 || * p2 != 0) { if ( * p1 == * p2) { //compara os conteúdos apontados por p1 e p2 p1++; //próxima posição de p1 p2++; //próxima posição de p2 //retorna 1 se forem diferentes } else { return 1; } //se percorrer a string totalmente e nao encontrar nada diferente retorna 0 } return 0; } int main(void) { char vet1[20] = "IFSC"; char vet2[20] = "IFSCC"; printf("%d\n", str_cmp(vet1, vet2)); return (0); }

6. Implementar uma função que recebe como parâmetro o endereço de duas variáveis float que contêm a parte real e imaginária de um número complexo no formato polar (ângulo em radianos). A função deve converter do formato polar retangular colocando a coordenada x no primeira variável cujo endereço foi fornecido como parâmetro e a coordenada y na segunda variável.

   void converte_polar_retang(float *parte1, float *parte2)
   {
   }
   
   int main(void)
   {
     float num1=1.5, num2=10.6;
   
     /*chamar a função aqui */
   
     /* imprimir os valores de num1 e num2 aqui */
   }
   

   solução Ex. 6

   #include <stdio.h> #include <math.h> void converte_polar_retang(float *parte1, float *parte2) { float real, img; real = *parte1 * cos(*parte2);//parte real img = *parte1 * sin(*parte2);//parte imaginaria *parte1 = real; *parte2 = img; } int main(void) { float num1=1.5, num2=10.6; /*chamar a função aqui */ converte_polar_retang(&num1,&num2); // passa-se o endereço das variáveis como parâmetro /* imprimir os valores de num1 e num2 aqui */ printf("%f %f\n",num1,num2); return (0); }

7. Implementar uma função que recebe como parâmetro o endereço de duas variáveis do tipo char e após a chamada da função os valores das variáveis devem estar maiúsculos (caso elas contenham letras minúsculas).

   void capitaliza(char *c1, char *c2)
   {
   }
   
   int main(void)
   {
     char alfa='a', beta='b';
   
     capitaliza(&alfa, &beta);
     
     /* aqui os valores de alfa e beta deverão ser A e B */
   }
   

   solução Ex. 7
   #include <stdio.h> void capitaliza(char *c1, char *c2) { *c1 = *c1-32;//subtrai do valor do char -32 para transformar o 'a' em 'A' *c2 = *c2-32; } int main(void) { char alfa='a', beta='b'; capitaliza(&alfa, &beta); printf("alfa : %c e beta: %c\n",alfa,beta); /* aqui os valores de alfa e beta deverão ser A e B */ }

8. Implementar uma função que recebe uma string contendo uma cadeia de caracteres com dígitos numéricos e retorna o valor inteiro da string. Usar ponteiros.

   int a_toi(char *p)
   {
   }
   
   main()
   {
     char *p="123";
     int x;
   
     x = a_toi(p);
     
     /* neste ponto x deve conter 123 */
   }
   

   solução Ex. 8

9. Construir uma função usando ponteiros que retorna a média de um vetor de inteiros passado como parâmetro. O tamanho do vetor também deve ser fornecido.

   float media_vet(int *vet, int tamanho)
   {
   }
    
   /* exemplo de uso */
    
   main()
   {
      int x[10]= {0,1,29,3,42,5,61,7,82,9};
      float media;
    
      media = media_vet(x,10); /* em media_vet deve ficar a média do vetor */
   }
   

   solução Ex. 9
   float media_vet(int *vet, int tamanho) { float media, total; int i; for(i=0;i<tamanho;i++){ total = total+*vet; printf("tao : %f\n",*vet); vet++; } media = total/tamanho; } /* exemplo de uso */ main() { int x[10]= {0,1,29,3,42,5,61,7,82,9}; float media; media = media_vet(x,10); /* em media_vet deve ficar a média do vetor */ //printf("%f\n",media); }