algoritmos e estrutura de dados i revisão - ponteiros prof.: ricardo argenton ramos

Algoritmos e Estrutura de Dados I

Revisão - Ponteiros

Prof.: Ricardo Argenton Ramos

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.

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

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.

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.

Passagem de Argumentos por Valormain(){

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

Cria duas variáveis a e b que serãoutilizadas como parâmetro da função

Incrementa().

Imprime o valor e o endereço das variáveis a e bantes e após chamar a função.

Invoca a função para incrementar os valores de a e 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);

}

Cria duas novas variáveis a e b, incrementaelas em 2 unidades e imprime seus valores e endereços.

Passagem de Argumentos por Valormain(){

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

ab

Passagem de Argumentos por Valormain(){

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

ab

55

Passagem de Argumentos por Valormain(){

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

ab

55

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 inteirosque foram recebidos

ab

5577

Executando....

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

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

Luiza

1

1

2

3

4

5

endereços

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

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

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.

Exemplo de ponteirosmain() {

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

Cria duas variáveis a e b, atribui o valor5 a cada uma delas, imprime o valor

e endereço de cada uma.

Chama a função incrementa passando como parâmetroo endereço de memória das variáveis a e b.

A função incrementa() possui como parâmetro doisponteiros 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 ponteirosmain() {

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

}

ab

55

1

2

3

4

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.

*a

*b

12

77

Executando...

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

Função é chamada, passandopara ela dois endereços de variáveis

Os endereços recebidos serão armazenadosem variáveis ponteiros.

O conteúdo da variável apontada recebeele mesmo acrescido de 2.

O valor do ponteiro aO endereço do ponteiro &a

O valor da variável apontada pelo ponteiro *a

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.

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

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;

}

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 ponteiroque apontarão para os endereços que serão

recebidos por parâmetro. Qualquer operaçãocom esses ponteiros afetará o valor das variáveis

apontadas.

Executando...

Operador e Operando

Exemploa++ operador ++, operando a

a – b operador -, operandos a e b

&a operador & e operando a

*p operador * e operando p

Operadores - Direto (&) e Indireto (*)

Para declarar variáveis do tipo Ponteiroint *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...

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

}

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.

Executando...

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.

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 (x,y)

{ int temp;

temp = x;

x = y;

y = temp;

};

troca (int *ax, int *ay)

{ int temp;

temp = *ax

*ax = *ay;

*ay = temp;

};

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;

}

Cria duas variáveis e as inicializacom os valores 6 e 5.

Se o valor da variável menor é > que o valorda variável maior, invoca a função troca

para permutar esses valores dessas variáveis

Função que recebe como parâmetro doisendereços para variáveis do tipo int.

Cria uma variável temp para permutaros valores que estão sendo apontados.

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

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

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

}

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

}

xy

int

int

55

6684148

6684144

6684140

6684136

*px

*py

5

6

6684148

66841446684148

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.

ExercícioFaç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.