Linguagem_C-_Volume_3

Prévia do material em texto

Recife, 2009
Programação 2
Sônia Virginia Alves França
Universidade Federal Rural de Pernambuco
Reitor: Prof. Valmar Corrêa de Andrade
Vice-Reitor: Prof. Reginaldo Barros
Pró-Reitor de Administração: Prof. Francisco Fernando Ramos Carvalho
Pró-Reitor de Extensão: Prof. Paulo Donizeti Siepierski
Pró-Reitor de Pesquisa e Pós-Graduação: Prof. Fernando José Freire
Pró-Reitor de Planejamento: Prof. Rinaldo Luiz Caraciolo Ferreira
Pró-Reitora de Ensino de Graduação: Profª. Maria José de Sena
Coordenação de Ensino a Distância: Profª Marizete Silva Santos
Produção Gráfica e Editorial
Capa e Editoração: Allyson Vila Nova, Rafael Lira, Italo Amorim e Marcella Almeida
Revisão Ortográfica: Marcelo Melo
Ilustrações: Diego Almeida e Glaydson da Silva
Coordenação de Produção: Marizete Silva Santos
Sumário
Apresentação ........................................................................................5
Conhecendo o Volume 3 ......................................................................6
Capítulo 1 – Armazenamento de Dados em Vetores .........................8
1.1 O que são vetores? ......................................................................8
1.2 Declaração de Vetores .................................................................9
1.3 Referência a elementos de vetor ................................................11
1.4 Inicialização de vetores ..............................................................13
1.5 Leitura de elementos para o vetor ..............................................15
1.6 Impressão dos elementos de um vetor .......................................22
1.7 Tamanho de um vetor e segmentação de memória ...................27
1.8 Passando vetores como parâmetros de funções .......................28
Capítulo 2 – Armazenamento de Dados em Registros ....................35
2.1 O que são registros? ..................................................................35
2.2 Declaração de um Registro ........................................................36
2.3 Acessando os campos do registro ..............................................39
2.4 Vetor de registro .........................................................................40
2.5 Acessando os campos do vetor de registro ................................42
2.6 Usando vetor de registro ............................................................43
Capítulo 3 – Armazenamento de Dados em Arquivos .....................61
3.1 O que são arquivos? ...................................................................61
3.2 Comandos para manipular arquivos binários .............................64
3.3 Implementação das operações básicas em um arquivo .............76
Considerações Finais .......................................................................102
Conhecendo a Autora .......................................................................104
Apresentação
Caro(a) aluno(a),
Seja bem-vindo (a) ao terceiro módulo da disciplina Programação II. Neste módulo, 
vamos dar mais um passo no nosso aprendizado sobre a linguagem de programação 
C.
Nos dois volumes anteriores, aprendemos os comandos básicos do C, a utilizar 
as estruturas de controle (seleção e repetição) e a modularizar nossos programas em 
módulos ou funções. Com estes assuntos, adquirimos a capacidade de desenvolver 
programas mais elaborados. 
Neste livro, nós vamos aprender novas formas de armazenar nossos dados. Com os 
vetores e registros, poderemos manusear um volume maior de dados, de forma facilitada. 
Outro assunto muito importante que será abordado neste volume é o armazenamento de 
dados em arquivos. Atualmente, ao terminar a execução do programa, todos os dados 
que foram digitados são perdidos. Com o armazenamento de dados em arquivos, isto 
não acontece. Assim, iremos desenvolver programas com operações como: cadastro de 
elementos, remoção, alteração, consultas, listagens, etc. 
Continuem resolvendo as questões propostas no final de cada capítulo, além de 
executar buscas na Internet, visando um maior aprofundamento de cada assunto. Ao final 
deste módulo, teremos a capacidade de resolver questões com operações presentes 
nos principais sistemas de controle do mercado, como por exemplo: sistema de controle 
de estoque, sistema de controle de cliente, etc. Vamos começar mais uma nova etapa 
no conhecimento da linguagem de programação C?
Bons estudos!
Professora Sônia Virginia Alves França
6
Programação 2
Conhecendo o Volume 3
Neste terceiro volume, vocês irão encontrar o módulo 03 da 
disciplina: Programação II. Este volume está estruturado em três 
capítulos, que serão estudados ao longo de 15h/aula. Para facilitar 
seus estudos, veja a organização deste volume.
Capítulo 1: Armazenamento de Dados em Vetores
Carga Horária do Capítulo 1: 5 h/aula
Objetivos do Capítulo 1: Apresentar o uso de vetores para o 
armazenamento de dados. 
Conteúdo Programático do Capítulo 1
• Definição de vetores;
• Declaração, leitura e escrita de dados em vetores; 
• Passagem de vetores como parâmetros de funções; 
Capítulo 2: Armazenamento de Dados em Registros
Carga Horária do Capítulo 2: 5 h/aula
Objetivos do Capítulo 2: Apresentar o uso de registros para o 
armazenamento de dados. 
Conteúdo Programático do Capítulo 2
• Definição de registros; 
• Declaração, leitura e escrita de dados em registros;
• Vetor de registro;
Capítulo 3: Armazenamento de Dados em Arquivos 
Carga Horária do Capítulo 3: 5 h/aula
Objetivos do Capítulo 3: Apresentar os principais comandos para 
o armazenamento de dados em arquivos. Com os arquivos, os dados 
manipulados no programa podem ser armazenados definitivamente. 
Conteúdo Programático do Capítulo 3
• Definição de arquivos;
7
Programação 2
• Ponteiros;
• Comandos para manipulação de dados em arquivos; 
Ao final de cada capítulo vocês encontrarão:
• A seção “Atividades e Orientações de Estudo”: que contém 
exercícios para a fixação do assunto estudado, além de 
indicação de fóruns de discussão. 
• A seção “Conheça Mais”: que contém dicas de sites e livros 
que devem ser lidos para ampliar os seus conhecimentos.
• A seção “Vamos Revisar?”: que apresenta um resumo dos 
principais tópicos abordados no capítulo.
8
Programação 2
Capítulo 1 – Armazenamento de 
Dados em Vetores
Vamos conversar sobre o assunto?
Neste terceiro volume, vamos aprender novas formas de armazenar 
nossos dados. Começaremos aprendendo como armazenar os dados 
em vetores. Com os vetores, nós podemos armazenar um grande 
conjunto de dados, facilitando o acesso e manuseio dos mesmos. Os 
dados são a “alma” de um programa. Assim, a manipulação dos dados 
de forma mais adequada e facilitada, trará ganhos para o programa e 
para o programador. Vamos continuar a nossa caminhada?
1.1 O que são vetores?
Imaginem que um professor nos encomendou um programa, que 
tenha que armazenar as médias dos 50 alunos de uma turma. Como 
faríamos para armazenar essas médias? Até o ponto que estudamos 
a linguagem C, teríamos que declarar 50 variáveis do tipo float, uma 
por uma. Que trabalheira, não é mesmo? E se o professor tivesse 300 
alunos? Passaríamos um tempão só declarando variáveis e, além 
disso, teríamos muito trabalho para fazer o controle das mesmas. 
Mas não se preocupem, com os vetores, o professor pode ter mais de 
1000 alunos, que a declaração e manuseio dos dados será bem fácil.
Os vetores são usados quando precisamos armazenar um conjunto 
de dados do mesmo tipo. Por exemplo: armazenar as 50 médias dos 
alunos de uma turma (todas as médias são do tipo float). Os vetores 
são bem convenientes já que iremos colocar todas as informações 
dentro de um mesmo conjunto e faremos referência de cada dado, 
individualmente, através de um índice1. De maneira mais formal, os 
vetoressão chamados de estruturas de dados homogêneas (já 
que armazenam dados do mesmo tipo). Os vetores são formados 
por dados de mesmo tipo (homogêneo) e possuem número fixo de 
elementos (estático). 
Para entendermos melhor os vetores, vamos visualizar a sua 
representação gráfica, na figura 1.1. 
Saiba Mais
1 Em inglês, um 
vetor é chamado 
de array (que 
significa cadeia). 
Assim, quando 
temos um array, 
temos uma cadeia 
de inteiros, reais 
ou caracteres.
9
Programação 2
media 3.0 7.5 5.8 9.5 8.2
0 1 2 3 4
Figura 1.1: Representação gráfica de um vetor
Na figura 1.1 temos um vetor chamado media, formado por 5 
elementos. Vocês lembram quando tínhamos uma variável simples? 
Representávamos com uma única caixa. Agora, com os vetores, 
teremos um conjunto de dados, por isso ele é formado por várias 
caixas. Em cada uma delas poderemos armazenar um valor. Todas as 
caixas têm um único nome. Neste exemplo, o vetor se chama media. 
Notem que, abaixo de cada caixa temos um número. Estes números 
são chamados de índices. É através do índice, que iremos informar 
qual das caixas do vetor é que estamos querendo acessar. Já que 
todas as caixas têm um único nome (media), a forma de diferenciar 
uma da outra é o índice. Entenderam? 
Na linguagem C, o índice de um vetor, começa a partir de 0. Assim, 
em um vetor com 5 elementos, os índices variam de 0 a 4 (como no 
exemplo da figura 1.1). Por isso, o primeiro elemento do vetor media 
está na posição de índice 0. Podemos dizer que a média do segundo 
aluno está na posição de índice 1 do vetor media, e é igual a 7.5. 
Esta não é a única maneira de estruturar um conjunto de dados. 
Também podemos organizar dados sob forma de tabelas. Neste caso, 
cada dado é referenciado por dois índices e dizemos que se trata de 
um conjunto bidimensional (ou matriz). 
Vamos aprender, nas próximas seções, como manusear os vetores 
nos nossos programas. 
1.2 Declaração de Vetores
Como já foi mencionado, um vetor é um conjunto de variáveis 
do mesmo tipo, que possuem um nome identificador e um índice de 
referência. A sintaxe para a declaração de um vetor é a seguinte:
Sintaxe
tipo identificador[tamanho];
10
Programação 2
onde:
•	 tipo: é o tipo de dados que o vetor armazena: int, float, char, 
etc.
•	 identificador: é o nome do vetor. As regras para nomear um 
vetor são as mesmas usadas para nomear variáveis, constantes 
e funções.
•	 tamanho: é o tamanho do vetor. Isto é, o número de elementos 
que o vetor pode armazenar. 
A seguir, são apresentados exemplos de declarações de vetores. 
Os vetores são declarados na seção de declaração de variáveis do 
programa. Se estivermos desenvolvendo um programa modularizado, 
podemos declarar o vetor como uma variável local de um módulo.
Exemplo 1.1: declaração de vetores
1
2
3
int idade[100];
float nota[25]; 
char nome[80]; 
No primeiro exemplo, temos a declaração de um vetor chamado 
idade, que pode armazenar até 100 números inteiros. No segundo 
exemplo, temos um vetor chamado nota, com capacidade para 
armazenar até 25 números reais. E, finalmente, no terceiro exemplo, 
temos um vetor chamado nome, com capacidade de armazenar até 
80 caracteres2.
Ao declararmos o vetor, já temos que ter uma previsão de quantos 
elementos serão armazenados no mesmo. Com isso, o processador 
saberá quanto de memória precisa ser reservada para armazenar os 
dados do vetor, ao executar o programa. A quantidade de memória 
(em bytes) usada para armazenar um vetor pode ser calculada como: 
quantidade de memória = tamanho do tipo * tamanho do vetor
O tamanho do tipo indica quantos bytes um determinado tipo de 
variável utiliza para ser armazenado (vimos este assunto no Volume 
1 – Capítulo 3). Ao compilar o programa, a quantidade de memória 
necessária para armazenar o vetor é alocada. Os vetores têm 
tamanhos fixos e não podemos armazenar mais elementos do que a 
quantidade que foi solicitada no momento da declaração do vetor. Por 
Atenção
2 Nós já havíamos 
utilizado vetor 
de caracteres, já 
que trabalhamos 
com variáveis 
que armazenam 
uma cadeia de 
caracteres. No 
próximo volume, 
teremos um 
capítulo dedicado 
a este assunto.
11
Programação 2
isso, são chamados de estáticos. A quantidade de elementos não 
pode aumentar em tempo de execução do programa.
Também é possível declarar um vetor com tamanho parametrizado: 
usando uma constante. Declaramos uma constante com a diretiva 
#define, no início do programa, e depois declaramos o vetor com 
esta constante como tamanho do vetor. Deste modo, podemos alterar 
o número de elementos do vetor antes de qualquer compilação do 
programa. Esta é uma maneira simples de administrar o espaço de 
memória usado pelo programa, e também testar os limites de um 
vetor.
Exemplo 1.2: 
Declaração de vetor usando uma constante no local do tamanho do vetor.
1
2
#define TAMANHO 30
int valor[TAMANHO];
No exemplo 1.2, o vetor valor terá capacidade de armazenar 30 
elementos (este é o valor da constante TAMANHO).
1.3 Referência a elementos de vetor
Agora que já sabemos como criar os vetores, a partir da sua 
declaração, vamos aprender como acessar um elemento do vetor. 
Segue abaixo a sintaxe.
Sintaxe
identificador[indice]
onde:
•	 identificador: é o nome do vetor que queremos acessar. 
•	 índice: é o índice do elemento do vetor que queremos acessar. 
Cada elemento do vetor é referenciado pelo nome do vetor e, 
entre colchetes, tem-se o índice, que é um número inteiro. O índice 
irá indicar qual elemento do vetor estamos querendo referenciar. A 
seguir, são apresentadas algumas atribuições a elementos de um 
vetor chamado valor, que é composto por 10 elementos do tipo float. 
12
Programação 2
Exemplo 1.3: Acessando os elementos de um vetor
1
2
3
4
5
6
float valor[10]; //declaração do vetor
int x;
x = 3;
valor[1] = 6.6;
valor[x] = 9.9
valor[x+2] = 10.0;
Entre os colchetes, que indicam o índice do vetor que será 
acessado, podemos ter: um valor (exemplo da linha 4), uma variável 
(exemplo da linha 5) ou uma expressão (exemplo da linha 6). 
Devemos ter cuidado quando usamos variáveis e expressões, pois 
estas devem ser inteiras e devem ter um valor dentro da capacidade 
de armazenamento do vetor. Ou seja, se o vetor foi declarado com 
tamanho 10, não podemos tentar acessar o índice 18 do vetor.
Na linha 4, foi atribuído 6.6 ao elemento de índice 1 do vetor valor. 
Na linha 5, como a variável x tem armazenado 3, então o valor[3], 
receberá 9.9. Quando temos uma expressão, que é o caso da linha 
6, a expressão é resolvida primeiro. Assim, como x = 3, e entre os 
colchetes temos x+2, o resultado será 5. Dessa forma, valor[5] 
receberá 10.0. A seguir, temos a situação final do vetor valor, após as 
atribuições dos valores do exemplo.
Valor 6.6 9.9 10.0
0 1 2 3 4 5 6 7 8 9
Figura 1.2: Situação do vetor valor após atribuições 
Viram como é fácil trabalhar com vetor? Em uma única linha, nós 
criamos um conjunto de variáveis, do tamanho da nossa necessidade. 
Posteriormente, acessamos cada uma destas variáveis utilizando o 
nome do vetor e o índice da variável.
Na próxima seção, vamos ver como fazemos para inicializar os 
elementos de um vetor, no momento da declaração.
13
Programação 2
1.4 Inicialização de vetores
No momento da declaração de um vetor, também podemos 
inicializar os seus elementos, fazendo a atribuição de valores aos 
mesmos. A sintaxe para a inicialização dos elementos de um vetor é 
a seguinte:
Sintaxe
tipo identificador[tamanho] = {lista de valores};
Onde:
• tipo: é o tipo dos elementos do vetor: int, float, char, etc.
• identificador: é o nome do vetor. 
• tamanho: é o tamanho do vetor. Isto é, o número de elementos 
que o vetor pode armazenar.• lista de valores: é uma lista, separada por vírgulas, dos valores 
de cada elemento do vetor. A lista de valores é colocada entre 
chaves.
Vamos ver a seguir, exemplos de inicialização de vetores. 
Exemplo 1.4: Inicialização de vetores
1
2
3
4
int idade[7] = {12, 30, 14, 7, 13, 15, 6};
char vogal[5] = {‘a’, ‘e’, ‘i’, ‘o’, ‘u’};
float nota[5] = {8.4, 6.9, 4.5};
float media[5] = {0};
No exemplo da linha 1, temos o vetor chamado idade e para cada 
posição do vetor, foi atribuído um valor. Após esta atribuição, o vetor 
idade ficará assim:
idade 12 30 57 25 18 15 13
0 1 2 3 4 5 6
Figura 1.3: Situação do vetor idade após inicialização 
No segundo exemplo, temos um vetor de caracteres, chamado 
vogal. Quando inicializamos um vetor deste tipo de variável, os valores 
14
Programação 2
devem ser colocados entre apóstrofo. Ao final desta atribuição, o vetor 
vogal ficará como mostra a figura 1.4.
vogal a e i o u
0 1 2 3 4
Figura 1.4: Situação do vetor idade após inicialização 
Na linha 3, temos a inicialização do vetor nota, que é composto 
por cinco elementos. Notem que, entre as chaves, não temos cinco 
valores. Temos apenas três. Quando não quisermos inicializar todo o 
vetor, podemos colocar apenas os valores dos primeiros elementos, e 
aos demais, será atribuído zero (automaticamente). Vejam na figura 
1.5 como ficará o vetor nota, após a sua inicialização. 
nota 8.4 6.9 4.5 0.0 0.0
0 1 2 3 4
Figura 1.5: Situação do vetor idade após inicialização 
Seguindo o raciocínio do exemplo anterior, quando precisarmos 
inicializar todos os elementos do vetor com zero, fazemos como 
mostra o exemplo da linha 4. Colocamos apenas um zero entre as 
chaves, o primeiro elemento será inicializado com zero, e os demais 
também. Neste caso, o vetor media ficará como apresentado na figura 
1.6.
media 0.0 0.0 0.0 0.0 0.0
0 1 2 3 4
Figura 1.6: Situação do vetor media após inicialização 
Opcionalmente, podemos inicializar os elementos do vetor 
enumerando-os um a um. No exemplo 1.5, a seguir, observem que 
estas duas inicializações são possíveis:
15
Programação 2
Exemplo 1.5: Inicialização de vetores
1
2
3
4
5
6
int valor[3] = {7,4,20};
ou
int valor[3];
valor[0] = 7;
valor[1] = 4;
valor[2] = 20;
Na próxima seção, vamos aprender a armazenar, em um vetor, 
valores que são fornecidos via teclado. 
1.5 Leitura de elementos para o vetor
Agora suponham que os valores que vão ser armazenados no 
vetor sejam fornecidos pelo usuário, via teclado. O que devemos 
fazer? Devemos utilizar uma estrutura de repetição, para controlar o 
preenchimento dos dados no vetor, um por um. Assim, podem ocorrer 
duas situações: 
• Nós sabemos quantos elementos o usuário vai digitar;
• Nós não sabemos a quantidade de elementos que o usuário 
vai digitar.
Vamos ver como tratar cada uma das situações? Quando nós 
sabemos quantos elementos o usuário vai digitar, poderemos usar 
uma estrutura de repetição como o for, que irá repetir a leitura dos 
elementos, na quantidade definida. Vamos ver o Programa Completo 
1.1 a seguir: o usuário precisa armazenar 5 elementos em um vetor 
de inteiros, chamado valor. 
16
Programação 2
Programa Completo 1.1: 
Ler 5 números inteiros, armazenando-os em um vetor
1
2
3
4
5
 
