21 - Estruturas em C (Novos Tipos)

Registros

Unesp – Campus de Guaratinguetá

Curso de Programação Computadores

Prof. Aníbal Tavares
Profa. Cassilda Ribeiro
Ministrado por: Prof. André Amarante
 21. 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 Estruturas em C correspondem aos

Registros em outra linguagens.
 Registros são Estruturas que podem agrupar diferentes
tipos de informações (dados).

 uma Estrutura é um conjunto de uma ou

Então,
mais variáveis agrupadas sob um único nome.
Estruturas em C 2
 21. 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.
 As Estruturas (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 3
 21.1 Estrutura: Declaração - Struct
A declaração de 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 estruturaEstruturas
para em referenciá-la.
C 4
 21.1 Estrutura: Declaração - Struct

 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 struct Dados
queiramos armazenar os dados {
relativos a um indivíduo, como
mostrado a seguir: int idade;
char est_civil, sexo, nome[20];
int idade; } pessoa;
char Nome[60];
char est_civil,sexo;

Não esquecer do ponto-e-vírgula !

Estruturas em C 5
 21.1 Estrutura: Declaração - Struct
 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
idade pessoa.idade

pessoa est_civil pessoa.est_civil

sexo pessoa.sexo

nome[20] pessoa.nome

 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
Estruturas emcampo.
C 6
 21.1 Estrutura: Declaração - Struct

struct Dados
Nome do novo tipo de dado
{
int idade; Campo idade do tipo int
char est_civil, sexo;
Campo estado civil e sexo do
char nome[20];
tipo char
} pessoa;
Campo nome do tipo string

Variável do tipo Dados

Estruturas em C 7
 21.1 Estrutura: Declaração - Struct e Variáveis

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;

 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
Estruturas em C Dados 8
 21.1 Estrutura: Declaração - Struct e Variáveis
 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.
Estruturas em C 9
 21.1 Estrutura: Declaração - Struct e Variáveis
 Exemplo 2: Faça uma estrutura para armazenar as
coordenadas (x,y) de um ponto:
Declaração: y
struct ponto{ p1(x, y)
3
p2(x, y)
float x; 1
float y;
} p1, p2; 2 4 x

 A estrutura contém dois floats, x e y

 p1 e p2 são duas variáveis tipo ponto contendo
duas coordenadas cada.
Estruturas em C 10
 21.2 Estrutura: Acesso aos dados da Estrutura.

 Para se acessar um membro qualquer de uma

estrutura usa-se o operador ponto (.) Por ex: p1.x,
p1.y
Exemplo 3:
struct {  Neste exemplo, foram atribuídos à
variável p1 (ao ponto p1 ) os valores de
float x; coordenadas 2.0 e 1.0. E à variável p2
float y; (ao ponto p2) foram atribuídos os
valores de coordenadas 4.0 e 3.0
} p1, p2;
p1.x = 2.0;
p1.y = 1.0;
p2.x = 4.0;
p2.y = 3.0; Estruturas em C 11
 21.2 Estrutura: Acesso aos dados da Estrutura.
#include <stdio.h>
Exemplo 4 : Criar uma estrutura struct Data
capaz de armazenar datas {int Dia, Ano; char Mes[20];};
com 3 campos (dia, ano e main()
mês) em que cada campo é {
de um tipo diferente. struct Data d1;
printf(“Entre com o dia:”);
scanf(“%d”,&d1.Dia);
fflush(stdin);
struct Data
printf(“Entre com o mes:”);
{ gets(d1.Mes);
int Dia, Ano; printf(“Entre com o ano:”);
char Mes[20]; scanf(“%d”,&d1.Ano);
}; printf(“A data digitada e:”);
printf(“%d/%s”,d1.Dia,d1.Mes);
printf(“/%d\n”,d1.Ano);
Estruturas em C 12
}
 21.2 Estrutura: Acesso aos dados da Estrutura.

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

Estruturas em C 13
 21.3 Estrutura: Carga Inicial Automática
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 14
 21.3 Estrutura: Carga Inicial Automática
Exemplo 6 – Inicialização
printf(“Entre com o dia:”);
#include <stdio.h> scanf(“%d”,&d1.Dia);
#include <stdlib.h>
fflush(stdin);
struct Data
printf(“Entre com o mes:”);
{int Dia, Ano; char Mes[20];};
gets(d1.Mes);
main()
printf(“Entre com o ano:”);
{
scanf(“%d”,&d1.Ano);
struct Data d1 = {23,67,“Jan”};
printf(“A data digitada e:”);
printf(“Data inicial e:”); printf(“%d/%s”,d1.Dia,d1.Mes);
printf(“%d/%s”,d1.Dia,d1.Mes); printf(“/%d\n”,d1.Ano);
printf(“/%d\n”,d1.Ano); system(“pause”);
} em C
Estruturas 15
21.3 Estrutura: Carga Inicial Automática

Estruturas em C 16
 21.4 Estruturas: typedef
 Todas as vezes em que se for declarar uma variável do tipo
estrutura fora do local de 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 17
 21.4 Estruturas: typedef
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.

 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. Estruturas em C 18
 21.4 Estruturas: typedef
 Pode-se também empregar a palavra reservada typedef
junto com a definição da estrutura:
typedef struct Data
{
int Dia, Ano; Typedef define que o sinônimo de
char Mes[20]; struct Data {...} é a palavra Dt.
} Dt;

main()
{ Dt d1; Não é necessário empregar a
d1.Dia = 26; palavra struct Data e sim apenas Dt.
d1.Mes = “Jan”;
Estruturas em C 19
d1.Ano = 93; }
 21.4 Estruturas: typedef
A seguir são ilustradas as três formas possíveis para se declarar
um novo tipo Data utilizando struct com ou sem typedef:
struct Data typedef struct Data
struct Data
{ {
{
int Dia, Ano; int Dia, Ano;
int Dia, Ano;
char Mes[20]; char Mes[20];
char Mes[20];
}; } Dt;
};
typedef struct Data Dt;
main()
main() main()
{ struct Data d1;
{ Dt d1; { Dt d1;
d1.Dia = 26;
d1.Dia = 26; d1.Dia = 26;
d1.Mes = “Jan”;
d1.Mes = “Jan”; d1.Mes = “Jan”;
d1.Ano = 93;}
d1.Ano =Estruturas
93; } em C d1.Ano = 93; } 20
 21.4 Estruturas: typedef
Exemplo 7 – Atribuições
#include <stdio.h> Atribuição de valores
typedef struct Data entre estruturas:
{int Dia, Ano; char Mes[20];} Dt;
main() d2 = d1;
{
Equivale à:
int n_Dias;
Dt d2, d1 = {23, 67, “Jan”}; d2.Dia = d1.Dia;
printf(“Data inicial e:”);
printf(“%d/%s/%d\n”,d1.Dia,d1.Mes,d1.Ano); d2.Mes = d1.Mes;
d2 = d1; d2.Ano = d2.Ano;
printf(“Entre com n. de dias:”);
scanf(“%d”,&n_Dias); Observe que para vetor
d2.Dia = d1.Dia + n_Dias; e matriz a atribuição
printf(“A nova data e:”); é sempre feita
printf(“%d/%s/%d\n”,d2.Dia,d2.Mes,d2.Ano); elemento por elemento!
}

Problema: 31/12/1999 -> 32/12/1999 ?em C

Estruturas 21
 21.5 Novos Tipos: funções + struct
Exemplo 8: Fazer um programa que dado uma data
e um certo número de dias, ele imprime a nova data.

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 22
 21.5 Novos Tipos: funções + struct
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.
typedef struct Data
Data dia mês ano
{int Dia,
int Mes,
int Ano;}Data;

Estruturas em C 23
 21.5 Novos Tipos: funções + struct
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);

