aula21 estruturas

Prévia do material em texto

Unesp – Campus de Guaratinguetá
21 21 -- Estruturas em C (Novos Tipos)Estruturas em C (Novos Tipos)
RegistrosRegistros
Curso de Programação Computadores
Prof. Aníbal Tavares
Profa. Cassilda Ribeiro
Ministrado por: Prof. André Amarante
Estruturas em C 2
21. Estrutura21. Estrutura
 Até o presente momento os nossos dados eram 
armazenados ou através de variáveis simples do tipo 
char, int, float ou double, ou através de conjuntos de 
valores do mesmo tipo, relacionados em vetores.
 As EstruturasEstruturas em Cem C correspondem aos 
Registros em outra linguagens.
 RegistrosRegistros são EstruturasEstruturas que podem agrupar diferentes 
tipos de informações (dados). 
 Então, Então, uma uma EstruturaEstrutura éé um conjunto de uma ou um conjunto de uma ou 
mais varimais variááveis agrupadas sob um veis agrupadas sob um úúnico nome. nico nome. 
Estruturas em C 3
21. Estrutura21. Estrutura
 Então as estruturas podem conter elementos de 
qualquer tipo de dados tais como int, char, float, 
double, ponteiros, vetores, matrizes, strings ou 
mesmo outras estruturas.
 As componentes armazenadas dentro de uma 
Estrutura também são chamadas de campos ou 
membros. 
 AsAs EstruturasEstruturas (Registros) Registros) são chamadas de variáveis 
compostas heterogêneas, pois elas são compostas de 
vários campos e cada campo pode ser de um tipo diferente 
de dados.
Estruturas em C 4
21.1 Estrutura: Declara21.1 Estrutura: Declaraççãoão -- StructStruct
A declaração de Estruturas Estruturas é feita através da seguinte sintaxe:
 Formato da declaração:
struct nome_da_estrutura {
tipo_1 dado_1; 
tipo_2 dado_2; 
... 
tipo_n dado_n;
};
 A estrutura pode agrupar um número arbitrário de dados de 
tipos diferentes
 Pode-se nomear a estrutura para referenciá-la. 
Estruturas em C 5
21.1 Estrutura: Declara21.1 Estrutura: Declaraççãoão -- StructStruct
 A declaração de uma estrutura corresponde somente à
definição de um novo tipo (isto é, da sua estrutura). Nela não 
está implícita a declaração de variáveis do tipo estrutura.
Exemplo 1: Suponha que 
queiramos armazenar os dados
relativos a um indivíduo, como 
mostrado a seguir:
int idade;
char Nome[60];
char est_civil,sexo;
struct Dados
{ 
int idade;
char est_civil, sexo, nome[20];
} pessoa;
Não esquecer do ponto-e-vírgula !
Estruturas em C 6
 A definição da estrutura Dados (struct Dados) indica que a 
partir daquele momento o compilador passa a conhecer um 
outro tipo, chamado struct Dados, que é composto por um 
inteiro, dois caracteres e um vetor de 20 caracteres. E uma 
variável pessoa do tipo Dados
21.1 Estrutura: Declara21.1 Estrutura: Declaraççãoão -- StructStruct
pessoa.sexosexo
pessoa.nomenome[20]
pessoa.est_civilest_civilpessoa
pessoa.idadeidade
 Ou seja, Dados não é uma variável e sim o nome pelo 
qual é conhecido o novo tipo de dados. Cada um dos 
elementos de Dados é denominada campo.
Estruturas em C 7
struct Dados
{ 
int idade;
char est_civil, sexo;
char nome[20];
} pessoa;
Nome do novo tipo de dado
Campo idade do tipo int
Campo estado civil e sexo do 
tipo char
Campo nome do tipo string
Variável do tipo Dados
21.1 Estrutura: Declara21.1 Estrutura: Declaraççãoão -- StructStruct
Estruturas em C 8
21.1 Estrutura: Declara21.1 Estrutura: Declaraçção ão -- StructStruct e Varie Variááveisveis
 Pode-se também declarar uma variável do tipo estrutura 
usando o struct. No exemplo anterior a declaração da 
variável pessoa poderia ser feita do seguinte modo: 
struct Dados pessoa;
onde pessoa é a variável do tipo struc Dados
A declaração de variáveis do tipo estrutura pode ser feita no 
momento em que se faz a definição da própria estrutura
struct nome_da_estrutura {
tipo_1 dado_1; 
tipo_2 dado_2; 
... 
tipo_n dado_n;
} lista de variáveis; 
Estruturas em C 9
 A definição de uma estrutura pode ser feita sem indicar o seu 