6
7
8
9
10
11
main()
{ 
 int valor[5];
 int i;
 printf(“Cadastro dos elementos do vetor Valor 
\n\n”);
 for (i=0; i<5; i++)
 { printf(“\n\nElemento %d: “,i+1);
 scanf(“%d”,&valor[i]);
 }
 getche();
}
Comentários sobre o Programa Completo 1.1:
•	 Linha	3: declaração do vetor valor, que tem a capacidade de 
armazenar 5 números inteiros. 
•	 Linha	4: declaração da variável i, que irá controlar o for.
•	 Linha	5: printf para que o usuário saiba que será feito o cadastro 
dos elementos no vetor. 
•	 Linha	6: for que será repetido 5 vezes, fazendo a leitura dos 
elementos do vetor. Notem que a variável de controle do for, o i, 
é inicializado com 0. Isso acontece porque o primeiro índice do 
vetor é 0.
•	 Linha	 7: Abre chaves que inicia a sequência de comandos 
do for (já que teremos mais de um comando). Nesta linha, 
também temos o printf para que o usuário saiba qual elemento 
do vetor está sendo cadastrado no momento. Vejam que neste 
printf temos a expressão: i+1. O motivo de colocarmos esta 
expressão no printf é que, como o i começa com zero e vai até 
4, não ficaria muito interessante que saísse uma mensagem, na 
tela, informando que o usuário estaria cadastrando o elemento 
0. O correto é dizer que ele está cadastrando o elemento 1. Por 
17
Programação 2
isso, usamos a expressão i+1. 
•	 Linha	8: scanf que lê o valor, armazenando no vetor. Notem 
que estamos usando a variável i, no índice do vetor. Dessa 
forma, o i vai variando a cada vez que o for é repetido, e assim, 
os elementos são armazenados em índices diferentes do vetor. 
Com isso, nenhum elemento irá sobrepor o outro.
•	 Linha	 9: fecha chaves que indica o final da sequência de 
comandos do for. 
•	 Linha	10: comando getche que faz com que a tela de execução 
do programa fique aberta, e assim podemos ver o resultado do 
programa. 
•	 Linha	 11: fecha chaves, indicando o final do programa 
principal. 
A figura 1.7, apresenta a tela de execução do Programa Completo 
1.1.
Figura 1.7: Tela de execução do Programa Completo 1.1
Para facilitar o entendimento, vamos fazer um acompanhamento 
dos valores das variáveis do Programa Completo 1.1, ao longo da 
sua execução. Vamos considerar que o usuário está cadastrando os 
valores apresentados na figura 1.7. A figura 1.8 mostra os valores das 
variáveis do programa, conforme o programa vai sendo executado.
18
Programação 2
i i+1 valor
0 
 
 
1 
 
 
10
0 1 2 3 4
1 
 
 
2 
 
 
10 15
0 1 2 3 4
2 
 
 
3 
 
 
10 15 9
0 1 2 3 4
3 
 
 
4 
 
 
10 15 9 6
0 1 2 3 4
4 
 
 
5 
 
 
10 15 9 6 12
0 1 2 3 4
Figura 1.8: Acompanhamento das variáveis do Programa Completo 1.1
O que fazemos quando não sabemos quantos elementos serão 
armazenados no vetor? Neste caso, como não sabemos quantas 
vezes o for deve ser executado, poderemos fazer a leitura dos dados 
que serão colocados no vetor, usando um do/while, como mostra o 
Programa Completo 1.2, a seguir. Neste programa, iremos fazer 
a leitura de uma quantidade indeterminada de números inteiros, 
armazenando em um vetor.
19
Programação 2
Programa Completo 1.2: 
Ler um conjunto de números inteiros, armazenando-os em um vetor.
1
2
3
4
5
 