Estruturas em C 24
 21.5 Novos Tipos: funções + struct

Em 1582, Gregório XIII fez uma nova definição

para ano bissexto:

Calendário Gregoriano

1 1 1 1
365,242199  365    
4 100 400 3300
Cada 4 anos + 1 dia

Cada 100 anos - 1 dia

Cada 400 anos + 1 dia Estruturas em C 25

 21.5 Novos Tipos: funções + struct

Em 1582, Gregório XIII fez uma nova definição

para ano bissexto:

Calendário Gregoriano
Ano Bissexto Algoritmo
Se resto(ano/100) é 0
(a) Não divisível por 100 e
Se (ano/400) é 0
divisível por 4.
então bissexto; (b)
Senão não_bissexto; (c)
(b) Divisível por 100 e 400.
Senão
Se resto(ano/4) é 0
(c) Os demais anos não
então bissexto; (a)
são Bissextos.
Senão não_bissexto; (c)

OBSERVAÇÃO: Subtrair 1 diaEstruturas

do calendário
em C a cada 3300 anos 26
 21.5 Novos Tipos: funções + struct
Função que 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;
}
Estruturas em C 27
 21.5 Novos Tipos: funções + struct
Data addDia(Data di, int nDias)
{ int auxD, TRUE = 1;
auxD = di.Dia + nDias; Função para adicionar dias na data.
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 Estruturas em C 28
 21.5 Novos Tipos: funções + struct
Exemplo 8 – Funções + struct
#include <stdio.h>
#include <stdlib.h> Fazer um programa
typedef struct Data
{int Dia, Mes, Ano;}Data;
que dado uma data
// Protótipos das funções. e um certo número
void printData(Data di); de dias, ele imprime
int bissexto(int ano); a nova data.
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:"); Estruturas em C 29
printData(d2);}
 21.5 Novos Tipos: funções + struct
