EstruturaDados Tipos Abstratos Dados #C

Prévia do material em texto

Estrutura de Dados
Tipos abstratos 
de dados/ 
estruturas em C
Prof. Marcos Virgilio
marcos.virgilio@ifsc.edu.br
 
● Utilizados para estruturar dados complexos, 
nos quais as informações são compostas por 
diversos campo;
● São mecanismos que permitem agrupar tipos 
distintos;
● Em C, podemos definir um tipo de dado cujos 
campos são compostos de vários valores de 
tipos mais simples;
● Também chamados de tipos abstratos de 
dados (TAD), por encapsularem/ esconderem 
a complexibilidade da implementação 
concreta da estrutura;
Tipo abstrato de dado/ Struct
 
Exemplo: pontos em um plano cartesiano;
● Cada ponto pode ser representado por suas 
coordenadas x e y, ambas dadas por valores 
reais;
● Sem o uso de um TAD para agrupar as duas 
informações, temos que representar cada 
ponto por duas variáveis; 
● Deste modo, os dois valores que representam 
um ponto ficam dissociados;
● Para o caso de manipular vários pontos, cabe 
ao programador não misturar as coordenadas 
de cada um dos pontos;
Tipo abstrato de dado/ StructTipo abstrato de dado/ Struct
 
● Para evitar este problema, podemos 
definir um TAD/ estrutura “ponto”;
● Neste caso, as duas variáveis que 
representam as coordenadas x e y seriam 
agrupadas;
● Exemplo:
struct ponto {
 float x;
 float y;
};
Tipo abstrato de dado/ StructTipo abstrato de dado/ Struct
 
A estrutura ponto passa a ser um tipo e 
podemos então declarar variáveis deste tipo;
Exemplo: struct ponto p;
Os elementos de uma estrutura podem ser 
acessados por intermédio do operador 
“ponto” (.);
Exemplo:
p.x = 10.0;
p.y = 5.0;
Tipo abstrato de dado/ StructTipo abstrato de dado/ Struct
 
#include <stdio.h>
#include <stdlib.h>
struct ponto {
 float x;
 float y; };
int main (void) {
 struct ponto p;
 printf("Digite o ponto(x y):");
 scanf("%f %f", &p.x, &p.y);
 printf("Ponto:(%.2f,%.2f)\n", p.x, p.y);
 return 0;
}
Tipo abstrato de dado/ StructTipo abstrato de dado/ Struct
 
Podemos definir TADs/ estruturas que 
agrupam (encapsulam) variáveis do tipo 
ponteiro;
Exemplo:
struct Ponteiros {
 int * pInt1;
 int * pInt2;
};
int main (void) {
 struct Ponteiros p;
...}
Struct + Ponteiros
 
#include <stdio.h>
#include <stdlib.h>
struct Ponteiros {
 int *pInt1;
 int *pInt2; };
int main (void) {
 struct Ponteiros p;
 p.pInt1 = (int*)malloc(4);
 p.pInt2 = (int*)malloc(4);
 printf("Digite dois numeros: ");
 scanf("%d %d", p.pInt1, p.pInt2 );
 printf("Numeros: (%d,%d)\n", 
 *p.pInt1, *p.pInt2);
 return 0; }
Struct com ponteiros
 
Também podemos definir ponteiros 
para TADs/ estruturas;
Exemplo:
struct Ponteiros {
 int * pInt1;
 int * pInt2;
};
int main (void) {
 struct Ponteiros * p;
...}
Ponteiros para TADs/ estruturas
 
● Da mesma forma que os vetores, as 
estruturas podem ser alocadas 
dinamicamente;
● Uma estrutura complexa pode 
dificultar o calculo do espaço de 
memória necessário para sua 
alocação;
● Por esta razão, é recomendado o 
uso da função sizeof() junto com a 
função malloc();
Alocação dinâmica de Structs 
 
