O documento apresenta um resumo sobre ponteiros em 3 frases: 1) Ponteiros armazenam endereços de memória de outras variáveis em vez de valores diretamente. 2) Operadores como * e & são usados para acessar e obter endereços de memória de variáveis apontadas por ponteiros. 3) Ponteiros permitem a passagem de parâmetros por referência, alocação dinâmica de memória e estruturas de dados complexas como listas ligadas.

1. Programação Estruturada II
Aula 05 – Ponteiros
Prof. Thomás da Costa
thomasdacosta@gmail.com
Anhanguera – 2015.1

2. Ponteiros
PONTEIROS
Prof. Thomás da Costa Programação Estruturada II

3. Ponteiros
O que é:
É um tipo de variável que armazena um endereço de memoria referente a uma
outra variável. O ponteiro não armazena diretamente um valor como os outros
tipos em C++.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II

4. Ponteiros
Mais detalhes:
- O entendimento de ponteiros é complexo
- São utilizados quando desejamos passar vetores como parâmetros da função
- É utilizado em passagem de parâmetros por referência
- Quando desejamos alocar e desalocar memória manualmente
- Em vetores do tipo char
- Criar estruturas complexas, como lista encadeadas e árvores binárias
- Atuar com desenvolvimento de aplicações complexas
Ponteiros
Prof. Thomás da Costa Programação Estruturada II

5. Ponteiros
Operadores:
Para operação com ponteiros, utilizamos dois operadores unários:
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Operador Descrição
* Utilizado para declarar um ponteiro e para retornar o valor
& Utilizado para retornar o endereço de memória da variável
Vamos ver como declarar uma variável do tipo ponteiro !!!

6. Ponteiros
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Declarando uma variável do tipo ponteiro:
int *ptr;
Tipo da variável
Nome da variável
Operador unário

7. Prof. Thomás da Costa Programação Estruturada II
Exemplo 1#include <iostream>
using namespace std;
int main()
{
int *ptr;
cout << ptr << endl;
}
Declarando um ponteiro
Exibe o endereço da variável, neste caso,
nenhum endereço foi atribuído

8. Ponteiros
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Declaração e atribuição de ponteiros:
Variável ponteiro
Atribuindo o endereço de
memória
int *ptr;
int valor;
valor = 1500;
ptr = &valor;

9. Prof. Thomás da Costa Programação Estruturada II
Exemplo 2
#include <iostream>
using namespace std;
int main()
{
int valor;
int *ptr;
valor = 1500;
ptr = &valor;
cout << ptr << endl;
cout << *ptr << endl;
}
ptrvalor
0x23fe480x23fe44
0x23fe480x23fe44 0x23fe441500

10. Ponteiros
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Mais detalhes:
- Ponteiro armazena o endereço de memória
- O operador & mostra o endereço da variável
- O operador * é utilizado na declaração do ponteiro
- Exibindo o valor de um ponteiro com cout é mostrado o
endereço referenciado
- Utilizando o operador * seguido pelo nome da variável
de ponteiro é exibido o valor atribuído no endereço de
memória referente.
Vamos ver mais um exemplo !!!

11. Prof. Thomás da Costa Programação Estruturada II
Exemplo 3
#include <iostream>
using namespace std;
int main()
{
int valor;
int *ptr;
int total;
valor = 1600;
ptr = &valor;
total = *ptr;
cout << *ptr << endl;
cout << total << endl;
}
ptrvalor
0x23fe480x23fe44
total
0x23fe40
0x23fe480x23fe44 0x23fe401600 0x23fe44 1600

12. Ponteiros
Importante:
A atribuição de valores para ponteiros, deve ser do mesmo tipo. Quando as
variáveis são de tipos diferentes, vamos ter um erro de compilação.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II

13. Prof. Thomás da Costa Programação Estruturada II
Exemplo 4
#include <iostream>
using namespace std;
int main()
{
// PROGRAMA COM ERRO NAO COMPILA !!!!
int *ptr_inteiro;
double valor;
valor = 345.76;
ptr_inteiro = &valor;
cout << *ptr_inteiro << endl;
}
ERRO !!!

14. Ponteiros
Conversão de valores:
Para atribuir ponteiros de tipos diferentes, utilizamos um conceito chamado cast.
O cast de variáveis ocorre em tipos similares. Neste processo as variáveis de um
tipo são convertido em outro tipo. Muitas vezes esta conversão não ocorre 100%
conforme o esperado.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II