// 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 <=Estruturas em C
28) break; 30
else auxD = auxD - 28;
 21.5 Novos Tipos: funções + struct
// 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; Estruturas em C 31
}
 21.5 Novos Tipos: funções + struct

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
Estruturas em C 32
 21.6 Estrutura: Exemplos 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 33
 21.6 Estrutura: Exemplos Resolvidos
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

Estruturas em C 34
 21.6 Estrutura: Exemplos Resolvidos
#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; } em C
Estruturas 35
 21.6 Estrutura: Exemplos Resolvidos
do //Início laço principal
{ system("CLS"); Exemplo 9
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);
Estruturas em C 31 36
 21.6 Estrutura: Exemplos Resolvidos
//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
Estruturas em C 37
 21.6 Estrutura: Exemplos Resolvidos
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
Estruturas em C 38
 21.6 Estrutura: Exemplos Resolvidos
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
Estruturas em C 39
 21.6 Estrutura: Exemplos Resolvidos
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] Estruturas
= conta[i+1];
em C
} 40
35
 21.6 Estrutura: Exemplos Resolvidos
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

Estruturas em C 41
21.6 Estrutura: Exemplos Resolvidos

Exemplo 10 – Polinômio
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.

Estruturas em C 42
 21.6 Estrutura: Exemplos 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:

Nome n typedef struct Pol

da init { float v[101];
variável int n;
V[0] V[1] V[2] ... V[n]
inteminit;}Pol;
Estruturas C 43
 21.6 Estrutura: Exemplos Resolvidos
#include <stdio.h>
#include <stdlib.h>
typedef struct Pol
{float v[101]; int n; int init;}Pol; Exemplo 10
// 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"); Estruturas em C 44
38
}
 21.6 Estrutura: Exemplos Resolvidos
// 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; Estruturas em C 45
39
}
 21.6 Estrutura: Exemplos Resolvidos
// 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;
}

Estruturas em C 46
 21.6 Estrutura: Exemplos Resolvidos
// 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;
}
Estruturas em C 47
21.6 Estrutura: Exemplos Resolvidos

Estruturas em C 48
 21.6 Estrutura: Exemplos Resolvidos

Exemplo 11: Construir um programa que armazene e manipule

informações de uma usina hidrelétrica, tais como dadas abaixo:

Nome Volume Defluência Polinômio grau 4: Volume x Altura

(x) (u) Polinômio grau 4: Defluência X Altura

Furnas

(x)

(u)
Estruturas em C 49
 21.6 Estrutura: Exemplos Resolvidos
Exemplo 11 – Usinas Hidro Exemplo 11 – Usinas Hidro
#include <stdio.h> // Inicializa os dados de uma usina.
typedef struct usinaH usinaH initUsinaH(usinaH h)
{char nome[100]; float x, u; { Pol px, pu;
Pol px, pu;} usinaH; printf(“\n Entre nome da usina:”);
gets(h.nome);
// Protótipos das funções. printf(“\n Entre com volume:”);
void printUsinaH(usinaH h); scanf(“%f”,&h.x);
usinaH initUsinaH(usinaH h); printf(“\n Entre com defluencia:”);
float calcAltx(usinaH h); scanf(“%f”,&h.u);
h.px = initPol(px);
// Função principal. h.pu = initPol(pu);
main() return h;}
{ // Imprime dados de uma usina.
usinaH h; float x; void printUsinaH(usinaH h)
printf(“Iniciando usina:”); {printf(“\n Nome da usina:”);
h = initUsinaH(h); puts(h.nome);
printf(“\n Mostrando h:”); printf(“\nVolume:%f”,h.x);
printUsinaH(h); printf(“\nDefluencia:%f”,h.u);
printf(“px=%f\n”,calcAltx(h)); printf(“\n
Estruturas em C Polx = ”);printPol(h.px); 50
} printf(“\n Polu = ”);printPol(h.pu);}
 21.6 Estrutura: Exemplos Resolvidos
