Linguagem de
programação I A
Carlos Oberdan Rolim
Ciência da Computação
Sistemas de Informação
Versão: 220514_01
Ponteiros
O C é altamente dependente dos ponteiros. Para ser um
bom programador em C é fundamental que se tenha um bom
domínio deles
O Ministério da Saúde adverte: o uso descuidado de
ponteiros pode levar a sérios bugs e a dores de cabeça
terríveis :-).
Ponteiros em Linguagem C
O Que é uma variável?
É uma área da memória do computador onde é armazenado um valor….
Exemplo 1:
int a = 1;  Atribui ao endereço 1000 o valor 1
1000
1
1001
1002
1003
Variável
Posição
a
1000
Ponteiros em Linguagem C
O Que É Um Ponteiro?
Um ponteiro é uma variável que aponta para outra variável. Isto significa
que um ponteiro mantém o endereço de memória de outra variável. Em
outras palavras, o ponteiro não contém um valor no sentido tradicional,
mas sim o endereço de outra variável. Um ponteiro "aponta para" esta
outra variável mantendo uma cópia de seu endereço
Convém dizer que a expressão “apontar para...” significa “armazenar o
endereço de memória de...”
Como um ponteiro contém um endereço, e não um valor, terá duas
partes. O ponteiro contém um endereço e o endereço aponta para um
valor. Há o ponteiro e o valor para o qual ele aponta. Este fato pode
ser um tanto confuso, até você se familiarizar com ele. Superada a etapa
da familiarização, ele se torna extremamente eficaz.
Ponteiros em Linguagem C
Operadores relacionados a Ponteiros:
*(asterisco): informa que uma variável irá armazenar o endereço de outra
variável; ou:
Informa ao computador que você deseja o conteúdo que está no endereço
armazenado;
- Pode ser lido como “o conteúdo no endereço”
q = *m;
 q recebe o valor armazenado no endereço m