6
7
8
9
10
 
11
12
13
main()
{ int valor[5];
 int q, continuar;
 q=0;
 printf(“Cadastro dos elementos do vetor Valor 
\n\n”);
 do
 { printf(“\n\nElemento %d: “,q+1);
 scanf(“%d”,&valor[q]);
 q++;
 printf(“\n\nCadastrar outro elemento 
(1-sim/2-nao)? “);
 scanf(“%d”, &continuar);
 } while ((continuar==1) && (q<5));
}
Neste caso, a leitura será finalizada quando o vetor ficar cheio, 
com cinco elementos, ou quando o usuário decidir que não deseja 
mais continuar a leitura. Neste último caso, saberemos quantos 
elementos foram armazenados no vetor através da variável q. É esta 
variável que indica, também, em qual índice do vetor o elemento deve 
ser armazenado3.
Comentários sobre o Programa Completo 1.2:
•	 Linhas	2: declaração do vetor valor, que tem a capacidade de 
armazenar 5 números inteiros. 
•	 Linha	3: declaração das variáveis q (que controla a quantidade 
de elementos que já foram cadastrados no vetor) e continuar 
(que armazena a resposta do usuário informando se quer 
cadastrar mais elementos ou não). 
•	 Linha	4: inicialização da variável q com 0.
•	 Linha	5: printf para que o usuário saiba que seráfeito o cadastro 
Atenção
3 Quando não 
sabemos quantos 
elementos serão 
cadastrados, 
temos que 
estipular um valor 
para a quantidade 
de elementos 
que serão 
armazenados no 
vetor. Isso se dá 
porque temos que 
saber o tamanho 
do vetor no 
momento da sua 
declaração.
20
Programação 2
dos elementos no vetor. 
•	 Linha	6: do indicando o início da repetição.
•	 Linha	7: Abre chaves que inicia a sequência de comandos do 
do/while (já que teremos mais de um comando). Nesta linha 
também temos o printf para que o usuário saiba qual elemento 
do vetor está sendo cadastrado no momento. 
•	 Linha	8: scanf que lê o valor que será armazenado no vetor. 
Notem que estamos usando a variável q, no índice do vetor. 
•	 Linha	 9: incremento da variável q, indicando que mais um 
elemento foi cadastrado no vetor. Através do valor de q, 
saberemos se o vetor já está cheio ou não.
•	 Linha	10: prinft que pergunta ao usuário se deseja cadastrar 
outro elemento no vetor. O usuário pode parar o cadastro dos 
elemento do vetor, no momento que ele desejar. Nesse caso, o 
vetor pode ficar com posições sem valores armazenados.
•	 Linha	11: scanf para ler a resposta do usuário.
•	 Linha	 12: fecha chaves do do/while e while com a condição 
que faz com que a repetição fique sendo executada. Como 
a condição é formada por duas expressões relacionais, nós 
colocamos cada expressão relacional entre parênteses e depois 
colocamos toda a expressão entre parênteses. As expressões 
estão conectadas pelo operador && (e). Com isso, quando uma 
das expressões der falso, a repetição para. Vai parar porque 
o vetor está cheio (q=5) ou porque o usuário desejou parar, 
respondendo 2 a pergunta se deseja continuar.
•	 Linha	 13: fecha chaves, indicando o final do programa 
principal. 
A figura 1.9, apresenta a tela de execução do Programa Completo 
1.2. 
21
Programação 2
Figura 1.9: Tela de execução do Programa Completo 1.2
Vamos acompanhar o valor das variáveis do Programa Completo 
1.2? A Figura 1.9 mostra o cadastramento de 3 elementos no vetor. O 
usuário respondeu que não queria mais cadastrar após dar entrada 
ao terceiro elemento. A figura 1.10 mostra os valores das variáveis do 
programa, conforme o programa vai sendo executado.
q q+1 valor
0 
 
 
1 
 
 
12
0 1 2 3 4
1 
 
 
2 
 
 
12 15
0 1 2 3 4
2 
 
 
3 
 
 
12 15 18
0 1 2 3 4
Figura 1.10: Acompanhamento das variáveis do Programa Completo 1.2
Agora que já sabemos colocar informações em um vetor via 
teclado, vamos ver como apresentar, na tela, os valores armazenados 
em um vetor.
22
Programação 2
1.6 Impressão dos elementos de um vetor
Quando desejarmos apresentar os elementos que estão 
armazenados no vetor, devemos utilizar uma estrutura de repetição, 
que fará com que cada uma das posições do vetor seja “visitada” e 
seu conteúdo apresentado. Vale lembrar que, quando declaramos um 
vetor, indicamos a sua capacidade de armazenamento. Mas durante a 
execução do programa, pode ser que o usuário não armazene dados 
suficiente para preencher todas as posições do vetor. Assim, quando 
formos imprimir os dados de um vetor, precisamos saber quantos 
elementos têm armazenado no momento da impressão. O Programa 
Completo 1.3, mostra a leitura e a impressão dos dados armazenados 
em um vetor.
Programa Completo 1.3: Ler e imprimir um conjunto de números inteiros, 
armazenando-os em um vetor.
1
2
3
4
5
 
6
7
8
9
10
 
