Algoritmos e Introducao a Programacao

Prévia do material em texto

Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
1 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Algoritmos e Introdução à Programação 
 
Linguagem C
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
2 
 
 
 
Índice 
 
 
 
1. Algoritmos ...................................................................................................... 4 
1.1. Introdução................................................................................................ 4 
1.2. Representação de algoritmos .................................................................. 5 
1.2.1. Pseudocódigo.................................................................................... 5 
1.2.2. Diagrama de Fluxo de Dados............................................................ 6 
1.2.3. Diagrama de Chapin ......................................................................... 7 
1.3. Linguagens de Programação Interpretadas e Compiladas ...................... 7 
2. Linguagem C .................................................................................................. 9 
2.1. Histórico................................................................................................... 9 
2.2. Bibliotecas e Cabeçalhos....................................................................... 10 
2.3. Comentários .......................................................................................... 10 
2.4. Bloco de Instruções ............................................................................... 11 
3. Manipulação de Dados................................................................................. 11 
3.1. Constantes............................................................................................. 11 
3.2. Variáveis ................................................................................................ 12 
3.3. Tipos de Dados...................................................................................... 12 
4. Operadores .................................................................................................. 13 
4.1. Operadores Aritméticos ......................................................................... 13 
4.2. Operadores Aritméticos de Atribuição ................................................... 13 
4.3. Operadores Relacionais ........................................................................ 13 
4.4. Operadores Lógicos............................................................................... 14 
4.5. Operadores de Incremento/Decremento................................................ 14 
4.6. Precedência de Operadores .................................................................. 14 
4.7. Exercícios de Fixação............................................................................ 14 
5. Entrada/Saída .............................................................................................. 15 
5.1. Introdução.............................................................................................. 15 
5.2. Expressões de Controle......................................................................... 15 
5.3. Códigos de Formatação......................................................................... 16 
5.4. printf....................................................................................................... 16 
5.4.1. Exercícios de Fixação ..................................................................... 18 
5.5. scanf ...................................................................................................... 18 
5.5.1. Exercícios de Fixação ..................................................................... 19 
6. Algoritmo de Seleção ................................................................................... 21 
6.1. Introdução.............................................................................................. 21 
6.2. If – Else.................................................................................................. 21 
6.2.1. Exercícios de Fixação ..................................................................... 23 
6.3. Switch – Case........................................................................................ 24 
6.3.1. Exercícios de Fixação ..................................................................... 25 
7. Algoritmo de Repetição ................................................................................ 26 
7.1. Introdução.............................................................................................. 26 
7.2. While...................................................................................................... 26 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
3 
7.2.1. Exercícios de Fixação ..................................................................... 27 
7.3. For ......................................................................................................... 28 
7.3.1. Exercícios de Fixação ..................................................................... 29 
8. Vetores ......................................................................................................... 30 
8.1. Introdução.............................................................................................. 30 
8.2. Exercícios de Fixação............................................................................ 31 
9. Matrizes........................................................................................................ 32 
9.1. Introdução.............................................................................................. 32 
9.2. Exercícios de Fixação............................................................................ 33 
10. Strings ........................................................................................................ 35 
10.1. Introdução............................................................................................ 35 
10.2. Exercícios de Fixação.......................................................................... 35 
11. Registros ou Structs ................................................................................... 37 
11.1. Introdução............................................................................................ 37 
11.2. Exercícios de Fixação.......................................................................... 38 
12. Ponteiros .................................................................................................... 40 
12.1. Introdução............................................................................................ 40 
12.2. Exercícios de Fixação.......................................................................... 41 
13. Funções...................................................................................................... 42 
13.1. Introdução............................................................................................ 42 
13.2. Exercícios de Fixação.......................................................................... 43 
14. Arquivos ..................................................................................................... 44 
14.1. Introdução............................................................................................ 44 
14.2. Exercícios de Fixação.......................................................................... 46 
Bibliografia........................................................................................................48 
Manual de utilização do Dev-C++ .................................................................... 49 
Bibliotecas e Funções mais utilizadas.............................................................. 52 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
4 
Algoritmos e Introdução à Programação 
 
1. Algoritmos 
 
Um algoritmo é uma seqüência finita de instruções bem definidas e não 
ambíguas, cada uma das quais pode ser executada mecanicamente em um 
período de tempo finito e com uma quantidade de esforço finita. 
 
1.1. Introdução 
 
O conceito de algoritmo é freqüentemente ilustrado pelo exemplo de uma 
receita, embora muitos algoritmos sejam mais complexos. Eles podem repetir 
passos (fazer iterações) ou necessitar de decisões (tais como comparações ou 
lógica) até que a tarefa seja completada. Um algoritmo corretamente executado 
não irá resolver um problema se estiver implementado incorretamente ou se 
não for apropriado ao problema. 
Um algoritmo não representa, necessariamente, um programa de 
computador, e sim os passos necessários para realizar uma tarefa. Sua 
implementação pode ser feita por um computador, por outro tipo de autômato 
ou mesmo por um ser humano. Diferentes algoritmos podem realizar a mesma 
tarefa usando um conjunto diferenciado de instruções em mais ou menos 
tempo, espaço ou esforço do que outros. 
Tal diferença pode ser reflexo da complexidade computacional aplicada, 
que depende de estruturas de dados adequadas ao algoritmo. Por exemplo, 
um algoritmo para se vestir pode especificar que você vista primeiro as meias e 
os sapatos antes de vestir a calça enquanto outro algoritmo especifica que 
você deve primeiro vestir a calça e depois as meias e os sapatos. Fica claro 
que o primeiro algoritmo é mais difícil de executar que o segundo apesar de 
ambos levarem ao mesmo resultado. 
O conceito de um algoritmo foi formalizado em 1936 pela Máquina de 
Turing de Alan Turing e pelo cálculo lambda de Alonzo Church, que formaram 
as primeiras fundações da Ciência da computação. 
 
Não se aprende algoritmos: 
Copiando algoritmos 
Estudando algoritmos 
Só se aprende algoritmos: 
Construindo algoritmos 
Testando algoritmos 
 
Todo algoritmo deve ter as seguintes propriedades: 
Possui estado inicial 
Possui dados de entrada 
Possui uma seqüência lógica e finita de ações claras e precisas 
Produz dados de saída e estado final previsível 
Deve ser eficaz 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
5 
 
 
 
1.2. Representação de algoritmos 
 
Existem diversas formas de representação de algoritmos, mas não há um 
consenso com relação à melhor delas. O critério usado para classificar 
hierarquicamente estas formas está diretamente ligado ao nível de detalhe ou, 
inversamente, ao grau de abstração oferecido. 
Algumas formas de representação de algoritmos tratam os problemas 
apenas em nível lógico, abstraindo-se de detalhes de implementação muitas 
vezes relacionados com alguma linguagem de programação específica. Por 
outro lado existem formas de representação de algoritmos que possuem uma 
maior riqueza de detalhes e muitas vezes acabam por obscurecer as idéias 
principais do algoritmo, dificultando seu entendimento. 
Dentre as formas de representação de algoritmos mais conhecidas 
podemos citar: pseudocódigo, diagrama de fluxo de dados e diagrama de 
chapin. 
 
1.2.1. Pseudocódigo 
 
Pseudocódigo (ou português estruturado ou portugol) é uma forma genérica 
de escrever um algoritmo, utilizando uma linguagem simples (nativa a quem o 
escreve, de forma a ser entendida por qualquer pessoa) sem necessidade de 
conhecer a sintaxe de nenhuma linguagem de programação. É, como o nome 
indica, um pseudocódigo e, portanto, não pode ser executado num sistema real 
(computador) — de outra forma deixaria de ser pseudo. 
Os livros sobre a ciência de computação utilizam freqüentemente o 
pseudocódigo para ilustrar os seus exemplos, de forma que todos os 
programadores possam entendê-los (independentemente da linguagem que 
utilizem). 
 
SÍNTESE 
 Objetivo: analisar a idade de uma pessoa 
 Entrada: uma idade 
 Saída: situação da maturidade da pessoa 
 
DECLARAÇÕES 
 inteiro IDADE; 
INÍCIO 
 escreva (“Informe sua idade: “); 
 leia (IDADE); 
 se (IDADE < 21) então 
 escreva (“você é jovem”); 
 senão 
 escreva (“você é adulto”); 
 fim_se; 
FIM 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
6 
A linguagem de comunicação natural é imprecisa e muitas vezes prolixa, 
dificultando a comunicação correta com o computador se usada de forma bem 
natural. Por isso é necessária à agregação de regras e normas que permitam a 
representação organizada e eficiente da solução desejada, indicando sempre, 
com clareza e precisão, o que realmente o computador deve fazer. 
 
1.2.2. Diagrama de Fluxo de Dados 
 
