Exercício da aula anterior

Altere o programa anterior, de modo que armazene informações referentes a

NRALUNOS alunos, e depois as imprima. Para isto, aproveite a função
imprime_dados_aluno da aula anterior, e utilize as definições abaixo:
/*Programa que lê dados de alunos (nome e notas), calcula e informa média
e conceito: */
#include <stdio.h>
#include <string.h>
#define NRALUNOS 3 // número de alunos da turma
#define NRNOTAS 3 // número de provas

struct struct_aluno
{
char nome[15 + 1];
float nota[NRNOTAS]; // vetor é um tipo de variável (indexada)
float media; // exclui a média do vetor de notas
char conceito;
};
char conceito( float media ); //calcula o conceito de um aluno
float nota_valida(); // le e valida uma nota
struct struct_aluno le_dados_aluno (); // prototipo da funcao de leitura
// prototipo da funcao de impressao
void imprime_dados_aluno (struct struct_aluno) ;
Slide 1 Inf 01202 - Prof. Marcelo Walter – Aula 23
int main()
{
// vetor com elementos do tipo struct_aluno
struct struct_aluno aluno[NRALUNOS];
int ind_al;

// leitura dos alunos

for (ind_al=0; ind_al < NRALUNOS; ind_al++)
aluno[ind_al] = le_dados_aluno();

// impressao dos alunos:

for (ind_al=0; ind_al < NRALUNOS; ind_al++)
imprime_dados_aluno (aluno[ind_al]);

return 0;
}

Slide 2 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Subrotina de conceito

//função tipada que retorna o conceito do aluno

char conceito( float media )
{
char c;

if (media >= 9.0)

c = 'A'; // conceito A
else // conceito A já foi excluído!
if (media >= 7.5)
c = 'B'; // conceito B
else // sobraram C e D
if (media >= 6.0)
c = 'C'; // conceito C
else // sobrou conceito D (assuma que o aluno possui frequencia)
c = 'D';
return c;
} //fim da subrotina

Slide 3 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Subrotina de leitura nota válida
(melhoramentos aula anterior)

// funcao que que le e valida uma nota

float nota_valida()
{
float n;

scanf ( "%f", &n );

while (n < 0 || n > 10)
{ // só entra no laço se a nota for inválida
printf("*** Nota inválida! ***");
printf ( ”Nova nota: );
scanf ( "%f", &n);
}
return n;
}

Slide 4 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Subrotina de leitura (aula anterior)
// funcao que que le os dados de um aluno, retornando um struct (aula anterior)
struct struct_aluno le_dados_aluno ()
{
struct struct_aluno aluno; // variável do tipo struct_aluno
int ind_nota;
// leitura dos campos da variável de tipo structure aluno:
printf ( "\nNome: ");
fflush(stdin);
gets(aluno.nome);
aluno.media = 0; //zera variável média, para poder acumular notas lidas
for (ind_nota = 0; ind_nota < NRNOTAS ; ind_nota++) // para cada nota
{
printf ( "Nota %d: ", ind_nota + 1);
aluno.nota[ind_nota] = nota_valida();
//soma a nota lida e consistida em média (as 3 notas):
aluno.media += aluno.nota[ind_nota];
} // fim do laço de leitura de notas

// calcula media aritmetica:

aluno.media = aluno.media / NRNOTAS;
aluno.conceito = conceito(aluno.media);
return aluno;
} //fim da subrotina
Slide 5 Inf 01202 - Prof. Marcelo Walter – Aula 23
 Subrotina de impressao (aula anterior)

void imprime_dados_aluno (struct struct_aluno aluno)

{ // funcao que imprime dados sobre um aluno, armazenados em uma estrutura
int ind_nota; // contador para percorrer notas
// bloco abaixo copiado do exercicio anterior
printf("\n%-15s prova1 prova2 prova3 media conc", "Nome do aluno");
printf ( "\n%-15s ", aluno.nome);
for (ind_nota = 0; ind_nota < NRNOTAS ; ind_nota++)
printf ("%6.2f ", aluno.nota[ ind_nota ] ) ;
printf ("%6.2f ", aluno.media);
printf ( " %c\n\n ", aluno.conceito);
}