11
12
13
14
15
16
17
main()
{ int valor[5];
 int q, continuar, i;
 q=0;
 printf(“Cadastro dos elementos do vetor Valor 
\n\n”);
 do
 { printf(“\n\nElemento %d: “,q+1);
 scanf(“%d”,&valor[q]);
 q++;
 printf(“\n\nCadastrar outro elemento 
(1-sim/2-nao)? “);
 scanf(“%d”, &continuar);
 } while ((continuar==1) && (q<5));
 printf(“\n\nElementos do Vetor: “);
 for (i=0; i<q; i++)
 printf(“ %d “,valor[i]);
 getche();
}
23
Programação 2
Até a linha 12, o Programa Completo 1.3 é, praticamente, idêntico 
ao Programa Completo 1.2. A única diferença é que temos, na linha 
3, a declaração da variável i, que será usada no for que imprimirá os 
elementos do vetor. Vamos ver o que está acontecendo nas demais 
linhas?
•	 Linha	 13: printf para informar que serão apresentados os 
elementos do vetor. Notem que o texto entre aspas não termina 
com \n. Isso se dá porque não queremos que o cursor vá para 
a linha seguinte.
•	 Linha	 14: for que será utilizado para percorrer o vetor, 
acessando cada uma das posições do vetor. A variável que tem 
a informação de quantos elementos foram armazenados no 
vetor é q. Dessa forma, o i do for vai variar de 0 até q-1. Uma 
vez que se q for 3, a última posição ocupada no vetor é 2. 
•	 Linha	15: printf que apresenta o elemento do vetor, na posição 
de índice i. Este printf também não tem o \n, porque queremos 
que os elementos do vetor sejam impressos um ao lado do 
outro. Este é o único comando do for, por isso não houve a 
necessidade de delimitar com chaves.
•	 Linha	16: getche que evita o fechamento da janela de execução 
do programa, e assim poderemos ver os elementos do vetor 
impresso.
•	 Linha	 17: fecha chaves, indicando o final do programa 
principal.
A figura 1.11 apresenta a tela de execução do programa 1.3. Foram 
cadastrados os mesmos valores do exemplo anterior. 
24
Programação 2
Figura 1.11: Tela de execução do Programa Completo 1.3
Neste caso, apesar do vetor ter sido declarado com 5 posições, só 
foram preenchidas 3 posições. Vejam que, após o usuário responder 
que não quer mais cadastrar, os elementos do vetor são apresentados 
um ao lado do outro.
Vamos ver outro Programa Completo? Neste programa iremos 
ler as matrículas e notas dos alunos de uma turma e imprimir as 
matrículas dos alunos de tiveram nota acima da média das notas da 
turma.
Programa Completo 1.4
1
2
3
4
5
6
7
8
9
10
main()
{ int mat[10];
 float nota[10]; 
 int q, i, continuar;
 float soma, media;
 soma = 0;
 q=0;
 do
 { system(“cls”);
 printf(“Universidade Aberta do Brasil - 
UFRPE\n\n”);
25
Programação 2
11
 
12
13
14
15
16
17
18
 
19
20
21
22
23
 
24
25
 
26
27
28
29
30
 printf(“\n\nDados do Alunos %d\n\n”, 
q+1);
 printf(“\nMatricula: “);
 scanf(“%d”,&mat[q]);
 printf(“\nNota: “);
 scanf(“%f”,&nota[q]);
 soma = soma + nota[q];
 q++;
 printf(“\n\nCadastrar outro(1-sim/2-nao)? 
“);
 scanf(“%d”, &continuar);
 } while ((continuar==1) && (q<10));
 media = soma/q;
 system(“cls”);
 printf(“Universidade Aberta do Brasil - UFRPE 
\n\n”);
 printf(“Media da turma: %.2f\n\n\n”,media);
 printf(“Alunos com nota acima da media da 
turma\n\n”); 
 for (i=0; i<q; i++)
 { if (nota[i]>media)
 printf(“%d \n”,mat[i]);
 }
 printf(“\n\nDigite qualquer tecla para sair 
“);
31
32
 getche();
}
Comentários sobre o Programa Completo 1.4:
•	 Linhas	 2	 a	 5: declaração das variáveis do programa. Vejam 
que precisamos de um vetor para armazenar as matrículas e 
um outro para armazenar as notas. 
26
Programação 2
•	 Linhas	6	e	7: inicialização das variáveis soma (que acumula as 
notas de todos os alunos) e q (que conta quantos elementos 
foram cadastrados no vetor).
•	 Linhas	8	a	20: do/while que faz a leitura das matrículas e das 
notas de cada aluno, armazenando nos respectivos vetores. 
Neste do/while, o usuário pode parar o cadastro no momento 
que ele desejar. Para calcularmos a média da turma, temos que 
somar as notas de todos os alunos e dividir pela quantidade 
de alunos. Assim, enquanto estivermos no do/while, estamos 
acumulando as notas de todos osalunos na variável soma.
•	 Linha	 21: ao sair do do/while, a média da turma pode ser 
calculada. 
•	 Linha	22: usa o system(“cls”) para limpar a tela e dar início a 
tela que irá apresentar os resultados.
•	 Linha	24: printf para apresentar a média da turma. 
•	 Linhas	 26	 a	 29: for para visitar cada posição do vetor que 
armazena as notas dos alunos. Quando verifica que a nota do 
aluno é maior que a média da turma (armazenada na variável 
media), a matrícula do aluno é apresentada. 
A figura 1.12 apresenta a tela de execução do programa 1.4, na 
fase do cadastramento dos dados dos alunos (matrícula e nota). 
Figura 1.12: Tela de Execução do Programa Completo 1.4 – Cadastro de Alunos
A figura 1.13 apresenta a tela de execução do programa completo 
1.4, na fase do apresentação dos resultados.
27
Programação 2
Figura 1.13: Tela de Execução do Programa Completo 1.4 – Apresentação dos Resultados
1.7 Tamanho de um vetor e segmentação de 
memória
Na linguagem C, devemos ter cuidado com os limites de um vetor. 
Embora na declaração tenhamos que definir o tamanho de um vetor, 
o C não faz nenhum teste de verificação de acesso a um elemento 
dentro do vetor ou não.
Por exemplo, se declaramos um vetor como int valor[5], 
teoricamente, só tem sentido usarmos os elementos valor[0], valor[1], 
valor[2] , valor[3] e valor[4]. Porém, o C não acusa erro se usarmos 
valor[12] em algum lugar do programa. Estes testes de limite devem 
ser feitos dentro do programa, pelo programador.
Este fato se deve à maneira como o C trata os vetores. A memória 
do computador é um espaço (físico) particionado em porções de 1 
byte. Se declararmos um vetor como int valor[3], estamos reservando 
12 bytes (3 segmentos de 4 bytes – lembrando que cada int ocupa 
4 bytes) de memória para armazenar os seus elementos. O primeiro 
segmento será reservado para valor[0], o segundo segmento para 
valor[1] e o terceiro segmento para valor[2]. O segmento inicial é 
chamado de segmento base, de modo que valor[0] será localizado no 
segmento base. Quando acessamos o elemento valor[i], o processador 
acessa o segmento localizado em base+i. Se i for igual a 2, estamos 
acessando o segmento base+2 ou valor[2] (o último segmento 
reservado para o vetor). Porém, se i for igual a 7, estamos acessando 
o segmento base+7 que não foi reservado para os elementos do vetor 
e que provavelmente está sendo usado por uma outra variável ou 
contém uma informação inesperada (lixo). 
28
Programação 2
Observem que o acesso a um segmento fora do espaço destinado 
a um vetor pode destruir informações reservadas de outras variáveis. 
Estes erros são difíceis de detectar, pois o compilador não gera 
nenhuma mensagem de erro. Por isso, a solução mais adequada é 
sempre avaliar os limites de um vetor antes de manipulá-lo. Como 
feito no Programa Completo 1.2 que vai cadastrando os elementos no 
vetor e para quando o vetor completa a sua capacidade.
A princípio, este fato poderia parecer um defeito da linguagem, 
mas na verdade trata-se de um recurso muito poderoso do C. Poder 
manipular sem restrições todos os segmentos de memória é uma 
flexibilidade apreciada por programadores mais experientes. 
1.8 Passando vetores como parâmetros de 
funções
Os vetores, assim como as variáveis simples, podem ser usados 
como argumentos de funções. Veremos como se declara uma função 
que recebe um vetor como parâmetro e como se chama uma função 
passando um vetor como parâmetro. 
A sintaxe de uma função que recebe um vetor como parâmetro é a 
seguinte:
Sintaxe
tipo_retorno nome_função(tipo_vetor nome_vetor[])
{
 //corpo da função 
}
Onde:
•	 tipo_retorno: é o tipo de retorno da função.
•	 nome_função: é o nome da função.
•	 tipo_vetor: é o tipo de dados dos elementos do vetor.
•	 nome_vetor: é o nome do vetor. Observe que depois do nome 
do vetor temos o [ e o ], mas não colocamos nada entre eles. 
Neste caso, não é necessário informar o tamanho do vetor. 
Quando formos chamar uma função que recebe um vetor como 
29
Programação 2
parâmetro, usamos a seguinte sintaxe:
Sintaxe
nome_da_função(nome_do_vetor);
Onde:
•	 nome_da_função: é o nome da função que será chamada.
•	 nome_do_vetor: é o nome do vetor que queremos passar 
como parâmetro. Neste caso, indicamos apenas o nome do 
vetor, sem os colchetes. 
O exemplo 1.6, a seguir, apresenta a declaração de uma função 
que tem um vetor como parâmetro e a chamada da função.
Exemplo 1.6: 
declaração e chamada de uma função que tem um vetor como parâmetro
1
2
3
4
5
6
7
8
9
10
 
11
12
float media(float vetor[],float N)
{
 //corpo da função 
}
main()
{ float valor[30]; // declaração do vetor
 float n;
 ...
 med = media(valor, n); // passagem do vetor 
para a função
 ...
}
Atenção: Ao contrário das variáveis comuns, o conteúdo de um 
vetor pode ser modificado pela função chamada. Isto significa que 
podemos passar um vetor para uma função e alterar os valores de 
seus elementos. Isto ocorre porque a passagem de vetores para 
funções é feita de modo especial dito passagem por endereço. 
Portanto, devemos ter cuidado ao manipular os elementos de um 
30
Programação 2
vetor dentro de uma função para não modificá-los por descuido.
Atividades e Orientações de Estudos
Vamos fazer um conjunto de exercícios, usando o assunto que 
acabamos de aprender? Segue abaixo uma lista de exercícios em 
que os dados serão armazenados em vetores. Vamos começar?
1. Ler um conjunto de números e imprimi-los na ordem inversa da 
leitura. A quantidade de números também será lida e será no 
máximo 10.
2. Ler o tamanho e os elementos de dois vetores e, em seguida, 
caso os vetores tenham o mesmo tamanho, gere e imprima o 
vetor SOMA, onde seus elementos serão formados pela soma 
dos elementos de mesmos índices dos dois vetores lidos. 
Exemplo:
A 1 4 7 2 9
0 1 2 3 4
B 3 5 11 4 8
0 1 2 3 4
Soma 4 9 18 6 17
0 1 2 3 4
3. Ler um vetor de números e imprimir os valores armazenados 
nas posições PARES e, em seguida, os valores armazenados 
nas posições ÍMPARES. Exemplo:
V 1 4 7 2 9
0 1 2 3 4
Valores nas posições pares: 1 7 9
31
Programação 2
Valores nas posições impares: 4 2
4. Ler dois vetores e caso tenham tamanhos iguais, armazene seus 
elementos alternadamente em um terceiro vetor. Exemplo:
A 1 4 7 2 12
0 1 2 3 4
B 3 5 11 4 15
0 1 2 3 4
Resultante 1 3 4 5 7 11 2 4 12 15
0 1 2 3 4 5 6 7 8 9
5. Ler um vetor de números inteiros e imprimir as posições do 
maior e do menor elemento do vetor. Assuma que não existem 
elementos repetidos no vetor. Exemplo:
V 14 13 7 22 9
0 1 2 3 4
O menor elemento se encontra na posição 2
O maior elemento se encontra na posição 3
6. Ler um vetor de números e inverter a ordem dos elementos 
desse vetor no próprio vetor. Exemplo:
 Vetor antes de ser invertido:
V 14 13 7 22 9
0 1 2 3 4
 Vetor depois de ser invertido:
32
Programação 2
V 9 22 7 13 14
0 1 2 3 4
7. Ler dois vetores de números e gerar um terceiro vetor formado 
pela INTERSECÇÃO dos dois vetores lidos. O resultado da 
interseção de dois conjuntos é: os elementos que fazem parte 
dos dois conjuntos. Exemplo:
A 1 4 7 2 12
0 1 2 3 4
B 3 4 2 14 25
0 1 2 3 4
interseccao 4 2
0 1 2 3 4
8. Ler dois vetores de números e gerar um terceiro vetor formado 
pela DIFERENÇA dos dois vetores lidos. O resultado da 
diferença de dois conjuntos é: os elementos do conjunto A que 
não fazem parte do conjunto B. Exemplo:
A 1 4 7 2 12
0 1 2 3 4
B 3 4 2 14 25
0 1 2 3 4
Diferenca 1 7 12
0 1 2 3 4
33
Programação 2
9. Ler dois vetores de números e gerar um terceiro vetor formado 
pela UNIÃO dos dois vetores lidos. O resultado da união de doisconjuntos é: todos os elementos que fazem parte dos conjuntos 
A e B. Exemplo:
A 1 4 7 2 12
0 1 2 3 4
B 3 4 2 14 25
0 1 2 3 4
União 1 4 7 2 12 3 14 25
0 1 2 3 4 5 6 7 8 9
10. Ler um vetor de números e imprimir os números que se repetem 
nesse vetor. Exemplo:
V 1 4 7 1 2 1 4 25 3 7
0 1 2 3 4 5 6 7 8 9
 Os números que se repetem no vetor são: 1 4 7