15. Ponteiros
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Conversão de valores:
int *ptr_inteiro;
double valor;
ptr_inteiro = (int *)&valor;
Conversão de valores

16. Ponteiros
Conversão de valores:
Temos um pequeno problema quando existe a conversão de ponteiros de tipos
diferentes. Vamos ver no próximo exemplo.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II

17. Prof. Thomás da Costa Programação Estruturada II
Exemplo 5
#include <iostream>
using namespace std;
int main()
{
double valor;
int *ptr_inteiro;
valor = 345.76;
ptr_inteiro = (int *)&valor;
cout << *ptr_inteiro << endl;
}
ptr_inteirovalor
0x23fe480x23fe40
0x23fe40345.76 0x23fe480x23fe40
Valor exibido:
-171798692
Valor incorreto exibido pelo ponteiro !!!

18. Prof. Thomás da Costa Programação Estruturada II
Exemplo 6
#include <iostream>
using namespace std;
int main()
{
int *ptr_inteiro;
double valor_1;
double valor_2;
valor_1 = 345.76;
ptr_inteiro = (int *)&valor_1;
valor_2 = *ptr_inteiro;
cout << valor_1 << endl;
cout << *ptr_inteiro << endl;
cout << valor_2 << endl;
}
São exibidos valores errados
Conversão não funciona completamente

19. Ponteiros
Atribuição de valores:
Podemos atribuir um valor diretamente para um ponteiro. Para isso utilizamos o
operador * antes do nome da variável do tipo ponteiro.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
*ptr = 999;
Variável do tipo ponteiro
Atribuindo um valor

20. Prof. Thomás da Costa Programação Estruturada II
Exemplo 7
#include <iostream>
using namespace std;
int main()
{
int *ptr;
int x;
ptr = &x;
*ptr = 999;
cout << &x << endl;
cout << ptr << endl;
cout << *ptr << endl;
}
xptr
0x23fe440x23fe48
0x23fe48 0x23fe440x23fe44 999

21. Ponteiros
Operação com ponteiros:
Em ponteiros, possuímos operações de incremento e decremento, tanto para
valores como para o endereço do ponteiro.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Operador Descrição
++ Incrementa um valor ou o endereço do ponteiro
-- Decrementa um valor ou o endereço do ponteiro
Quando o valor de um endereço de ponteiro é incrementado ou decrementado, a
operação sempre irá acontecer utilizando o tamanho do tipo da variável. Por
exemplo: se uma variável for do tipo inteiro, o ponteiro será incrementado e
decrementado de 4 em 4.

22. Ponteiros
Como incrementar e decrementar um ponteiro:
No exemplo abaixo, a posição de memória será incrementada e decrementada em
4 posições de acordo com o tamanho da variável inteira.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
int *ptr;
ptr++;
ptr--;
Incremento de ponteiro
Decremento de ponteiro
Somente o endereço do ponteiro
atribuído na variável será
incrementado ou decrementado

23. Ponteiros
Como incrementar e decrementar o valor de um ponteiro:
No exemplo abaixo, o valor de um ponteiro é incrementado e decrementado.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
int *ptr;
(*ptr)++;
(*ptr)--;
Incremento do valor do
ponteiro
Decremento do valor do
ponteiro
O valor atribuído na posição de
memória do ponteiro, será
incrementado ou decrementado

24. Prof. Thomás da Costa Programação Estruturada II
Exemplo 8
#include <iostream>
using namespace std;
int main()
{
int *ptr;
int x;
ptr = &x;
*ptr = 999;
cout << "Valor Original:" << ptr << endl;
ptr++;
cout << "Incremento:" << ptr << endl;
ptr--;
cout << "Decremento:" << ptr << endl;
(*ptr)++;
cout << "Inc. valor:" << *ptr << endl;
(*ptr)--;
cout << "Dec. valor:" << *ptr << endl;
}
Este programa efetua operações com ponteiros. Vamos
analisar com mais detalhes. Para isso iremos ocultar as
linhas de cout, pois não afetam o nosso código