Slide 6 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Exemplo de execução

Slide 7 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Comando typedef
A linguagem C provê um mecanismo para criarmos novos
nomes para tipos de dados com o comando typedef
Facilita a legibilidade de programas, por exemplo, no
exercício anterior usaríamos a seguinte definição:

typedef struct struct_aluno

{
char nome[15 + 1];
float nota[NRNOTAS]; // vetor é um tipo de variável (indexada)
float media; // exclui a média do vetor de notas
char conceito; As maiúsculas não são necessárias, mas
} TIPO_ALUNO; ajudam a lembrar que este é um tipo “criado”
Neste exemplo a declaração: pelo programador e não nativo do C
struct struct_aluno aluno[NRALUNOS];

Seria substituída por:

TIPO_ALUNO aluno[NRALUNOS];
Slide 8 Inf 01202 - Prof. Marcelo Walter – Aula 23
 Typedef – Exemplos

*/ Vetor de Estruturas */
typedef struct { struct s_pessoa mulher[3];
int dia; ou
char mês [3+1] ; TIPO_PESSOA mulher [3];
int ano;
} TIPO_DATA;

typedef struct s_pessoa {

char nome [60] ; /* Inicializando */
float salario; TIPO_PESSOA mulher [3] = {
TIPO_DATA nasc;
} TIPO_PESSOA; {“Ana”, 5400.00, {2, “Jan”, 1980} },
{“Joana”, 400.00, {28, “Dez”, 1989} },
{“Laura”, 2100.00, {2, “Jul”,1979} },
};

Slide 9 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Passagem de parâmetros (por valor)
com typedef
void mostrar (TIPO_PESSOA x)
{
printf ("Nome : %s\n", x.nome);
printf ("Idade : %d\n\n", x.idade);
printf ("Data Nasc : %d/%s/%d\n", x.nasc.dia, x.nasc.mes, x.nasc.ano);
};

