9_Estrutura

Prévia do material em texto

Estruturas (Registros) 
Os vetores e as matrizes, como vimos anteriormente, são estruturas capazes de 
armazenar diversos valores do mesmo tipo. Mas, e se quiséssemos armazenar 
em uma estrutura diversos valores, não necessariamente de mesmo tipo? Para 
isto existem os registros, que são estruturas capazes de armazenar valores de 
tipos diferentes. 
Na linguagem algorítmica, os registros são declarados através da palavra 
estrutura. A declaração de uma estrutura é feita da seguinte forma: 
 
estrutura <identificador> 
{ campo_1: <tipo>; 
 campo_2: <tipo>; 
 ... 
 campo_n: <tipo>; 
} <nomes das variáveis> (opcional) ; 
No qual: 
• identificador: identificador (ou nome) do registro; 
• campo_1: nome do primeiro campo do registro; 
• campo_2: nome do segundo campo do registro; 
• campo_n: nome do campo n do registro; 
• tipo: tipo de dado de cada campo do registro. 
Por exemplo: 
estrutura registro 
 { nome: texto; 
 idade: inteiro; 
 sexo: caracter; 
 } reg; 
declara uma variável registro de nome reg. Essa variável registro possui 3 
campos, sendo eles: nome (de tipo texto), idade (de tipo inteiro) e sexo (de tipo 
caracter). Note que a variável reg é capaz de armazenar 3 valores de tipos 
diferentes. 
Para ler ou escrever variáveis do tipo registro através dos comandos leia e 
escreva NÃO podemos simplesmente fazer: 
leia(reg); 
escreva(reg); 
Para ler ou escrever em um registro é necessário ler ou escrever em cada um de 
seus campos individualmente. Para acessar um campo de um registro basta 
utilizar o identificador do registro (nome da variável do tipo registro) e o 
identificador (nome) de seus campos, na seguinte sintaxe: 
<identificador>.<campo>; 
No qual: 
• identificador: nome da variável de tipo registro; 
• campo: nome do campo que se queira acessar. 
Por exemplo, suponha que queiramos atribuir o valor 'José da Silva' ao campo 
nome da variável reg: 
reg.nome ← 'José da Silva'; 
No nosso exemplo, nome é um dos campos da variável de tipo registro reg. Esse 
campo é uma variável do tipo texto, porque assim declaramos em nosso exemplo. 
Assim sendo é possível que esta variável consiga armazenar uma seqüência de 
caracteres delimitada por apóstrofos. 
Para ler valores do teclado e armazenar esses valores em um registro é 
necessário fazê-lo campo a campo do registro. Por exemplo, para ler 3 valores do 
teclado, correspondentes ao nome, idade e sexo de uma pessoa e armazená-los 
no registro reg, pode-se fazer: 
escreva('Digite o nome de uma pessoa'); 
leia(reg.nome); 
escreva('Digite a idade da pessoa'); 
leia(reg.idade); 
escreva('Digite o sexo da pessoa, F (feminino) ou M (masculino)'); 
leia(reg.sexo); 
O trecho de algoritmo acima lê 3 valores do teclado, correspondentes ao nome, 
idade e sexo de uma pessoa, e os armazena no registro reg. Note que para 
acessar um campo de um registro é preciso utilizar o nome do registro, ponto e o 
nome do campo desejado. Assim, para armazenar o nome digitado no campo 
nome do registro reg, foi necessário fazer leia(reg.nome). 
Ainda, é possível fazer o mesmo para escrever o conteúdo do registro reg na tela 
do computador. 
escreva(reg.nome); 
escreva(reg.idade); 
escreva(reg.sexo); 
Exercício 1 
Faça um algoritmo que leia dados referentes ao nome, idade e sexo de uma 
pessoa, armazene em um registro e mostre em seguida o conteúdo do registro. 
Para fazer esse exercício, basta juntarmos os trechos de algoritmos feitos 
anteriormente: 
01 | Algoritmo Exercício1; 
02 | { 
03 | estrutura registro 
04 | { nome: texto; 
05 | idade: inteiro; 
06 | sexo: caracter; 
07 | } reg; 
08 | 
09 | 
10 | /* Leitura dos campos do registro */ 
11 | escreva('Digite o nome de uma pessoa'); 
12 | leia(reg.nome); 
13 | escreva('Digite a idade da pessoa'); 
14 | leia(reg.idade); 
15 | escreva('Digite o sexo da pessoa (F ou M)'); 
16 | leia(reg.sexo); 
17 | 
18 | /* Mostra o conteúdo do registro reg*/ 
19 | escreva('Nome: ', reg.nome); 
20 | escreva('Idade: ',reg.idade); 
21 | escreva('Sexo: ', reg.sexo); 
22 | 
23 | } 
Note que no exercício acima só é possível armazenar informações de uma só 
pessoa. Seria interessante podermos armazenar o nome, idade e sexo de 
diversas pessoas. Como podemos modificar o algoritmo acima para que ele 
consiga armazenar o nome, a idade e o sexo de várias pessoas? 
E se tivéssemos um vetor, no qual cada elemento deste vetor conseguisse 
armazenar o nome, a idade e o sexo de uma pessoa. Bem, poderíamos fazer com 
que cada elemento do vetor fosse do tipo registro. A figura abaixo ilustra a 
estrutura na qual estamos interessados. 
 