O DFD ou Diagrama de Fluxos de Dados (ou Fluxograma ou diagrama de 
blocos) é uma ferramenta para a modelagem de sistemas. Ela fornece apenas 
uma visão do sistema, a visão estruturada das funções, ou seja, o fluxo dos 
dados. 
O DFD pode ter vários níveis de detalhamento de acordo com a 
necessidade do sistema. 
As principais figuras usadas na elaboração de um fluxograma estão 
relacionadas a seguir, sendo importante esclarecer que são várias as figuras 
geométricas empregadas na construção dos mesmos, porém neste estudo se 
estará buscando a compreensão da lógica racional proposta por este tipo de 
representação. As figuras usadas são: 
 
 
 
Imagine uma situação onde a idade de uma pessoa deva ser analisada para 
sua classificação em jovem ou adulto. O algoritmo a seguir é apresentado 
graficamente por meio do fluxograma coerente com a solução desejada. 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
7 
 
 
1.2.3. Diagrama de Chapin 
 
Elaborado por Nassi e Shneiderman e ampliada por Ned Chapin. Almejada 
a substituição da representação tradicional (diagrama de blocos) por uma 
diagramação com quadros que oferecessem a visão hierárquica e estruturada 
da lógica proposta para um programa. 
Entre os diversos métodos existentes para este tipo de representação, o 
Diagrama de Chapin é um dos menos utilizados atualmente, principalmente, 
porque exige bastante atenção do programador na representação do seu 
raciocínio, ao invés de se concentrar mais sobre o próprio problema a ser 
analisado e posteriormente solucionado. 
 
 
 
1.3. Linguagens de Programação Interpretadas e Compiladas 
 
Uma linguagem de programação pode ser convertida, ou traduzida, em 
código de máquina por compilação ou interpretação, que juntas podem ser 
chamadas de tradução. 
Se o método utilizado traduz todo o texto do programa (também chamado 
de código), para só depois executar (ou rodar, como se diz no jargão da 
computação) o programa, então se diz que o programa foi compilado e que o 
mecanismo utilizado para a tradução é um compilador (que por sua vez nada 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
8 
mais é do que um programa). A versão compilada do programa tipicamente é 
armazenada, de forma que o programa pode ser executado um número 
indefinido de vezes sem que seja necessária nova compilação,o que 
compensa o tempo gasto na compilação. Isso acontece com linguagens como 
Pascal e C (linguagem de programação). 
Se o texto do programa é traduzido na medida em que vai sendo 
executado, como em Javascript, Python, Perl ou PHP, num processo de 
tradução de trechos seguidos de sua execução imediata, então diz-se que o 
programa foi interpretado e que o mecanismo utilizado para a tradução é um 
interpretador. Programas interpretados são geralmente mais lentos do que os 
compilados, mas são também geralmente mais flexíveis, já que podem interagir 
com o ambiente mais facilmente (freqüentemente linguagens interpretadas são 
chamadas também de script). 
Embora haja essa distinção entre linguagens interpretadas e compiladas, as 
coisas nem sempre são tão simples. Há linguagens compiladas para um código 
de máquina de uma máquina virtual (sendo esta máquina virtual apenas mais 
um software, que emula a máquina virtual sendo executado em uma máquina 
real), como o Java e C#. 
E também há outras formas de interpretar em que os códigos-fontes, ao 
invés de serem interpretados linha-a-linha, têm blocos “compilados” para a 
memória, de acordo com as necessidades, o que aumenta a performance dos 
programas quando os mesmos módulos são chamados várias vezes, técnica 
esta conhecida como Just-in-Time. 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
9 
2. Linguagem C 
 
A linguagem C é classificada de alto nível pela própria definição desse tipo 
de linguagem. A programação em linguagens de alto nível tem como 
característica não ser necessário conhecer o processador, ao contrário das 
linguagens de baixo nível. 
 
2.1. Histórico 
 
A primeira versão de C foi criada por Dennis Ritchie em 1972 nos 
laboratórios Bell para ser incluído como um dos softwares a ser distribuídos 
juntamente com o sistema operacional Unix do computador PDP-11, na equipe 
certificada por Ken Thompson. 
Ao ponto de vista técnico, o surgimento do C iniciou com a linguagem 
ALGOL 60, definida em 1960. ALGOL era uma linguagem de alto nível, que 
permitia ao programador trabalhar "longe da máquina", sem se preocupar com 
os aspectos de como cada comando ou dado era armazenado ou processado. 
Foi criado para substituir o FORTRAN. ALGOL não teve sucesso, talvez por 
tentar ser de muito alto nível em uma época em que a maioria dos sistemas 
operacionais exigiam do usuário um grande conhecimento de hardware. 
Em 1967 surgiu CPL (Combined Programming Language) nas 
universidades de Londres e Cambridge com o objetivo, segundo a equipe do 
projeto, de "trazer ALGOL à terra", ou "manter contato com a realidade de um 
computador real". Da mesma forma de ALGOL, CPL não foi bem aceita, em 
especial pelos projetistas de sistemas operacionais que a consideravam difícil 
de implementar. 
Ainda em 1967, em Cambridge, Martin Richards criou o BCPL (Basic CPL), 
uma simplificação do CPL, tentando manter apenas as "boas coisas do CPL". 
Em 1970, Ken Thompson, chefe da equipe que projetou o UNIX para o 
PDP11 do Bell Labs, implementou um compilador para uma versão mais 
reduzida do CPL. Batizou a linguagem de B. 
Tanto BCPL quanto B mostravam-se muito limitadas, prestando-se apenas 
para certas classes de problemas. Isto se fez sentir especialmente na primeira 
versão do PDP11, lançado no mercado em 1971. Um dos fatores que levou à 
isto foi a intenção do grupo responsável pelo UNIX de reescrevê-lo todo em 
uma linguagem de alto nível, e para isto B era considerado lenta. 
Estes problemas levaram a que o projetista Dennis Ritchie, do Bell Labs, 
fosse encarregado de projetar uma nova linguagem, sucessora do B, que viria 
então, a ser chamada de C. 
A linguagem C buscou manter o “contato com o computador real” e ainda 
sim dar ao programador novas condições para o desenvolvimento de 
programas em áreas diversas, como comercial, científica e de engenharia. 
Por muitos anos (aproximadamente 10) a sintaxe (formato) tida como 
padrão da linguagem C foi aquela fornecida com o UNIX versão 5.0 do Bell 
Labs. A principal documentação deste padrão encontra-se na publicação “The 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
10
C Programming Language”, de Brian Kernighan e Dennis Ritchie (K&R), a 
“bíblia da linguagem C”. 
O mais interessante desta versão de C era que os programas-fonte criados 
para rodar em um tipo de computador podiam ser transportados e 
recompilados em outros sem grandes problemas. A esta característica dá-se o 
nome de portabilidade. Com ela, uma empresa que desenvolve um programa 
pode fazê-lo rodar em diferentes computadores sem ter um elevado custo a 
cada vez que isto for feito. 
Em 1985, ANSI (American National Standards Institute) estabeleceu um 
padrão oficial de C o chamado “C ANSI”. 
 
2.2. Bibliotecas e Cabeçalhos 
 
Na linguagem C, arquivos de cabeçalho (header files) é uma característica 
de certas linguagens que permite aos programadores separar certos elementos 
de códigos-fonte de programas em arquivos reusáveis. 
As bibliotecas e cabeçalhos são incluídos no código-fonte através de 
diretiva de pré-processamento #include. 
Abaixo, listamos os cabeçalhos mais utilizados na linguagem C: 
 
stdio.h Manipulação de entrada/saída 
conio.h Manipulação de caracteres na tela 
string.h Tratamento de cadeia de caracteres 
math.h Funções matemáticas comuns em computação 
stdlib.h Funções de alocação de memória, conversões, etc 
 
2.3. Comentários 
 
Comentário é uma maneira simples e bastante útil em programação que 
serve para explicar um trecho de código-fonte para uma futura referência ou 
mesmo para que outro membro da equipe de programação entenda o que foi 
desenvolvido. 
Na linguagem C, comentários têm o seguinte formato: 
 
/* 
explicação ... 
*/ 
 
Tudo que se encontrar entre /* e */ não será lido pelo compilador. Em C++, 
que é uma linguagem posterior ao C que inclui orientação a objetos, 
comentários também podem ser representados por // antes da explicação, 
como: 
 
// explicação ... 
 
Se estivermos utilizando para desenvolver em C um compilador de C++, 
ambos os tipos de comentários irão funcionar. 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
11
2.4. Bloco de Instruções 
 
Os programas em C sempre seguirão o modelo descrito abaixo, incluindo 
comentários, bibliotecas, função principal e a função getch. 
 
/* Programa 1 */ comentário 
#include <stdio.h> biblioteca 
#include <conio.h> biblioteca 
main( ) função principal 
{ inicio 
 . 
 . 
 <corpo do programa> 
 . 
 . 
getch(); função que espera entrada por 
teclado 
} fim 
 
Usaremos o compilador Dev-C++, que compila tanto códigos-fonte em C 
quanto em C++, portanto necessita das bibliotecas deste modelo para compilar. 
 
3. Manipulação de Dados 
 