int main ()
{
TIPO_PESSOA p = {"Joao",2300.00, {23, “Set", 1964}};
mostrar (p);

return 0;
}

Slide 10 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Passagem de estruturas
por referência
(TIPO_PESSOA
(TIPO_PESSOA *ptr)
*ptr) (TIPO_PESSOA *ptr)
Para
Paraleitura
leitura Para leitura
gets (*ptr.nome) gets (ptr->nome);
gets ((*ptr).nome);

Equivalentes!

Operador Ponto tem maior precedência do que o

Ponteiro
Compilador vai interpretar como *(ptr.nome) , mas ptr
não é do tipo estrutura, é tipo ponteiro para estrutura.
ERRO!!
Slide 11 Inf 01202 - Prof. Marcelo Walter – Aula 23
 Operador seta: ->

•  Utilizado em funções com parâmetro do tipo estrutura, onde

seja necessário o uso de ponteiros (parâmetro passado por
referência).
•  Indica o acesso a um campo de uma estrutura por meio de um
ponteiro para esta estrutura.
•  Escrever aluno-> media equivale a escrever (*aluno).media.
•  O parênteses é necessário porque o ● (ponto ) tem prioridade
maior que o *.
Atenção: a notação com o operador seta é a de uso mais frequente.

Slide 12 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Exercício: refazer o exercício anterior, usando uma
função void para fazer a leitura de um aluno passando
a variável tipo estrutura por referência, inicialmente
sem a notação seta
/* Leitura e escrita de arranjo de estrutura, usando funções, com passagem por elemento:
lê e imprime um aluno por vez: */
# include <stdio.h>

#define NRALUNOS 5
#define NRNOTAS 3
struct struct_aluno
{
char nome[15+1];
float nota[NRNOTAS];
float media;
char conceito;
};
void imprime_dados_aluno (struct struct_aluno aluno) {... // mesma rotina de impressao
void le_aluno(struct struct_aluno *aluno);

Slide 13 Inf 01202 - Prof. Marcelo Walter – Aula 23

// main para a chamada das rotinas
int main( )
{
int ind_al;
struct struct_aluno al[NRALUNOS]; // cada elemento passado como parâmetro

for (ind_al = 0; ind_al < NRALUNOS; ind_al++)

le_aluno(&al[ind_al]); // manda endereço como argumento

for (ind_al = 0; ind_al < NRALUNOS; ind_al++)

imprime_dados_aluno(al[ind_al]); // manda conteúdo como argumento

printf(“\n”);

return 0;
}

Slide 14 Inf 01202 - Prof. Marcelo Walter – Aula 23

Função de leitura do exercício anterior sem o operador seta

// funcao que faz a leitura de informacoes de um único aluno

// Recebe ponteiro para elemento tipo struct
void le_aluno(struct struct_aluno *aluno)
{
int ind_al;
printf("\nNome: ");
gets((*aluno).nome); //campo nome do conteudo apontado pela variavel aluno
(*aluno).media = 0;
for (ind_al = 0; ind_al < NRNOTAS; n++)
{
printf("Nota %d: ", ind_al + 1);
(*aluno).nota[ind_al] = nota_valida();
(*aluno).media += (*aluno).nota[ind_al];
}

(*aluno).media = (*aluno).media / NRNOTAS;

(*aluno).conceito = conceito((*aluno).media);

Slide 15 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Função de leitura do exercício anterior usando o operador
seta

void lealuno (struct struct_aluno *aluno)

{
int ind_al;

printf("\nNome: ");
gets(aluno->nome); //aponta para posição: conteúdo
aluno->media = 0;
for (ind_al = 0; ind_al < NRNOTAS; n++)
{
printf("\nNota %d: ", ind_al + 1);
aluno->nota[ind_al] = nota_valida();
aluno->media = aluno->media + aluno->nota[ind_al];
}
aluno->media = aluno->media / NRNOTAS;
aluno->conceito = conceito(aluno->media);

Slide 16 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Exercício:

•  Escrever uma rotina que faça a leitura de um conjunto

de alunos (e não individualmente, como nos exemplos
anteriores).

• Da mesma maneira, escreva uma rotina de impressão que

permita a impressão de diversos alunos.

Obs: O número máximo de alunos é dado por NRALUNOS,

mas a turma pode ter um número de alunos menor do que
esse.

Slide 17 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Função com parâmetro: vetor de estruturas
/* Leitura e escrita de arranjo de estrutura, usando funções, com passagem por elemento:
lê e imprime vetor de estrutura */
# include <stdio.h>
#define NRALUNOS 5
#define NRNOTAS 3
struct struct_aluno
{
char nome[15+1]; // limite de 15 caracteres digitados
float nota[NRNOTAS];
float media;
char conceito;
};
void le_alunos(struct struct_aluno[ ], int);// recebe vetor: ptr implícito para 1º elem.
void imprime_alunos(struct struct_aluno [ ] ,int); // recebe vetor
int main( )
{
int i, num_alunos;
struct struct_aluno al[NRALUNOS]; // array de alunos
printf(“Entre o numero de alunos da turma:”);
scanf(“%d”, &num_alunos);
le_alunos(al, num_alunos); // envia vetor como argumento, e seu tamanho
printf("\n\nResultado:\n");
// cabeçalho
printf("\n%-15s prova1 prova2 prova3 media conc", "Nome do aluno");
imprime_alunos(al, num_alunos); // envia vetor como argumento
return 0;
} Slide 18 Inf 01202 - Prof. Marcelo Walter – Aula 23
/* recebe ponteiro implícito para 1 elemento do vetor de estruturas, a ser preenchido, e
nro de alunos e de notas – poderia referir constantes, mas assim é mais estruturado e
generico:*/
void le_alunos (struct struct_aluno aluno[ ], int numalunos)
{
int ind_al,ind_nota;
for (ind_al = 0; ind_al < numalunos; ind_al++) // para cada aluno:
{ // leitura dos campos da variável aluno[ind_al]:
printf ( "\nNome: ");
gets(aluno[ind_al].nome);
aluno[ind_al].media = 0; //zera variável média, para poder acumular notas lidas
for (ind_nota = 0; ind_nota < NRNOTAS; ind_nota++) // para cada nota
{
printf ( " Nota %d: ", ind_nota + 1);
aluno[ind_al].nota[ ind_nota ] = nota_valida();
//soma a nota lida e consistida em média (as 3 notas):
aluno[ind_al].media += aluno[ind_al].nota[ind_nota];
} // fim do laço de leitura de notas
// calcula média aritmetica:
aluno[ind_al].media = aluno[ind_al]. media / NRNOTAS;
aluno[ind_al].conceito = conceito(aluno[ind_al].media);
} // fim do processamento de 1 aluno - aluno[ind_al]
} // fim da função de leitura de dados

Slide 19 Inf 01202 - Prof. Marcelo Walter – Aula 23

/* recebe conteúdo do vetor de estruturas, que é 1 ponteiro implícito:
cuidado para não alterar conteúdos!!! */
void imprime_alunos (struct struct_aluno aluno[ ], int numalunos)
{
int ind_al,ind_nota;
for (ind_al = 0; ind_al < numalunos; ind_al++) // para cada aluno:
{
printf ( "\n%-16s ", aluno[ind_al].nome); // imprime alinhado à esquerda
// laço de impressão das notas:
for (ind_nota = 0; ind_nota < NRNOTAS ; ind_nota++) // para cada nota
printf ("%6.2f ", aluno[ind_al].nota[ ind_nota ] ) ;
printf ("%6.2f ", aluno[ind_al]. media);
printf ( " %c ", aluno[ind_al]. conceito);
} // fim do processamento de 1 aluno - aluno[ind_al]
printf(“\n”);
} // fim da função

Slide 20 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Execução do programa:

Slide 21 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Exercício

Defina em C um novo tipo denominado Passagem,

conforme layout do bilhete de passagem de ônibus
mostrado abaixo.

Viação VIAJE BEM

Cod. Empresa: ______ Nome do Passageiro: _________________

Origem: ___________ Destino: _____________
Data: ___/___/___ Horário: ____:____
Assento:___________ Valor do bilhete: ______________ .

Slide 22 Inf 01202 - Prof. Marcelo Walter – Aula 23

/* Definir tipo bilhete de passagem de ônibus. */
#include <stdio.h>

// struct como parâmetro: precisa ser global!!!

struct est_data
{
int dia, mes, ano; Viação VIAJE BEM
};
struct est_hora Cod. Empresa: ______ Nome do Passageiro: ____________
{ Origem: ___________ Destino: _____________
int hora, min;
Data: ___/___/___ Horário: ____:____
};
struct est_bilhete Assento:___________ Valor do bilhete: ______________ .
{
int cod;
char nome_p[21];
char origem[21], destino[21];
struct est_data data_b;
struct est_hora hora_b; Sem Typedef
int assento;
float valor;
};
int main ( )
{
} // fim de main

Slide 23 Inf 01202 - Prof. Marcelo Walter – Aula 23

/* Definir tipo bilhete de passagem de ônibus. */
#include <stdio.h>

// struct como parâmetro: precisa ser global!!!

typedef struct est_data
{ Viação VIAJE BEM
int dia, mes, ano;
}TIPO_DATA; Cod. Empresa: ______ Nome do Passageiro: ______
typedef struct est_hora Origem: ___________ Destino: _____________
{
int hora, min; Data: ___/___/___ Horário: ____:____
}TIPO_HORA; Assento:___________ Valor do bilhete: _________ .
typedef struct est_bilhete
{
int cod;
char nome_p[21];
char origem[21], destino[21];
TIPO_DATA data_b;
TIPO_HORA hora_b; Com Typedef
int assento;
float valor;
}TIPO_BILHETE;
int main ( )
{
} // fim de main

Slide 24 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Exercício

A partir da estrutura definida no item 1, implemente as

funções ler_bilhete e mostrar_bilhete, que
permitem, respectivamente, ler e mostrar todos os
dados relativos a um determinado bilhete.

A função ler_bilhete pode ser implementada através de

uma função sem parâmetros (que retorna um
struct), ou através de uma função void (ou seja, sem
retorno) que recebe o struct como parâmetro. No
segundo caso, a passagem deve ser feita por
referência!

Slide 25 Inf 01202 - Prof. Marcelo Walter – Aula 23

// função que efetua a leitura dos dados de uma passagem:
void ler_bilhete (struct est_bilhete *bilhete)
struct est_data
{ {
int dia, mes, ano;
printf ("Cod. da Empresa: "); };
scanf ("%d", &bilhete->cod); struct est_hora
{
int hora, min;
};
printf ("Nome do Passageiro: "); struct est_bilhete
{
gets(bilhete->nome_p); int cod;
char nome_p[20];
char origem[20], destino[20];
printf ("Origem: "); struct est_data data_b;
struct est_hora hora_b;
gets(bilhete->origem); int assento;
float valor;
};
printf ("Destino: ");
gets(bilhete->destino);

printf ("Data do Bilhete (dd mm aa): ");

scanf ("%d%d%d", &bilhete->data_b.dia, &bilhete->data_b.mes,
&bilhete->data_b.ano);
printf ("Horario do Bilhete (hh mm): ");
scanf ("%d%d", &(*bilhete).hora_b.hora, &bilhete->hora_b.min);
printf ("Assento: ");
scanf ("%d", &bilhete->assento);
printf ("Valor do Bilhete: ");
scanf ("%f", &(*bilhete).valor); // notação por extenso
} // fim
Slide 26 ler_bilhete Inf 01202 - Prof. Marcelo Walter – Aula 23
// função que efetua a impressão dos dados de uma passagem
// como os dados do bilhete não devem ser alterados, a passagem por valor eh
mais adequada!!!
void mostra_bilhete ( struct est_bilhete bilhete ) // recebe o conteúdo
{
printf ("\nCod. da Empresa: %d", bilhete.cod);
printf ("\nNome do Passageiro: %s",bilhete.nome_p);
printf ("\nOrigem: %s ",bilhete.origem);
printf ("\nDestino: %s ",bilhete.destino);
printf ("\nData do Bilhete: %d/%d/%d", bilhete.data_b.dia,
bilhete.data_b.mes, bilhete.data_b.ano);
printf ("\nHorario do Bilhete: %d:%d hs.", bilhete.hora_b.hora,
bilhete.hora_b.min);
printf ("\nAssento: %d", bilhete.assento);
printf ("\nValor do Bilhete: R$ %.2f \n\n", bilhete.valor);
}

Slide 27 Inf 01202 - Prof. Marcelo Walter – Aula 23

 /* Name: viajebem.cpp
Description: definir tipo
bilhete de passagem de onibus. */
#include <stdio.h>
// struct como parâmetro: precisa ser global!!!
struct est_data
{
int dia, mes, ano;
};
struct est_hora
// programa principal: {
int main( ) int hora, min;
};
{ struct est_bilhete
struct est_bilhete passagem; {
int cod;
char nome_p[20];
ler_bilhete(&passagem); char origem[20], destino[20];
mostra_bilhete(passagem); struct est_data data_b;
struct est_hora hora_b;
int assento;
return 0; float valor;
} };
void ler_bilhete (struct est_bilhete *bilhete )
.....
void mostra_bilhete ( struct est_bilhete bilhete )
......
int main ( )
{
} // fim de main

Slide 28 Inf 01202 - Prof. Marcelo Walter – Aula 23

 Exercício
Escreva um programa para processar as informações sobre um campeonato de futebol.
Os 5 times são: Alemanha, Brasil, França, Itália e Argentina. Cada time joga com o
outro 2 vezes, uma em casa e outra fora. Leia do usuário o resultado das 20
partidas e ao final apresenta os times e seus pontos. Vitória conta 2 pontos, empate
um ponto e derrota nenhum ponto. Utilize as seguintes estruturas no seu programa:
#define NTIMES 5
struct est_time{
char nome[15];
int pontos;
};
struct est_resultado{
int local, visitante;
};

int main(){
struct est_time times[NTIMES] = {“Alemanha”, 0, “Franca”, 0, “Brasil”, 0,”Italia”, 0,
“Argentina”, 0 };
struct est_resultado jogos[NTIMES][NTIMES];
…
}
Slide 29 Inf 01202 - Prof. Marcelo Walter – Aula 23