25. Prof. Thomás da Costa Programação Estruturada II
Exemplo 8
#include <iostream>
using namespace std;
int main()
{
int *ptr;
int x;
ptr = &x;
*ptr = 999;
ptr++;
ptr--;
(*ptr)++;
(*ptr)--;
}
ptr
0x23fe38
x
0x23fe34
0x23fe380x23fe34 0x23fe34999
0x23fe380x23fe38 0x23fe34999
0x23fe380x23fe34 0x23fe34999
0x23fe380x23fe34 0x23fe341000
0x23fe380x23fe34 0x23fe34999

26. Prof. Thomás da Costa Programação Estruturada II
Exemplo 9
#include <iostream>
using namespace std;
int main()
{
double *ptr;
double x;
ptr = &x;
*ptr = 999.98;
cout << "Valor Original:" << ptr << endl;
ptr++;
cout << "Incremento:" << ptr << endl;
ptr--;
cout << "Decremento:" << ptr << endl;
(*ptr)++;
cout << "Inc. valor:" << *ptr << endl;
(*ptr)--;
cout << "Dec. valor:" << *ptr << endl;
}
Mesmo processo do programa anterior utilizando outro
tipo de variável.

27. Ponteiros
Comparação de Ponteiros:
Na comparação de ponteiros, utilizamos os operadores maior, menor e igual. O
resultado da comparação, indica se o endereço de ponteiro é igual, se está mais ou
menos avançado que o endereço que está sendo comparado.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II

28. Prof. Thomás da Costa Programação Estruturada II
Exemplo 10
#include <iostream>
using namespace std;
int main()
{
int *ptr_1;
int *ptr_2;
int x, y;
ptr_1 = &x;
ptr_2 = &y;
cout << ptr_1 << endl;
cout << ptr_2 << endl;
cout << (ptr_1 > ptr_2) << endl;
cout << (ptr_1 < ptr_2) << endl;
ptr_1 = &x;
ptr_2 = &x;
cout << (ptr_1 == ptr_2) << endl;
}
Ponteiros são iguais
Comparação de ponteiros

29. Ponteiros
Vetores:
Normalmente um vetor, pode ser representado diretamente por um ponteiro. No
caso de um vetor de char, podemos efetuar atribuições diretamente, sem precisar
representá-los por posições de memórias. Isto é uma característica da linguagem e
do compilador.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II

30. Prof. Thomás da Costa Programação Estruturada II
Exemplo 11
#include <iostream>
#include <strings.h>
using namespace std;
int main()
{
char valores[100];
char *ptr;
strcpy(valores, "Isto é um teste");
ptr = valores;
cout << valores << endl;
cout << ptr << endl;
ptr = (char *)"Isto é um outro teste";
cout << ptr << endl;
cout << valores[3] << endl;
cout << *(ptr+3) << endl;
}
Exibindo valor na posição
do vetor

31. Ponteiros
Operadores bit-a-bit:
São operações que efetuamos diretamente com os bits de um tipo de dados. Para
isso, cada operador possui uma tabela verdade.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
Operador Descrição
& AND
| OR
^ OR Exclusivo (XOR)
~ Negação
>> Deslocamento de bit a direita
<< Deslocamento de bit a esquerda

32. Ponteiros
Tabela verdade dos operadores bit-a-bit:
Ponteiros
Prof. Thomás da Costa Programação Estruturada II
p q p & q
0 0 0
0 1 0
1 0 0
1 1 1
Operador AND (&):
p q p | q
0 0 0
0 1 1
1 0 1
1 1 1
Operador OR(|):
p q p & q
0 0 0
0 1 1
1 0 1
1 1 0
Operador XOR(^):
O operador ~ (NOT), inverte o resultado, se for 0 se torna 1 e vice-versa. Os
operadores >> e <<, deslocam bit a esquerda e a direita.