Exemplo 1:
struct ponto {
 float x;
 float y; 
};
void imprime (struct ponto* pp){
 printf("O ponto fornecido foi: 
 (%.2f,%.2f)\n", pp->x, pp->y);
}
Alocação dinâmica de Structs 
 
Exemplo 1:
int main (void)
{
 struct ponto* p;
 p = (struct ponto*) 
 malloc (sizeof(struct ponto));
 printf("Digite a 
 coordenada(x,y):");
 scanf("%f %f", &p->x, &p->y);
 imprime(p);
 return 0;
}
Alocação dinâmica de Structs 
 
#include <stdio.h>
#include <stdlib.h>
struct Ponteiros {
 int * pInt1;
 int * pInt2; };
int main (void) {
 struct Ponteiros * p = (struct Ponteiros*)
 malloc(sizeof(struct Ponteiros));
 (*p).pInt1 = (int*)malloc(4);
 (*p).pInt2 = (int*)malloc(4);
 printf("Digite dois numeros: ");
 scanf("%d %d",(*p).pInt1,
 (*p).pInt2);
 printf("Numeros: (%d,%d)\n",
 *(*p).pInt1, *(*p).pInt2);
 return 0;}
Ponteiros para TADs/ estruturas
 
● O acesso aos campos de um TAD/ 
estrutura pode ser feito também 
pelo operador de acesso (->);
● Se temos uma variável estrutura e 
queremos acessar seus campos, 
usamos o ponto (p.x); 
● Se temos uma variável ponteiro 
para estrutura, usamos o operador 
de acesso seta (p->x);
Ponteiros para TADs/ estruturas
 
#include <stdio.h>
#include <stdlib.h>
struct Ponteiros {
 int * pInt1;
 int * pInt2;};
int main (void) {
 struct Ponteiros * p = (struct Ponteiros*)
 malloc(sizeof(struct Ponteiros));
 p->pInt1 = (int*)malloc(4);
 p->pInt2 = (int*)malloc(4);
 printf("Digite dois numeros: ");
 scanf("%d %d", 
 p->pInt1, p->pInt2 );
 printf("Numeros: (%d,%d)\n", 
 *p->pInt1, *p->pInt2);
 return 0; }
Ponteiros para TADs/ estruturas
 
● TADs/ estruturas são como 
qualquer outro tipo de variável;
● Podemos também declarar 
arrays e vetores de TADs/ 
estruturas;
● Assim como passar structs como 
parâmetro e declararmos como 
tipo de retorno de subrotinas;
TADs/ estruturas
 
● A passagem de estruturas para 
subrotinas se processa de forma 
análoga à passagem de variáveis;
● É criada uma cópia de toda a 
estrutura para escopo da 
subrotina;
● Logo, a subrotina acessa apenas 
os dados desta cópia recebida do 
sctruct;
Structs como parâmetros
 
● Subrotinas não tem como alterar 
os valores dos elementos do 
struct original;
● Copiar uma estrutura inteira para 
o escopo de uma subrotina pode 
ser uma operação custosa;
● É sugerido passar apenas o 
ponteiro da estrutura como 
parâmetro para subrotinas;
Structs como parâmetros
 
Exemplo 1:
struct ponto {
 float x;
 float y; 
};
void imprime (struct ponto* pp){
 printf("O ponto fornecido foi: 
 (%.2f,%.2f)\n", pp->x, pp->y);
}
Structs como parâmetros
 
Exemplo 1:
int main (void)
{
 struct ponto p;
 printf("Digite a
 Coordenada (x,y):");
 scanf("%f %f", &p.x, &p.y);
 imprime(&p);
 return 0;
}
Structs como parâmetros
 
Referências
 
Waldemar Celes e José Lucas Rangel, Apostila de 
Estruturas de Dados. PUC-RIO - Curso de Engenharia. 
2002.
PEREIRA, S. L. Estruturas de dados fundamentais: 
conceitos e aplicações. Edição 12. São Paulo, Érica, 
2008. 
TENENBAUM, A.; LAGSAM, Y.; AUGENSTEIN, M. 
Estruturas de dados usando C. São Paulo. Pearson. 
1995.
PREISS, B. R., Estruturas de dados e algoritmos: 
Padrões de Projeto orientado a objetos com Java. Rio 
de Janeiro. Elsevier. 2001. 
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21