Registros
• Ementa da Aula:
Fundamentos de construção de modelos e
programas; Abstração de dados e Notações
referentes à Estrutura Composta de Dados
(Registros).
• Objetivo:
Introduzir o conceito de modelagem de dados
utilizando e registros / structs.
Estruturas Compostas de Dados
• Homogêneas (vetores e matrizes)
Registros/Estruturas
• Motivação:
o MODELAGEM DE DADOS:
• MUNDO REAL: o Objetos/conceitos complexos. • MODELO:o Representações que simplificam a realidade. o Tornam possível o estudo e a manipulação. o Úteis para um determinado propósito.
Registros/Estruturas
• Motivação:
o MODELAGEM DE DADOS:
MUNDO REAL
MODELO
Simplificação Aluno Nome RA CR SexoRegistros/Estruturas
• Motivação:
o MODELAGEM DE DADOS:
MUNDO REAL
MODELO
Simplificação Aluno Nome RA CR Sexo Entidade:Algo que é relevante para o sistema.
Pode estar associada a um elemento concreto, ou a um conceito “abstrato”.
Registros/Estruturas
• Motivação:
o MODELAGEM DE DADOS:
MUNDO REAL
MODELO
Simplificação Aluno Nome RA CR Sexo Atributos:Conjunto de propriedade particulares que descrevem uma entidade .
Registros/Estruturas
• Problema:
o Como representar um modelo em linguagem
C?
• Conjunto de variáveis.MUNDO REAL
Linguagem C
Implementação Aluno Nome RA CR Sexo SimplificaçãoMODELO
char nome[100]; int ra;
char sexo; float cr;
Registros/Estruturas
• Problema:
o Como representar um modelo em linguagem
C?
• Conjunto de variáveis.
• Podem ser agrupadas em estruturas.
MUNDO REAL
Linguagem C
Implementação Aluno Nome RA CR Sexo SimplificaçãoMODELO
char nome[100]; int ra;
char sexo; float cr;
Registros/Estruturas
• Definição:
o Uma
estrutura
(registro) é um tipo de dado
cujo formato é definido pelo programador.
o Ela agrupa elementos, chamados
membros
ou
campos
da estrutura, que não necessitam ser
do mesmo tipo.
Exemplo:
#include <stdio.h> #include <string.h> struct Aluno{ char nome[100]; int ra; float cr; char sexo; int curso; }; int main(){struct Aluno aluno;
strcpy(aluno.nome,"Fulano da Silva"); aluno.ra = 923348; aluno.cr = 7.0; aluno.sexo = 'M'; aluno.curso = 43; return 0; }
Exemplo:
#include <stdio.h> #include <string.h> struct Aluno{ char nome[100]; int ra; float cr; char sexo; int curso; }; int main(){struct Aluno aluno;
strcpy(aluno.nome,"Fulano da Silva"); aluno.ra = 923348; aluno.cr = 7.0; aluno.sexo = 'M'; aluno.curso = 43; return 0; }
Definição do formato da
estrutura.
Exemplo:
#include <stdio.h> #include <string.h> struct Aluno{ char nome[100]; int ra; float cr; char sexo; int curso; }; int main(){struct Aluno aluno;
strcpy(aluno.nome,"Fulano da Silva"); aluno.ra = 923348; aluno.cr = 7.0; aluno.sexo = 'M'; aluno.curso = 43; return 0; } Membros da estrutura “Etiqueta” da estrutura
Exemplo:
#include <stdio.h> #include <string.h> struct Aluno{ char nome[100]; int ra; float cr; char sexo; int curso; }; int main(){struct Aluno aluno;
strcpy(aluno.nome,"Fulano da Silva"); aluno.ra = 923348; aluno.cr = 7.0; aluno.sexo = 'M'; aluno.curso = 43; return 0; }
Declaração de uma
variável do tipo definido.
Exemplo:
#include <stdio.h> #include <string.h> struct Aluno{ char nome[100]; int ra; float cr; char sexo; int curso; }; int main(){struct Aluno aluno;
strcpy(aluno.nome,"Fulano da Silva"); aluno.ra = 923348; aluno.cr = 7.0; aluno.sexo = 'M'; aluno.curso = 43; return 0; } Acessando membros da estrutura. nome_registro.campo
Registros/Estruturas
• Operações de entrada e saída (leitura e
escrita):
o A
leitura
/
escrita
de estruturas pela
entrada
/
saída
padrão, deve ser feita campo a
campo, como se os membros fossem variáveis
independentes.
//fgets(aluno.nome,99,stdin); scanf(" %[^\n]",aluno.nome); scanf("%d",&aluno.ra); scanf("%f",&aluno.cr); scanf(" %c",&aluno.sexo); scanf("%d",&aluno.curso);printf("Nome: %s\n",aluno.nome); printf("RA: %d\n",aluno.ra);
printf("CR: %.2f\n",aluno.cr); printf("Sexo: %c\n",aluno.sexo); printf("Curso: %d\n",aluno.curso);
Registros/Estruturas
• Atribuição entre estruturas:
o O conteúdo de uma variável estrutura pode ser atribuído a outra variável estrutura do mesmo tipo.
o Todos campos da estrutura de origem são atribuídos aos membros correspondentes da estrutura de destino.
int main(){
struct Aluno aluno1; struct Aluno aluno2; ...
aluno1 = aluno2; ...
return 0; }
Estruturas Aninhadas
• Estruturas com campos que são estruturas.
• Recurso para a criação de tipos de dados
complexos
.
struct Data{ int dia; int mes; int ano; }; struct Endereco{ char rua[100]; char bairro[100]; char cidade[100]; int cep; }; struct Aluno{ char nome[100]; int ra; float cr; char sexo; int curso;struct Data nascimento; struct Endereco endereco; };
Estruturas Aninhadas
• Estruturas com campos que são estruturas.
• Recurso para a criação de tipos de dados
complexos
.
int main(){
struct Aluno aluno;
strcpy(aluno.nome,"Fulano da Silva"); aluno.ra = 923348; aluno.cr = 7.0; aluno.sexo = 'M'; aluno.curso = 43; aluno.nascimento.dia = 13; aluno.nascimento.mes = 9; aluno.nascimento.ano = 1980;
strcpy(aluno.endereco.rua,"Av. Dr. Alberto Sarmento"); strcpy(aluno.endereco.bairro,"Castelo");
strcpy(aluno.endereco.cidade,"Campinas"); aluno.endereco.cep = 1306275;
As estruturas podem ser inicializadas a partir de listas de inicializadores, assim como acontece com os arrays.
Para inicializar uma estrutura, siga o nome da variável na
declaração com um sinal de igual e uma lista, delimitada por chaves, de inicializadores separados por vírgulas.
Por exemplo, a declaração
struct card aCard = { “Três”, “Copas” }; cria a variável aCard para ser do tipo struct card (conforme definido na Seção 10.2) e inicializa o membro face como “Três” e o membro suit como “Copas”.
Dois operadores são usados para acessar membros das estruturas: o
operador de membro de estrutura (.) — também chamado de
operador de ponto — e o operador de ponteiro de estrutura (->) — também chamado operador de seta.
O operador de membro da estrutura acessa um membro da estrutura por meio do nome da variável da estrutura.
Por exemplo, para imprimir o membro suit da variável da estrutura aCard declarada na Seção 10.3, use a instrução
O operador de ponteiro da estrutura — que consiste em um sinal de subtração (-) seguido de um sinal de maior (>) — acessa um
membro da estrutura por meio de um ponteiro para a estrutura. Suponha que o ponteiro cardPtr tenha sido declarado para
apontar para struct card, e que o endereço da estrutura aCard tenha sido atribuído a cardPtr.
Para imprimir o membro suit da estrutura aCard com o ponteiro cardPtr, use a instrução
A expressão cardPtr->suit é equivalente a
(*cardPtr).suit, que desreferencia o ponteiro e acessa o membro suit usando o operador de membro da estrutura.
Aqui, os parâmetros são necessários porque o operador de membro da estrutura (.) tem uma precedência maior que o operador de
desreferência de ponteiro (*).
O operador de ponteiro da estrutura e o operador de membro da
estrutura, com os parênteses (para chamar funções) e colchetes ([]) usados para subscrito de array, possuem a precedência de operador mais alta, e são associados da esquerda para a direita.
Por exemplo, a declaração a seguir typedef struct {
char *face; char *suit; } Card;
cria o tipo de estrutura Card sem a necessidade de uma instrução typedef separada.
Card agora pode ser usado para declarar variáveis do tipo struct card.
A declaração
Card deck[ 52 ];
declara um array de 52 estruturas Card (ou seja, variáveis do tipo struct card).
Criar um novo nome com typedef não cria um novo tipo;
typedef simplesmente cria um novo nome de tipo, que pode ser usado como um alias para um nome de tipo existente.