Conheça Mais
Para ampliar nossos conhecimentos sobre os assuntos tratados 
neste capítulo, leiam o capítulo que aborda armazenamento em 
vetores, do livro:
• SCHILDT, Herbert. C Completo e Total. São Paulo: Makron, 
1996.
34
Programação 2
Vamos Revisar?
Vamos lembrar rapidinho o que foi visto neste capítulo? 
Leia o resumo a seguir, composto com os principais conceitos 
apresentados.
Vetores: conhecidos como estruturas de dados homogêneas, os 
vetores são um conjunto de variáveis que armazenam elementos 
do mesmo tipo.
Índices: para acessar um elemento do vetor, precisamos indicar em 
que posição do vetor está o elemento.
No momento da declaração dos vetores, precisamos indicar quantos 
elementos serão armazenados no mesmo.
É de responsabilidade do programador o acesso aos elementos do 
vetor. Se o programa tentar acessar uma posição que não existe no 
vetor, o compilador não indicará o erro. 
Quando passamos um vetor como parâmetro de uma função, seus 
valores podem ser alterados
35
Programação 2
Capítulo 2 – Armazenamento de 
Dados em Registros
Vamos conversar sobre o assunto?
Neste capítulo, vamos aprender mais uma forma de armazenamento 
de dados, que são os registros. Nos registros podemos agrupar dados 
de tipos diferentes. Por conta disto, os registros são chamados de 
estruturas de dados heterogêneas. Assim como os vetores, os registros 
vão facilitar o gerenciamento dos dados dos nossos programas, que 
estão cada vez maiores. Veremos, também, como unir os conceitos 
de vetores e registros, trabalhando com vetor de registro. Leiam este 
capítulo com calma e atenção, uma vez que iremos utilizar registros 
em muitas situações nos nossos programas, certo?
2.1 O que são registros?
Nós já sabemos que um conjunto homogêneo de dados é composto 
por variáveis do mesmo tipo (vetores). Mas, e se tivermos um conjunto 
em que os elementos não são do mesmo tipo? Teremos, então, um 
conjunto heterogêneo de dados, que são chamados de registros. 
O registro é uma das principais formas de estruturar os dados no 
programa. O conceito de registro visa facilitar o agrupamento de 
variáveis de tipos diferentes, mas que possuem uma relação lógica.
Um registro é um conjunto de uma ou mais variáveis, que podem 
ser de tipos diferentes, agrupadas sobre um único nome. O fato de 
variáveis agrupadas em um registro poderem ser referenciadas por 
um único nome, facilita a manipulação dos dados armazenados nestas 
estruturas. Como exemplo de um registro, imaginem uma estrutura que 
armazene as diversas informações do boletim de um aluno. O boletim 
é formado por um conjunto de informações logicamente relacionadas, 
porém de tipos diferentes, tais como: número de matrícula (inteiro), 
nome do aluno (caractere), nome da disciplina (caractere), média (real) 
e situação (caractere), que são subdivisões do registro (elementos 
de conjunto), também chamadas de campos. Logo, um registro é 
composto por campos que são partes que especificam cada uma das 
informações. A figura 2.1 apresenta o boletim de notas de um aluno.
36
Programação 2
Boletim de Notas
Matricula...: 12345
Nome........: Michel
Disciplina..: Matemática
Média........: 10.0
Situação....: Aprovado
Figura 2.1 Boletim de Notas
Notem que, o boletim é composto por informações de diferentes 
tipos. No entanto, todas as informações do boletim estão relacionadas 
ao mesmo aluno. O agrupamento de informações de tipos diferentes, 
que tem uma relação lógica, facilitará a manipulação de dados. 
Nas próximas seções, vamos aprender a declarar e manipular 
registros.
2.2 Declaração de um Registro
Para declarar uma variável, precisamos informar o seu tipo e dar 
um nome à mesma. Mas, um registro é formado por várias variáveis 
de tipos diferentes. Como iremos declarar um registro? Para declarar 
um registro, é necessário informar quais variáveis, e seus respectivos 
tipos, fazem parte do registro. Dessa forma, precisamos declarar 
cada campo do registro, agrupando-os em um novo tipo de dado. 
A declaração de um registro passa por duas fases: definição de um 
novo tipo de dado e declaração do registro propriamente dito. Vamos 
entender melhor isso tudo?
Primeiramente, precisamos definir quais campos fazem parte 
do registro e criar um novo tipo de dado para o nosso programa. 
Precisamos criar um novo tipo de dado porque não conseguiríamos 
representar o tipo de informação que o registro armazena, utilizando 
os tipos primitivos disponíveis na linguagem: int, float, char, etc. Uma 
vez que o registro agrupa variáveis de tipos de dados diferentes. Para 
criar um novo tipo de dado, utilizamos a seguinte sintaxe:
37
Programação 2
Sintaxe
typedef struct { declaração das variáveis;
 } nome_do_tipo;
Onde:
• typedef: indica que um novo tipo de dado será definido. 
• struct: indica que o tipo de dado que será definido é um 
registro, ou seja, um agrupamento de variáveis de tipos de 
dados diferentes.
• declaração das variáveis: são as variáveis que fazem parte do 
registro. Neste local, precisamos especificar quais as variáveis 
irão compor o registro, além do tipo das mesmas. As variáveis 
são colocadas entre chaves.
• nome_do_tipo: é dado um nome ao novo tipo de dado que 
está sendo criado. Só depois que o novo tipo de dado é criado, 
é que o registro poderá ser declarado.
Na sequência, vamos ver a declaração de um registro. Assim como 
toda variável, ao declarar uma variável que é um registro, precisamos 
dizer que tipo de dado o registro armazena. Neste caso, iremos dizer 
que o registro é do tipo de dado que acabamos de definir no typedef. 
A sintaxe é a seguinte:
Sintaxe
nome_do_tipo nome_do_registro;
Onde:
•	 nome_do_tipo: é o nome do tipo de dado que definimos 
no nosso programa, formado pelo agrupamento de várias 
variáveis.
•	 nome_do_registro: é o nome da variável registro que está 
sendo declarada. O nome de um registro segue as regras dos 
identificadores.
O exemplo 2.1 apresenta a declaração do registro do boletim do 
aluno:
38
Programação 2
Exemplo	2.1:	Definição	de	tipo	e	declaração	de	registro
1
2
 
3
4
5
typedef struct { int matricula;
 char nome[20], disciplina[20], 
situação[10];
 float media;
 } Tipo_Aluno;
Tipo_Aluno aluno;
Primeiramente, entre as linhas 1 e 4, foi definido o conjunto de 
variáveis que fazem parte do registro. É nesta parte que está sendo 
definido um novo tipo de dado.
• Linha 1: com o typedef estamos informando que será definido 
um novo tipo de dado. O struct indica que este tipo é um 
agrupamento de variáveis de tipos diferentes, ou seja, um 
registro. Colocamos o abre chaves e começamos a declarar 
as variáveis que irão compor o registro. Começamos com a 
declaração da variável inteira matricula. Se houvesse mais 
variáveis do tipo int, poderiam ser declaradas nesta mesma 
linha.
• Linha 2: declaração das variáveis do tipo char: nome, disciplina 
e situacao.
• Linha 3: declaração da variável media que é do tipo float.
• Linha 4: Após a declaração de todas as variáveis que compõe 
o registro, podemos fechar a chaves e, em seguida, dar um 
nome a esse tipo de agrupamento, que acabamos de definir. 
Neste caso, o tipo foi chamado de Tipo_Aluno. Ao definirmos 
um tipo de dado no nosso programa, significa que: podemos 
declarar variáveis dos tipos de dados primitivos (int, float, char, 
etc), além de variáveis do tipo de dado que nós definimos,neste 
caso, Tipo_Aluno. 
• Linha 5: declaração de uma variável chamada aluno, e o tipo 
de dado que ela armazena é Tipo_Aluno, ou seja, armazena: 
matricula, nome, disciplina, situacao e media.
A figura 2.2 mostra a representação gráfica da variável aluno, que 
é do tipo Tipo_Aluno.
39
Programação 2
 
matricula
nome
disciplina
situacao
media
aluno
Figura 2.2: Representação gráfica do registro aluno
Notem que, a variável aluno (que é um registro) é formada pelos 
campos definidos no Tipo_Aluno.
Como uma variável registro é formada por vários campos, 
precisamos utilizar uma forma diferenciada para informar qual campo 
do registro nós estamos querendo acessar. Lembram dos vetores, que 
precisávamos dizer qual elemento do vetor seria acessado? Com os 
registros vai acontecer algo parecido. Mas isto, nós vamos aprender 
na próxima seção.
2.3 Acessando os campos do registro
De acordo com a figura 2.2, a variável aluno é um registro formado 
por vários campos. Para acessar um campo de um registro, devemos 
usar a seguinte sintaxe:
Sintaxe
nome_do_registro.campo
Onde:
•	 nome_do_registro: é o nome da variável registro que queremos 
acessar.
•	 Após o nome_do_registro devemos colocar um ponto, que 
irá separar o nome do registro, do campo que vem logo em 
seguida.
•	 campo: é o campo do registro que será acessado. 
40
Programação 2
Pensem da seguinte forma: suponham que queremos acessar 
o registro aluno, do exemplo 2.1. Ao acessarmos esta variável, ela 
possui vários campos. Precisamos dizer qual deles será acessado 
no momento. A seguir, são apresentados exemplos de acesso aos 
campos do registro aluno. Ao acessar um campo do registro, podemos 
atribuir valores, como mostra o exemplo 2.2.
Exemplo 2.2: Acesso aos campos de um registro
1
2
3
4
aluno.matricula = 12345;
scanf(“%f”, &aluno.media);
gets(aluno.nome);
printf(“Situacao do aluno: %s”, aluno.situacao);
Na linha 1, estamos acessando o campo matricula do registro 
aluno. Assim, colocamos o nome do registro, o ponto e o campo que 
queremos acessar. Com acesso ao campo, fizemos uma atribuição4.
Na linha 2, estamos acessando o campo media do registro aluno. 
Neste caso, ao invés de atribuir um valor ao campo de registro, estamos 
fazendo uma leitura via teclado e armazenando o valor digitado no 
campo media. Como o campo media é do tipo float, colocamos o %f 
no scanf, indicando que será lido um número real.
Na linha 3, temos o comando de leitura gets, responsável por ler 
variáveis do tipo char. Neste gets, estamos fazendo uma leitura via 
teclado e armazenando o valor digitado no campo nome do registro 
aluno.
Na linha 4, temos um printf que apresenta a situação do aluno. 
Para isso, acessamos o campo situacao do registro aluno. 
Notem que, se tivermos vários alunos em uma turma, precisaremos 
de várias variáveis registro do tipo Tipo_Aluno, uma para cada 
aluno. Para fazer isso de forma mais simplificada, devemos juntar os 
conceitos de vetores e registros e criar um vetor de registro. Vamos 
aprender como faz isto?
2.4 Vetor de registro
Os vetores são formados por um conjunto de dados do mesmo 
tipo. No capítulo anterior, utilizamos vetores que armazenavam dados 
Saiba Mais
4 O ponto que 
aparece neste 
comando, deve 
ser lido como 
“campo”. Assim, 
a leitura do 
comando da linha 
1 seria: aluno no 
campo matricula 
recebe 12345.
41
Programação 2
de tipos primitivos, ou seja, tipos disponíveis na linguagem – int, 
float, char, etc. Veremos que podemos utilizar como elemento do vetor 
não apenas um tipo primitivo, mas também os tipos construídos (tipos 
definido pelo programador), neste caso, os registros. Imaginem que 
queremos armazenar os boletins dos 50 alunos de uma turma. Para 
isso, será necessário um registro diferente para cada aluno. Para 
agrupar todos estes registros, iremos definir um vetor de registro. 
Como possuímos 50 alunos, podemos criar um vetor no qual cada 
posição, armazena um Tipo_Aluno. 
Para declarar um vetor de registro, precisamos antes definir os 
elementos do registro, utilizando o typedef struct, e assim, definir um 
novo tipo de dado que será utilizado no programa. Após definirmos o 
novo tipo de dado, o vetor poderá ser declarado. Para declararmos 
um vetor, precisamos informar o tipo de dado que o vetor armazena, 
damos um nome ao vetor e informamos, entre colchetes, o tamanho 
do vetor. O exemplo 2.3 apresenta a declaração do vetor de registro 
alunos:
Exemplo	2.3:	definição	do	registro	e	declaração	do	vetor	de	registro
1
2
 