Qualquer programa tem que fazer alguma coisa (nem que seja enviar um 
sinal bip) senão não é um programa, ou seja, ele tem que apresentar conteúdo. 
Assim, como apresenta conteúdo, vai “alterar” estados dentro do computador, 
sendo que, o estado de uma das peças que vai inevitavelmente se alterar é a 
memória interna. 
É inevitável um programa utilizar a memória do computador, assim, o 
programa precisa de um espaço físico na memória e para isso terá que o 
requisitar. 
Já realizamos abstrações desse tipo na matemática, pois uma variável é 
uma expressão que varia e normalmente é representado por uma incógnita X, 
e uma constante é uma expressão que não se altera (o número de Avogrado, o 
Pi, o número de Neper)que pode ser representado por uma letra. Veremos a 
seguir, que constantes e variáveis se comportam igualmente na computação. 
 
3.1. Constantes 
 
São valores que não se alteram ao longo do programa. Uma constante 
pode aparecer sob forma de um valor explícito (constante literal) ou um nome 
simbólico que representa um determinado valor ao longo do programa 
(constante simbólica). 
 
Exemplo: 
 
PI = 3.1416; 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
12
 
3.2. Variáveis 
 
Uma variável identifica um espaço na memória do computador, reservado 
para armazenar valores de um determinado tipo. Este espaço de memória 
guarda informações que podem ser alteradas no curso da execução do 
programa. 
 
Exemplo: 
 
a = 3; 
a = a + 2; 
 
3.3. Tipos de Dados 
 
Os tipos de dados mais usuais em C são: 
 
� char: Caracter: O valor armazenado é um caractere. Caracateres 
geralmente são armazenados em códigos (usualmente o código ASCII). 
� int: Número inteiro é o tipo padrão e o tamanho do conjunto que pode 
ser representado normalmente depende da máquina em que o programa 
está rodando. 
� float: Número em ponto flutuante de precisão simples. São conhecidos 
normalmente como números reais. 
 
Porém, existem vários tipos de dados suportados pelo padrão ANSI C, que 
são: 
 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
13
4. Operadores 
 
Operadores são símbolos matemáticos e lógicos que servem para a 
realização de operações aritméticas, lógicas e relacionais. 
 
4.1. Operadores Aritméticos 
 
Os operadores aritméticos são usados para calcular expressões 
matemáticas. Os operadores aritméticos seguem abaixo: 
 
Significado Símbolo 
Atribuição = 
Soma + 
Subtração - 
Multiplicação * 
Divisão / 
Resto % 
 
4.2. Operadores Aritméticos de Atribuição 
 
São combinações de operadores que simplificam as instruções e que 
geralmente são usados por programadores experientes. Dessa forma uma 
instrução escrita da forma: 
 
Normal Reduzida 
var = var + expr; var += expr; 
var = var – expr; var -= expr; 
var = var * expr; var *= expr; 
var = var / expr; var /= expr; 
 
4.3. Operadores Relacionais 
 
Esses operadores são responsáveis pelas comparações de expressões nos 
programas. Os operadores relacionais seguem abaixo: 
 
Significado Símbolo 
Maior > 
Maior ou igual >= 
Menor < 
Menor ou igual <= 
Igualdade == 
Diferença != 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
14
4.4. Operadores Lógicos 
 
Os operados lógicos servem para interligar mais de uma operação 
relacional. Os operadores lógicos seguem abaixo: 
 
Significado Símbolo 
E && 
OU || 
Não ! 
 
4.5. Operadores de Incremento/Decremento 
 
O operador de incremento (++) soma 1 ao seu operando enquanto que o de 
decremento (--) subtrai um. Eles podem ser pré-fixados ou pós-fixados 
conforme mostra a tabela abaixo: 
 
Operador Instrução Pós-fixado Pré-fixado 
++ var = var + 1; var = var++; 
ou 
var++; 
var = ++var; 
ou 
++var; 
-- var = var – 1; var = var--; 
ou 
var--; 
var = --var; 
ou 
--var; 
 
4.6. Precedência de Operadores 
 
Para evitar ordem errada em um cálculo, utilizamos a precedência de 
operadores, com a seguinte ordem: 
 
1º parênteses e funções 
2º potência e resto 
3º multiplicação e divisão 
4º adição e subtração 
5º operadores relacionais 
6º operadores lógicos 
 
4.7. Exercícios de Fixação 
 
Diga o resultado das expressões abaixo: 
 
a) x = 5 * 4 / 6 + 7 
b) x = 5 * 4 % 6 + 7 
c) x = ((4 / 2) + (3 * 5)) 
d) x = (3 + 2 * (4 + (2+4))) % 2 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
15
5. Entrada/Saída 
 
Entrada/saída (sigla I/O (em inglês)) é um termo utilizado quase que 
exclusivamente no ramo da computação (ou informática), indicando entrada 
(inserção) de dados por meio de algum código ou programa, para algum outro 
programa ou hardware, bem como a sua saída (obtenção de dados) ou retorno 
de dados, como resultado de alguma operação de algum programa, 
consequentemente resultado de alguma entrada. 
São exemplos de unidades de entrada de um computador: disco rígido, 
microfone, teclado, mouse, tela sensível ao toque, Scanner, Leitor de código de 
barras, Celular, Pendrive, Máquina fotográfica digital, Webcam, joystick e 
outros acessórios de jogos. 
São exemplos de unidades de saída de um computador: monitor, caixas de 
som, impressora, disco rígido. 
Algumas unidades são de entrada e saída de dados ou também chamados 
Dispositivos Híbridos: disco rígido, disco flexível ou disquete, monitor sensível a 
toques, joystick vibratório. 
As interfaces de entrada e saída são responsáveis pela conexão entre as 
várias partes de um sistema computacional baseado na arquitetura de Von-
Neumann. Esta interface é responsável por conectar fisicamente o processador 
e a memória do sistema ao barramento, tornando-se o terceiro elemento do 
sistema computacional proposto. 
Ao contrário do que se pode pensar a interface de entrada e saída não é só 
o conector físico e sim também o responsável pela comunicação lógica entre o 
barramento e o dispositivo. Essa função de conexão foi basicamente 
desenvolvida para que seja possível a comunicação entre vários dispositivos, 
fazendo com que a velocidade do barramento seja mais bem aproveitada e 
ainda tanto os periféricos quanto os elementos essenciais tenham 
programação/produção mais voltada ao seu desempenho, deixando a 
interconexão com as interfaces de entrada e saída. 
 
5.1. Introdução 
 
Entrada/Saída na linguagem C é realizada através de muitas funções da 
linguagem, porém as mais simples veremos agora, que são o printf e o scanf. 
 
5.2. Expressões de Controle 
 
As expressões de controle contêm tanto caracteres para serem impressos 
na tela como códigos de formato que especificam como apresentar o restante 
dos argumentos. São utilizados para entrada de dados junto ao scanf e saída 
de dados junto ao printf. 
 
Código Significado 
%c Exibe um caractere 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
16
%d Exibe um inteiro em formato decimal 
%i Exibe um inteiro 
%e Exibe um número em notação científica (com e minúsculo) 
%E Exibe um número em notação científica (com E maiúsculo) 
%f Exibe um ponto flutuante em formato decimal 
%g Usa %e ou %f, o que for menor 
%G O mesmo que %g, só que um E maiúsculo é usado se o formato %e 
for escolhido 
%o Exibe um número em notação octal 
%s Exibe uma string 
%u Exibe um decimal sem sinal 
%x Exibe um número em hexadecimal com letras minúsculas 
%X Exibe um número em hexadecimal com letras maiúsculas 
%% Exibe um sinal de % 
%p Exibe um ponteiro 
 
5.3. Códigos de Formatação 
 
Os códigos de formatação servem para exibir formatos na exibição dos 
caracteres na tela. São eles: 
 
Código Significado 
\n Nova linha 
\t Tabulação 
\b Retrocesso 
\” Aspas 
\\ Barra 
\f Salta formulário 
\0 Nulo 
 
5.4. printf 
 
A função printf é parte de um conjunto de funções pré-definidas 
armazenadas em uma biblioteca padrão de rotinas da linguagem C stdio.h. 
Ela permite apresentar na tela os valores de qualquer tipo de dado. Para tanto, 
printf utiliza o mecanismo de formatação, que permite traduzir a representaçãointerna de variáveis para a representação ASCII que pode ser apresentada na 
tela. 
O primeiro argumento de printf é um string de controle, uma seqüência de 
caracteres entre aspas. Esta string, que sempre deve estar presente, pode 
especificar através de caracteres especiais (as seqüências de conversão) 
quantos outros argumentos estarão presentes nesta invocação da função. 
Estes outros argumentos serão variáveis cujos valores serão formatados e 
apresentados na tela. Por exemplo, se o valor de uma variável inteira x é 12, 
então a execução da função: 
 
 printf("Valor de x = %d", x); 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
17
 
Imprime na tela a frase Valor de x = 12. Se y é uma variável do tipo caráter 
com valor 'A', então a execução de: 
 
 printf("x = %d e y = %c\n", x, y); 
 