Exemplo 11 – Usinas Hidro
// Função que calcula phi(x)
// (altura de montante).
float calcAltx(usinaH h)
{
float y;
y = calcPol(h.px, h.x);
return y;
}

Observação Importante:
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. Estruturas em C 51
21.6 Estrutura: Exemplos Resolvidos
Exemplo 12 – Cadastro2
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çõesEstruturas
para em
fazer
C
as impressões. 52
 21.6 Estrutura: Exemplos ResolvidosExemplo 12 – Cadastro2
#include <stdio.h> // Função principal.
#include <stdlib.h> main()
typedef struct Data {Pd p[3]; int i;
{int D, M, A;} Dt; printf("Leitura de
typedef struct Produto produtos:");
{char Nome[100]; for (i=0; i < 3; i++)
Data Venda; { fflush(stdin);
float Preco;} Pd; p[i]=initProd();
// Protótipos das funções. fflush(stdin);
void printData(Dt d); printProd(p[i]);}
void printProd(Pd p); printf("\n\n");
Dt initData(void); system("pause");
Pd initProd(void); }
// Função principal. // Função que imprime Data.
main() void printData(Dt d)
{Pd p[3]; int i; {printf("%d/%d/%d",d.D,d.M
printf("Leitura de ,d.A);}
produtos:");
Estruturas em C 53
 21.6 Estrutura: Exemplos Resolvidos Exemplo 12 – Cadastro2

// Função que inicializa

// Função que imprime Produto.
void printProd(Pd p) // produto.
{ printf("\tResumo Pd initProd(void)
Venda:"); {Pd p;
printf("\n\tProduto: "); printf("\n-----------------
puts(p.Nome); -----\n");
printf("\tData de venda: printf("\n Nome Produto:");
"); gets(p.Nome);
printData(p.Venda); fflush(stdin);
printf("\n\tPreco printf("\n Data da venda ");
Produto: "); p.Venda = initData();
printf("R$ %10.2f \n", printf("\n Preco da venda:
p.Preco);} ");
// Função que inicializa Data.
Dt initData(void) scanf("%f",&p.Preco);
{ Dt d; printf("\n-----------------
printf("DD/MM/AAAA: "); -----\n");
scanf("%d%d%d",&d.D, printf("\n-----------------
&d.M, &d.A); -----\n");
return d;} return
Estruturas em C p; 54
}
21.6 Estrutura: Exemplos ResolvidosExemplo 12 – Cadastro2

Estruturas em C 55
 21.7 Novos Tipos: enum
Definição
A palavra enum associa a um
Exemplo13
conjunto de nomes, valores
inteiros a partir de zero (padrão) No exemplo abaixo é criada
uma estrutura enum que
ou a partir de um primeiro valor
associa para cada palavra
fornecido. Se um valor for
um valor inteiro.
fornecido à alguns nomes e não
à outros, o compilador atribui
o próximo valor inteiro aos que enum Mes
{ Jan = 1, Fev, Mar, Abr, Mai,
não tiverem valor. Tipos enum
Jun, Jul, Ago, Set, Out,
são tratados como inteiros e
Nov, Dez
qualquer operação de números };
inteiros com eles é válida. Estruturas em C 56
 21.7 Novos tipos: enum
Exemplo 13.1 – Enum Mes Exemplo 13.2 – Enum Mes
#include <stdio.h> #include <stdio.h>
enum meses {Jan = 1, Fev, Mar, enum meses {Jan = 1, Fev, Mar,
Abr, Mai, Jun, Jul, Ago, Set, Out, Abr, Mai, Jun, Jul, Ago, Set, Out,
Nov, Dez}; Nov, Dez};
main() main()
{ int dia; { int dia;
meses mes; meses mes;
mes = Set; mes = meses(9); // int -> meses !
if (mes == Jan || mes == Mar || if (mes == Jan || mes == Mar ||
mes == Mai || mes == Jul || mes == Mai || mes == Jul ||
mes == Ago || mes == Out || mes == Ago || mes == Out ||
mes == Dez) mes == Dez)
dia = 31; dia = 31;
else else
if (mes == Fev) if (mes == Fev)
dia = 28; dia = 28;
else else
dia = 30; dia = 30;
printf(“Numero dias: %d \n”,dia); } printf(“Numero
Estruturas em C dias: %d \n”,dia); } 57
 21.8 Novos tipos: resumo

(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 úteis para 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 ‘.’.

(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.
Estruturas em C 58
21.8 Novos tipos: fim da aula 21

Fim de
Novos Tipos
Structs, Typedef e
Enum

Estruturas em C 59