nome, mas nesses caso, todas as variáveis desta estruturas 
tem que ser declaradas no momento da definição.
Ex: struct {
int dia; 
char mes[15]; 
int hora;
} data_vest2, dat_vest1; 
No exemplo acima, não foi dado um nome para a 
estrutura, mas isso não tem problema porque as 
variáveis dat_vest1 e data_vest2 foram declaradas 
junto da definição da estrutura.
21.1 Estrutura: Declara21.1 Estrutura: Declaraçção ão -- StructStruct e Varie Variááveisveis
Estruturas em C 10
 Exemplo 2: Faça uma estrutura para armazenar as 
coordenadas (x,y) de um ponto:
Declaração:
struct ponto{
float x;
float y;
} p1, p2;
 A estrutura contém dois floats, x e y 
 p1 e p2 são duas variáveis tipo ponto contendo 
duas coordenadas cada.
p1(x, y)
x
y
p2(x, y)
2 4
1
3
21.1 Estrutura: Declara21.1 Estrutura: Declaraçção ão -- StructStruct e Varie Variááveisveis
Estruturas em C 11
 Para se acessar um membro qualquer de uma 
estrutura usa-se o operador ponto (.) Por ex: p1.x, 
p1.y
 Neste exemplo, foram atribuídos à
variável p1 (ao ponto p1 ) os valores de 
coordenadas 2.0 e 1.0. E à variável p2 
(ao ponto p2) foram atribuídos os 
valores de coordenadas 4.0 e 3.0
21.2 Estrutura: 21.2 Estrutura: Acesso aos dados da Estrutura.Acesso aos dados da Estrutura.
Exemplo 3:
struct {
float x;
float y;
} p1, p2;
p1.x = 2.0;
p1.y = 1.0;
p2.x = 4.0; 
p2.y = 3.0;
Estruturas em C 12
struct Data
{ 
int Dia, Ano;
char Mes[20];
}; 
Exemplo 4 : Criar uma estrutura 
capaz de armazenar datas 
com 3 campos (dia, ano e 
mês) em que cada campo é
de um tipo diferente.
#include <stdio.h>
struct Data
{int Dia, Ano; char Mes[20];};
main() 
{
struct Data d1;
printf(“Entre com o dia:”);
scanf(“%d”,&d1.Dia); 
fflush(stdin);
printf(“Entre com o mes:”);
gets(d1.Mes);
printf(“Entre com o ano:”);
scanf(“%d”,&d1.Ano);
printf(“A data digitada e:”);
printf(“%d/%s”,d1.Dia,d1.Mes);
printf(“/%d\n”,d1.Ano);
}
21.2 Estrutura: 21.2 Estrutura: Acesso aos dados da Estrutura.Acesso aos dados da Estrutura.
Estruturas em C 13
OBS: No Exemplo 4, a variável d1 é do tipo Data e uma 
informação pertencente a um dado campo da estrutura 
Data é acessada utilizando-se o ponto ‘.’, isto é:
d1.Dia d1.Mes d1.Ano
21.2 Estrutura: 21.2 Estrutura: Acesso aos dados da Estrutura.Acesso aos dados da Estrutura.
Estruturas em C 14
21.3 Estrutura: Carga Inicial Autom21.3 Estrutura: Carga Inicial Automááticatica
Uma Estrutura pode ser iniciada quando ela é declarada. Para 
tanto, usa-se a seguinte sintaxe:
struct nome_estrutura variavel = { valor1, valor2,..., valorn}
 Coloca-se entre chaves os valores dos membros da 
estrutura, pela ordem em que eles foram escritos na sua 
definição.
Exemplo 5: struct Data d1 = {23, 58, “Jun”};
Neste exemplo a variável d1.Dia vai receber o valor 23.
A variável d1.Ano recebe o valor 58 e a variável d1.Mes recebe
o valor “Jun”.
Estruturas em C 15
#include <stdio.h>
#include <stdlib.h>
struct Data
{int Dia, Ano; char Mes[20];};
main() 
{
struct Data d1 = {23,67,“Jan”};
printf(“Data inicial e:”);
printf(“%d/%s”,d1.Dia,d1.Mes);
printf(“/%d\n”,d1.Ano);
Exemplo 6 – Inicialização
21.3 Estrutura: 21.3 Estrutura: Carga Inicial AutomCarga Inicial Automááticatica
printf(“Entre com o dia:”);
scanf(“%d”,&d1.Dia); 
fflush(stdin);
printf(“Entre com o mes:”);
gets(d1.Mes);
printf(“Entre com o ano:”);
scanf(“%d”,&d1.Ano);
printf(“A data digitada e:”);
printf(“%d/%s”,d1.Dia,d1.Mes);
printf(“/%d\n”,d1.Ano);
system(“pause”);
}
Estruturas em C 16
21.3 Estrutura: Carga Inicial Autom21.3 Estrutura: Carga Inicial Automááticatica
Estruturas em C 17
21.4 Estruturas: 21.4 Estruturas: typedeftypedef
 Todas as vezes em que se for declarar uma variável do tipo 
