Programação Estruturada 2 - Aula 05

380 visualizações

Publicada em

Aula 05 - Ponteiros

Publicada em: Tecnologia
0 comentários
1 gostou
Estatísticas
Notas
  • Seja o primeiro a comentar

Sem downloads
Visualizações
Visualizações totais
380
No SlideShare
0
A partir de incorporações
0
Número de incorporações
41
Ações
Compartilhamentos
0
Downloads
11
Comentários
0
Gostaram
1
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Programação Estruturada 2 - Aula 05

  1. 1. Programação Estruturada II Aula 05 – Ponteiros Prof. Thomás da Costa thomasdacosta@gmail.com Anhanguera – 2015.1
  2. 2. Ponteiros PONTEIROS Prof. Thomás da Costa Programação Estruturada II
  3. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 43. Ponteiros Obrigado !!! Prof. Thomás da Costa Programação Estruturada II

×