Imprime na tela a frase x = 12 e y = A seguida pelo caráter de nova linha 
(\n), ou seja, a próxima saída para a tela aconteceria na linha seguinte. 
Observe que a seqüência de conversão pode ocorrer dentro de qualquer 
posição dentro da string de controle. 
A função printf não tem um número fixo de argumentos. Em sua forma mais 
simples, pelo menos um argumento deve estar presente, a string de controle. 
Uma string de controle sem nenhuma seqüência de conversão será 
literalmente impressa na tela. Com variáveis adicionais, a única forma de saber 
qual o número de variáveis que será apresentado é por inspeção da string de 
controle. Desta forma, cuidado deve ser tomado para que o número de 
variáveis após a string de controle esteja de acordo com o número de 
seqüências de conversão presente na string de controle. 
Além de ter o número correto de argumentos e seqüências de conversão, o 
tipo de cada variável deve estar de acordo com a seqüência de conversão 
especificada na string de controle. A seqüência de conversão pode ser 
reconhecida dentro da string de controle por iniciar sempre com o caráter %. 
O primeiro programa que geralmente é desenvolvido por alunos de 
programação é o chamado “Olá Mundo!” ou “Hello World!”. Segue abaixo: 
 
/* Programa Ola_Mundo */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
printf(“\n Ola Mundo!”); 
getch(); 
} 
 
Podemos ver nesse exemplo que, utilizamos apenas uma função de escrita 
para exibir uma frase na tela. 
Outro exemplo mais completo que trata da soma entre duas constantes 
pode ser visto abaixo: 
 
/* Programa Soma_A_B */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int a; 
int b; 
int c; 
a = 2; 
b = 3; 
c = a + b; 
printf(“\n A soma e: %d”, c); 
getch(); 
} 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
18
 
5.4.1. Exercícios de Fixação 
 
1. Faça um algoritmo tendo 2 valores (a = 4, b = 2) e mostre as quatro 
operações matemáticas básicas entre estes 2 números. 
2. Faça um algoritmo que calcule a área de um triângulo, sabendo-se que 
base e altura são: b = 6, h = 3. (bxh)/2 
3. Faça um algoritmo que através de quatro notas (n1 = 50, n2 = 70, n3 = 
60, n4 = 80) calcule as médias aritmética, harmônica e geométrica. 
 
 
5. Faça um algoritmo que imprima como resposta o sucessor e o 
antecessor do número 9, utilizando o número 9 em uma variável. 
6. Faça um algoritmo que imprima nome, endereço e telefone (Ana, 
Andradas, 99991111). 
5.5. scanf 
 
Para ler um item deve-se passar uma string que representa o formato da 
entrada e os endereços das variáveis de destino. Essa string do formato pode 
possuir caracteres normais que se espera na entrada e combinações especiais 
usando o caractere % para representar os valores a serem lidos. 
Na sintaxe: 
 
scanf(“%d”, &a); 
 
Notamos que o valor a ser lido é um valor inteiro devido ao %d dentro das 
aspas, e esse valor será atribuído à variável a. O & (e comercial) indica que o 
valor digitado será enviado para o endereço de memória da variável a. 
Um exemplo completo da soma entre duas variáveis lidas através do scanf 
pode ser visto abaixo: 
 
/* Programa Ler_A_B_Somar */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int a; 
int b; 
int c; 
scanf(“%d”, &a); 
scanf(“%d”, &b); 
c = a + b; 
printf(“\n A soma e: %d”, c); 
4
4321 nnnn
ma
+++
=
4
1
3
1
2
1
1
1
1
nnnn
mh
+++
=
100
404303202101 XnXnxnxn
mg +++=
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
19
getch(); 
} 
 
Em outro exemplo, scanf("%c%d", &l, &i) lê um caractere (%c) seguido de 
um número (%d) e guarda nas variáveis l e i, que devem ser dos tipos char e 
int, respectivamente. 
As expressões dos dados são sempre um % seguido de uma letra que 
indica o tipo a ser lido. Entre esses dois pode haver um número que indica o 
máximo de caracteres a serem usados para montar o valor a ser lido. 
Dessa forma scanf("%3s%4d", s, &i) lê uma string (%s) de no máximo 3 
caracteres e um número com no máximo 4 dígitos (incluindo o sinal) e guarda 
em s e i, respectivamente. 
 
5.5.1. Exercícios de Fixação 
 
1. Mostra na tela o produto entre 28 e 43. 
2. Mostra a média aritmética entre 3 números passados pelo usuário. 
3. Lê um número e mostra seu sucessor e seu antecessor na tela. 
4. Lê dois números e mostra a soma. Ante do resultado, deverá aparecer a 
mensagem: SOMA. 
5. Lê um número e mostra a terça parte deste número. 
6. Lê dois números e mostre os seguintes resultados: 
a. Dividendo: 
b. Divisor: 
c. Quociente: 
 d. Resto: 
7. Leia 4 números e mostre a média ponderada, sabendo-se que os pesos 
são respectivamente: 1, 2, 3 e 4. 
8. Lê o saldo de uma aplicação e imprime o novo saldo, considerado o 
reajuste de 7%. 
9. Entre com a base e a altura de um retângulo e mostre os resultados: 
 a. Perímetro (Perímetro é igual à soma dos 4 lados) 
 b. Área (Área é igual a lado vezes lado) 
10. Lê o raio de um círculo e mostre como saída o perímetro (2*π*Raio) e a 
área (π*Raio2). 
11. Calcule e mostre a área de um triângulo (área é igual a: (base x altura) 
dividido por 2) 
12. Calcule o valor de uma prestação em atraso, utilizando a fórmula: 
PRESTAÇÃO = VALOR + (VALOR * (TAXA/100) * TEMPO). 
13. Leia o numerador e o denominador de uma fração e transforme-o em 
um número decimal. 
14. Lê um valor de hora e informa quantos minutos se passaram desde o 
início do dia. 
15. Faça um programa que leia a idade de uma pessoa expressa em anos, 
meses e dias e mostre-a expressa apenas em dias. 
16. Faça um programa que leia dois valores nas variáveis A e B 
respectivamente, troque o valor contido na variável A pelo valor em B, e o valor 
em B pelo valor em A, isto é, imprimiremos A e B com os valores trocados. 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
20
17. Faça um programa que leia A, B e C e calcule a seguinte fórmula: 
(7*C+5*B) / (2*A*3), armazenando-a na variável Result. 
18. Faça um programa que leia a idade de uma pessoa expressa em dias e 
mostre-a expressa em anos, meses e dias. 
19. Faça um programa que leia o número do funcionário, o número de horas 
trabalhadas mensais, o valor que recebe por hora e o número de filhos com 
idade menor de 14 anos. Calcular e escrever o salário deste funcionário, sendo 
que cada filho menor de 14 anos acrescenta 10% do salário. 
20. O custo ao consumidor de um carro novo é a soma do custo de fábrica 
com a percentagem do distribuidor e dos impostos (aplicados ao custo de 
fábrica). Supondo que a percentagem do distribuidorseja de 28% e os 
impostos de 45%, escreva um programa em C que leia o custo de fábrica de 
um carro e escreva o custo ao consumidor. 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
21
6. Algoritmo de Seleção 
 
Um algoritmo no qual a execução de determinados passos está 
subordinada à veracidade de uma condição é denominado de algoritmo de 
seleção. 
 
6.1. Introdução 
 
Uma seleção permite a escolha de uma ou de um conjunto de instruções 
(bloco) a ser executado quando determinadas condições, representada por 
expressões lógicas ou relacionais, são ou não satisfeitas. Os algoritmos de 
seleção também são conhecidos como algoritmos condicionais, devido aos 
desvios condicionais em seu código-fonte. 
Em algoritmos necessitamos de ações diferentes dependendo da avaliação 
de certas condições. O uso de condições ou comandos de decisão permite a 
alteração do fluxo de execução das instruções de um algoritmo. Com isso, 
diferentes instruções serão executadas de acordo com a entrada fornecida ao 
algoritmo. Na linguagem C, os comandos de seleção mais utilizados são: if – 
else (se – então) e o switch – case (caso – escolha). 
 
6.2. If – Else 
 
A estrutura If – Else (Se – Senão) permite vários tipos de condição. 
Veremos cada uma delas. 
A primeira estrutura, consiste em apenas o comando If. Essa estrutura é 
utilizada quando não precisamos escrever na tela uma resposta falsa. 
Podemos ver essa estrutura no exemplo abaixo: 
 
/* Programa seleção_if */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int a; 
a = 10; 
if (a >= 10) 
 { 
 printf(“\n Maior”); 
 } 
getch(); 
} 
Neste programa, a seleção com o comando if verifica se a variável a é 
maior ou igual ao valor 10. Como o valor de a é igual a 10, torna a resposta 
verdadeira, portanto o printf é executado escrevendo na tela a palavra ‘Maior’. 
Quando existe apenas uma linha após o if, não precisamos abrir e fechar o 
bloco condicional utilizando { e }, porém como usamos a função getch() no final 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
22
do programa, temos que abrir e fechar o bloco condicional pois poderia ser 
entendido como parte integrante da condição. 
Quando necessitamos exibir tanto uma resposta verdadeira quanto uma 
resposta falsa, usamos o exemplo abaixo utilizando if -else: 
 