estrutura fora do localde definição da mesma, é necessário 
colocar antes do nome da variável a palavra reservada struct
seguida do nome da estrutura. 
Ex: struct Data d1;  declaração da variável d1
 Existe uma outra maneira de se declarar uma variável do 
tipo estrutura, utilizando uma palavra sinônimo para a 
estrutura. Isto é feito através da palavra reservada typedef, 
cuja sintaxe é:
typedef tipo_existente sinônimo 
OBS: A palavra typedef não cria um novo tipo, ela apenas 
permite que um determinado tipo possa ser denominado 
de forma diferente
Estruturas em C 18
21.4 Estruturas: 21.4 Estruturas: typedeftypedef
 A utilização da palavra reservada typedef não se limita 
apenas as estruturas, ela estabelece um sinônimo para 
qualquer conjunto de palavras, por ex:
typedef float real;
O tipo float passa também a ser representado pela palavra 
real. Pode-se então declarar uma variável utilizando as duas 
palavras: float e real.
Ex: typedef struct Data Dt;
Dt d1;
OBS: Neste exemplo foi criado o sinônimo Dt para o tipo 
struct Data. Deste modo, a declaração da variável d1 foi feita 
utilizando esse sinônimo.
Estruturas em C 19
 Pode-se também empregar a palavra reservada typedef
