Memria

Ponteiros
Introduo Cincia da Computao I
Prof. Denis F. Wolf

Memria
2

7 8

O operador & quando aplicado sobre um

identificador (nome de varivel, por exemplo)
retorna o seu endereo

int y = x + 6;
printf(%d, x);

int main () {
int x;
x = 10;
return 0;
}

scanf(%d, &x );

Memria
0

Endereo de Memria

9 10 11 12 13 14 15 16 17 18 19 20

16

10

7 8

Ponteiros

9 10 11 12 13 14 15 16 17 18 19 20

Um ponteiro uma varivel que contm (armazena)

um endereo de memria
Declarao:
tipo_dado *nome_ponteiro;
onde "*" indica que a varivel um ponteiro

Ex: int x;
int *px; /* compilador sabe que px ponteiro */
/* px um ponteiro para inteiro */

scanf(%d, &x );

O que um ponteiro?
5

7 8

9 10 11 12 13 14 15 16 17 18 19 20

Como usar um ponteiro?

0

7 8

9 10 11 12 13 14 15 16 17 18 19 20

10

10

10

pi

pi

int x = 10, *pi;

pi = &x;
printf("&x: %p pi: %p", &x, pi);
Sada em tela:
&x: 0x4 pi: 0x4

int x = 10, *pi, y;

pi = &x;
y = *pi;
O operador * quando aplicado sobre um ponteiro retorna
o dado apontado

Utilizando Ponteiros

Utilizando Ponteiros

#include <stdio.h>

#include <stdio.h>

int main() {
int x = 10;
int *pi;
pi = &x;
/* *pi igual a 10 */
(*pi)++;
/* *pi igual a 11 */
printf("%d" , x);
return 0;
}

int main() {
int x = 10;
int *pi, *pj;
pi = &x;
pj = pi;
(*pi)++;
(*pj)++;
printf("%d", x);
return 0;

ao alterar *pi estamos alterando o contedo de x

/*
/*
/*
/*
/*

*pi == 10 */
*pj == 10 */
(*pi, *pj, x) == 11 */
(*pi, *pj, x) == 12 */
Escrever 12 */

Referenciando Arrays
Pode-se referenciar os elementos de um array
atravs de ponteiros

PONTEIROS & ARRAYS

Ex: float m[] = { 1.0, 3.0, 5.75, 2.345 };

float *pf;
pf = &m[2];
printf("%f", *pf); /* Escreve 5.75 */

Referenciando Elementos
Pode-se utilizar ponteiros e colchetes:
float m[] = { 1.0, 3.0, 5.75, 2.345 };
float *pf;
pf = &m[2];
printf("%f", pf[0]); /* ==> 5.75 */

Note que o valor entre colchetes o

deslocamento a ser considerado a partir do
endereo de referncia

PONTEIROS & PARMETROS DE

FUNES

pf[n] => indica n-simo elemento a partir de pf

Passagem de Informaes

Exemplo

Argumentos passados por referncia

Quando chamada, a funo passa a referenciar
(apontar) a varivel informada
Portanto o processo consiste em informar o
endereo da varivel para o que o parmetro
formal possa referenci-lo.
Os argumentos deixam de existir aps a execuo
do mtodo, porm as variveis informadas e que
foram referenciadas permanecem (pois no so
dadas por este bloco de comandos).

#include <stdio.h>

/* Definio das subrotinas */

/* Prottipos */
void funcPorVarlor(int a);
void funcPorRefer(int *b);

void funcPorVarlor(int a){

a = 1;
}

int main () {
int x = 0, y = 0;

void funcPorRefer(int *b){

*b = 2; /* ... o contedo apontado
por b recebe 2 */
}

funcPorValor(y);
printf("%d %d\n", x, y);

funcPorRefer(&y);
printf("%d %d\n", x, y);
return 0;
}

Note que as variveis x e y so locais

a funo main, enquanto os
parmetros a e b so locais a
funcPorValor e funcPorRefer,
respectivamente.

15

Operaes Vlidas Sobre Ponteiros

vlido

somar ou subtrair um
inteiro a um ponteiro
(pi int)

incrementar ou
decrementar ponteiros
(pi++, pi--)

subtrair ponteiros (produz

um inteiro)
(pf - pi)

comparar ponteiros
( >, >=, <, <=, == )

No vlido

somar ponteiros
(pi + pf)

multiplicar ou dividir
ponteiros
(pi*pf, pi/pf)

operar ponteiros com

double ou float
(pi 2.0)

Exerccios
1) Faa um programa que leia 2 valores inteiros e
chame uma funo que receba estas 2 variveis e
troque o seu contedo, ou seja, esta rotina
chamada passando duas variveis A e B por
exemplo, e aps a execuo da rotina A conter o
valor de B e B ter o valor de A.
2) Escreva uma funo que dado um nmero real
passado como parmetro, retorne a parte inteira e
a parte fracionria deste nmero.

Exerccios
3) Crie uma funo que recebe os
coeficientes de uma funo do 2o. grau
e retorna as razes sem usar vetor.

Exerccios
5) Faa um programa que acha o maior e o
menor inteiro dentro de um vetor de 10
inteiros.
Obs: usar apenas as variveis a seguir:
int v[10], i, *maior, *menor;

4) Faa um programa leia um vetor de 5

inteiros e, depois de ler, imprima os valores,
sem usar a notao de vetor [].