/* Programa if_else */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int a; 
a = 10; 
if(a > 10) 
 { 
 printf(“Maior”); 
 } 
else 
 { 
 printf(“Menor ou igual”); 
 } 
getch(); 
} 
 
Neste caso, o programa escreve na tela o teste com a resposta falsa pois 
recai na parte da condição do ‘senão’ (else). Lendo em português, a pergunta 
da condição seria: ‘Se a é maior que 10 então escreva a palavra ‘Maior’, senão 
(se a não for maior que 10) escreva as palavras ‘Menor ou igual’’. 
Em um terceiro caso, a estrutura if – else possibilita condições aninhadas, 
que são condições dentro de condições. Podemos ver no exemplo abaixo: 
 
/* Programa if_else_aninhado */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int a; 
a = 7; 
if(a <= 4) 
 { 
 printf(“Reprovado”); 
 } 
else 
if((a > 4) && (a < 7)) 
 { 
 printf(“Recuperação”); 
 } 
else 
 { 
 printf(“Aprovado”); 
 } 
getch(); 
} 
 
Como a variável a contém o valor 7, o programa mostra escrito na tela 
‘Aprovado’, pois a primeira condição é para valores abaixo ou igual a 4, a 
segunda condição é para valores maiores que 4 e ao mesmo tempo menores 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
23
que 7, e a terceira condição (apenas o senão, pois não precisa ter uma 
condição a mais) para valores que não se encaixam nas condições anteriores, 
ou seja, igual ou maior que 7. 
 
6.2.1. Exercícios de Fixação 
 
1. Escrever um algoritmo para ler dois valores numéricos e apresentar a 
diferença do maior pelo menor. 
2. Faça um algoritmo que leia um número e mostre uma mensagem 
indicando se este número é par ou ímpar e se é positivo ou negativo. 
3. Escrever um algoritmo para ler dois números. Se os números forem 
iguais imprimir a mensagem: “Números iguais” e encerrar a execução; caso 
contrário, imprimir o de maior valor, acompanhando pela mensagem “é maior 
número”. 
4. Escrever um algoritmo para ler e imprimir três números: 
- Se o primeiro for positivo, imprimir sua raiz quadrada, caso contrário, 
imprimir o seu quadrado; 
- Se o segundo número for maior que 10 e menor que 100, imprimir a 
mensagem: “Número está entre 10 e 100 – intervalo permitido”; 
- Se o terceiro número for menor que o segundo, calcular e imprimir a 
diferença entre eles, caso contrário, imprimir o terceiro número adicionado de 
1. 
5. Tendo como dados de entrada a altura e o sexo de uma pessoa, construa 
um algoritmo para calcular seu peso ideal, utilizando as seguintes fórmulas: 
- para homens: 72,7 * altura – 58 
- para mulheres: 62,1 * altura – 44,7 
6. Elabore um algoritmo que, dada a idade de um nadador, classifique-o em 
uma das seguintes categorias: 
- Infantil A: 5 a 7 anos; 
- Infantil B: 8 a 10 · anos; 
- Juvenil A: 11 a 13 anos; 
- Juvenil B: 14 a 17 anos; 
- Sênior: maiores de 18 anos. 
7. Faça um algoritmo que leia duas notas obtidas por um aluno na disciplina 
de Cálculo I, o número de aulas ministradas e o número de aulas assistidas por 
este aluno nesta disciplina. Calcule e mostre a média final deste aluno e diga 
se ele foi aprovado ou reprovado. Considere que para um aluno ser aprovado 
ele deve obter média final igual ou maior a 6.0 e ter no mínimo 75% de 
freqüência. 
8. Leia 3 valores inteiros (X, Y, Z), determina e escreve o menor deles. 
9. Desenvolva um algoritmo que efetue a leitura de três valores para os 
lados de um triângulo, considerando lados como: A, B e C. O algoritmo deverá 
verificar se os lados fornecidos formam realmente um triângulo (cada lado é 
menor que a soma dos outros dois lados). Se for esta condição verdadeira, 
deverá ser indicado qual tipo de triângulo foi formado: isósceles (dois lados 
iguais e um diferente), escaleno (todos os lados diferentes) ou eqüilátero (todos 
os lados são iguais). 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
24
10. A Secretaria de Meio Ambiente, que controla o índice de poluição, 
mantém 3 grupos de indústrias que são altamente poluentes do meio ambiente. 
O índice de poluição aceitável varia de 0,05 até 0,29. Se o índice sobe para 0,3 
as indústrias do 1º grupo são intimadas a suspenderem suas atividades, se o 
índice crescer para 0,4 as indústrias do 1º e 2º grupo são intimadas a 
suspenderem suas atividades, se o índice atingir 0,5 todos os grupos devem 
ser notificados a paralisarem suas atividades. Faça um programa que leia o 
índice de poluição 
11. Um Banco concederá um crédito especial aos seus clientes, variável 
com o saldo médio no último ano. Faça um algoritmo que leia o saldo médio de 
um cliente e calcule o valor do crédito de acordo com a tabela abaixo. Mostre 
uma mensagem informando o saldo médio e o valor do crédito. 
Saldo médio Percentual 
de 0 a 200,00 nenhum crédito (crédito = 0) 
de 201,00 a 400,00 20% do valor do saldo médio 
de 401,00 a 600,00 30% do valor do saldo médio 
acima de 600,00 40% do valor do saldo médio 
12. Um vendedor necessita de um programa que calcule o preço total 
devido por um cliente. O programa deve receber o código de um produto e a 
quantidade comprada e calcular o preço total,usando a tabela abaixo. Mostrar 
uma mensagem no caso de código inválido. 
Código Produto Preço Unitário 
1001 R$ 5,32 
1324 R$ 6,45 
6548 R$ 2,37 
987 R$ 5,32 
7623 R$ 6,45 
13. Ler um número inteiro, e verificar se o número corresponde a um mês 
válido no calendário e escrever o nome do mês, senão escrever uma 
mensagem ‘Mês Inválido’. 
 
6.3. Switch – Case 
 
O Switch – Case (Escolha – Caso) é um comando de seleção que tem por 
finalidade tomar uma decisão baseando-se no conteúdo de uma variável ou no 
resultado de uma expressão. Esse comando pode simplificar o uso do 
comando if. 
Ou seja, é quase que um if com várias possibilidades, mas com algumas 
diferenças importantes. 
1ª diferença: Os cases não aceitam operadores lógicos. Portanto, não é 
possível fazer uma comparação. Isso limita o case a apenas valores definidos. 
2ª diferença: O switch executa seu bloco em cascata. Ou seja, se a variável 
indicar para o primeiro case e dentro do switch tiver 5 cases, o switch 
executará todos os outros 4 cases a não ser que utilizemos o comando para 
sair do switch. (Nos referimos ao BREAK). 
 
Agora, que conhecemos diferenças importantes, veremos como proceder 
com o switch - case. Podemos acompanhar o exemplo abaixo: 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
25
 
 
/* Programa switch-case */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int num; 
printf("Digite numero (1 ou 2 apenas): "); 
scanf("%d", &num); 
switch(num) 
 { 
 case 1: printf("\nSolteiro"); break; 
 case 2: printf("\nCasado"); break; 
 default: printf("\nNumero invalido"); 
 } 
getch(); 
} 
 
Podemos ver algumas particularidades, como por exemplo, a opção default 
que é chamada quando nenhuma escolha é válida dentro das opções. Outra 
novidade é o break que faz o programa parar quando a condição é satisfeita. 
Quando usamos o case com um tipo char, usamos a seguinte sintaxe: 
 
case ‘a’: <operação>; break; 
 
6.3.1. Exercícios de Fixação 
 
1. Construa um algoritmo que lê um número de 1 a 7 e informa o dia da 
semana correspondente, sendo domingo o dia de número 1. Se o dia não 
corresponder ao dia da semana, é mostrada uma mensagem de erro. 
2. Crie um algoritmo que leia uma letra e mostre uma mensagem: se é 
vogal maiúscula, vogal minúscula ou consoante. Considere somente as letras 
do alfabeto. 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
26
7. Algoritmo de Repetição 
 
São algoritmos com a característica de realizar um conjunto de instruções, 
ou uma única instrução, que será executada repetidamente, de acordo com o 
resultado de um teste condicional que compõem a instrução de repetição e 
permite o laço para nova execução destas instruções que compõem o bloco de 
repetição. 
 
7.1. Introdução 
 
As estruturas de repetição ou iteração são de crucial importância para a 
programação do algoritmo, e nos possibilitam executar o mesmo trecho de 
código várias vezes seguidas, enquanto um dado critério não é satisfeito. 
As estruturas de repetição ou iteração são, comumente, dadas pelos 
comandos while (enquanto) ou for (para). 
Qualquer estrutura, seja for ou while, funciona com 1 variável que 
chamamos de sentinela (ou contador ou acumulador). Essa variável irá ditar 
quando o programa deverá sair da repetição e geralmente tem 3 
características: 
1°. Qual valor esta variável irá iniciar; 
2°. Como esta variável terá seu valor modificado para que chegue ao valor 
final; 
 3°. Qual valor esta variável deve atingir para que pare a repetição. 