& (e comercial): retorna o endereço de uma variável;
- Pode ser lido como “o endereço de”
m = &count;  m recebe o endereço de count
Ponteiros em Linguagem C
int main() {
int i,j;
int *p;
p = &i;
*p=5;
j=i;
printf(("%d %d %d\n", i, j, *p);
return 0;
}
==> 5 5 5
Operadores de ponteiros
* (asterisco) indica que a variável é um ponteiro
tipo_dado *nome_ponteiro;
Ex:
int x;
int *pi;
/* compilador sabe que pi é ponteiro */
/* pi é um ponteiro para inteiro */
Operadores de ponteiros
o operador “&” quando aplicado sobre uma variável retorna
o seu endereço
Ex:
int x = 10, *pi;
pi = &x;
printf(“&x: %p pi: %p”, &x, pi);
=> &x: 0x03062fd8 pi: 0x03062fd8
Operadores de ponteiros
o operador “*” quando aplicado sobre um ponteiro retorna
o dado apontado
0xABA0
Ex:
tmp_ptr
void main () {
int *tmp_ptr;
int x, y;
x = 10;
tmp_ptr = &x;
y = *tmp_ptr; /* (*tmp_ptr) = 10 */
}
0xABA0
10
x
0xABA2
10
y
Outro exemplo ilustrado
int i;
int *p;
p = &i;
*p=5;
Relembrando...
operador *
Usado na declaração de um ponteiro
int *x
Usado para acessar o conteúdo de um endereço apontado
*x = 10; // atribui o valor 10 ao local apontado pelo ponteiro ‘x’
printf(“%d”, *x); // imprime o valor armazenado no local apontado por ‘x’
operador &
acessa o endereço de uma variável
Exemplo de uso
 declara variavel inteiro com
valor 1
int *pt_a;
 declara um ponteiro para um
inteiro
pt_a = &a;
 ponteiro recebe o endereco da
variavel a
printf(“%d”, *pt_a);  imprime o valor apontado pelo
ponteiro
int a = 1;
Ponteiros
ponteiros são variáveis tipadas:
(int *) ≠ (float *) ≠ (char *)
As variaveis ponteiro devem sempre apontar para os tipos
de dados corretos. Uma variavel ponteiro declarada como
apontador de dados inteiros deve sempre apontar para
dados deste tipo.
Ex:
main() {
int *ip, x;
float *fp, z;
ip = &x; /* OK */
fp = &z; /* OK */
ip = &z; /* erro */
fp = &x; /* erro */
}
Ponteiros
espaço ocupado pelas variáveis
Ponteiro aponta para o tamanho segundo seu tipo
1 byte
(int *)
1 byte
(float *)
(char *)
Exemplo de uso
Exemplo:
int a = 1;
int *pt_a;
pt_a = &a;
1000
1
1001
1000
1002
1003
Variável
Posição
a
1000
pt_a
1001
Ponteiros em Linguagem C
Onde usar isto???
Funções!
Alocação Dinâmica
Não sei o tamanho que o vetor precisa ter….!
Não sei o tamanho que cada string precisa
ter…
Não sei o tamanho que a matriz precisa ter…
Utilizando Ponteiros
void main() {
int x = 10;
int *pi;
pi = &x; /* *pi == 10 */
(*pi)++; /* *pi == 11 */
printf(“%d”, x);
}
==> 11
ao alterar *pi estamos alterando o conteúdo de x
Utilizando Ponteiros
void main() {
int x = 10;
int *pi, *pj;
pi = &x;
/* *pi == 10 */
pj = pi;
/* *pj == 10 */
(*pi)++;
/* (*pi, *pj, x) == 11 */
(*pj)++;
/* (*pi, *pj, x) == 12 */
printf(“%d”, x);
/* ==> 12 */
printf(“%x”, &pj); /* Endereco de x ==> 0x0c220c */
}
Arrays e ponteiros
Lembrando: arrays são agrupamentos de dados
adjacentes na memória
declaração:
tipo nome_array[<tamanho>];
define um arranjo de <tamanho> elementos adjacentes na
memória do tipo tipo_dado
Arrays e ponteiros’
Representação na memória:
float m[10], *pf;
pf = m;
m
pf
Note que m é um ponteiro !!!!
Referenciando Arrays
em float m[10] m é uma constante que endereça o primeiro
elemento do array
portanto, não é possível mudar o valor de m
Ex:
float m[10], n[10];
float *pf;
m = n;
/* erro: m é constante ! */
pf = m; /* ok */
Referenciando Elementos
pode-se referenciar os elementos do array através do seu
nome e colchetes:
m[5] = 5.5;
if (m[5] == 5.5)
printf(“Exito”);
else
printf(“Falha”);
Referenciando Elementos
Pode-se referenciar os elementos de um array através de
ponteiros:
float m[ ] = { 1.0, 3.0, 5.75, 2.345 };
float *pf;
pf = &m[2];
printf(“%f”, *pf); /* ==> 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 endereço de referência
pf[n] => indica enésimo elemento a partir de pf
Exemplo
void main ()
{
int arint[ ] = { 1,2,3,4,5,6,7 };
int size = 7;
/* tamanho do array */
int i, *pi;
for (pi=arint, i=0; i < size; i++, pi++)
printf(“ %d “, *pi);
}
==> 1 2 3 4 5 6 7
Exemplo - variação
void main ()
{
int arint[] = { 1,2,3,4,5,6,7 };
int size = 7;
/* tamanho do array */
int i, *pi;
for (pi=arint, i=0; i < size; i++)
printf(“ %d “, *pi++);
}
==> 1 2 3 4 5 6 7
Exemplo - variação
void main () {
int arint[] = { 1,2,3,4,5,6,7 };
int size = 7;
/* tamanho do array */
int i, *pi;
pi = arint;
printf(“ %d “, *pi); pi += 2;
printf(“ %d “, *pi); pi += 2;
printf(“ %d “, *pi); pi += 2;
printf(“ %d “, *pi);
}
==> 1 3 5 7
Isso causa a maior confusão....
int main() {
int vetor[] = {1, 3, 5, 7, 9};
int *p = vetor;
printf("%d \n", *p ); /* imprime 1 (posicao 0)*/
printf("%d \n", *p++ ); /* imprime 1 e incrementa o p para proxima posicao (posicao 1) */
printf("%d \n", (*p)++ ); /* imprime 3 e incrementa valor que esta posicao 1 (onde p aponta) */
printf("%d \n", *p ); /* p estah apontando para posicao 1, imprime 4 */
p++; /* p agora aponta para a proxima posicao, isto eh posicao 2, valor 5 */
printf("%d - %p\n", *p , p); /* imprime posicao 2, valor 5 */
==> 1 1 3 4 5
Resumindo:
p++  incrementa o ponteiro para próxima posição
*p++  retorna o valor para onde p aponta e depois incrementa o p para próxima posição
(*p)++  retorna o valor para onde p aponta e depois incrementa o valor que está ali armazenado
(não muda a posição de p)
Aritmética de Ponteiros
É possível fazer operações aritméticas e relacionais
entre ponteiros e inteiros
Aritmética de Ponteiros
Atribuição: Da mesma maneira que ocorre com uma variável
comum, o conteúdo de um ponteiro pode ser passado para
outro ponteiro do mesmo tipo.
Observar que em C é possível atribuir qualquer endereço a
uma variável ponteiro.
Deste modo é possível atribuir o endereço de uma variável
do tipo float a um ponteiro do tipo int. No entanto, o
programa não irá funcionar da maneira correta.
....
int vetor [] = { 10, 20, 30, 40, 50 };
int *p1 , *p2;
int i = 100;
p1 = &
vetor [2];
p2 = &i;
p2 = p1;
...
Aritmética de Ponteiros
Soma e subtração:
Quando soma-se 1 a uma variável seu valor é incrementado
em 1. No caso de ponteiros quando adiciona-se 1 o valor é
incrementado de um valor que corresponde a quantidade de
bytes do tipo para o qual aponta
Assim, ao somar 1 a um ponteiro de int o seu valor será
incrementado em 4 (devido a int = 4 bytes)
Ao somar-se um inteiro n a um ponteiro, endereçamos n
elementos a mais (n positivo) ou a menos (n negativo)
pf[2]
equivale a *(pf+2)
*(pf + n)
endereça n elementos a frente
*(pf - n)
endereça n elementos atrás
pf++
endereça próximo elemento array
pf--
endereça elemento anterior array
Aritmética de Ponteiros
Exemplos
p = p + 3;  p aponte para o terceiro elemento após o atual
*(p+1)=10;  armazena o valor 10 na posição seguinte
A diferença entre ponteiros fornece quantos elementos do
tipo do ponteiro existem entre os dois ponteiros
int main (void) {
float vetor [] = { 1.0, 2.0, 3.0, 4.0, 5.0 };
float *p1 , *p2;
p1 = & vetor [2]; /* endereco do terceiro elemento */
p2 = vetor;
/* endereco do primeiro elemento */
printf(" Diferenca entre ponteiros %d\n", p1 -p2 );
return 0;
}
==> 2
Operações Válidas Sobre Ponteiros
É valido:
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 ( >, >=, <, <=, == )
Não é válido:
somar ponteiros
(pi + pf)
multiplicar ou dividir ponteiros (pi*pf, pi/pf)
operar ponteiros com double ou float (pi ± 2.0)
Cuidados...
C não controla os limites dos arrays, o programador deve
fazê-lo
Ex:
encontrar o erro:
void main () {
int arint[] = { 1,2,3,4,5,6,7 };
int size = 7, i, *pi;
for (pi=arint, i=0; i < size; i++, pi += 2)
printf(“ %d “, *pi);
}
Cuidados...
void main ()
{
int arint[] = { 1,2,3,4,5,6,7 };
int size = 10;
int i;
for (pi=arint, i=0; i < size; i++)
printf(“ %d “, arint[i]);
}
Cuidados...
Um ponteiro deve sempre apontar para um local válido
antes de ser utilizado
Ex:
void main ()
{
int i=10, *pi;
*pi = i;
/*erro ! pi nao tem endereco valido*/
}
void main ()
{
int i=10, *pi = NULL;
*pi = i;
}
/*erro ! pi nao tem endereco valido*/
Ponteiros e Strings
Quando imprimimos uma cadeia de caracteres constantes
(string) com printf o que é passado é o ponteiro para a
cadeia.
Printf(“Ola como vai?”);
Dessa forma é possível carregar o endereço da string em um
ponteiro do tipo char
char * lista;
lista = "Ola como vai ?";
printf("%s", lista );
Ponteiros e Strings
Na verdade, strings são arrays de caracteres e podem ser
acessados através de char *
void main ()
{
char str[]=“abcdef”, *pc;
for (pc = str; *pc != ‘\0’; pc++)
putchar(*pc);
}
==> abcdef
o incremento de pc o posiciona sobre o próximo caracter
(byte a byte)
Ponteiros e Strings
Outra forma de mostrar uma string usando laço
char *origem = "testando";
do{
printf("%c ", *origem);
}while (*origem++); /* origem == \0 encerra o laco */
Primeiro retorna o conteúdo da
posição apontada e depois
incrementa a posição (precedência
de operadores)
Arrays Multidimensionais
Arrays podem ter diversas dimensões, cada uma identificada
por um par de colchetes na declaração
Ex:
char multi[5][10];
declara um array de 5 linhas e 10 colunas:
[0,0]
na memória, entretanto, os caracteres são
armazenados linearmente:
[4,9]
[0,0]
[0,9]
[1,9]
[4,9]
Arrays Multidimensionais
Percorrendo array com índices:
void main () {
char multi[5][10];
int lin, col;
for (lin=0; lin<5; lin++)
for (col =0; col<10; col++)
multi[lin][col] = ‘ ‘;
}
as colunas (dimensões mais a direita) mudam mais rápido
Arrays Multidimensionais
Percorrendo array com ponteiro:
void main () {
char multi[5][10];
char *pc;
pc aponta para primeira
posição do array
int i;
for (i=0, pc=multi[0]; i < 50; i++, pc++)
*pc = ‘ ‘;
}
Perceba a quantidade
total de elementos
Arrays Multidimensionais
Outra forma de visualizar
char multi[5][10]
O nome multi[5] é por si só um array indicando que existem 5 elementos,
cada um deles sendo um array de 10 caracteres.
multi[0] = {'0','1','2','3','4','5','6','7','8','9'}
multi[1] = {'a','b','c','d','e','f','g','h','i','j'}
multi[2] = {'A','B','C','D','E','F','G','H','I','J'}
multi[3] = {'9','8','7','6','5','4','3','2','1','0'}
multi[4] = {'J','I','H','G','F','E','D','C','B','A‘
Como os arrays são contíguos na memória, nosso bloco de memória para
o array acima pode ser algo do tipo:
0123456789abcdefghijABCDEFGHIJ9876543210JIHGFEDCBA
inicio no endereço &multi[0][0]
Arrays Multidimensionais
multi[0] = {'0','1','2','3','4','5','6','7','8','9'}
multi[1] = {'a','b','c','d','e','f','g','h','i','j'}
multi[2] = {'A','B','C','D','E','F','G','H','I','J'}
multi[3] = {'9','8','7','6','5','4','3','2','1','0'}
multi[4] = {'J','I','H','G','F','E','D','C','B','A‘
O compilador sabe quantas colunas estão presentes no array de forma que ele
pode interpretar multi + 1 como o endereço do 'a' na segunda linha. Ou seja,
ele acrescenta 10, o número de colunas, para obter sua posição
Assim, o endereço de 9 na quarta linha acima seria &multi[3][0] ou (multi + 3)
em notação de ponteiro
Para obter o conteúdo do segundo elemento na quarta linha nós
acrescentaríamos 1 a seu endereço e dereferenciaríamos o resultado como
em
*(*(multi + 3) + 1)
Com um pouco de raciocínio, podemos ver que:
*(*(multi + lin) + col)
e multi[lin][col]
dão o mesmo resultado.
Arrays Multidimensionais
Outra forma de implementar o programa anterior
int main( ){
char multi[5][10];
int lin, col;
for (lin=0; lin < 5; lin++)
for (col=0; col < 10; col++)
*(*(multi + lin) + col) = 'A';
for (lin=0; lin < 5; lin++)
for (col=0; col < 10; col++)
printf("%c", *(*(multi + lin) + col)
}
);
Array de Strings
Neste caso, cada elemento do array é um ponteiro para um
caracter
Declaração:
char *arstr[] = {“Joao”, “Maria”, “Antonio”,
“Zacarias”, “Carlos”};
arstr é um array de ponteiros para char, iniciado com os
strings indicados
Array de Strings
Comparando array de string com array de char
char *as[]
= {“Joao”,“Maria”,“Antonio”,“Zacarias”,“Carlos”};
char ma[5][10] = {“Joao”,“Maria”,“Antonio”,“Zacarias”,“Carlos”};
Matriz (ma)
Ponteiros (as)
“Joao”
“Maria”
“Antonio”
“Zacarias”
“Carlos”
J
M
A
Z
C
o
a
n
a
a
a
r
t
c
r
o \0
i a \0
o n i o \0
a r i a s \0
l o s \0
Cuidados com Strings
É comum esquecer de alocar uma área para
armazenamento de caracteres
void main() {
char *pc; char str[] = “Um string”;
strcpy(pc, str); /* erro! pc indeterminado */
...
}
Ponteiros Genéricos
Um ponteiro genérico é um ponteiro que pode apontar
para qualquer tipo de dado
Define-se um ponteiro genérico utilizando-se o tipo void:
void *pv;
int x=10;
float f=3.5;
pv = &x;
pv = &f;
/* aqui pv aponta para um inteiro */
/* aqui, para um float */
Ponteiros Genéricos
O tipo de dado apontado por um void pointer deve ser
controlado pelo usuário
Usando um type cast (conversão de tipo) o programa pode
tratar adequadamente o ponteiro
pv = &x;
type cast
printf(“Inteiro: %d\n”, *(int *)pv);
/*=> 10*/
pv = &f;
printf(“Real: %f\n”, *(float *)pv);
/*=> 3.5*/
Ponteiros para Ponteiros
É possível definir ponteiros para ponteiros até um nível
arbitrário de indireção
Ex:
char *pc; /* ponteiro para char */
char **ppc;/* ponteiro para ponteiro para char */
pc = “teste”;
ppc = &pc;
putchar(**ppc); /* ==> ‘t’ */
Ponteiros para Ponteiros
Ponteiro para ponteiro para ponteiro...
Ex:
char *pc, **ppc, ***pppc;
Um ponteiro permite modificar o objeto apontado ou apontar
para outro objeto do mesmo tipo
Alocação dinâmica de memória
Pode-se alocar dinâmicamente (em tempo de execução) um
espaço de memória para uso com arrays, structs, etc...
int main() {
int *p;
p = (int *) malloc(sizeof(int));
if (p == 0) {
printf("ERRO: Sem memória\n");
return 1;
}
*p = 5;
printf("&d\n", *p);
free(p);
return 0;
}
Aloca de forma dinâmica espaço para um inteiro
Alocação dinâmica de memória
malloc
Utilizamos a função malloc() quando não conseguimos prever a
quantidade de memória que nosso programa irá necessitar.
A função malloc() pode ser utilizada em run time para determinar o
tamanho de um array.
Exemplo
char * p;
p = malloc(50);
p = (char *) malloc (sizeof (char));
free
Libera memória alocada previamente
Exemplo
free(p);
Realocação de memória
Função realloc()
O realloc tenta realocar a quantidade de memória pedida na
seqüência da já alocada, se não consegue, ele aloca uma
nova área e retorna o ponteiro pra essa área, liberando a
área previamente alocada.
Declaração: void *realloc(void *ptr, size_t size);
Parâmetros:
Se ptr é nulo realloc() aloca o tamanaho em bytes na
memória e retorna um ponteiro.
Se size é zero, a memória apontada por ptr é liberada
Exemplo de realocação de memória
int main() {
/* aloca um espaco para 10 caracteres – 10 bytes*/
char *pointer = (char *) malloc(10 *sizeof(char));
/* realocando espaco para 20 bytes)
realloc(pointer, 20); /* errado */
/* realocando espaco para 20 bytes)
pointer = (char *) realloc(pointer, 20); /* certo */
return 0;
}
Não esquecer do
casting
Alocação dinâmica de arrays
void main() {
int numero = 10, i;
int *ar;
ar = (int *) malloc(numero * sizeof(int));
for (i=0; i < numero; i++) {
arr[i] = i;
printf("%d \n", arr[i]);
}
free(arranjo);
}
Aloca de forma dinâmica espaço para um array de inteiros de 10 posições
int main() {
int linhas, colunas, lin, col, i;
int *vetor, **matriz;
printf("\nDigite o numero de linhas: ");
scanf("%d",&linhas);
printf("\nDigite o numero de colunas: ");
scanf("%d",&colunas);
/****** Primeira forma de fazer
( .... Continuacao ... )
/* Para demonstrar le um valor , coloca no array
e depois mostra o valor da posicao */
for(col=0; col < colunas; col++)
for(lin=0; lin < linhas; lin++){
printf("Informe um valor para [%d][%d]\n",
lin, col);
vetor = (int *) malloc( linhas * colunas * sizeof(int) );
matriz = (int **) malloc( linhas * sizeof(int) );
for(i=0;i<linhas;i++)
matriz[i]= &vetor[i];
scanf("%d", &matriz[lin][col]);
printf(" Valor lido-> %d\n\n“, matriz[lin][col]);
*/
}
/****** Segunda forma de fazer */
matriz= (int **) malloc( linhas * sizeof( int ) );
for(i=0;i<linhas;i++)
matriz[i]= (int *) malloc( colunas * sizeof( int ) );
/*a partir deste ponto pode ser usado matriz[a][b]
sendo a o número da linha e b o número da coluna
para qualquer parte do programa*/
/*faz a liberação da memória alocada*/
free(vetor);
free(matriz);
return 0;
}
Aloca de forma dinâmica espaço para um array bidimensional com tamanho
fornecido pelo usuário