Algoritmos e Estrutura de Dados I

1. Algoritmos e Estrutura de Dados I Revisão - Ponteiros Prof.: Ricardo Argenton Ramos

2. Roteiro • Definição de Ponteiros; • Passagem de Argumentos por Valor e Referência; • Retornando Dados de Funções; • Operadores - Direto (&) e Indireto (*); • Operações com Ponteiros.

3. Introdução • Três razões para o uso de ponteiros: • Funções podem modificar seus argumentos; • Alocação dinâmica de memória • Aumentar a eficiência de algumas rotinas • Cuidado ao utilizá-los • Ponteiros não inicializados • Erro do Windows

4. Ponteiros • Um Ponteiro é uma variável que contém o endereço de memória de outra variável. • É possível ter um ponteiro para qualquer tipo de variável.

5. Passagem por Valor • Em C todos os argumentos (parâmetros) de funções são passados por valor • Isso significa que uma cópia dos valores dos argumentos é dada à função chamada, e ela cria outras variáveis temporárias para armazenar esses valores • O ponto principal é que, em C, uma função chamada não pode alterar o valor de uma variável da função que chama; ela só pode alterar a sua cópia temporária.

6. Imprime o valor e o endereço das variáveis a e b antes e após chamar a função. Cria duas variáveis a e b que serão utilizadas como parâmetro da função Incrementa(). Invoca a função para incrementar os valores de a e b Passagem de Argumentos por Valor main(){ int a, b; a = 5; b = 5; printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); incrementa(a,b); printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); }

7. Cria duas novas variáveis a e b, incrementa elas em 2 unidades e imprime seus valores e endereços. int incrementa(int a, int b){ a = a + 2; b = b + 2; printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); }

8. a b Passagem de Argumentos por Valor main(){ int a, b; a = 5; b = 5; printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); incrementa(a,b); printf ("--- Depois de chamar a funcao ---\n"); printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); } int incrementa(int a, int b){ a = a + 2; b = b + 2; printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); }

9. Passagem de Argumentos por Valor a 5 b 5 main(){ int a, b; a = 5; b = 5; printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); incrementa(a,b); printf ("--- Depois de chamar a funcao ---\n"); printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); } int incrementa(int a, int b){ a = a + 2; b = b + 2; printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); }

10. Passagem de Argumentos por Valor a 5 b 5 main(){ int a, b; a = 5; b = 5; printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); incrementa(a,b); printf ("--- Depois de chamar a funcao ---\n"); printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); } int incrementa(int a, int b){ a = a + 2; b = b + 2; printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); } a 5 7 b 5 7 Dois valores inteiros são passados para a função, mas ela não sabe quem são (onde estão) essas variáveis. Nesse momento ela cria duas variáveis para armazenar os valores inteiros que foram recebidos

11. Executando....

12. O que são Ponteiros ? • Proporciona um modo de acesso a variáveis sem referenciá-las diretamente. • O mecanismo usado para isso é o endereço da variável. Esse endereço age com um intermediário entre a variável e o programa que a acessa • Basicamente, um ponteiro é uma representação simbólica de um endereço • São usados onde a passagem de valores é difícil ou indesejável

13. 1 Luiza 2 endereços 3 4 1 5 Ponteiros Variáveis • Um ponteiro variável possui como conteúdo um endereço de memória. Esse endereço é a localização de uma outra variável de memória • Diz-se que uma variável aponta para outra quando a primeira possui o endereço da segunda

14. Ponteiros Constantes • Ponteiros variáveis são variáveis que armazenam endereços de memória • Ponteiros constantes são endereços de memória • O nome de uma matriz é um exemplo de um ponteiro constante

15. Razões para usar ponteiros • Deseja modificar os argumentos que recebem • Para criar estruturas de dados complexas, como listas encadeadas e árvores binárias • Compilam mais rapidamente, tornando o código mais eficiente

16. Retornando dados de Funções • O primeiro exemplo mostrará como que uma função pode alterar os valores dos argumentos da função chamadora • Vamos iniciar com uma nova versão do programa mostrado anteriormente.

