PONTEIROS

Prof. Luciane
PONTEIROS
Variável que armazena um ENDEREÇO
de memória.
Esse endereço é a posição de outra
variável na memória.
Se uma variável contém o endereço
de outra, então, essa variável “deve”
apontar para a outra.
PONTEIROS
Os operadores especiais para ponteiros são:

* (redireção ou indireção)
retorna o valor apontado pelo ponteiro.

& (operador de endereço)

retorna o endereço na memória de seu operando.
DECLARAÇÃO E USO
A forma geral para declarar uma variável ponteiro é:
tipo *nome;
onde tipo refere-se ao tipo da variável para a qual a variável ponteiro irá
apontar, * indica que a variável é um ponteiro e nome refere-se ao nome
da variável ponteiro.
Para atribuir o endereço de uma variável a um
ponteiro → utilizamos o operador de endereço (&).
EXEMPLO
------------------------
int i = 10;
int *pi;
pi = &i;

*pi = 20:
------------------------
EXEMPLO
------------------------
int i = 10;
int *pi;
pi = &i;

*pi = 20:
------------------------
EXEMPLO
------------------------
int i = 10;
int *pi;
pi = &i;

*pi = 20:
------------------------
EXEMPLO
------------------------
int i = 10;
int *pi;
pi = &i;

*pi = 20:
------------------------
E se a gente esquecer de colocar o *??

------------------------
int i = 10;
int *pi;
pi = &i;

pi = 20:
------------------------
Funções e
parâmetros
Chamada por valor
Uma CÓPIA dos valores dos parâmetros é passada
para a função.

Desse modo, a função tem acesso apenas ao valor da

variável passada por parâmetro, não à própria variável
original.

A função não pode modificar o valor da variável

original.
Chamada por valor
void main(void){
int nota = 5;

fnota(nota);
printf(“nota: %d\n", nota);
}

void fnota(int nota){

nota = 10;
}
Chamada por valor

void main(void){
int nota = 5;

fnota(nota);
printf(“nota: %d\n", nota);
}

void fnota(int nota){

nota = 10;
}
Chamada por valor

void main(void){
int nota = 5;

fnota(nota);
printf(“nota: %d\n", nota);
}

void fnota(int nota){

nota = 10;
}
Chamada por valor

void main(void){
int nota = 5;

fnota(nota);
printf(“nota: %d\n", nota);
}

void fnota(int nota){

nota = 10;
}
Chamada por referência
A função recebe o endereço de memória do parâmetro
(uma referência – um PONTEIRO).

Assim, a função pode alterar o valor da variável original.

 Chamada por referência
void main(void){
int nota = 5;

fnota(&nota);
printf(“nota: %d\n", nota);
}

void fnota(int *pnota){

*pnota = 10;
}
Chamada por referência
void main(void){
int nota = 5;

fnota(&nota);
printf(“nota: %d\n", nota);
}

void fnota(int *pnota){

*pnota = 10;
}
Chamada por referência
void main(void){
int nota = 5;

fnota(&nota);
printf(“nota: %d\n", nota);
}

void fnota(int *pnota){

*pnota = 10;
}
Chamada por referência
void main(void){
int nota = 5;

fnota(&nota);
printf(“nota: %d\n", nota);
}

void fnota(int *pnota){

*pnota = 10;
}
Ponteiro → Operações
Um ponteiro pode receber o endereço de uma variável comum.
pv = &v
Um ponteiro pode receber o valor (endereço) de outra variável ponteiro
(desde que, as duas variáveis apontem para variáveis do mesmo tipo).
pv = px
Uma variável ponteiro pode ser assinalada com um valor nulo.
pv = NULL
Um valor inteiro pode ser adicionado ou subtraído de um ponteiro.
pv = pv + 1 ou ++py
Duas variáveis ponteiro podem ser comparadas.
pv == py
Aritmética de Ponteiros
Suponha que px seja uma variável ponteiro representando o
endereço da variável x.
Podemos escrever expressões como ++px, --px, px = px + 3.
Cada expressão representa um endereço localizado a alguma
distância do endereço original representado por px.
A distância será o produto da quantidade inteira pelo número
de bytes correspondente ao tipo do ponteiro.
Aritmética de Ponteiros
Suponha que px aponte para uma variável inteira e que cada
variável inteira ocupe 4 bytes de memória.
Desse modo, a expressão (px = px + 3) resultará em um
endereço 12 bytes após o endereço para o qual px aponta.
px = px + (3*4)
px = px + 12

Entretanto, esse novo endereço não representa necessariamente

o endereço de outro item de dado, pois os itens de dados
armazenados entre os dois endereços podem envolver tipos de
dados diferentes.
Vetores e Ponteiros
Um subscrito da vetor representa a localização do elemento da
vetor em relação ao seu primeiro elemento.
Isso funciona pois todos os elementos da vetor são do mesmo
tipo e, portanto, cada elemento ocupa o mesmo número de
bytes na memória.
O espaço de memória ocupado por cada elemento da vetor
depende do tipo da vetor.
Vetores e Ponteiros
Desse modo, o nome do vetor é um ponteiro que guarda o
endereço do primeiro byte.
Assim, podemos acessar determinado elemento do vetor
utilizando o subscrito do vetor ou a aritmética de ponteiros.
EXEMPLO – Vetores e ponteiros

Podemos imprimir o valor do primeiro elemento do vetor:

printf(“%d”, v[0]);
ou
printf(“%d”, v);
EXEMPLO – Vetores e ponteiros

Podemos imprimir o valor do último elemento do vetor:

printf(“%d”, v[4]);
ou
printf(“%d”, *(v+4));
Responda ...
No bloco de código abaixo, conseguimos efetuar a leitura do valor de saldo?

#include <stdio.h>

int main(){
float saldo;
float *Psaldo;
Psaldo = &saldo;
scanf("%f", Psaldo);
printf("%f", saldo);
}
Responda ... SIM!!
pois
No bloco de código abaixo, conseguimos Psaldo
efetuar a leitura== &saldo
do valor de saldo?

#include <stdio.h>

int main(){
float saldo;
float *Psaldo;
Psaldo = &saldo;
scanf("%f", Psaldo);
printf("%f", saldo);
}
 PRÓXIMA AULA:
15-julho

BOM FINAL Exercícios no

moodle
DE SEMANA!!!
Data de envio:
14-julho