No caso, a variável de controle ou sentinela sempre deverá ter essas 
características ou poderá ocorrer um erro que chamamos de loop infinito. Isso 
ocorre por causa de erro de lógica, no qual a variável sentinela nunca chega ao 
seu resultado final. 
 
7.2. While 
 
O comando while é um laço de repetição que é bastante usado para fazer 
loop controlado com condições. É bem simples e fácil de usar. O while executa 
uma comparação com a variável. Se a comparação for verdadeira, ele executa 
o bloco de instruções ( { } ) ou apenas a próxima linha de código logo abaixo. 
Podemos acompanhar sua sintaxe no exemplo abaixo: 
 
/* Programa while */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int a; 
a = 1; 
while(a <= 100) 
 { 
 printf("\n %d", a); 
 a++; 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
27
 } 
getch(); 
} 
 
Este programa inicializa a variável a com o valor 1 e escreve seu valor na 
tela através do printf. Cada vez que o programa executa o laço while, escreve o 
valor de a e o incrementa em 1 (‘a++’ é igual a ‘a = a + 1’). Após o incremento, 
o novo valor de a é testado novamento pelo while, e enquanto não for satisfeita 
a condição, seguirá executando. Portanto, esse programa escreverá todos os 
números de 1 até 100, e quando a atingir o valor de 100, o laço termina e o 
programa finaliza. 
 
7.2.1. Exercícios de Fixação 
 
1. Faça um programa que solicite ao usuário para digitar valores numéricos 
inteiros positivos. Encerre a entrada de dados quando for digitado um número 
negativo ou zero. Calcule a média dos números positivos digitados. 
2. Faça um programa que solicite ao usuário 10 números inteiros e, ao final, 
informe a quantidade de números ímpares e pares lidos. Calcule também a 
soma dos números pares e a média dos números ímpares. 
3. Uma determinada empresa armazena para cada funcionário (10 no total) 
uma ficha contendo o código, o número de horas trabalhadas e o seu número 
de dependentes. Considerando que: 
a. A empresa paga 12 reais por hora e 40 reais por dependente. 
b. Sobre o salário são feitos descontos de 8,5% para o INSS e 5% para IR. 
Faça um programa para ler o código, número de horas trabalhadas e 
número de dependentes de cada funcionário. Após a leitura, escreva qual o 
código, os valores descontados para cada tipo de imposto e finalmente o 
salário líquido de cada um dos funcionários. 
4. Em uma pesquisa de campo, uma editora solicitou os seguintes dados 
para os entrevistados: sexo, idade e quantidade de livros que leu no ano de 
2008. Faça um programa que leia os dados digitados pelo usuário, sendo que 
deverão ser solicitados dados até que a idade digitada seja um valor negativo. 
Depois, calcule e imprima: 
a) A quantidade total de livros lidos pelos entrevistados menores de 10 
anos. 
b) A quantidade de mulheres que leram 5 livros ou mais. 
c) A média de idade dos homens que leram menos que 5 livros. 
d) O percentual de pessoas que não leram livros. 
5. Foi realizada uma pesquisa com 200 pessoas que assistiram a uma peça 
de teatro, em relação a sua opinião sobre a mesma. Cada espectador 
respondeu a um questionário que solicitava os seguintes dados: 
a) idade da pessoa; 
b) o identificador da pessoa; 
c) opinião em relação à peça (de 0 a 10). 
Faça um programa que, a partir destes dados, calcule e imprima: 
a) A quantidade de respostas 10. 
b) A média de idade das pessoas que responderam o questionário. 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
28
c) A percentagem de pessoas que responderam 5 ou menos para a opinião 
da peça. 
d) O identificador da pessoa mais velha. 
* Considere que a maior idade não é repetida. 
6. Foi feita uma pesquisa para saber o perfil dos alunos que cursam o 
ginásio de uma determinadaescola. Cada aluno fornecia a sua série (primeira-
1, segunda-2, terceira-3 ou quarta-4), quantos livros liam por mês e se 
gostavam de fazer redação (Sim-1 ou Não-0). Fazer um programa que leia os 
dados, calcule e imprima: 
a) A quantidade de alunos que está na terceira série; 
b) A maior quantidade de livros lidos por um aluno que está na quarta série; 
c) A porcentagem de alunos que não gostam de fazer redação e que estão 
na terceira série. 
OBS: A condição de parada (flag) é que seja digitado 0 (zero) para idade. 
7. Uma empresa realizou uma pesquisa com os seus fornecedores, na qual 
foram coletados os seguintes dados referentes aos produtos fornecidos: ID, 
Valor e Percentual de aumento. 
Obs. Se o produto não tiver sofrido alteração de preço, o percentual de 
aumento será igual a 0. 
Faça um programa que determine e escreva: 
a) O novo valor de cada um dos produtos. 
b) A quantidade de produtos mais caros que R$ 100,00 (após aumento) e 
que tiveram aumento superior a 5%. 
c) A média de valor dos produtos que não sofreram aumento. 
d) O valor do produto mais caro (após aumento). 
Obs.: o programa solicita dados até que o ID digitado seja zero. 
 
7.3. For 
 
Este comando aparece em várias linguagens de programação, mas na 
linguagem C ele apresenta uma grau maior de flexibilidade. A idéia básica do 
comando for é a seguinte. Uma variável de controle, geralmente um contador, 
recebe um valor inicial. 
O trecho de programa que pertence ao laço é executado e ao final a 
variável de controle é incrementada ou decrementada e comparada com o 
valor final que ela deve alcançar. Caso a condição de término tenha sido 
atingida o laço é interrompido. 
Podemos ver sua sintaxe no exemplo abaixo: 
 
/* Programa for */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int a; 
for(a = 1; a <= 100; a++) 
 { 
 printf("\n %d", a); 
 } 
getch(); 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
29
} 
 
Vemos que sua utilização na resolução de problemas computacionais é a 
mesma que o comando while, porém, o for inicializa o valor da variável, coloca 
o limite dessa variável e o contador em apenas 1 linha de código. 
 
7.3.1. Exercícios de Fixação 
 
1. Escreva um programa que dados 15 números, imprima seus quadrados, 
obs: você não precisa necessariamente imprimir no final. 
2. Escreva um programa que dado um número, ele diz se é primo ou não. 
3. Escreva um programa que dados dois números, imprime o MMC. 
4. Escreva um programa que dados dois números, imprime o MDC 
5. Escreva um programa que imprima os números de 100 a 999 em forma 
de matriz quadrada. 
6. Escreva um programa que imprima na tela os números de 1 a 500 que 
são múltiplos de 5. 
7. Escreva um programa que imprima na tela os números de 1 a 500 que 
são múltiplos de 5 e de 3 (os dois ao mesmo tempo). 
8. Escreva um programa que some os números de 1 a 100. 
9. Escreva um programa onde o usuário diz quantos números quer digitar, 
em seguida solicite a ele que digite todos os números e diga qual o maior 
número daqueles digitados. 
10. Ler um determinado número e dizer quantos são pares e quantos são 
ímpares. 
11. Criar um programa que informa quantos números entre 100 e 200 foram 
digitados. O programa pára quando o usuário digitar 0. 
12. Dado um país A, com 5.000.000 de habitantes e uma taxa de natalidade 
de 3% ao ano, e um país B com 7.000.000 de habitantes e uma taxa de 
natalidade de 2% ao ano, calcular e imprimir o tempo necessário para que a 
população do país A ultrapasse a população do país B. 
13. Um marciano chegou a uma floresta e se escondeu atrás de uma das 
100 árvores quando viu um caçador. O caçador só tinha cinco balas em sua 
espingarda. Cada vez que ele atirava, e não acertava, é claro, o marciano dizia: 
estou mais à direita ou mais à esquerda. Se o caçador não conseguir acertar o 
marciano, ele será levado para marte. Implementar este jogo para dois 
jogadores, onde um escolhe a árvore em que o marciano irá se esconder, e o 
outro tenta acertar. 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
30
8. Vetores 
 
Vetores são usados para tratamento de conjuntos de dados que possuem 
as mesmas características. Uma das vantagens de usar vetores é que o 
conjunto recebe um nome comum e elementos deste conjunto são 
referenciados através de índices. 
 
8.1. Introdução 
 
A forma geral da declaração de um vetor é: 
 
tipo nome [tamanho]; 
 
Onde tipo é um tipo qualquer dados, nome é o nome pelo qual o vetor vai 
ser referenciado e tamanho é o número de elementos que o vetor vai conter. 
Observar que, em C, o primeiro elemento tem índice 0 e o último tamanho - 1. 
Exemplos de declarações de vetores são: 
 
int numeros[1000]; /* conjunto de 1000 numeros inteiros */ 
float notas[65]; /* conjunto de 65 numeros reais */ 
char nome[40]; /* conjunto de 40 caracteres */ 
 
