Ponteiros (Cap.7) Conceito (Cap.

7)
Sumário:
É uma variável que contém um endereço de memória
•Entender o Conceito de ponteiros
como valor. O ponteiro faz uma referência indireta
•Chamadas por referência a um valor.
•Relacionamentos entre ponteiros e arrays
•Aritmética de ponteiros
iptr i

● 3000 4

Características (Cap.7) Declaração (Cap.7)

O ponteiro é uma variável que “aponta” para outra cujo
conteúdo é de um “tipo específico”.
inteiro
- Grande poder x grande responsabilidade
- Simula chamadas por referência float *A, B;
- Permite a criação de estruturas de tamanho variável int *contptr, cont;
em tempo de execução
- É uma variável ponteiro
tipo *nome;

OBS: Muitos programadores utilizam o sufixo ptr para

lembrar que a variável e do tipo ponteiro. Utiliza-se o * para
declarar um ponteiro.

Inicialização (Cap.7) Operadores de Ponteiros (Cap.7)

Podem ser inicializados ao serem declarados ou em uma Operador &: devolve o endereço do operando.
atribuição.
Tipos: - zero Exemplo:
- endereço int y=5; int x;
int *yptr;
- null stdio.h
yptr = &y;
Exemplo:
int *aptr, b; int *aptr = null; Operador *: devolve o valor da variável apontada pelo
aptr = 0; operando.
(aptr= &b;) próxima seleção
Exemplo:
aptr = null; x = *yptr;
OBS: Jamais usar um ponteiro sem antes inicializá-lo!

1
 Exemplo (Cap.7) Chamada de Função por Referência (Cap.7)

# include <stdio.h>
main( ) - Caso dos ARRAYS: é passado a função o
{ endereço de início do array.
int a, * aptr;
a = 7;
aptr = &a;
- Caso dos ESCALARES: é passado o valor da
printf (“o endereço de a é %p\n” variável.
“o valor de aptr é %\n\n”, &a, aptr);
printf (“o valor de a é %d\n\n” - PONTEIRO: permite que seja passado o endereço
“o valor de *aptr é %d\n\n”, a, *aptr); onde a variável esta armazenada.
}

A especificação %p envia o end. em HEXA (pg 313), especificadores de conversão

Exemplo: (Cap.7) Exemplo: (Cap.7)

a) Passagem por valores: b) Passagem de referência

/* Eleva uma variável ao cubo usando chamada por valor */ # include <stdio.h>
#include <studio.h> void cuboporreferência(int *);
int cuboporvalor (int); main
main ( ) {
{ int numero = 5
int numero = 5 printf(“o valor original do número é %d\n”, número); (5)
printf(“o valor original do numero é %d\m”,numero); (5) cuboporreferência (&numero);
numero = cuboporvalor (numero); printf (“o novo valor do numero é %d\n”, numero); (125)
printf (“o novo valor do numero é %d\m”, numero); (125) return 0
return 0; }
} void cuboporreferência (int *nptr)
int cuboporvalor (int n) {
{ *nptr = *nptr * *nptr * *nptr
return n*n*n; }
}

Aritmética de Ponteiros (Cap.7) Ponteiros e Arrays (Cap.7)

Tipos de Operações:
- Incremento (- -)
- Decremento (+ +)
→ Estão intimamente relacionados.
- Adição de um inteiro → Exemplo:
- Subtração de um inteiro
- Subtração de ponteiros Tem o mesmo
Exemplo: Suponha que o inteiro tenha 4 bytes. int b [5]; (declaração) efeito
int *bptr;
vptr ● 3000 3004 3008 3012
bptr = b; (aponta para o primeiro elemento de b)
vptr += 2 vptr 3008 (3000+ (2*4) ) bptr = &b[0]
Vptr ++ vptr 3012 O valor do offset(3)
*(bptr + 3) → b[3] equivale ao subscrito
OBS: A aritmética de ponteiros difere da convencional. O incremento de um do array b[3]
ponteiro corresponde um deslocamento de tamanho igual tipo da variável
em bytes.

2
 Programa Exemplo (Cap.4) Operador Sizeof (Cap.7)
#include <stdio.h> (pg. 233 – estudar)
main( )
{
Determina o tamanho de um elemento em bytes.
int i, offset, b[ ] = {10, 20, 30, 40};
int – bptr = b; #include <stdio.h>
printf (“array b impresso com:\n” main( )
“notação de subscrito de array\n”);
for (i = 0; i<=3; i++) Int i
printf (“notação ponteiro/offset”\n); {
for (offset = 0; offset <=3; offset++)
printf (“*(b+%d) = %d\n”, offset, - (b + offset)); Printf (“sizeof(i) = %d\n”, sizeof(i) );
printf (“notação subscrito de ponteiro\n”);
}
for (i = 0; i <= 3; i ++)
printf (“bptr [%d] = %d\n”, i, bptr[i]);
printf (“notação ponteiro/offset\n”);
for (offset = 0; offset <=3; offset++)
printf (“+(bptr+%d) = %d\n”, offset, *(pbtr+offset));
return 0;
}

Ponteiros (Cap.7) Arrays de Ponteiros (Cap.7)

Ponteiros para Ponteiros Ex:
O ponteiro contém um endereço de outro ponteiro que aponta para char *naipe[4] = {“copas”, “ouros”, “paus”, “espadas”}
uma variável de interesse.

Ex: “Naipe” é um array de quatro posições cujos elementos (são

main( ) endereços) apontam para caracteres.
{
Cada uma das cadeias de caracteres são armazenados em um
int x, *p, **q; dado local disponível de memória e são terminadas por “\0”. Cada
x = 10; um dos ponteiros do array aponta para o endereço do primeiro
p = &x; caractere de cada uma delas.
q = &p;
printf (“%d”, **q);
Vantagem: Não é necessário alocar um espaço “retangular”
}

Ponteiros para Função (Cap.7) Exercícios (Cap.7)

Um ponteiro para função guarda o endereço inicial da #include <stdio.h> (pg. 233 – estudar)
main( )
posição onde a função esta armazenada. {
int i, offset, b[ ] = {10, 20, 30, 40};
int – bptr = b;
ANALOGIA: printf (“array b impresso com:\n”
“notação de subscrito de array\n”);
..................................................
.......................................
Nome do Array → endereço inicial onde esta armazenado. ..........................

Nome da função → endereço inicial (onde está armazenado)

do código que realiza a tarefa.
Multiplicação de matrizes utilizando ponteiros