3
4
5
typedef struct { int matricula;
 char nome[20], disciplina[20], 
situação[10];
 float media;
 }Tipo_Aluno;
Tipo_Aluno alunos[50];
Neste exemplo, cada uma das 50 posições do vetor alunos irá 
armazenar todos os dados que compõe o Tipo_Aluno, ou seja: 
matricula, nome, disciplina, situacao e media. A figura 2.3, a seguir, 
representa o vetor de registro declarado no exemplo.
alunos 
matricula 
nome 
disciplina 
media 
situacao
matricula 
nome 
disciplina 
media 
situacao
matricula 
nome 
disciplina 
media 
situacao
matricula 
nome 
disciplina 
media 
situacao
0 1 ... 48 49
Figura 2.3: Representação gráfica do vetor de registro aluno 
42
Programação 2
Se apenas com os vetores, já havíamos adquirido uma facilidade 
na declaração e manipulação de um grande conjunto de variáveis, 
com os vetores de registros, esta facilidade será aumentada.
Vamos aprender, na próxima seção, como acessamos um campo 
de um vetor de registro.
2.5 Acessando os campos do vetor de 
registro
Quando precisamos acessar um elemento do vetor, informamos, 
entre colchetes, o índice do elemento do vetor que será acessado. 
Quando queremos acessar um campo do registro, informamos o 
nome da variável registro, colocamos um ponto e o nome do campo 
que queremos acessar. Já no caso de um vetor de registro, temos 
que usar a seguinte sintaxe:
Sintaxe
nome_do_vetor[indice].campo
Onde:
nome_do_vetor: nome do vetor que queremos acessar.
[índice]: índice do vetor que será acessado.
.campo: campo do registro que será acessado.
O exemplo 2.4 apresenta acessos a campos do vetor de registro 
alunos.
Exemplo 2.4: Acesso aos elementos de um vetor de registro 
1
2
3
4
alunos[2].media = 7.5;
alunos[3].matricula = 12345;
gets(alunos[0].nome);
scanf(“%d”,&alunos[2].matricula);
Na linha 1, acessamos o elemento de índice 2 do vetor alunos e 
atribuímos 7.5 ao campo media. Na linha 2, acessamos o elemento 
de índice 3 do vetor alunos e atribuímos 12345 ao campo matricula.
Nas linhas 3 e 4, temos acessos através de comandos de entrada 
43
Programação 2
de dados. Na linha 3, temos um gets, que obtém o nome do aluno, via 
teclado, e armazena no índice 0 do vetor alunos, no campo nome. Na 
linha 4, temos o scanf que lê a matrícula do aluno, armazenando no 
índice 2 do vetor alunos, no campo matricula.
2.6 Usando vetor de registro
Vamos fazer um programa completo usando vetor de registro? 
Este programa será um pouco maior do que os outros programas que 
já fizemos, e apresentará uma gama de coisas novas. Além do uso 
de vetor de registro, aprenderemos a mostrar os dados do vetor de 
registro em forma de tabela. Vamos começar?
Primeiramente, vamos ler e entender o enunciado do Programa 
Completo 2.1: Faça um programa que cadastre e apresente os 
dados dos alunos de uma escola. Os dados dos alunos devem 
ser armazenados em um vetor de registro, com a capacidade de 
armazenar até 20 alunos. A quantidade de alunos que será cadastrada 
é desconhecida. No momento do cadastro serão informados os 
seguintes dados para cada aluno: matrícula, nome, série(1-4) e se 
tem irmão na escola (1-sim/0-nao). O programa irá calcular o valor 
damensalidade do aluno, que depende da série do aluno e se o 
mesmo tem irmão na escola. Valor da Mensalidade: 1ª Serie: R$110, 
2ª Serie: R$130, 3ª Serie: R$160, 4ª Serie: R$170. O aluno que tiver 
irmão na escola, receberá 20% de desconto no valor da mensalidade. 
Quando o usuário decidir que não deseja mais cadastrar, o programa 
apresentará os dados de todos os alunos, em forma de tabela. Para 
facilitar o entendimento deste enunciado, vejam os exemplos das telas 
que são apresentadas durante a execução do programa:
Colégio Legal
Cadastro de Aluno
Matricula..: 
Nome.......: 
Serie(1-4): 
Irmao na escola (1-sim/0-nao):
Cadastrar outro aluno (1-sim/0-nao)?
44
Programação 2
Colégio Legal
Relatório Geral
Matricula Nome Serie Irmao Mensalidade
xx xxxxx x x xx.xx
xx xxxxx x x xx.xx
xx xxxxx x x xx.xx
xx xxxxx x x xx.xx
xx xxxxx x x xx.xx
Tecle enter para sair...
Figura 2.4:Exemplos de telas do programa completo 2.1 
A primeira tela representa a operação de cadastramento dos 
dados dos alunos. Nesta tela, é que serão fornecidos os dados para o 
cadastramento dos alunos. Como a mensalidade é um dado calculado 
pelo programa, o usuário não fornecerá este dado no momento do 
cadastro.
A segunda tela representa a apresentação dos dados de todos 
os alunos, em forma de tabela (listagem ou relatório). Cada linha da 
tabela apresentará os dados de um aluno.
Como precisamos armazenar os vários dados de cada um dos 
alunos da escola, se faz necessário o uso de um vetor de registro.
Segue o código do programa completo 2.1, que será comentado 
posteriormente.
45
Programação 2
Programa Completo 2.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
22
23
#include <stdio.h>
main()
{ typedef struct{ int mat, serie, irmao;
 char nome[20];
 float mens;
 } Tipo_Aluno;
 Tipo_Aluno alunos[20];
 int qa, i, resp;
 qa =0;
 do
 { system(“cls”);
 printf(“Colegio Legal\n”); 
 printf(“\n\nCadastro de Alunos\n\n”);
 printf(“\nMatricula.: “);
 scanf(“%d”,&alunos[qa].mat);
 printf(“\nNome......: “);
 fflush(stdin);
 gets(alunos[qa].nome);
 printf(“\nSerie(1-4): “);
 scanf(“%d”,&alunos[qa].serie);
 printf(“\nIrmao na escola(1-sim/0-nao): 
“);
 scanf(“%d”,&alunos[qa].irmao);
 switch(alunos[qa].serie)
24
25
26
27
28
 { case 1: alunos[qa].mens = 110; break;
 case 2: alunos[qa].mens = 130; break;
 case 3: alunos[qa].mens = 160; break;
 case 4: alunos[qa].mens = 170; break;
 }
46
Programação 2
29
30
31
32
 
33
34
35
36
37
38
39
 
40
41
42
 
 
43
44
45
46
 if (alunos[qa].irmao == 1)
 alunos[qa].mens = alunos[qa].mens*0.8;
 qa++;
 printf(“\n\nDeseja cadastrar outro aluno(1-
sim/0-nao)? “);
 scanf(“%d”,&resp);
 }while ((resp == 1) && (qa <20));
 system(“cls”);
 printf(“Colegio Legal\n”);
 printf(“\n\nRelatorio Geral\n”);
 printf(“\n________________________________”);
 printf(“\nMatricula Nome Serie Irmao 
Mensalidade”);
 printf(“\n________________________________”);
 for(i = 0; i < qa; i++)
 printf(“\n%9d %-20s %5d %5d %11.2f”, 
alunos[i].mat, alunos[i].nome, alunos[i].serie, 
alunos[i].irmao, alunos[i].mens);
 printf(“\n_______________________________”);
 printf(“\nTecle enter para sair...”);
 getche();
}
Comentários sobre o Programa Completo 2.1
•	 Linha	1: inclusão da biblioteca stdio.h devido o uso do comando 
fflush.
•	 Linha	2: início do programa principal. 
•	 Linhas	 3	 a	 6: definição de um novo tipo de dado, que será 
chamado de Tipo_Aluno. O Tipo_Aluno é formado pelos dados 
dos alunos: mat (matrícula), nome, serie, irmao (indica se tem 
irmão na escola) e mens (mensalidade). 
•	 Linha	7: declaração do vetor de registro alunos, com capacidade 
de armazenar 20 elementos do Tipo_Aluno.
47
Programação 2
•	 Linha	 8: declaração das variáveis qa (que irá controlar a 
quantidade de alunos cadastrados no vetor), i (utilizada como 
variável de controle do for) e resp (utilizada para saber se o 
usuário deseja continuar cadastrando novos alunos). 
•	 Linha	9: inicialização da variável qa com 0;
•	 Linhas	 10	 a	 34: repetição do tipo do/while que irá controlar 
o cadastro dos dados dos alunos no vetor de registro. Este 
do/while irá parar a sua execução se o vetor ficar cheio (20 
elementos) ou se o usuário não quiser mais cadastrar. 
•	 Linha	11: Cada vez que o do/while é executado, queremos que 
a tela seja limpa. Para isso, usamos o system(“cls”). Esta linha 
tem, também, o abre chaves que indica o início da sequência 
de comandos do do/while.
•	 Linhas	12	e	13: printf para indicar o nome do colégio (Colégio 
Legal) e para indicar o que está sendo feito nesta tela (Cadastro 
de Alunos).
•	 Linhas	14	e	15: printf informando que o usuário deve digitar 
a matrícula do aluno e scanf que obtêm a matrícula do aluno, 
armazenado-a no vetor de registro alunos, na posição qa e no 
campo mat. Notem que a variável qa iniciou com 0. Na primeira 
vez que o do/while for executado, os dados dos alunos serão 
armazenados na posição 0 do vetor. A cada vez que a repetição 
é executada, a variável qa é incrementada de uma unidade. 
Assim, os dados de cada aluno serão armazenados em uma 
posição, diferente, no vetor de registro.
•	 Linhas	16	a	18: printf informando que o usuário deve digitar o 
nome do aluno. fflush para limpar o buffer e, em seguida, o gets 
responsável por ler o nome do aluno, armazenando no vetor de 
registro alunos, na posição qa e no campo nome. 
•	 Linhas	19	e	20: printf informando que o usuário deve digitar a 
série do aluno (que pode ser de 1 a 4). scanf responsável por 
ler a série do aluno, armazenando no vetor de registro alunos, 
na posição qa e no campo serie. 
•	 Linhas	21	e	22: printf informando que o usuário deve digitar se 
o aluno tem irmão na escola (digitar 1 se tiver irmão e 0 se não 
tiver irmão na escola). scanf responsável por ler se o aluno tem 
irmão na escola, armazenando no vetor de registro alunos, na 
48
Programação 2
posição qa e no campo irmao. 
•	 Linhas	23	a	28: depois de obter todos os dados de um aluno, 
o programa vai calcular o valor da mensalidade do aluno, 
verificando a série e se tem irmão na escola. Como cada uma 
das séries da escola tem um valor diferente de mensalidade, 
este switch serve para verificar em que série o aluno está 
matriculado, para atribuir ao campo mens do registro do aluno, 
o valor da mensalidade correspondente a sua série.
•	 Linhas	29	e	30: if para verificar se o aluno tem irmão na escola. 
De acordo com o enunciado, os alunos que tem irmão na escola, 
recebem uma desconto de 20% na sua mensalidade. Como o if 
só tem um comando, não foi necessário o uso de chaves.
•	 Linha	 31: neste momento, todo o registro do aluno já foi 
preenchido. Com isso, fazemos o incremento da variável qa, 
informando que mais um aluno acabou de ser cadastrado. 
•	 Linhas	 32	 e	 33: printf que pergunta se o usuário deseja 
continuar cadastrando novos alunos. scanf para ler a resposta 
do usuário (1 se ele deseja continuar cadastrando e 0 se deseja 
parar).
•	 Linha	34: fechamento do do/while com a condição que faz a 
repetição parar. Como mencionado anteriormente, este do/
while fica em execução enquanto tem posições disponíveis no 
vetor ou enquanto o usuário desejar. Nesta linha, termina a fase 
de cadastramento dos dados dos alunos no vetor de registro. 
•	 Linhas	 35	 a	 47: Esta sequência de comando serve para 
apresentar os dados dos alunos que foram armazenados 
no vetor de registro. Por uma questão de organização, estes 
dados serão apresentados na forma de tabela. Assim, cada 
linha da tabela corresponderá aosdados de um aluno, ou 
seja, uma posição do vetor de registro. Para que a tabela fique 
alinhada, precisamos saber que: a tela tem 80 colunas por 25 
linhas. Dessa forma, temos que distribuir as informações de um 
jeito que não extrapole as 80 colunas da tela. Para entender 
melhor esta parte do programa, acompanhem os comandos, 
observando a figura 2.9 (tela de execução do programa). 
•	 Linha	35: limpa a tela para darmos início à apresentação dos 
dados de todos os alunos.
49
Programação 2
•	 Linhas	36	e	37: printf para informar o nome do colégio e para 
informar o que esta tela faz (Relatório Geral).
•	 Linha	38: printf para passar uma linha na tela. Esta linha vai 
delimitar o cabeçalho da tabela.
• Linha 39: printf que imprime os títulos de cada coluna da tabela. 
A tabela será composta pelas seguintes colunas: Matricula, 
Nome, Serie, Irmao e Mensalidade. Os títulos que devemos 
dar as colunas da tabela são sempre indicados nos enunciados 
das questões, certo? Sigam esta dica, porque vocês estão 
começando a aprender a fazer tabelas agora. Este printf é cheio 
de detalhes, mas vamos ver isso agora, observando a figura 
2.5. O resultado deste printf é a linha que está indicada com a 
seta.
Figura 2.5: Apresentação dos dados em forma de tabela
• Vamos ver quais são os passos para montar o printf da linha 39 
(cabeçalhos/títulos das colunas da tabela).
» Para cada coluna da tabela, verifiquem quantas letras tem 
no seu cabeçalho. Por exemplo, a palavra matrícula, tem 9 
letras. Vejam que, na figura 2.5, tem a indicação de quantas 
letras tem em cada um dos cabeçalhos. A quantidade de 
letras que tiver o cabeçalho, será a largura da coluna.
» Agora, precisamos verificar se os dados dos alunos vão 
extrapolar a largura de cada uma das colunas da tabela. 
Vamos ver uma por uma:
√ Matricula: a coluna que será utilizada para apresentar 
a matrícula, tem uma largura de 9 espaços (quantidade 
de letras da palavra matrícula). Vamos considerar que 
nossas matrículas tem sempre menos que 9 dígitos. 
50
Programação 2
Assim, a largura de 9 espaços para esta coluna, é 
suficiente.
√ Nome: a palavra nome só tem 4 letras. Vejam que o 
nome do aluno foi declarado com 20 letras. Assim, se 
deixarmos a coluna Nome, com largura 4, não será 
suficiente para apresentar os nomes dos alunos. 
Quando a quantidade de letras do cabeçalho é menor 
que o conteúdo que vem na coluna da tabela, devemos 
completar a coluna com espaços em branco até fazer 
com que a coluna tenha a largura que precisamos.
√ Série: tem 5 letras. A série do aluno varia entre 1 e 4, 
dessa forma, a largura da coluna Serie (5 espaços), 
será suficiente para apresentar o dado.
√ Irmão: também tem 5 letras. A variável que armazena 
se o aluno tem ou não irmão na escola, varia entre 0 e 
1, dessa forma, a largura da coluna Irmao (5 espaços), 
será suficiente para apresentar o dado.
√ Mensalidade: tem 11 letras. Esta largura é suficiente 
para apresentar o valor da mensalidade do aluno.
» Agora que já sabemos que apenas a coluna Nome não tem 
largura suficiente para apresentar os nomes dos alunos, 
vamos ver quantos espaços em branco nós temos que 
colocar depois da palavra Nome, para que esta coluna 
tenha a largura que precisamos. Se o nome do aluno tem 
até 20 letras e a palavra Nome tem apenas 4 letras, faremos 
a seguinte conta: 20 – 4 = 16. Assim, depois da palavra 
Nome, temos que colocar 16 espaços em branco, para que 
a nossa coluna passe a ter a largura que precisamos (20). 
» Por fim, temos que definir um espaçamento para separar 
uma coluna da outra. Nos nossos exemplos, vamos usar 
sempre três espaços separando uma coluna da outra. 
A padronização do espaçamento entre as colunas visa 
facilitar a programação, já que estamos vendo este assunto 
agora e o mesmo é cheio de detalhes. 
» Agora vamos montar o printf, vejam a figura 2.6. Nós 
vamos colocando os títulos das colunas da tabela, e entre 
cada palavra, vamos colocando três espaços em branco, 
51
Programação 2
que foi o espaçamento definido para separar as colunas. 
Só no caso da coluna nome, que depois que colocamos 
Nome, devemos dar os 16 espaços em branco para que ela 
passe a ser uma coluna de largura 20. Mas ainda teríamos 
que dar mais 3 espaços em branco, que é para separar a 
coluna nome, da coluna serie.
Figura 2.6: Detalhamento do printf da linha 39
» O printf está pronto! A primeira vista, parece complicado, 
mas depois vocês estarão fazendo a tabela bem rápido. 
•	 Linha	40: printf para passar uma linha na tela. Esta linha vai 
delimitar o cabeçalho da tabela.
•	 Linha	 41: for para visitar cada uma das posições do vetor e 
apresentar os dados dos alunos. A variável de controle do for, 
o i, vai variar de 0 até a ultima posição ocupada do vetor. A 
variável que tem esta informação é o qa. 
•	 Linha	 42: este printf é que vai fazer a montagem das linhas 
da tabela, apresentado os dados dos alunos que estão 
armazenados no vetor de registro. Este printf também tem 
macetes, pois está relacionado com o printf da linha 39. Vamos 
lá! Lembram que fizemos a contagem para saber a largura 
de cada coluna da tabela? Vamos precisar desta informação 
agora.
» Na primeira parte do printf, temos a string de controle 
(a figura 2.7 faz o detalhamento dessa parte do printf). 
Sabemos que as colunas da tabela são: matricula( número 
inteiro e esta coluna deve ter largura 9), nome (vetor de 
caracteres com até 20 letras), serie (número inteiro e esta 
coluna tem largura 5), irmão (número inteiro e esta coluna 
tem largura 5) e mensalidade (número real e esta coluna 
tem largura 11). Além disso, sabemos que entre cada 
coluna, nós colocamos três espaços em branco. Com estas 
informações, vamos montar a string de controle do printf da 
52
Programação 2
linha 42. 
Figura 2.7: Detalhamento do printf da linha 42
» Entre o % e a letra que indica o que vai ser impresso (%d, 
%s ou %f), devemos colocar a largura da coluna. A primeira 
coluna da tabela é a da matricula, que é um número inteiro 
e que tem largura 9. Por isso, temos o %9d. Após cada 
uma das formatações, colocamos três espaços em branco, 
já que foi o espaçamento definido entre as colunas da 
tabela. No caso da variável caractere nome do aluno (que 
é a segunda coluna da tabela) colocamos %-20s (o – é 
para que o nome do aluno seja alinhado pela esquerda). 
Nas demais formatações não precisamos colocar o -, só 
utilizamos em campos caractere. 
» Após a string de controle, colocamos as variáveis que serão 
apresentadas na tela, na ordem em que as colunas foram 
definidas.
•	 Linha	43: printf para passar uma linha na tela. Esta linha vai 
fechar a tabela.
•	 Linha	 44: printf que informa que o usuário deve teclar enter 
para sair.
•	 Linha	 45: getche() que evita que a tela de execução feche 
antes de vermos os resultados.
•	 Linha	46: fecha chaves do programa principal.
A figura 2.8 apresenta a tela de execução do programa 2.1, na 
fase do cadastramento dos alunos.
53
Programação 2
Figura 2.8: Tela de execução do programa completo 2.1 - Cadastro
A figura 2.9 apresenta a tela de execução do programa 2.1, na 
fase do apresentação dos dados de todos os alunos cadastrados, em 
forma de tabela. 
Figura 2.9: Tela de execução do programa completo 2.1 – Relatório Geral
Viram como esta questão é cheia de detalhes? Mas não se 
assustem, a explicação precisava ser minuciosa, para que cada linha 
do programa fosse entendida. Agora precisamos treinar esse tipo de 
questão. Não percam tempo!
Atividades e Orientações de Estudos
Vamos resolver mais uma lista de exercícios? Esta lista é composta 
por questões em que se faz necessário o uso de vetor de registro. 
DICA: sempre coloque as tabelas com os mesmos cabeçalhos 
propostos nos enunciados (exemplos de telas). Mãos a obra!
1.Uma empresa de turismo deseja um programa que calcule o 
valor das viagens dos clientes. Serão informados os seguintes 
54
Programação 2
dados: código do cliente, nome, roteiro desejado(1-Brasil, 
2-EUA, 3-África), tipo de quarto (1-Standard, 2-Luxo), Se deseja 
alugar carro(1-sim/0-nao) e a quantidade de dias. A quantidade 
de clientes é desconhecida. O programa irá calcular o total da 
viagem usando os valores da tabela abaixo, que variam de 
acordo com o roteiro escolhido. A diária do quarto de luxo é 
R$30 mais cara que o valor da diária em um quarto standard. 
Exemplo: Se a pessoa escolher roteiro 2, em quarto de luxo, a 
diária irá custar: 320 + 30 = R$ 350.
Roteiro Diária – Hotel 
Quarto Standard
Diária - Aluguel 
de carro
1 R$ 170 R$ 50
2 R$ 350 R$ 60
3 R$ 370 R$ 75
Total da Viagem: 
dias*diáriahotel + dias*diariacarro(se o cliente for alugar carro)
 Armazenar os dados em um vetor de registro. Imprimir os dados 