É importante notar que em C não há verificação de limites em vetores. Isto 
significa que é possível ultrapassar o fim de um vetor e escrever em outras 
variáveis, ou mesmo em trechos de código. É tarefa do programador fazer com 
que os índices dos vetores estejam sempre dentro dos limites estabelecidos 
pela declaração do vetor. 
Até então, estávamos acostumados com uma variável acumulando apenas 
1 valor a cada momento. O vetor é uma variável que acumula vários valores 
em apenas uma variável. O vetor sempre inicia pelo índice 0, portanto um vetor 
de 10 posições terá índices entre 0 e 9. 
Podemos ver como é a manipulação de um vetor de inteiros com o exemplo 
abaixo: 
 
 
/* Programa vetor_int */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int dados[3]; 
dados[0] = 3; 
dados[1] = 9; 
dados[2] = 6; 
printf("%d", dados[1]); 
getch(); 
} 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
31
Vemos nesse programa, os dados sendo carregados nos índices e após, 
uma escrita de apenas um dos índices. 
8.2. Exercícios de Fixação 
 
1. Faça um programa para declarar um vetor M com 6 elementos do tipo 
inteiro. Inicializar M com valores de 1 até 6. 
2. Escreva um algoritmo em linguagem C que leia 5 números inteiros e 
armazene-os em um vetor. A seguir imprima o conteúdo desse vetor. 
3. Escreva um algoritmo em linguagem C que leia um vetor de números 
inteiros com o seu respectivo tamanho, calcule e mostre o número de 
elementos pares lidos. 
4. Escreva um algoritmo em linguagem C que leia um vetor com 100 
elementos inteiros e verifique o número de elementos múltiplos de 3. Devem 
ser impressas todas as posições destes elementos no vetor. 
5. Escreva um algoritmo em linguagem C que leia um vetor com o seu 
respectivo tamanho, calcule e mostre o menor elemento e a sua respectiva 
posição. 
6. Escreva um programa em linguagem C que leia um vetor com 10 
números inteiros, calcule e mostre os números primos e suas respectivas 
posições. 
7. Faça um algoritmo em linguagem C que leia 10 números inteiros, calcule 
dois vetores resultantes: o 1º vetor resultante deve conter somente os números 
positivos lidos; o 2º deve conter os números negativos. 
8. Escreva um algoritmo em linguagem de programação C que leia dois 
vetores, X e Y, cada um com 10 números inteiros, calcule um terceiro vetor Z 
contendo a soma entre cada elemento de X e cada elemento de Y 
(Z[i]=X[i]+Y[i]). 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi32
9. Matrizes 
 
Matriz é o nome genérico para um arranjo de dimensões n > 2, ou seja, é 
um vetor de 2 (vetor bidimensional) ou mais dimensões. 
 
9.1. Introdução 
 
Já vimos como declarar matrizes unidimensionais (vetores). Vamos tratar 
agora de matrizes bidimensionais. A forma geral da declaração de uma matriz 
bidimensional é muito parecida com a declaração de um vetor: 
 
 tipo_da_variável nome_da_variável [linhas][colunas]; 
 
 É muito importante ressaltar que, nesta estrutura, o índice da esquerda 
indexa as linhas e o da direita indexa as colunas. Quando vamos preencher ou 
ler uma matriz no C o índice mais à direita varia mais rapidamente que o índice 
à esquerda. Mais uma vez é bom lembrar que, na linguagem C, os índices 
variam de zero ao valor declarado, menos um; mas o C não vai verificar isto 
para o usuário. Manter os índices na faixa permitida é tarefa do programador. 
Vemos um exemplo de manipulação de matriz abaixo: 
 
/* Programa matriz */ 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
int x, y, cont, num[3][3]; 
cont = 1; 
x = 0; 
y = 0; 
while(x < 3) 
 { 
 while(y < 3) 
 { 
 num[x][y] = cont; 
 cont++; 
 y++; 
 } 
 y = 0; 
 x++; 
 } 
x = 0; 
y = 0; 
while(x < 3) 
 { 
 while(y < 3) 
 { 
 printf("%d", num[x][y]); 
 y++; 
 } 
 printf("\n"); 
 y = 0; 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
33
 x++; 
 } 
getch(); 
} 
 
No primeiro while desse exemplo, carregamos valores na matriz, iniciando 
com o cont em 1, e incrementando de 1 a cada novo valor. No segundo while, 
escrevemos na tela a matriz usando um \n para ‘quebrar’ a matriz de 3 em 3 
valores. A resposta desse programa deve ser: 
 
1 2 3 
4 5 6 
7 8 9 
 
9.2. Exercícios de Fixação 
 
1. Desenvolva um algoritmo que leia uma matriz 2 x 2, calcule e mostre o 
maior elemento com a respectiva posição. 
2. Escreva um programa para converter todos os elementos de uma matriz 
4 x 3 em um vetor. 
3. Escreva um algoritmo que leia uma matriz 10 x 3 com as notas de 10 
alunos em três provas. Deve ser apresentado como resultado um relatório 
contendo o número de alunos que obtiveram a maior nota na prova 1, o 
número de alunos que obtiveram a maior nota na prova 2 e o número de alunos 
que obtiveram a maior nota na prova 3. 
4. Ler dois vetores A e B, cada um com 5 elementos. Construir uma matriz 
C de duas dimensões, onde a primeira coluna deverá ser formada pelos 
elementos do vetor A e a segunda coluna deverá ser formada pelos elementos 
do vetor B. 
5. Desenvolva um algoritmo que leia uma matriz 4 x 5 e uma segunda 
matriz 5 x 2, calcule e mostre a matriz resultante do produto matricial das duas 
anteriores, armazenando o resultado em uma terceira matriz 4 x 2. 
6. Um elemento Aij de uma matriz é dito ponto de sela da matriz A se, e 
somente se, Aij for ao mesmo tempo o menor elemento da linha i e o maior 
elemento da coluna j. Escreva um algoritmo que leia uma matriz 4 x 5 e 
verifique se a matriz possui ponto de sela. Em caso afirmativo, deve ser 
impresso o valor e a respectiva posição. 
7. Escreva um algoritmo que leia uma matriz 5 x 5 com números inteiros, 
calcule e mostre quais os elementos da matriz que se repetem e quantas vezes 
cada um está repetido. 
8. Escreva um algoritmo que leia uma matriz 3 x 3 e determine se ela é 
simétrica. Uma matriz é simétrica se ela apresenta Aij= Aji. 
9. Desenvolva um algoritmo que leia uma matriz 4 x 4 de números inteiros e 
crie dois vetores de 4 posições cada um. O primeiro vetor conterá os maiores 
elementos de cada uma das linhas da matriz lida e o segundo vetor conterá os 
menores elementos de cada uma das colunas. O algoritmo deve fornecer como 
saída a matriz lida e os dois vetores calculados. 
10. Escreva um algoritmo que leia uma matriz J de ordem M x N, onde M e 
N também são valores de entrada, e obtenha a matriz transposta de J. A 
transposição de uma matriz é a troca das linhas pelas colunas, ou seja, cada 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
34
linha da matriz original se transforma em uma coluna da matriz transposta. 
Sabese que M não deve ser maior que 200 e N não deve ser maior que 100. 
11. Escreva um algoritmo que leia uma matriz J de ordem N x N, onde N é 
um valor de entrada, e um escalar k, calcule e escreva uma segunda matriz L 
também de ordem N x N em que cada elemento é obtido pela seguinte 
equação: Lij= k . Jji. Sabe-se que N não deve ser maior que 1000. 
12. Desenvolva um algoritmo que leia duas matrizes de ordem M x N e 
calcule uma terceira matriz de ordem M x N correspondente à soma das duas 
primeiras. Sabe-se que M não deve ser maior que 500 e N não deve ser maior 
que 300. 
13. Escreva um algoritmo que leia uma matriz M x N e outra matriz N x O, 
calcule e escreva uma terceira matriz de ordem M x O resultante da 
multiplicação da primeira pela segunda matriz. Sabe-se que M não deve ser 
maior que 600, que N não deve ser maior que 400 e O não deve ser maior que 
200. 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
35
10. Strings 
Na linguagem C, strings são manipuladas através de vetores. 
10.1. Introdução 
 
Para manipulação de vetores de caracteres (cadeia de caracteres) devemos 
utilizar a biblioteca string.h. E a função que lê a string digitada não é a 
função scanf, que lê apenas caractere a caractere, e sim a função gets, que lê 
um bloco de caracteres. 
Podemos ver essas diferenças no exemplo abaixo: 
 
/* Programa vetor_string */ 
#include <string.h> 
#include <stdio.h> 
#include <conio.h> 
main( ) 
{ 
char nome[5]; 
printf("Digite nome: "); 
gets(nome); 
printf("%c", nome[2]); 
getch(); 
} 
 
Neste exemplo, declaramos um vetor de strings de 5 posições, que é lido 
com gets, e após escrevemos na tela apenas a letra da posição 2 do vetor. 
Podemos ver no exemplo abaixo uma outra maneira de declarar um vetor 
de strings, quando as strings são constantes: 
 
#include <stdio.h> 
#include <conio.h> 
main() 
{ 
char nome[] = {'f', 'a', 'b', 'i', 'o'}; 
printf("%c", nome[4]); 
getch(); 
} 
 
