Conceitos de ponteiros struct e buffers

2,922 views
2,730 views

Published on

Conceitos básicos sobre ponteiros, structs e buffers circulares.

Published in: Technology
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
2,922
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
64
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Conceitos de ponteiros struct e buffers

  1. 1. ELT048 - SOEPonteiros, Structs e Buffers Circulares Rodrigo Almeida Universidade Federal de Itajubá
  2. 2. Ponteiros
  3. 3. Ponteiros● São variáveis que guardam o endereço (localização) de memória. ● Nestes endereços da memória é possível colocar valores e utilizá-los.● Os tipos de valores colocados nos endereços de memória são definidos na declaração de um ponteiro. ● É esse tipo que indica ao compilador a quantidade de memória necessária para armazenar os valores.● Uma variável do tipo ponteiro aponta para uma variável de um determinado tipo (char, int, float, double, . . .).
  4. 4. Ponteiros● É necessário na ● Sintaxe: declaração de um tipo *nomeVariavel; ponteiro, especificar para qual tipo de variável ele irá apontar.● Os ponteiros são declarados com um * antes do nome da variável.
  5. 5. Ponteirosint *aux; ● aux, temp e pont sãofloat *temp; variáveis que armazenam endereçoschar *pont; de memória e não valores do tipo int, float ou char. ● * é usado quando deseja-se acessar o valor que está na posição de memória e não ao endereço da memória.
  6. 6. Ponteiros
  7. 7. Ponteiros● Operador &: ● Operador *: ● Obtém sempre o ● O operador * faz o endereço de uma contrário do operador variável &. ● Como os ponteiros ● Dado um ponteiro, o também são variáveis operador * acessa o eles também ocupam conteúdo apontado memória. por ele. – Pode-se obter o endereço do ponteiro e ter ponteiros para ponteiros (múltiplos *).
  8. 8. Ponteiros● Simbolo &: ● Simbolo *: ● “endereço de” ● “derreferenciando” ● “salvo em” ● “através de” ● “apontado por”
  9. 9. Exemplo#include <stdio.h>int main(int argc, char *argv[]){ int x=10; int *p1=&x; //ponteiro para um inteiro printf("x = %dnn", x); *p1=20; //ou p1[0]=20; printf("p1 = %un", p1); printf("x = %dn", x); printf("*p1 = %dn", *p1); printf("p1[0] = %dnn", p1[0]); return 0;} //end main
  10. 10. Passagem de parâmetros● As funções em linguagem C podem receber vários parâmetros e pode retornar um.● O método de envio dos parâmetros pode ser feito na pilha ou nos registradores. ● A pilha permite que diversos parâmetros sejam passados de uma única vez ● Os registros possuem menor overhead, sendo portanto mais rápidos e com menor tamanho de código
  11. 11. Passagem de parâmetros● No envio, os parâmetros são copiados para uma variável temporária, de modo que as alterações em seu valor são perdidas após o fim da função. ● A variável inicial não é alterada● Para evitar esta situação é comum realizar a passagem de parâmetro por referência.● Na passagem por referência é passado o endereço da variável de modo que a função consiga alterar o valor da variável original.
  12. 12. void incrementa(int a){ a += 1;}int main(int argc, char *argv[]){ int x = 10; incrementa(x); return 0;}
  13. 13. Rotina Principal Funçãovoid main(void){ int x = 10; incrementa(x); void incrementa(int a) { a+=1; return; } return 0;}
  14. 14. Rotina Principal Função Variáveisvoid main(void){ int x = 10; x=10 inc(x); void inc(int a){ a += 1; return; } return 0;}
  15. 15. Rotina Principal Função Variáveisvoid main(void){ int x = 10; x=10 a=10 inc(x); void inc(int a){ a += 1; return; } return 0;}
  16. 16. Rotina Principal Função Variáveisvoid main(void){ int x = 10; x=10 a=11 inc(x); void inc(int a){ a += 1; return; } return 0;}
  17. 17. Rotina Principal Função Variáveisvoid main(void){ int x = 10; x=10 descartado inc(x); void inc(int a){ a += 1; return; } return 0;}
  18. 18. void incrementaptr(int* a){ (*a) += 1;}int main(int argc, char *argv[]){ int x = 10; incrementaptr(&x); return 0;} //end main
  19. 19. Rotina Principal Função Variáveisvoid main(void){ int x = 10; x=10 incptr(&x); void incptr (int* a){ (*a) += 1; return; } return 0;}
  20. 20. Rotina Principal Função Variáveisvoid main(void){ int x = 10; x=10 temp=&x incptr(&x); void incptr (int* a){ (*a) += 1; return; } return 0;}
  21. 21. Rotina Principal Função Variáveisvoid main(void){ int x = 10; x=10 a=&x incptr(&x); void incptr (int* a){ (*a) += 1; return; } return 0;}
  22. 22. Rotina Principal Função Variáveisvoid main(void){ int x = 10; x=11 incptr(&x); void incptr a=&x * (int* a){ (*a) += 1; return; } return 0;}
  23. 23. Rotina Principal Função Variáveisvoid main(void){ int x = 10; x=11 descartado incptr(&x); void incptr (int* a){ (*a) += 1; return; } return 0;}
  24. 24. Passagem de parâmetros● A passagem de parâmetros por referência permite que uma função “retorne” mais de um parâmetro por vez.● Isto é feito passando-se uma variável via referência para que a função possa escrever nela.
  25. 25. Structs● As estruturas (structs) são a ferramenta pela qual o programador pode agrupar diversas variáveis de tipos diferentes num mesmo conjunto.● Utilizando-se a diretiva typedef é possível definir-se um novo tipo de variável.
  26. 26. Structstypedef struct{ char titulo[30]; char producao[20]; char dataCompra[8]; int temporada; float preco;}t_serietv;t_serietv s1 = {"Big Bang Theory", "Warner", "25/05/10", 3, 55.50};strcpy(s1.titulo,"The Big Bang Theory");strcpy(s1.producao, "Warner Bros");s1.temporada = 6;printf("A serie foi produzida pela %s,", s1.producao);printf(" e esta na temporada %dn", s1.temporada);
  27. 27. Structs● O acesso dos typedef struct{ char nome[20]; membros internos int idade; de estruturas }t_aluno; apontadas por ponteiros pode ser t_aluno *a1; feito através do (*a1).nome = "Joao"; operador -> (*a1).idade = 18; a1->nome = "Joao"; a1->idade = 18;
  28. 28. Buffers● Buffers são regiões de memória para armazenamento temporário de informações.● Podem ser implementados em SW ou HW.● Muito comuns em protocolos de comunicação.
  29. 29. Buffers● Buffers circulares auxiliam na implementação de filas do tipo FIFO (first in, first out)● Em geral são implementados em cima de um vetor com funções para a manipulação deste.● É necessário possuir ponteiros/variáveis que indiquem o começo e fim do buffer.● Deve-se tomar cuidado na escolha
  30. 30. Exercício● Implementar um buffer circular● Utilizar um vetor de 10 posições● Cada elemento do vetor é uma estrutura com duas variáveis ● char NomeDoProcesso ● int Prioridade● Criar uma função para adicionar novos elementos e uma para retirar os mais antigos.
  31. 31. Ponteiros para void● Aponta para uma região de memória sem especificar o tipo.● Não pode ser utilizado sem casting● Abstração que permite ao programador passar parâmetros de diferentes tipos para a mesma função. ● A função que os receber deve saber como tratar cada tipo.
  32. 32. Ponteiros para voidchar *name = "Paulo";double weight = 87.5;unsigned int children = 3;void main (void){ //não confundir com printf print(0, name); print(1, &weight); print(2, &children);}
  33. 33. Ponteiros para voidvoid print(int option; void *parameter){ switch(option){ case 0: printf("%s",(char*)parameter); break; case 1: printf("%f",*((double*)parameter)); break; case 2: printf("%d",*((unsigned int*)parameter)); break; }}
  34. 34. Exercício (cont)● Implementar um buffer circular● Utilizar um vetor de 10 posições● Cada elemento do vetor é uma estrutura com duas variáveis ● char tipo ● void* ptr● Criar uma função para adicionar novos elementos e uma para retirar os mais antigos. ● Add(char tipo, void* var); ● Remove(void);

×