em forma de tabela. Exemplo das telas:
Viagem Legal – Turismo
Cadastro de Cliente
Codigo: 
Nome: 
Roteiro (1-Brasil, 2-EUA, 3-África): 
Tipo de Quarto (1- Standard, 2-Luxo): 
Alugar Carro (1-sim/0-nao)? 
Quantidade de Dias: 
Inserir outro (1-sim,0-nao)?
Viagem Legal – Turismo
Relatório Geral
Código Nome Roteiro Quarto Carro Dias Total
xx xxxxx x x x xx xx.xx
xx xxxxx x x x xx xx.xx
xx xxxxx x x x xx xx.xx
Tecle enter para sair...
55
Programação 2
2. Faça um programa para montar a folha de pagamento dos 
empregados de uma empresa. Para cada empregado serão 
lidos os seguintes dados: matricula, nome, cargo(1-Analista 
de Sistemas/2- programador), sexo(1-mas/2-fem), anos de 
experiência e quantidade de filhos. O programa irá calcular 
para cada empregado o seu salário. Sabe-se que:
Cargo Salário Base
1 R$ 2500
2 R$ 1700
 O salário será calculado da seguinte forma: Cada cargo tem 
o salário base. Além do salário base, o empregado recebe os 
seguintes adicionais: R$ 50, para cada ano de experiência e R$ 
40 por cada filho. Portanto, um analista de sistemas com três 
anos de experiência e dois filhos terá o salário = 2500 + 50*3 + 
40*2 = R$ 2730.
 Armazenar as informações em um vetor de registros. Imprimir 