Para declarar esta estrutura podemos fazer: 
 
 
estrutura reg 
 { nome: texto; 
 idade: inteiro; 
 sexo: caracter; 
 } V[10]; 
Temos agora uma variável v do tipo vetor, no qual cada elemento do vetor é um 
registro. Cada elemento do vetor v deve ser acessado através de seu índice, 
então para armazenarmos informações no primeiro elemento do vetor v temos que 
fazer: 
 
v[1].nome ← 'Renata Pereira'; 
v[1].idade ← 23; 
v[1].sexo ← 'F'; 
Se quisermos ler as informações do teclado e armazená-las no vetor v, devemos 
utilizar um comando para, assim: 
 
para i ← 1 até 10 faça 
{ 
 escreva('Digite o nome da pessoa'); 
 leia(v[i].nome); 
 escreva('Digite a idade'); 
 leia(v[i].idade); 
 escreva('Digite o sexo (F ou M)'); 
 leia(v[i].sexo); 
} 
Devemos proceder da mesma forma se quisermos mostrar o couteúdo do vetor v: 
 
para i ← 1 até 10 faça 
{ 
 escreva('Nome: ', v[i].nome); 
 escreva('Idade: ', v[i].idade); 
 escreva('Sexo: ', v[i].sexo); 
} 
Vamos fazer um algoritmo que leia informações correspondentes ao nome, idade 
e sexo de 10 pessoas e armazene em um vetor. 
 
01 | Algoritmo Exemplo; 
02 | 
03 | contantes 
04 | MAX = 10; 
05 | 
06 | { 
07 | estrutura registro 
08 | { nome: texto; 
09 | idade: inteiro; 
10 | sexo: caracter; 
11 | } v[MAX]; 
12 | i: inteiro; 
13 | 
14 | 
15 | /* Lê dados do teclado e armazena no vetor v */ 
16 | para i ← 1 até MAX faça 
17 | { 
18 | escreva('Digite o nome da pessoa'); 
19 | leia(v[i].nome); 
20 | escreva('Digite a idade'); 
21 | leia(v[i].idade); 
22 | escreva('Digite o sexo (F ou M)'); 
23 | leia(v[i].sexo); 
24 | } 
25 | 
26 | /* Mostra o conteúdo do vetor v */ 
27 | para i ← 1 até MAX faça 
28 | { 
29 | escreva('Nome: ', v[i].nome); 
30 | escreva('Idade: ', v[i].idade); 
31 | escreva('Sexo: ', v[i].sexo); 
32 | } 
33 | } 
Tipos Definidos pelo Usuário 
Os tipos de dados que aprendemos até agora foram: inteiro, real, caracter, texto, 
vetor, matriz e registro. Todos esses tipos já vêm definidos para usarmos. Mas 
nós podemos também definir nossos próprios tipos de dados a partir dos tipos já 
definidos. Assim, como a palavra constantes indica que a seguir constantes serão 
declaradas, e a palavra variáveis indica que a seguir serão declaradas variáveis, 
a palavra tipo indica que a seguir serão declarados tipos de dados do usuário. 
Assim, se quisermos declarar o tipo int como inteiro, podemos fazer: 
 
