Post on 02-Feb-2016
description
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.