17. Cria duas variáveis a e b, atribui o valor 5 a cada uma delas, imprime o valor e endereço de cada uma. Chama a função incrementa passando como parâmetro o endereço de memória das variáveis a e b. A função incrementa() possui como parâmetro dois ponteiros para os endereços de memória que receberá como parâmetro. Qualquer operação com esses ponteiros afetará o valor das variáveis correspondentes. Exemplo de ponteiros main() { int a, b; a = 5; b = 5; printf ("--- Antes de chamar a funcao ---\n"); printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); incrementa(&a,&b); printf ("--- Depois de chamar a funcao ---\n"); printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n\n\n", b, &b); } incrementa(int *a, int *b) { *a = *a + 2; *b = *b + 2; printf("\n--- Dentro da funcao ---"); printf("\n\n O Valor do ponteiro a: %d , seu endereco e: %d, e conteudo de a:%d \n", a, &a, *a); printf("\n\n O Valor do ponteiro b: %d , seu endereco e: %d, e conteudo de b:%d \n", b, &b, *b);

18. Exemplo de ponteiros 1 a 7 5 2 b 7 5 3 *a 1 main() { int a, b; a = 5; b = 5; printf ("--- Antes de chamar a funcao ---\n"); printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n", b, &b); incrementa(&a,&b); printf ("--- Depois de chamar a funcao ---\n"); printf("\n O Valor de a: %d , e o seu endereco e: %d\n", a, &a); printf("\n O Valor de b: %d , e o seu endereco e: %d\n\n\n", b, &b); } incrementa(int *a, int *b) { *a = *a + 2; *b = *b + 2; printf("\n--- Dentro da funcao ---"); printf("\n\n O Valor do ponteiro a: %d , seu endereco e: %d, e conteudo de a:%d \n", a, &a, *a); printf("\n\n O Valor do ponteiro b: %d , seu endereco e: %d, e conteudo de b:%d \n", b, &b, *b); } 4 *b 2 5 6 Na chamada da função, ela cria duas variáveis do tipo ponteiro que armazenarão endereços do tipo inteiro. As operações serão realizadas sobre esses endereços.

19. Executando...

20. Função é chamada, passando para ela dois endereços de variáveis Os endereços recebidos serão armazenados em variáveis ponteiros. O conteúdo da variável apontada recebe ele mesmo acrescido de 2. Pontos Importantes incrementa(&a,&b); incrementa(int *a, int *b) { *a = *a + 2; *b = *b + 2; printf("\n\n O Valor do ponteiro a: %d , seu endereco e: %d, e conteudo de a:%d \n", a, &a, *a); O valor do ponteiro  a O endereço do ponteiro  &a O valor da variável apontada pelo ponteiro  *a

21. Exercício • Elaborar um programa que faça a atribuição de novos valores a duas variáveis (do tipo int) por referência sem utilizar uma função.

22. Outro Exemplo • O próximo exemplo difere do primeiro no sentido de que as variáveis do main() não possuem valores até que a função altera2() é chamada. • A única coisa que essa função faz é fornecer valores às variáveis criadas no main()

23. Cria duas variáveis e não atribui valor à elas. Chama a função altera2() passando os endereços dessas variáveis. A função cria variáveis do tipo ponteiro que apontarão para os endereços que serão recebidos por parâmetro. Qualquer operação com esses ponteiros afetará o valor das variáveis apontadas. Devolve2.c main() { int x,y; altera2(&x,&y); printf("\nO primeiro e %d, o segundo e %d\n\.", x,y); } altera2(int *px, int *py) { *px = 3; *py = 5; }

24. Executando...

25. Operador e Operando • Exemplo a++  operador ++, operando a a – b  operador -, operandos a e b &a  operador & e operando a *p  operador * e operando p

26. Operadores - Direto (&) e Indireto (*) • Para declarar variáveis do tipo Ponteiro int *px, *py; • Isso cria duas variáveis do tipo ponteiro. Essas variáveis podem conter endereços de variáveis do tipo int. • Operadores • & - operador direto que retorna o endereço da variável operando • * - operador indireto que retorna o conteúdo da variável localizada no endereço. • Se no programa anterior mandássemos imprimir o valor dos ponteiros...

27. Essas variáveis do tipo ponteiro apontam (endereçam) para as variáveis x e y. Ao imprimir, o valor das variáveis será mostrado. main() { int x,y; altera2(&x,&y); printf("\nO primeiro e %d, o segundo e %d\n\.", x,y); } altera2(int *px, int *py) { *px = 3; *py = 5; printf("\n\nO primeiro ponteiro e %d, o segundo ponteiro e %d\n\n\n.", *px, *py); }

28. Executando...

29. Considerações • Você deve se assegurar que suas variáveis ponteiro sempre apontam para variáveis do mesmo tipo • A função passa indiretamente os valores 3 e 5 para as variáveis x e y. isso é indireto porque a função não conhece os nomes das variáveis, assim ela usa seus endereços • main() acessa as variáveis x e y de um certo modo, enquanto altera2() de outro. main() denomina-as de x e y, enquanto que altera2() denomina-as de px e py.

30. Exemplo Prático • Rotina de ordenação não poderia permutar dois elementos fora de ordem com uma função de troca... • A solução é utilizar ponteiros para que a função realmente altere a ordem dos elementos do programa chamador troca (int *ax, int *ay) { int temp; temp = *ax *ax = *ay; *ay = temp; }; troca (x,y) { int temp; temp = x; x = y; y = temp; };

31. Cria duas variáveis e as inicializa com os valores 6 e 5. Se o valor da variável menor é > que o valor da variável maior, invoca a função troca para permutar esses valores dessas variáveis Função que recebe como parâmetro dois endereços para variáveis do tipo int. Cria uma variável temp para permutar os valores que estão sendo apontados. main() { int menor = 6, maior = 5; printf ("\n (main) valor de menor %d, valor do maior: %d", menor,maior); if (menor > maior) { troca(&menor,&maior); printf ("\n (depois da chamada) valor do menor: %d, valor do maior: %d\n\n", menor,maior); } } void troca(int *menor, int *maior) { int temp; temp = *maior; *maior = *menor; *menor = temp; }

32. Exercício • Implementem um programa que possua duas variáveis (a e b) do tipo int. • Deve haver uma função que some a em b, uma outra função que some b em a e uma outra que subtraia b de a. • Note que o valor das variáveis do main é que devem ser alterados

33. Operações com Ponteiros • São cinco as operações que podem ser feitas com ponteiros • O próximo programa mostra essas operações mostrando o valor do ponteiro, o valor armazenado na variável apontada e o endereço do próprio ponteiro. • O próximo exemplo também mostra o problema que pode ocorrer quando não se cuida dos endereçamentos...

34. operptr.c main() { int x=5, y=6; int *px, *py; px = &x; py = &y; printf ("--- Valor ----- Ponteiro -- Endereco do ponteiro\n\n"); printf("px = %u, *px = %d, &px = %u\n", px, *px, &px); printf("py = %u, *py = %d, &py = %u\n\n", py, *py, &py); py++; printf ("Incrementou py em uma unidade de inteiro\n\n"); printf("px = %u, *px = %d, &px = %u\n", px, *px, &px); printf("py = %u, *py = %d, &py = %u\n", py, *py, &py); printf ("py - px = %u\n", py - px); if (px < py) { printf("py - px = %u\n\n", py - px); } else { printf ("px - py = %u\n\n", px - py); } }

35. 6684148 x 5 5 6684144 y 6 5 6684140 *px int 6684136 *py int Executando... 6684148 6684144 6684148 main() { int x=5, y=6; int *px, *py; px = &x; py = &y; printf ("--- Valor ----- Ponteiro -- Endereco do ponteiro\n\n"); printf("px = %u, *px = %d, &px = %u\n", px, *px, &px); printf("py = %u, *py = %d, &py = %u\n\n", py, *py, &py); py++; printf ("Incrementou py em uma unidade de inteiro\n\n"); printf("px = %u, *px = %d, &px = %u\n", px, *px, &px); printf("py = %u, *py = %d, &py = %u\n", py, *py, &py); printf ("py - px = %u\n", py - px); if (px < py) { printf("py - px = %u\n\n", py - px); } else { printf ("px - py = %u\n\n", px - py); } }

36. As Operações • As operações que podem ser feitas com ponteiros são: • Atribuição • px = &x • Incremento de unidades (tipos) • px++ • Soma ou subtração • py – px (6684148 – 6684144 = 1) • px = px + 3; (6684148 + 3 = 6684160) • Comparações (>=, <=, > , <, ==, !=, null) • Somente quando os dois operandos são ponteiros e de mesmo tipo.

37. Exercício • Faça um programa que contenha 4 variáveis (a, b, c, d) com os valores iniciais 1, 2, 3 e 4 respectivamente, crie então 4 ponteiros (na função main). • Faça uma função especifica para que os 4 ponteiros apontem para a variável (d). Imprima os valores apontados pelos ponteiros. • Faça uma segunda função que atribua (por referência) o valor de a em b e de c em d (b=a e d=c). • Faça uma terceira função que compare os ponteiros e casos sejam maior que zero dever ser decrementados e se forem menor que zero devem ser incrementados.