10.2. Exercícios de Fixação 
 
1. Faça um programa que leia uma string do teclado, com no máximo 20 
caracteres, e retorne quantas vogais a string possui. 
2. Escreva um programa que leia uma string do teclado e imprima a string 
invertida (de trás para frente). 
3. Escreva um programa em C que receba uma linha de texto do teclado e 
imprima a linha com as palavras de trás para a frente. Use a função gets para 
ler linhas de texto do teclado. O programa deve perguntar linhas de texto até 
receber uma linha onde a primeira palavra seja "fim", totalmente em 
minúsculas. 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
36
Exemplo de execução do programa: 
entrada: Meu cachorro se chama Van Gogh 
saída: ueM orrohcac es amahc naV hgoG 
entrada: Otto ama Ana 
saída: ottO ama anA 
entrada: fim 
 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
37
11. Registros ou Structs 
 
Um registro (= record) é uma coleção de várias variáveis, possivelmente de 
tipos diferentes. Na linguagem C, registrossão conhecidos como structs 
(abreviatura de structures). 
 
11.1. Introdução 
 
Uma estrutura é uma coleção de variáveis ligadas através de índices. O 
conceito de orientação a objeto - principalmente classes que serão tratadas 
mais a frente - tem uma base muito sólida no conceito de estrutura de dados. 
As estruturas de dados consistem em criar apenas um dado que contém 
vários membros, que nada mais são do que outras variáveis. De uma forma 
mais simples, é como se uma variável tivesse outras variáveis dentro dela. 
A vantagem em se usar estruturas de dados é que podemos agrupar de 
forma organizada vários tipos de dados diferentes, por exemplo, dentro de uma 
estrutura de dados podemos ter juntos tanto um tipo float, um inteiro, um char 
ou um double. 
As variáveis que ficam dentro da estrutura de dados são chamadas de 
membros. 
Podemos ver um exemplo simples de utilização de struct em C abaixo: 
 
/* Programa struct */ 
#include <stdio.h> 
#include <conio.h> 
main() 
{ 
struct { 
char Primeiro[15]; 
char Meio[15]; 
char Sobrenome[15]; 
} Nome; 
printf("Digite seu primeiro nome: "); 
scanf("%s", &Nome.Primeiro); 
printf("Digite seu nome do meio: "); 
scanf("%s", &Nome.Meio); 
printf("Digite seu sobrenome: "); 
scanf("%s", &Nome.Sobrenome); 
printf("\nNome completo: %s %s %s", Nome.Primeiro, Nome.Meio, 
Nome.Sobrenome); 
getch(); 
} 
 
Vemos que a declaração da estrutura Nome segue o seguinte formato: 
 
struct { 
char Primeiro[15]; 
char Meio[15]; 
char Sobrenome[15]; 
} Nome; 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
38
A grande utilidade do uso de estruturas está em utilizar as structs da 
seguinte forma: 
 
struct { 
char Primeiro[15]; 
char Meio[15]; 
char Sobrenome[15]; 
} Nome[10]; 
 
Com Nome[10] podemos agora ler 10 nomes completos diferentes e 
armazená-los em memória para manipulação. Isso torna a sua utilização 
bastante válida quando temos que armazenar informações de tipos de dados 
diferentes interligadas entre si, por exemplo nome (char), telefone (int) e altura 
(float). 
 
 
11.2. Exercícios de Fixação 
 
1. Uma biblioteca possui obras de ciências exatas, ciências humanas e 
ciências biomédicas, totalizando 1.500 volumes, 500 de cada área. O 
proprietário resolveu informatizá-la e, para tal, agrupou as informações sobre 
cada livro do seguinte modo: 
Código de catalogação: __________ Doado:______________ 
Nome da obra: _____________________________________ 
Nome do autor: ____________________________________ 
Editora: _______________Nro de páginas:_______________ 
a) Construa um algoritmo que declare tal estrutura e que reúna todas as 
informações de todas as obras em três vetores distintos para cada área. 
b) Elabore um trecho de algoritmo que, utilizando como premissa o que foi 
feito no item anterior, realize uma consulta à informações. O usuário fornecerá 
o código da obra e sua área. Existindo tal livro, informa seus campos. Do 
contrário, envia mensagem de aviso. 
c) A consulta repete-se até que o usuário introduza código finalizador com o 
valor -1. 
Escreva um trecho de algoritmo que liste todas as obras de cada área que 
representem livros doados. 
d) Idem ao item anterior, porém, obras cujos livros sejam comprados e cujo 
número de páginas se encontre entre 100 e 300. 
e) Construa um trecho de algoritmo que efetue a exclusão de algum livro; o 
usuário fornecerá o código e a área. Lembres-se de que somente pode ser 
excluído um livro existente. 
2. Para o controle dos veículos que circulam em uma determinada cidade, a 
Secretaria dos Transportes criou o seguinte registro-padrão: 
Proprietário: __________ Combustível:_________________ 
Modelo: ____________________ Cor: _________________ 
Nro chassi: ____________Ano:_______ Placa:___________ 
O combustível pode ser álcool ou gasolina; a placa possui os três primeiros 
valores alfabéticos e os quatro restantes valores numéricos. Sabendo que o 
número máximo de veículos da cidade é de 5.000 unidades e que os valores 
não precisam ser lidos. 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
39
a) Construa um algoritmo que liste todos os proprietários cujos carros são 
do ano de 1980 ou posterior e que sejam movidos a diesel. 
b) Escreva um algoritmo que liste todas as placas que comecem com a letra 
A e terminem com 0, 2, 4 ou 7 e seus respectivos proprietários. 
c) Elabore um algoritmo que liste o modelo e a cor dos veículos cujas 
placas possuem como segunda letra uma vogal. 
d) Construa um algoritmo que permita a troca de proprietário com o 
fornecimento do número do chassi apenas para carros com placas que não 
possuam nenhum dígito igual a zero. 
3. Supondo não ser necessário suprir de informações as estruturas de 
dados a seguir, elabore um algoritmo capaz de responder às questões: 
De: _____________________ Para:_____________________ 
Data: ___/___/___ Horário: ___:___ Distância: _______km 
Poltronas: 1 2 3 ... 4 4 
Sendo que cada poltrona possui as seguintes informações: 
Número da passagem: ______________ 
Nome:____________________________ 
Sexo:  M  F 
a) Qual o horário de saída e a distância percorrida por um ônibus cuja a 
linha é fornecida? 
b)Quais as linhas de ônibus estão lotadas? 
c) Qual o horário estimado de chegada e duração da viagem de um dado 
ônibus em que o número da linha é fornecido (use velocidade média de 
60km/h). 
d) Qual a percentagem de ocupação e o número de poltronas livres para um 
dado ônibus fornecido pelo usuário? 
e) Qual a percentagem de passageiros do sexo masculino e do sexo 
feminino de um determinado ônibus cujo número da linha é fornecido pelo 
usuário? 
f) Forneça um relatório contendo a percentagem de ocupação de janelas e 
de corredores, além do número de poltronas disponíveis para todas as linhas 
de ônibus. 
 
Instituto Federal Farroupilha 
Campus Alegrete 
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas 
Prof. Fábio Diniz Rossi 
 
40
12. Ponteiros 
 
O ponteiro nada mais é do que uma variável que guarda o endereço de uma 
outra variável. 
 
12.1. Introdução 
 
A declaração de ponteiros é feita da seguinte forma: 
 
int *pa 
 
A instrução acima indica que pa é um ponteiro do tipo int. Agora veremos 
como atribuir valor ao ponteiro declarado. Para isto é necessário saber que 
existem dois operadores unitários que são utilizados com os ponteiros. O 
primeiro é o operador (*) através dele é possível retornar o valor da variável 
que está localizada no ponteiro. E o segundo é o operador (&) que retorna o 
endereço de memória que está localizado o valor da variavel contida no 
ponteiro. Portanto para atribuirmos um valor para o ponteiro é necessário 
referencia o valor da variável que se encontra no ponteiro utilizando o operador 
(*), como será demonstrado a seguir. 
 
*pa = 20; 
 
Desta forma estamos atribuindo o valor 24 para a variável que está contida 
no ponteiro. Para entender melhor quando e como utilizar os operadores (*) e 
(&), veja o programa mostrado abaixo: 
 
/* Programa ponteiro */ 
#include <stdio.h> 
#include <conio.h> 
main() 
{ 
int a, b; 
int *pa, *pb; 
a = 20; 
b = 12; 
pa = &a; 
pb = &b; 
printf("\nEndereco do ponteiro pa: %u", pa); 
printf("\nEndereco da variavel contida no ponteiro pa: %u", &pa); 
printf("\nValor da variavel contida no ponteiro pa: %d", *pa); 
printf("\nEndereco do ponteiro pb: %u", pb); 
printf("\nEndereco da variavel contida no ponteiro pb: %u", &pb); 
printf("\nValor da variavel contida no ponteiro pb: %d", *pb); 
getch(); 
} 
 
Quando os ponteiros são declarados, eles são inicializados