tipo 
 int = inteiro; 
Note que agora temos um tipo chamado int, para declararmos variáveis desse 
tipo, devemos fazer: 
 
 i, j: int; 
As variáveis i e j são do tipo int, isto é, são capazes de armazenar um valor 
inteiro. 
Qual a vantagem neste momento em declararmos algum tipo? Provavelmente, 
nunca faremos algo como o exemplo anterior, pois temos o tipo inteiro e é bem 
mais simples o utilizarmos como estamos acostumados.Mas, podemos usar a 
declaração de tipos para aquelas estruturas mais complexas que vimos no início 
dessa aula. 
Por exemplo, para declararmos um vetor de registros podemos fazer: 
 
 estrutura registro 
 { nome: texto; 
 idade: inteiro; 
 sexo: caracter; 
 } V[10]; 
Ou, podemos fazer: 
 
tipo 
 estrutura registro 
 { nome: texto; 
 idade: inteiro; 
 sexo: caracter; 
 }; 
 
 registro v[10]; 
 
01 | Algoritmo Exemplo; 
02 | 
03 | constantes 
04 | MAX = 10; 
05 | 
06 | tipos 
07 | estrutura registro 
08 | { nome: texto; 
09 | idade: inteiro; 
10 | sexo: caracter; 
11 | }; 
12 | 
13 | 
14 | { 
15 | registro V[MAX]; 
16 | i: inteiro; 
17 | 
18 | 
19 | /* Lê dados do teclado e armazena no vetor v */ 
20 | para i ← 1 até MAX faça 
21 | { 
22 | escreva('Digite o nome da pessoa'); 
23 | leia(v[i].nome); 
24 | escreva('Digite a idade'); 
25 | leia(v[i].idade); 
26 | escreva('Digite o sexo'); 
27 | leia(v[i].sexo); 
28 | } 
29 | 
30 | /*Mostra o conteúdo do vetor v */ 
31 | para i ← 1 até MAX faça 
32 | { 
33 | escreva('Nome: ', v[i].nome); 
34 | escreva('Idade: ', v[i].idade); 
35 | escreva('Sexo: ', v[i].sexo); 
36 | } 
37 | } 
 
Exercícios 
1. Defina um tipo registro para um cheque bancário. 
2. Para controle dos veículos que circulam em uma determinada cidade bem 
pequena (mas muito pequena), a Secretaria dos Transportes criou um 
registro-padrão que tem as seguintes informações: proprietário, combustível 
(que pode ser álcool, diesel ou gasolina), modelo, cor, número do chassi, 
ano e placa (placa possui os 3 primeiros valores alfabéticos e os 4 
restantes valores numéricos). Sabendo que o número máximo de veículos 
da cidade é de 5 unidades, faça (algoritmo e programa) os itens a seguir: 
o listar os nomes dos proprietários cujos carros são do ano de 1980 ou 
posterior e que sejam movidos à diesel; 
o listar as placas que comecem com a letra A e terminem com 0, 2, 4, 
ou 7 e seus respectivos proprietários; 
o listar o modelo e a cor dos veículos cujas placas possuem como 
segunda letra uma vogal;