33. Prof. Thomás da Costa Programação Estruturada II
Exemplo 12
#include <iostream>
#include <strings.h>
#include <stdlib.h>
using namespace std;
int main()
{
int *ptr_1, *ptr_2;
int valor_1, valor_2;
char valor_convertido[100];
ptr_1 = &valor_1;
ptr_2 = &valor_2;
valor_1 = 316;
valor_2 = 206;
*ptr_1 = *ptr_1 << 2;
cout << *ptr_1 << endl;
*ptr_1 = *ptr_1 >> 2;
cout << *ptr_1 << endl;
itoa(*ptr_1, valor_convertido, 2);
cout << "Valor binário:" << valor_convertido << endl;
itoa(*ptr_2, valor_convertido, 2);
cout << "Valor binário:" << valor_convertido << endl;
itoa(*ptr_2 & *ptr_1, valor_convertido, 2);
cout << "Operador AND:" << valor_convertido << endl;
itoa(*ptr_2 | *ptr_1, valor_convertido, 2);
cout << "Operador OR:" << valor_convertido << endl;
itoa(*ptr_2 ^ *ptr_1, valor_convertido, 2);
cout << "Operador XOR:" << valor_convertido << endl;
itoa(~*ptr_2, valor_convertido, 2);
cout << "Operador NEG:" << valor_convertido << endl;
}
Converte um número para
uma base específica

34. Ponteiros
Resumo:
- Um ponteiro armazena uma posição de memória
- Esta posição de memória é referente a um valor
- Atribuição de ponteiros deve acontecer se for do mesmo tipo
- Podemos efetuar operação de incremento e decremento em ponteiros
- Os operadores bit-a-bit são divididos em AND, OR, XOR, NOT
- Os operadores << e >> representam deslocamento de bit a esquerda e a direita
Ponteiros
Prof. Thomás da Costa Programação Estruturada II

35. Ponteiros
Lista Ligada Simples:
É uma lista de elementos ligados em sequência. Normalmente utilizamos
estruturas para representar lista ligadas.
Ponteiros
Prof. Thomás da Costa Programação Estruturada II

36. Ponteiros
Mais detalhes:
- São representados por estruturas
- São estruturas dentro de estruturas encadeadas
- A estrutura interna sempre é um ponteiro para outra estrutura
- Sendo um ponteiro, indica o endereço da próxima estrutura
- Vamos trabalhar com inserção no fim da lista encadeada
- Utilizadas para armazenar valores na memória de fácil acesso
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II

37. Ponteiros
Como funciona:
Um elemento de uma lista, possui o endereço do próximo. O último elemento da
lista tem o valor NULL
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II
1 2 3
Elementos da lista ligada simples
Endereço de memória para o próximo elemento

38. Ponteiros
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II
Exemplo:
Próximo elemento da listastruct alunos
{
char nome[100];
int idade;
alunos *proximo;
} *lista_alunos;

39. Ponteiros
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II
Alocando memória:
Para o nosso exemplo vamos efetuar alocação dinâmica de memória utilizando a
palavra reservada new.
Efetuando alocação de memória
alunos *novo_aluno = new alunos;

40. Prof. Thomás da Costa Programação Estruturada II
Exemplo 13
Adicionando no final da lista
...
alunos *novo_aluno = new alunos;
cout << "Digite o nome do aluno:" << endl;
gets(novo_aluno->nome);
cout << "Digite a idade do aluno:" << endl;
cin >> novo_aluno->idade;
novo_aluno->proximo = NULL;
if (lista_alunos == NULL)
lista_alunos = novo_aluno;
else
{
alunos *p;
p = lista_alunos;
while (p->proximo != NULL)
p = p->proximo;
p->proximo = novo_aluno;
}
...

41. ...
alunos *p;
p = lista_alunos;
if (p->proximo == NULL)
{
cout << "------------------------------------" << endl;
cout << "Nome do Aluno:" << p->nome << endl;
cout << "Idade do Aluno:" << p->idade << endl;
cout << "------------------------------------" << endl;
}
else
{
while (p != NULL)
{
cout << "------------------------------------" << endl;
cout << "Nome do Aluno:" << p->nome << endl;
cout << "Idade do Aluno:" << p->idade << endl;
cout << "------------------------------------" << endl;
p = p->proximo;
}
}
...
Prof. Thomás da Costa Programação Estruturada II
Exemplo 13
Percorrendo a lista ligada

42. Ponteiros
Resumo:
Lembrando os itens do começo desse tópico:
- São representados por estruturas
- São estruturas dentro de estruturas encadeadas
- A estrutura interna sempre é um ponteiro para outra estrutura
- Sendo um ponteiro, indica o endereço da próxima estrutura
- Utilizadas para armazenar valores na memória de fácil acesso
Lista Ligada Simples
Prof. Thomás da Costa Programação Estruturada II

43. Ponteiros
Obrigado !!!
Prof. Thomás da Costa Programação Estruturada II