o relatório geral em forma de tabela contendo os dados de 
cada empregado. A quantidade de empregados da empresa é 
desconhecida (declarar o vetor com capacidade de armazenar 
20 funcionários). Exemplos das telas:
Empresa Legal
Cadastro de Funcionario
Matricula: 
Nome: 
Cargo(1-Analista de Sistemas, 2- programador): 
Sexo(1-mas/2-fem): 
Anos de experiência: 
Quantidade de filhos:
Cadastrar outro (1-sim/2-nao)?
56
Programação 2
Empresa Legal
Listagem Geral
Matricula Nome Cargo Sexo Anos Q. Filho Salário
xx xxxxx x x xx x xxx.xx
xx xxxxx x x xx x xxx.xx
xx xxxxx x x xx x xxx.xx
xx xxxxx x x xx x xxx.xx
Tecle enter para sair...
3. Faça um programa para uma empresa de celular contendo as 
seguintes operações: cadastro de clientes e listagem geral. 
Para cada cliente devemos armazenar: código, nome, sexo 
(1-feminimo/2-masculino), quantidade de ligações, plano que 
o cliente está associado (1-Dia/2-Noite/3-Fixo/4-Empresarial) e 
Valor da conta. O programa irá calcular o valor da conta de cada 
cliente. Sabe-se que, cada plano tem uma tarifa diferenciada, 
segundo a tabela abaixo:
Plano Valor de 1 ligação
Dia 1.30
Noite 1.60
Fixo 1.25
Empresarial 1.10
Armazenar os dados em um vetor de registro. Após o cadastro dos 
clientes, apresentar a listagem com os dados de todos os clientes, em 
forma de tabela. A quantidade de clientes é desconhecida. Declare o 
vetor com capacidade de receber até 50 clientes.
Exemplos das telas:
57
Programação 2
Ligue Mais
Cadastro de Cliente
Código: 
Nome: 
Sexo(1-fem/2-mas): 
Quantidade de Ligações: 
Plano(1-Dia/2-Noite/3-Fixo/4-Empresarial):
Cadastrar outro (1-sim/0-nao)?
Ligue Mais
Listagem Geral
Codigo Nome Sexo Quant. Lig. Plano Total
xx xxxxx x xx x xxx.xx
xx xxxxx x xx x xxx.xx
xx xxxxx x xx x xxx.xx
xx xxxxx x xx x xxx.xx
Tecle enter para sair...
4. Um professor quer um programa para o cálculo da média dos 
alunos de uma turma. Serão informadas a matrícula, nome (20 
caracteres), e as três notas dos alunos. O professor descarta 
a menor nota do aluno e a media é calculada com as duas 
maiores notas. Calcular a média e apresentar os resultados em 
forma de tabela, após o cadastramento. Armazenar os dados em 
um vetor de registro. A quantidade de alunos é desconhecida, 
declare o vetor com capacidade de receber até 20 alunos.
Exemplos das Telas:
Universidade Legal
Cadastro de aluno
Matricula: 
Nome: 
Nota 1: 
Nota 2: 
Nota 3:
Cadastraroutro (1-sim/0-nao)? 
58
Programação 2
Universidade Legal
Relatório Geral
Matricula Nota1 Nota2 Nota3 Media
x xxxxxxxxx x.x x.x x.x x.x
x xxxxxxxxx x.x x.x x.x x.x
x xxxxxxxxx x.x x.x x.x x.x
x xxxxxxxxx x.x x.x x.x x.x
Tecle enter para sair...
5. O MEC quer um programa para fazer um relatório sobre os 
pólos de educação a distância da UFRPE. Para cada pólo são 
informados os seguintes dados: código do pólo, cidade, total 
de alunos, total de tutores, se possui laboratório de informática 
(1-sim/0-não) e se possui laboratório de ciências (1-sim/0-não). 
O MEC quer saber quanto deve ser liberado de verba para cada 
pólo. O calculo será feito da seguinte forma:
• Por cada aluno são liberados: R$ 100
• Por cada tutor são liberados: R$ 500
• Se o pólo tem não tem laboratório de informática são liberados: 
R$ 20.000
• Se o pólo não tem laboratório de ciências são liberados: R$ 
17.000
Ex: um pólo com 150 alunos, com 15 tutores, que tem laboratório 
de informática, mas não tem laboratório de ciências: Verba = 100 x 
150 + 500 x 15 + 17000 = 15000 + 7500 + 17000 = 39500.
Armazenar os dados dos pólos em um vetor de registro. A 
quantidade de pólos é desconhecida. Declarar o vetor com a 
capacidade de armazenar até 20 pólos. Após o cadastros dos pólos, 
apresentar todos os dados dos pólos em forma de tabela.
Exemplos das telas:
59
Programação 2
Ministério da Educação 
Cadastro de Polo
Codigo: 
Cidade: 
Quantidade de alunos: 
Quantidade de tutores: 
Tem lab. de informatica (1-sim/0-nao)? 
Tem lab. de ciencias (1-sim/0-nao)?
Cadastrar outro pólo (1-sim,0-nao)?
Ministério da Educação
Listagem Geral
Codigo Cidade Alunos Tutores LI LC Verba Liberada
xx xxxxx xxx xxx x x xxxxx.xx
xx xxxxx xxx xxx x x xxxxx.xx
xx xxxxx xxx xxx x x xxxxx.xx
xx xxxxx xxx xxx x x xxxxx.xx
Tecle enter para sair...
Conheça Mais
Vocês poderão aprender mais sobre registros e vetores de registros 
lendo os livros:
 MONTGOMERY, Eduard. Programando em C: Simples e 
Prático. São Paulo: Alta Books, 2006.
 SCHILDT, Herbert. C Completo e Total. São Paulo: Makron, 
1996. 
Vamos Revisar?
Nesta seção iremos revisar os principais tópicos vistos neste 
60
Programação 2
capítulo. Vale a pena dar uma lida para verificar como está o nosso 
aprendizado. Observem o resumo a seguir:
Os registros são um agrupamento de variáveis de tipos diferentes, 
mas que tem uma relação lógica.
Por ser formado por elementos de diferentes tipos, os registros são 
chamados de estruturas de dados heterogêneas.
Para declarar uma variável registro, precisamos definir um novo 
tipo de dado para o programa, utilizando o typedef.
Cada elemento do registro é chamado de campo.
Unindo os conceitos de vetores e de registros, temos os vetores 
de registro que facilitam a declaração e o manuseio de grandes 
volumes de dados.
61
Programação 2
Capítulo 3 – Armazenamento de 
Dados em Arquivos
Vamos conversar sobre o assunto?
Neste capítulo, vamos aprender a armazenar nossos dados de 
forma definitiva. Até então, ao terminar a execução