junto com a definição da estrutura:
typedef struct Data
{
int Dia, Ano; 
char Mes[20];
} Dt;
main()
{ Dt d1;
d1.Dia = 26;
d1.Mes = “Jan”;
d1.Ano = 93; }
Typedef define que o sinônimo de 
struct Data {...} é a palavra Dt.
Não é necessário empregar a 
palavra struct Data e sim apenas Dt.
21.4 Estruturas: 21.4 Estruturas: typedeftypedef
Estruturas em C 20
struct Data
{
int Dia, Ano; 
char Mes[20];
};
main()
{ struct Data d1;
d1.Dia = 26;
d1.Mes = “Jan”;
d1.Ano = 93;}
typedef struct Data
{
int Dia, Ano; 
char Mes[20];
} Dt;
main()
{ Dt d1;
d1.Dia = 26;
d1.Mes = “Jan”;
d1.Ano = 93; }
struct Data
{
int Dia, Ano; 
char Mes[20];
};
typedef struct Data Dt;
main()
{ Dt d1;
d1.Dia = 26;
d1.Mes = “Jan”;
d1.Ano = 93; }
A seguir são ilustradas as três formas possíveis para se declarar 
um novo tipo Data utilizando struct com ou sem typedef: 
21.4 Estruturas: 21.4 Estruturas: typedeftypedef
Estruturas em C 21
#include <stdio.h>
typedef struct Data 
{int Dia, Ano; char Mes[20];} Dt;
main() 
{
int n_Dias;
Dt d2, d1 = {23, 67, “Jan”};
printf(“Data inicial e:”);
printf(“%d/%s/%d\n”,d1.Dia,d1.Mes,d1.Ano);
d2 = d1;
printf(“Entre com n. de dias:”);
scanf(“%d”,&n_Dias); 
d2.Dia = d1.Dia + n_Dias;
printf(“A nova data e:”);
printf(“%d/%s/%d\n”,d2.Dia,d2.Mes,d2.Ano);
}
Exemplo 7 – Atribuições
Atribuição de valores
entre estruturas:
d2 = d1;
Equivale à:
d2.Dia = d1.Dia;
d2.Mes = d1.Mes;
d2.Ano = d2.Ano;
Observe que para vetor
e matriz a atribuição 
é sempre feita 
elemento por elemento!
Problema: 31/12/1999 -> 32/12/1999 ?
21.4 Estruturas: 21.4 Estruturas: typedeftypedef
Estruturas em C 22
Exemplo 8: Fazer um programa que dado uma data 
e um certo número de dias, ele imprime a nova data.
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Para fazer esse programa é preciso verificar quantos dias 
tem o mês, isto é, se o mês tem 31, 30, 29 ou 28 dias. 
Os meses que tem 31 dias são os meses de Janeiro, 
Março, Maio, Julho, Agosto, outubro e Dezembro
Os meses com 30 dias são os meses de Abril, Junho, 
Setembro, Novembro.
Os meses com 28 dias temos somente o mês de 
Fevereiro, que se o ano for bissexto ele tem 29 dias.
Então também é preciso saber quando o ano é
bissexto
Estruturas em C 23
1. O programa terá uma estrutura de dados para armazenar o 
dia, mês e ano e esta estrutura terá duas variáveis (d1 e 
d2); d1 irá guardar da data de entrada e d2 vai guardar a 
nova data depois de somados os dias.
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
anomêsdiaData
typedef struct Data 
{int Dia, 
int Mes, 
int Ano;}Data;
Estruturas em C 24
2. O programa terá uma função (addDia) que que vai receber a 
data atual d1 e o número de dias que se quer adicionar e ela 
vai calcular e devolver nova data d2;
Data addDia(Data di, int nDias);
3. Uma função que vai verificar se o ano é bissexto. Se algum ano 
no intervalo da nova data for bissexto esta função devolve o 
valor 1, senão ela devolve o valor zero.
int bissexto(int ano);
Essa função será chamada dentro da função Data.
4. Um procedimento que recebe o valor de uma data e a imprime 
void printData(Data di);
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Estruturas em C 25
Em 1582, Gregório XIII fez uma nova definição 
para ano bissexto:
Calendário Gregoriano
3300
1
400
1
100
1
4
1365 365,242199 
Cada 4 anos + 1 dia
Cada 100 anos - 1 dia
Cada 400 anos + 1 dia
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Estruturas em C 26
Se resto(ano/100) é 0 
Se (ano/400) é 0 
então bissexto; (b)
Senão não_bissexto; (c)
Senão
Se resto(ano/4) é 0
então bissexto; (a)
Senão não_bissexto; (c)
Algoritmo
OBSERVAÇÃO: Subtrair 1 dia do calendário a cada 3300 anos
(a) Não divisível por 100 e 
divisível por 4.
(b) Divisível por 100 e 400.
(c) Os demais anos não 
são Bissextos.
Ano Bissexto
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Em 1582, Gregório XIII fez uma nova definição 
para ano bissexto:
Calendário Gregoriano
Estruturas em C 27
int bissexto(int ano){if (ano % 100 == 0)if (ano % 400 == 0)return 1;else return 0;elseif (ano % 4 == 0) return 1;else return 0;}
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Função que verifica se O ano é
bissexto (retorna 1 ou não (0))
Estruturas em C 28
Data addDia(Data di, int nDias)
{ int auxD, TRUE = 1;
auxD = di.Dia + nDias;
while (TRUE)
{//Inicio do While
if ((di.Mes == 1)||(di.Mes == 3)||(di.Mes == 5)||(di.Mes== 7)||
(di.Mes == 8)||(di.Mes == 10)||(di.Mes == 12)) 
if (auxD <= 31) break;
else auxD = auxD -31; 
else if((di.Mes == 4)||(di.Mes == 6)||(di.Mes == 9)||(di.Mes == 11))
if (auxD <= 30) break;
else auxD = auxD - 30; 
else if (di.Mes == 2)
if (bissexto(di.Ano))
if (auxD <= 29) break;
else auxD = auxD - 29;
else if (auxD <= 28) break;
else auxD = auxD - 28;
di.Mes = di.Mes + 1; 
// Verifica se ultrapassa 12 meses.
if (di.Mes > 12)
{ di.Ano = di.Ano + 1;
di.Mes = 1; }
} // Fim do while.
di.Dia = auxD;
return di;
} // fim função
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Função para adicionar dias na data.
Estruturas em C 29
Exemplo 8 – Funções + struct
#include <stdio.h>
#include <stdlib.h>
typedef struct Data 
{int Dia, Mes, Ano;}Data;
// Protótipos das funções.
void printData(Data di);
int bissexto(int ano);
Data addDia(Data di, int nDias); 
// Função principal.
main() 
{int nDias;
Data d2, d1 = {31,12,1999};
printf("Data inicial e:");
printData(d1);
d2 = d1;
printf("Entre com n. de dias:");
scanf("%d",&nDias); 
d2 = addDia(d1, nDias);
printf("A nova data e:");
printData(d2);}
Fazer um programa 
que dado uma data 
e um certo número 
de dias, ele imprime 
a nova data.
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Estruturas em C 30
// função que imprime a data. CONTINUAÇÃO - Exemplo 8
void printData(Data di)
{
printf(“A nova data eh:”);
printf(“%d/%s/%d\n”,di.Dia,di.Mes,di.Ano);
} 
//Função verifica se O ano é bissexto (retorna 1 ou não (0))
Data addDia(Data di, int nDias)
{ int auxD, TRUE = 1;
auxD = di.Dia + nDias;
while (TRUE)
{//Inicio do While
if ((di.Mes == 1)||(di.Mes == 3)||(di.Mes == 5)||(di.Mes== 7)||
(di.Mes == 8)||(di.Mes == 10)||(di.Mes == 12)) 
if (auxD <= 31) break;
else auxD = auxD -31;else if((di.Mes == 4)||(di.Mes == 6)||(di.Mes == 9)||(di.Mes
== 11))
if (auxD <= 30) break;
else auxD = auxD - 30; 
else if (di.Mes == 2)
if (bissexto(di.Ano))
if (auxD <= 29) break;
else auxD = auxD - 29;
else if (auxD <= 28) break;
else auxD = auxD - 28;
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Estruturas em C 31
// Acréscimo no mês. CONTINUAÇÃO - Exemplo 8
di.Mes = di.Mes + 1; 
// Verifica se ultrapassa 12 meses.
if (di.Mes > 12)
{ di.Ano = di.Ano + 1;
di.Mes = 1; }
} // Fim do while.
di.Dia = auxD;
return di;
} 
//Função verifica se O ano é bissexto (retorna 1 ou não (0))
int bissexto(int ano)
{if (ano % 100 == 0)
if (ano % 400 == 0)
return 1;
else 
return 0;
else
if (ano % 4 == 0) 
return 1;
else 
return 0;
}
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Estruturas em C 32
Exemplo 9: Fazer um programa que realize o cadastro de 
contas bancárias com as seguintes informações: Número 
da conta, nome do cliente e saldo. O banco permitirá o 
cadastramento de apenas 15 e não pode haver mais de 
uma conta com o mesmo número. Crie o menu de opções 
a seguir:
Menu de Opções:
1. Cadastrar contas
2. Visualizar todas as contas
3. Excluir a conta com menor saldo(suponha que não 
tem saldos iguais)
4. Sair
21.5 Novos Tipos: fun21.5 Novos Tipos: funçções + ões + structstruct
Estruturas em C 33
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Exemplo 9- Solução: O esquema de resolução deste problema é
o seguinte:
1) Fazer um laço com o comando do-while. 
2) Dentro deste laço, apresentar o menu de opções e pedir para 
escolher uma opção. 
Menu de Opções:
1. Cadastrar contas
2. Visualizar todas as contas
3. Excluir a conta com menor saldo(suponha que não tem 
saldos iguais)
4. Sair
Estruturas em C 34
3) Se (opçao = 1) , pedir para digitar o número da conta, verificar 
se esta conta já está cadastrada. Se ela estiver cadastrada 
escrever uma mensagem. Senão, verificar se a conta pode ser 
cadastrada e a seguir cadastrá-la .Voltar no inicio do do-while. 
4) Se (opçao = 2) , verificar se esta conta existe. Se ela existir, 
mostrar a conta. Senão escrever mensagem dizendo que a conta 
não existe. Voltar no início do do-while
5) Se (opçao = 3), procurar entre as contas cadastradas aquela que 
tem o menor saldo, achar a posição que ela ocupa no vetor de 
cadastro, apagá-la, reposicionar as demais contas no vetor de 
cadastro, e voltar no início do do-while. 
6) Se (opçao = 4), sair do laço e encerrar o programa.
A seguir está mostrado o programa deste exemplo
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 35
#include <conio.h>
#include <string.h>
#include <stdio.h> Exemplo 9
#include <stdlib.h>
struct
{ int num;
char nome[35];
float saldo;
} conta[15]; 
main()
{ int i,j, op, posi, achou, num_conta;
float saldo_cliente, menor_saldo;
char nome_cliente[35];
for (i=0;i<15;i++)
{ conta[i].num = 0;
strcpy(conta[i].nome,"\0");
conta[i].saldo = 0; }
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 36
do //Início laço principal
{ system("CLS");
printf("\nMenu de Opcoes");
printf("\n1 - Cadastrar contas");
printf("\n2 - Visualizar todas as contas de um 
determinado cliente");
printf("\n3 - Excluir conta de menor saldo");
printf("\n4 - Sair");
printf("\nDigite sua opcao: ");
scanf("%d",&op);
if ((op < 1) || (op > 4))
printf("\nOpcao Invalida!");
if (op == 1)
{ achou = 0;
printf( "\nDigite o numero da conta a ser 
incluida ");
scanf("%d",&num_conta); 31
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Exemplo 9
Estruturas em C 37
//Verifica se esta conta já está cadastrada
fflush(stdin);
for (i=0;i<15;i++) 
{ if (num_conta == conta[i].num)
achou = 1; }
if (achou == 1)
printf("\nJa existe conta cadastrada com este 
numero");
else // cadastrar a conta
{ posi = -1;
j = 0;
while (j < 15)// Verifica se pode cadastrar 
{ if (conta[j].num == 0)
{ posi = j;
j = 15;}
j++;
} // Fim while
if (posi == -1)
printf("\nImpossivel cadastrar novas contas"); 32
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 38
else
{ printf("\nDigite o nome do cliente ");
gets(nome_cliente);
fflush(stdin);
printf("\nDigite o saldo do cliente ");
scanf("%f",&saldo_cliente);
conta[posi].num = num_conta;
strcpy(conta[posi].nome,nome_cliente);
conta[posi].saldo = saldo_cliente;
printf( "\nConta cadastrada com sucesso!");
} 
}// Fim else cadastrar conta
getch();
} //Fim if (op==1)
fflush(stdin);
33
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 39
if (op == 2) 
{ printf( "\nDigite o nome do cliente a ser consultado ");
gets(nome_cliente);
achou = 0;
for (i=0;i<15;i++)
{ if (stricmp(conta[i].nome,nome_cliente) == 0)
{printf( "\nNumero conta: %d Saldo:%.2f ", 
conta[i].num, conta[i].saldo);
achou = 1; }
} // Fim for
if (achou == 0)
printf("\nNao existe conta cadastrada para este 
cliente!");
getch();
}// Fim if (op==2)
34
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 40
if (op == 3)
{ i = 0;
achou = 0;
while (i < 15)
{ if (conta[i].num != 0)
{ if (i==0)
{ menor_saldo = conta[i].saldo;
posi = i; }
else if (conta[i].saldo < menor_saldo)
{ menor_saldo = conta[i].saldo;
posi = i; }
achou = 1;
}
i++;
} // Fim while
if (achou == 0)
printf( "\nNenhuma conta foi cadastrada!");
else // excluir a conta 
{ for (i=posi;i<14;i++)
{ conta[i] = conta[i+1]; }
35
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 41
conta[i].num = 0;
strcpy(conta[i].nome,"\0");
conta[i].saldo = 0;
printf("\nConta excluida com sucesso!");
} // Fim else excluir a conta 
getch();
} // Fim if (op==3)
} while (op!=4); //Fim laço principal
} // Fim programa
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 42
Fazer um programa que leia os coeficientes de 
um polinômio P(x), imprima e calcule seu 
valor num ponto x (fornecido pelo usuário), e 
encontre os coeficientes do polinômio Q(x).
Utilize uma função para ler o polinômio, outra 
para imprimi-lo e outra para calcular o seu 
valor no ponto x.
Exemplo 10 – Polinômio
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 43
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
A estrutura de dados (struct Pol) para armazenar os coeficientes 
do polinômio deve ter um campo para: 
1. armazenar os coeficientes do polinômio – vetor v[ ]de até 100 
elementos reais;
2. armazenar o grau do polinômio - variável inteira n;
3. para indicar se o polinômio já foi inicializado ou não- variável 
inteira init. 
Então o tipo de dado struct Pol terá a seguinte forma:
V[n]...V[2]V[1]V[0]
init
nNome 
da 
variável
typedef struct Pol
{ float v[101]; 
int n; 
int init;}Pol;
Estruturas em C 44
#include <stdio.h>
#include <stdlib.h>
typedef struct Pol
{float v[101]; int n; int init;}Pol;
// Protótipos das funções.
void printPol(Pol px);
Pol initPol(Pol px); 
float valor_Pol(Pol px, float x);
Pol calcPol(Pol px, float x);
// Função principal.
main() 
{Pol p, p2;
float ponto;
printf("Iniciando p:");
p = initPol(p);
p2 = p;
printf("Em que ponto você deseja calcular o polinomio?");
scanf("%f",&ponto);
printf("\n Mostrando p:");
printPol(p); 
printf("p(x=%.2f)=%.2f\n",ponto,valor_Pol(p,ponto));
p2 = calcPol(p,ponto),
printf("\n Mostrando p2:");printPol(p2);
system("pause");
} 38
Exemplo 10
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 45
// Função de impressão de px.void printPol(Pol px) {int i;
//Se o polinômio foi inicializado. if (px.init){ for (i=px.n; i >= 0; i--)printf("\nc[%d]=%.2f",i,px.v[i]);printf("\n");} else printf("Inicialize px ! \n"); }
// Função de leitura de px.Pol initPol(Pol px){ int i; px.init = 1;printf("\nInsira grau px <= 100:");scanf("%d",&px.n);for (i=0; i <= px.n; i++){ printf("Entre com c[%d]:",i);scanf("%f",&px.v[i]); }return px;} 39
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 46
// Função que calcula o valor de px.float valor_Pol(Pol px, float x)
{ int i, n = px.n;float y;
if (n == 0)y = px.v[0]; 
else{
// Usando algoritmo de Briott-Rufini.
y = px.v[n-1] + px.v[n]*x;for (i=n-2; i >= 0; i--)y = px.v[i] + x*y;
}return y;
}
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 47
// Função que acha o polinomio Q(x)- Quociente da
//divisão de P(x)/(x-x1)
Pol calcPol(Pol px, float x){ //Pol pz;
int i, n = px.n;Pol pz;
pz = px; if (n == 0)pz.v[0]= px.v[0]; 
else{
// Usando algoritmo de Briott-Rufini.
pz.v[n-1] = px.v[n-1] + px.v[n]*x;for (i=n-2; i >= 0; i--)
pz.v[i] = px.v[i] + x*pz.v[i-1];pz.n = n - 1;}
return pz;}
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 48
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 49
Exemplo 11: Construir um programa que armazene e manipule
informações de uma usina hidrelétrica, tais como dadas abaixo:
Nome Volume
(x)
Polinômio grau 4: Volume x Altura
(x)
(u)
Furnas
Defluência
(u) Polinômio grau 4: Defluência X Altura
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 50
#include <stdio.h>
typedef struct usinaH
{char nome[100]; float x, u; 
Pol px, pu;} usinaH;
// Protótipos das funções.
void printUsinaH(usinaH h);
usinaH initUsinaH(usinaH h); 
float calcAltx(usinaH h);
// Função principal.
main() 
{
usinaH h; float x;
printf(“Iniciando usina:”);
h = initUsinaH(h);
printf(“\n Mostrando h:”);
printUsinaH(h); 
printf(“px=%f\n”,calcAltx(h));
}
Exemplo 11 – Usinas Hidro
// Inicializa os dados de uma usina.
usinaH initUsinaH(usinaH h)
{ Pol px, pu;
printf(“\n Entre nome da usina:”);
gets(h.nome);
printf(“\n Entre com volume:”);
scanf(“%f”,&h.x);
printf(“\n Entre com defluencia:”);
scanf(“%f”,&h.u);
h.px = initPol(px);
h.pu = initPol(pu);
return h;}
// Imprime dados de uma usina.
void printUsinaH(usinaH h)
{printf(“\n Nome da usina:”);
puts(h.nome);
printf(“\nVolume:%f”,h.x);
printf(“\nDefluencia:%f”,h.u);
printf(“\n Polx = ”);printPol(h.px);
printf(“\n Polu = ”);printPol(h.pu);}
Exemplo 11 – Usinas Hidro
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 51
// Função que calcula phi(x) 
// (altura de montante).
float calcAltx(usinaH h) 
{
float y; 
y = calcPol(h.px, h.x);
return y;
}
Exemplo 11 – Usinas Hidro
A estrutura usinaH utiliza uma
outra estrutura Pol que
representa um polinômio,
bem como as funções 
associadas a manipulação
da estrutura Pol.
Observação Importante:
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 52
Fazer um programa que leia o nome de um 
produto vendido, a data da compra, o preço da 
venda e imprima todos estes valores. A seguir 
imprima também um resumo da venda da 
seguinte maneira:
-----------------------------------------
Resumo da venda
Produto: geladeira
Data da venda:23/10/2008
Preço do produto: R$ 2500.00
------------------------------------------
Utilize uma estrutura para armazenar os dados 
dos produtos e funções para fazer as impressões.
Exemplo 12 – Cadastro2
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 53
#include <stdio.h>
#include <stdlib.h>
typedef struct Data
{int D, M, A;} Dt;
typedef struct Produto
{char Nome[100]; 
Data Venda; 
float Preco;} Pd;
// Protótipos das funções.
void printData(Dt d);
void printProd(Pd p);
Dt initData(void);
Pd initProd(void); 
// Função principal.
main() 
{Pd p[3]; int i;
printf("Leitura de 
produtos:");
// Função principal.
main() 
{Pd p[3]; int i;
printf("Leitura de 
produtos:");
for (i=0; i < 3; i++)
{ fflush(stdin);
p[i]=initProd();
fflush(stdin);
printProd(p[i]);}
printf("\n\n");
system("pause");
}
// Função que imprime Data.
void printData(Dt d)
{printf("%d/%d/%d",d.D,d.M
,d.A);}
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos ResolvidosExemplo 12 – Cadastro2
Estruturas em C 54
Exemplo 12 – Cadastro2
// Função que imprime Produto.void printProd(Pd p){ printf("\tResumoVenda:"); 
printf("\n\tProduto: ");puts(p.Nome);
printf("\tData de venda: ");printData(p.Venda);
printf("\n\tPrecoProduto: ");printf("R$ %10.2f \n", 
p.Preco);} 
// Função que inicializa Data.Dt initData(void){ Dt d;printf("DD/MM/AAAA: ");
scanf("%d%d%d",&d.D, &d.M, &d.A);return d;}
// Função que inicializa
// produto.
Pd initProd(void)
{Pd p;
printf("\n-----------------
-----\n");
printf("\n Nome Produto:");
gets(p.Nome);
fflush(stdin);
printf("\n Data da venda ");
p.Venda = initData();
printf("\n Preco da venda: 
");
scanf("%f",&p.Preco); 
printf("\n-----------------
-----\n");
printf("\n-----------------
-----\n");
return p;
} 
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos Resolvidos
Estruturas em C 55
21.6 Estrutura: 21.6 Estrutura: Exemplos ResolvidosExemplos ResolvidosExemplo 12 – Cadastro2
Estruturas em C 56
A palavra enum associa a um
conjunto de nomes, valores 
inteiros a partir de zero (padrão)
ou a partir de um primeiro valor
fornecido. Se um valor for 
fornecido à alguns nomes e não
à outros, o compilador atribui 
o próximo valor inteiro aos que
não tiverem valor. Tipos enum
são tratados como inteiros e
qualquer operação de números
inteiros com eles é válida.
21.7 Novos Tipos: 21.7 Novos Tipos: enumenum
Definição
enum Mes
{ Jan = 1, Fev, Mar, Abr, Mai,
Jun, Jul, Ago, Set, Out,
Nov, Dez
};
Exemplo13
No exemplo abaixo é criada
uma estrutura enum que
associa para cada palavra
um valor inteiro.
Estruturas em C 57
21.7 Novos tipos: 21.7 Novos tipos: enumenum
#include <stdio.h>
enum meses {Jan = 1, Fev, Mar, 
Abr, Mai, Jun, Jul, Ago, Set, Out, 
Nov, Dez}; 
main()
{ int dia; 
meses mes;
mes = Set; 
if (mes == Jan || mes == Mar || 
mes == Mai || mes == Jul || 
mes == Ago || mes == Out || 
mes == Dez)
dia = 31;
else
if (mes == Fev)
dia = 28;
else
dia = 30;
printf(“Numero dias: %d \n”,dia); }
Exemplo 13.1 – Enum Mes
#include <stdio.h>
enum meses {Jan = 1, Fev, Mar, 
Abr, Mai, Jun, Jul, Ago, Set, Out, 
Nov, Dez}; 
main()
{ int dia; 
meses mes;
mes = meses(9); // int -> meses !
if (mes == Jan || mes == Mar || 
mes == Mai || mes == Jul || 
mes == Ago || mes == Out || 
mes == Dez)
dia = 31;
else
if (mes == Fev)
dia = 28;
else
dia = 30;
printf(“Numero dias: %d \n”,dia); }
Exemplo 13.2 – Enum Mes
Estruturas em C 58
21.8 Novos tipos: resumo21.8 Novos tipos: resumo
(ii) A definição de tipos e tipos enumerados facilita a 
programação e permite melhorar o entendimento do
programa. Além disso, estruturas podem ser combinadas
com quaisquer outros tipos de dados tais como int, char,
float, vetores, matrizes e inclusive outras estruturas.
(i) Assim, como vetores e matrizes permitem agrupar e 
acessar uma grande quantidade de dados do mesmo tipo
sob o nome de uma variável com o uso de índices e colchetes, 
estruturas são muito úteispara definir um conjunto de
campos de valores para diferentes tipos de dados que 
podem ser armazenados em uma variável e acessados
através do operador ‘.’.
Estruturas em C 59
Fim deFim de
Novos TiposNovos Tipos
StructsStructs, Typedef e, Typedef e
EnumEnum
21.8 Novos tipos: fim da aula 2121.8 Novos tipos: fim da aula 21