Brauliro G Leal: Linguagem C

Brauliro G Leal
Versão 24/07/2023
Programação Básica para Engenharias
Linguagem C
Linguagem de Programação C
Conceitos Gerais
Função
Tipos de Dados
Variáveis e Contantes
Operadores e Expressões
Estruturas SDI
Biblioteca Padrão C
Quinta Edição
Juazeiro – BA
2022
Algoritmo e Programação para Engenharias 2
Copyright© 2018, 2019, 2020, 2021, 2022 Brauliro Gonçalves Leal
O conteúdo deste livro eletrônico é totalmente livre para uso de qualquer natureza desde
que citado a fonte. Toda e qualquer parte desta publicação pode ser reproduzida, distribuída
ou transmitida de qualquer forma ou por qualquer meio, ou armazenada de qualquer forma
ou em qualquer sistema desde que reconhecida a autoria.
Atribuição–CompartilhaIgual – esta licença permite que outros remixem,

adaptem e criem a partir deste trabalho, mesmo para fins comerciais, desde
que lhe atribuam o devido crédito e que licenciem as novas criações sob
termos idênticos (creativecommons.org/licenses).
Quinta Edição Eletrônica: Outubro de 2022

ISBN: a ser feito#
O autor
Brauliro Gonçalves Leal
Professor do Colegiado de Engenharia da Computação

Universidade Federal do Vale do São Francisco
Avenida Antônio Carlos Magalhães, 510 Santo Antônio
Juazeiro/BA – Brasil 48.902–300
e–mail: ccmp0016.0@gmail.com
site: www.univasf.edu.br/~brauliro.leal
Sobre este documento
Este documento foi escrito em LibreOffice (www.libreoffice.org), suas imagens foram

produzidas pelo Kolourpaint (www.kolourpaint.org), seus programas foram editados na IDE
Code::Blocks (www.codeblocks.org), OnlineGDB (www.onlinegdb.com), C Tutor
(pythontutor.com/c.html) e compilados com o GNU GCC (gcc.gnu.org). O Sistema Operacional
utilizado foi o GNU/Linux Mint Cinnamon.
Software livre é uma boa ideia.

Prefácio
Atualmente, os computadores são onipresentes, estão em todo lugar; eles trabalham

usando algoritmos para resolver nossos problemas, facilitando nossas vidas, economizando
tempo e recursos.
O uso de algoritmos estão conosco desde o início de nossa civilização, ao criarmos nos-
sas técnicas, também criamos algoritmos. Os algoritmos são procedimentos para resolver
problemas seguindo, passo a passo, uma sequência de instruções. Um problema ou uma ta-
refa pode ser resolvido usando diferentes algoritmos, a criatividade humana produziu, produz
e produzirá muitos deles. A criação de algoritmos requer inteligência mas, depois de feito,
basta sua execução para obter o resultado desejado – por isso o grande sucesso dos compu -
tadores, que não tem inteligência mas tem capacidade de repetição.
As famosas receitas de bolo, como seus ingredientes e modo de preparar, são bons
exemplos de algoritmos. A técnica de somar dois números usando os dedos das mãos é tam-
bém um bom exemplo de algoritmo. É bem conhecida o primitivo processo de fazer fogo, ele
também é um algoritmo. O que esses exemplos têm em comum é que são uma sequência de
instruções que utilizam um número finito de ações e são executadas para se obter o resulta -
do desejado. São soluções de uso geral – podemos somar diferentes números com os dedos,
fazer variados tipos de bolos – e podem ser adaptadas para gerar outros algoritmos para re-
solver outros problemas – fazer pão e multiplicar números. Tem a grande vantagem de se-
rem procedimentos automáticos ou automatizáveis – por isso, mais uma vez, o grande suces-
so dos computadores.
Muitos algoritmos podem ser executados por computadores, outros ainda não. A tecno-
logia avança e também os algoritmos. Fazer os computadores trabalharem para nós requer
programá-los, ou seja, adaptar nossos algoritmos para eles – que usam símbolos binários pa -
ra comunicar e executar seus processos. Para isso foram criadas as linguagens de programa-
ção.
Considerando que um programa de computador tem fundamento na lógica, é impessoal,
seus critérios são abstratos, generalizados e são dirigidos para a resolução de problemas ou
realizar tarefas com vista a resultados objetivos.
Considerando que nosso cérebro, em especial o córtex cerebral, é “responsável por des-
cobrir padrões, raciocinar de modo lógico, prever o pior e preparar–se para lidar com ele, cri-
ar tecnologia e transmiti–la através da cultura” (Suzana Herculano–Houzel), este texto busca
responder, para fins de aprendizagem, as questões:
• O que é algoritmo?
• O que é programa de computador?
• Como e quando usar os conceitos da Linguagem de Programação C.
• Como criar programas de computador para resolver problemas de engenharia.
Uma boa definição de Computador é uma máquina capaz de receber, armazenar, recu-
perar e processar dados usando programas mantidos em sua memória.
Fazer programas de computador é escrever códigos fontes corretos, não é um processo
evidente por si só, requer consciência crítica, atenta, conhecedora daquilo que se programa
e requer esforço direcionado a resultados.
Embora sejam apenas letras, o programa de computador é portador de uma dinâmica
que lhe é própria, que se tornará presente ao ser executado e, quem programa, deve anteci-
pá–la em detalhe no ato da escrita, no “passo a passo” de cada instrução – o que é conheci -
do como metacognição.
Pelo exposto, pode-se estabelecer que programar envolve uma sequência de ações cog-
nitivas que são capazes de promover o aprendizado. Segundo Sancho(2001), as vantagens
oferecidas pela programação incluem:
• a promoção do pensamento rigoroso

• a compreensão de conceitos gerais
• a aquisição da arte da heurística
• a depuração de erros como uma atitude reconstrutiva do pensamento
• a invenção de soluções
• a conscientização de que não existe um caminho certo para se chegar a uma solução
É igualmente bom destacar os quatro estágios principais para o pensamento computaci-

onal:
• Decomposição – dividir o problema em partes menores

• Generalização – identificar a solução que resolve o problema mas que também
resolva outros problemas similares; o mesmo que propor uma solução padronizada
• Abstração – transformar as partes do problema em conceitos gerais, aplicáveis a
outros problemas de ordem mais geral
• Algoritmos – sequência ordenada das etapas para resolver o problema e avaliar sua
eficácia.
Para auxiliar na aprendizagem da programação de computadores e na solução de pro-

blemas usando computadores, são usadas várias técnicas como dividir para conquistar, dicio-
nários de dados, plano de testes, descrição linha a linha, mapeamento variável valor, fluxo
de controle, fluxograma e o próprio pensamento computacional. Neste sentido é que foi es-
crito este livro. O autor espera que tenha contribuído com o ensino destes conteúdos de mo -
do a torná–los mais atraentes e aplicados nas diversas engenharias, quando cabível.
Não coloque limites neste texto! Amplie suas palavras e vá além … o além cada um de -
cide onde ele está ou é!
Cada um de nós tem maneiras diferentes de entender conceitos, uns entendem rápido,
outros mais devagar, também tem aqueles que entendem de forma errada. A aplicação do
conceito ajuda a sua compreensão e correção de erros e mal entendidos. A medida que ou -
tros conceitos vão surgindo, o corpo de conhecimento da Programação em Linguagem C e a
forma dos seus Algoritmos vai se consolidando. É o processo humano de aprendizagem.
Algumas lições precisam ser vividas antes de ser aprendidas.
Concentre-se menos nos estudos de casos específicos e mais em padrões.

Sumário
1. Linguagem de Programação C – LPC................................................................................................. 10
1.1. A Linguagem C........................................................................................................................... 10
1.2. Biblioteca Padrão C – BPC.......................................................................................................... 12
1.3. Compilador C – GCC................................................................................................................... 13
1.4. Estrutura Básica dos Programas................................................................................................ 14
1.5. Fluxo de Controle de Programa................................................................................................. 16
1.6. Comentários nos Programas-fontes........................................................................................... 17
1.7. Palavras Reservadas da Linguagem C....................................................................................... 18
1.8. Espaço, Vírgula e Ponto e Virgula.............................................................................................. 19
1.9. Exercícios e Questões................................................................................................................ 19
1.9.1. Questões Básicas................................................................................................................ 20
1.9.2. Exercícios............................................................................................................................ 21
2. Tipos de Dados Básicos.................................................................................................................... 23
2.1. Divisão Inteira............................................................................................................................ 25
2.2. BPC math.h................................................................................................................................ 27
2.3. Tipos de Dados Derivados......................................................................................................... 30
2.4.2. Questões Avançadas.......................................................................................................... 32
2.4.3. Exercícios Básicos............................................................................................................... 33
2.4.4. Exercícios Avançados......................................................................................................... 35
3. Identificadores, Contantes e Variáveis.............................................................................................. 36
3.1. Identificadores........................................................................................................................... 37
3.2. Constantes................................................................................................................................. 38
3.3. Variáveis.................................................................................................................................... 39
3.4. Dicionário de dados................................................................................................................... 43
4. Operações de Entrada e Saída (E/S)................................................................................................. 45
4.1.1. E/S dos Tipos Básicos.......................................................................................................... 47
4.1.2. E/S do Tipo string................................................................................................................ 50
4.1.3. Fluxograma da E/S.............................................................................................................. 51
4.1.4. Programa para Gerar Dados de Entrada.............................................................................51
4.2.1. Questões............................................................................................................................. 52
4.2.2. Exercícios............................................................................................................................ 53
5. Operadores e Expressões................................................................................................................. 54
5.1. Operadores Aritméticos............................................................................................................. 54
5.2. Operadores Relacionais............................................................................................................. 55
5.3. Operadores Lógicos................................................................................................................... 56
5.4. Operador Atribuição................................................................................................................... 57
5.5. Expressões................................................................................................................................. 59
5.6. Precedência e Associatividade dos Operadores.........................................................................62
5.7. Promoção de Tipos Básicos........................................................................................................ 65
5.8. Conversão de Tipos Básicos....................................................................................................... 67
5.9. Formatação e a Notação Científica............................................................................................ 68
5.10. Exercícios e Questões.............................................................................................................. 69
5.10.1. Questões Básicas.............................................................................................................. 69
5.10.2. Questões Avançadas........................................................................................................ 70
5.10.3. Exercícios Básicos............................................................................................................. 70
5.10.4. Exercícios Medianos.......................................................................................................... 73
5.10.5. Exercícios Avançados....................................................................................................... 74
5.10.6. Exercícios sobre o Sistema Solar...................................................................................... 75
5.10.7. Exercícios sobre Micro-organismos................................................................................... 75
6. Funções C......................................................................................................................................... 77
6.1. Sintaxe das Funções C............................................................................................................... 77
6.2. Funções que Retornam Valores................................................................................................. 81
6.3. Funções com Argumentos......................................................................................................... 83
6.4. Chamada de Funções................................................................................................................ 84
6.5. Funções de Biblioteca Padrão C................................................................................................. 86
6.6.2. Exercícios Básicos............................................................................................................... 87
6.6.3. Exercícios Avançados......................................................................................................... 87

6.6.4. Exercícios do Sistema Solar................................................................................................ 88
7. Estruturas......................................................................................................................................... 89
7.1. Estrutura de Sequência – ES...................................................................................................... 91
7.1.1. Exercícios e Questões......................................................................................................... 93
7.1.1.1. Questões Básicas......................................................................................................... 93
7.1.1.2. Exercícios Básicos........................................................................................................ 94
7.1.1.3. Exercícios Avançados.................................................................................................. 96
7.1.1.4. Exercícios das Estrelas e Galáxias............................................................................... 97
7.1.1.5. Exercícios dos Aminoácidos......................................................................................... 98
7.2. Estrutura de Decisão – ED......................................................................................................... 99
7.2.1. Exercícios e Questões....................................................................................................... 109
7.2.1.1. Exercícios Básicos...................................................................................................... 109
7.2.1.2. Exercícios Avançados................................................................................................ 111
7.3. Estrutura de Iteração – EI......................................................................................................... 112
7.3.1. Instrução while................................................................................................................. 113
7.3.2. Instrução for..................................................................................................................... 117
7.3.3. Aplicações......................................................................................................................... 122
7.3.4.1. Questões Básicas....................................................................................................... 135
7.3.4.2. Questões Avançadas................................................................................................. 135
7.3.4.4. Exercícios Intermediários........................................................................................... 138
8. Tipos de Dados Derivados.............................................................................................................. 146
8.1. Vetores.................................................................................................................................... 148
8.1.1. Vetor como Parâmetro de Função.................................................................................... 152
8.1.2. Operações Básicas com Vetores....................................................................................... 155
8.1.2.1. Álgebra de Vetores.................................................................................................... 155
8.1.2.2. Valores Extremos de Vetor........................................................................................ 159
8.1.2.3. Pesquisa em Vetor..................................................................................................... 161
8.1.2.4. Ordenação de Vetor................................................................................................... 163
8.1.3. Outras Operações com Vetores........................................................................................ 164
8.1.4.2. Questões Avançadas................................................................................................. 164
8.1.4.5. Exercícios do Sistema Solar....................................................................................... 169
8.2. Matrizes................................................................................................................................... 171
8.2.1. Matriz como Parâmetro de Função................................................................................... 176
8.2.2. Álgebra de Matrizes.......................................................................................................... 180
8.2.2.1. Operações com Linhas, Colunas e Diagonais de Matriz.............................................182
8.2.2.2. Valores Extremos de Matriz....................................................................................... 188
8.2.2.3. Pesquisa em Matriz.................................................................................................... 190
8.2.3. Outras Operações com Matrizes....................................................................................... 192
8.2.4.3. Exercícios Intermediários 1........................................................................................ 197
8.2.4.6. Exercícios Avançados 1............................................................................................. 200
8.2.4.7. Exercícios Avançados 2............................................................................................. 202
8.2.4.8. Exercícios do Sistema Solar....................................................................................... 202
8.3. String....................................................................................................................................... 204
8.3.1. String como Parâmetro de Função.................................................................................... 209
8.3.2. BPC string.h...................................................................................................................... 211
8.3.2.1. Entrada e Saída de Strings........................................................................................ 212
8.3.2.2. Manipulação de Strings.............................................................................................. 213
8.3.2.3. Pesquisa em Strings.................................................................................................. 215
8.3.2.4. Outras Operações com Strings.................................................................................. 217
8.3.3. Vetor de Strings................................................................................................................ 218

9. Resolvendo Problemas Usando Computadores............................................................................... 222
9.1. Desenvolvimento de Programas de Computador.....................................................................223
9.2. Entrada, Processamento e Saída............................................................................................. 224
9.2.1. Dividir para Conquistar..................................................................................................... 225
9.2.2. Pensamento Computacional............................................................................................. 225
9.2.3. Dicionários de Dados........................................................................................................ 227
9.2.4. Plano de Testes................................................................................................................. 228
9.2.5. Descrição Linha a Linha.................................................................................................... 230
9.2.6. Mapeamento Variável Valor.............................................................................................. 231
9.3. Algoritmo................................................................................................................................. 232
9.4. Conceito de Fluxo de Controle................................................................................................. 235
9.5. Fluxograma.............................................................................................................................. 236
9.6. Questões.................................................................................................................................. 237
10. Anexos.......................................................................................................................................... 238
10.1. Instrução switch..................................................................................................................... 238
10.2. Instrução ternária.................................................................................................................. 240
10.3. Instrução do/while.................................................................................................................. 241
10.4. Instruções break e continue................................................................................................... 244
10.5. Tópicos de Função................................................................................................................. 249
10.5.1. Programação Modular..................................................................................................... 249
10.5.2. Protótipo de Função........................................................................................................ 251
10.5.3. Passagem de Argumentos por Valor...............................................................................252
10.5.4. Recursividade................................................................................................................. 254
10.5.5. Recursividade x Interatividade....................................................................................... 257
10.5.6. Escopo de Nomes e Tempo de Vida de Variáveis...........................................................258
10.5.7. Exercícios e Questões..................................................................................................... 260
10.5.7.1. Questões Básicas..................................................................................................... 261
10.5.7.2. Exercícios Básicos.................................................................................................... 261
10.5.7.3. Exercícios Avançados.............................................................................................. 262
10.6. Biblioteca Padrão C (glibc)..................................................................................................... 262
10.7. Palavras Reservadas da Linguagem C................................................................................... 263
10.8. Algoritmos Gerais.................................................................................................................. 264
10.8.1. Algoritmos Básicos.......................................................................................................... 264
10.8.1.1. Contar...................................................................................................................... 265
10.8.1.2. Somar...................................................................................................................... 267
10.8.1.3. Valores extremos..................................................................................................... 269
10.8.1.4. Trocar...................................................................................................................... 270
10.8.2. Algoritmos Derivados...................................................................................................... 271
10.8.2.1. Média....................................................................................................................... 272
10.8.2.2. Percentagem........................................................................................................... 273
10.8.2.3. Ordenar................................................................................................................... 274
10.8.3. Algoritmos Diversos........................................................................................................ 274
10.8.3.1. Número Primo.......................................................................................................... 275
10.8.3.2. Máximo Divisor Comum........................................................................................... 275
10.8.3.3. Mínimo Múltiplo Comum.......................................................................................... 276
10.8.4.1. Questões Básicas..................................................................................................... 277
10.8.4.2. Exercícios Básicos.................................................................................................... 277
10.9. Tabela ASCII........................................................................................................................... 278
10.9.1.1. Questões.................................................................................................................. 280
10.9.1.2. Exercícios................................................................................................................ 280
11. Bibliografia.................................................................................................................................... 282
1. Linguagem de Programação C – LPC
O processo de produção de programas executáveis em computadores usando a Lingua-

gem C requer três elementos básicos, conforme mostrado no Quadro 1.1. O primeiro elemen-
to é a própria Linguagem de Programação C (LPC) e suas regras sintáticas, cuja aprendiza-
gem é razoavelmente rápida, o que permite escrever programas de computadores com eficá-
cia. O segundo elemento é a Biblioteca Padrão C (BPC) e sua rica coleção de funções, prontas
para uso, que facilita a solução de problemas de engenharia. Detalhes da BPC podem ser vis-
to no Quadro 10.1 (Anexo), que lista os cabeçalhos da Biblioteca Padrão ANSI C. O terceiro
elemento é o Compilador C, capaz de gerar programas executáveis para todos os tipos de
máquinas e sistemas operacionais atuais.
Quadro 1.1 Elementos da Linguagem C para produção de programas executáveis
Elemento Descrição
Linguagem C Estabelece as regras para a escrita de programas-fonte
Biblioteca Padrão C Funções padronizadas para uso imediato em programas-fonte
Compilador C Traduz programas-fonte em programas executáveis
1.1. A Linguagem C
A linguagem C foi criada na década de 1970 e, com o tempo, ela tornou-se uma das lin -
guagens de programação mais usadas, conforme discutido no Comentário 1.1. Ela é usada
para a criação de diversos softwares, como sistemas operacionais, editores de texto, navega-
dores, bancos de dados, drivers, servidores diversos, compiladores e interpretadores de ou-
tras linguagens. Ela é considerada uma linguagem de propósito geral.
Comentário 1.1 As bases da Linguagem C
A Linguagem C costuma ser a linguagem de quem entra no mundo da programação pois

fornece conhecimentos e habilidades sobre os fundamentos desta disciplina e como ela
funciona.
A aprendizagem inicial é feita a partir da solução computacional de pequenos problemas,

embora esta linguagem seja capaz de tratar e dar soluções para tarefas computacionais
complexas. Não há limites para a Linguagem C e a computação tem nela o seu grande
apoio, é a sua principal ferramenta.
A Linguagem C é complementada por uma biblioteca, denominada Biblioteca Padrão da

Linguagem C (BPC), que possui variadas funções de uso geral e prontas para uso imediato.
Além disso, o programador pode construir suas próprias bibliotecas de funções
especializadas para as mais diversas áreas do conhecimento e suas aplicações.
A Linguagem C foi criada na década de 1970, com mais de meio século de sucesso; devido
em grande parte a ser uma linguagem pequena, simples, amplamente disponível, fácil de
aprender e que resolve problemas pequenos, grandes e muito grandes.
Em linhas gerais, a linguagem C é uma linguagem de programação compilada, de propósito

geral, estruturada, imperativa, procedural e padronizada pela Organização Internacional
para Padronização (ISO) e também pelo Instituto Nacional Americano de Padrões (ANSI).
A Linguagem C Padrão continua a evoluir. Atualmente é mantida pelo GNU Compiler

Collection (GCC), e está disponível no endereço gcc.gnu.org.
A Linguagem C possui estruturas de controle de fluxo, como if/else, while, do/while e for
– recursos relacionados à abstração para formulação de programas. Como toda linguagem de
programação, a linguagem C é definida pelas regras gramaticais, palavras reservadas, tipos
de dados, criação de variáveis, operações e operadores, delimitadores, caracteres especiais,
instruções, estruturas de sequência, de decisão e de iteração, manipulação de apontadores,
criação de funções e estrutura modular, dentre outros.
As unidades léxicas comumente usadas na Linguagem C são apresentadas no Quadro
1.2, todas elas possuem regras sintáticas que definem seus formatos e regras semânticas
que especificam sua execução pela CPU.
Quadro 1.2 Unidades léxicas comumente usadas na Linguagem C
Unidade Léxica Descrição
Palavras Reservadas Palavras de uso exclusivo da linguagem
Comentário Sequência de caracteres iniciadas por // ou entre /* e */
Identificador Nome dado para uma constante, variável ou função
Tipos de dados primitivos da linguagem C: void, bool, char, int, float

Tipos de Dado
e double
Unidade Léxica Descrição
Espaços alocados na memória do computador para armazenar

Constante e Variável valores de um tipo de dado. Identificadores criados nos programas-
fonte.
Meios pelos quais se realizam operações com variáveis, constantes

Operador e funções; podem ser de atribuição, aritméticos, relacionais e
lógicos
Combinam variáveis, constantes, funções e operadores para

Expressão
calcular novos valores; podem ser aritméticas e lógicas
São as bases da programação estruturada, podem ser estruturas

Estrutura
de sequência, de decisão e de iteração
São as partes (interdependentes) dos programas que trabalham de

Função
forma integrada para alcançar os resultados esperados
Tipos de dados derivados dos tipos de dados primitivos, como

Dados Derivados
vetores, matrizes e texto (cadeia de caracteres ou string)
Tipo de dado que permite a interação entre o programa executável

Apontador
e componentes do hardware.
Os programas escritos em C são constituídos por funções que, por sua vez, são listas or-
denadas de instruções, organizadas em estruturas de sequência (ES), estruturas de decisão
(ED) e estruturas de iteração (EI). Estes programas também podem ser agrupados para cons-
truir projetos com múltiplos arquivos. Por isso C é considerada uma linguagem estruturada
(seus programas utilizam apenas as estruturas ES, ED e EI), imperativa (suas estruturas são
constituídas por listas ordenadas de instruções) e procedural (seus programas são modula-
res, compostos por funções).
1.2. Biblioteca Padrão C – BPC
A Biblioteca Padrão da Linguagem C (BPC) é projetada para

fornecer um conjunto básico de funções padronizadas para a Lin-
guagem C. Ela consiste de 24 cabeçalhos, cada um contendo uma
ou mais declarações de funções, tipos de dados e macros 1.
A BPC é uma caixa de ferramentas prontas para uso em pro-
gramas C; é parte do projeto GNU C Library e está em desenvolvi-
mento desde 1988. Ela está disponível no endereço www.gnu.org/
software/libc.
O Quadro 10.1, do Anexo, descreve os cabeçalhos da Biblioteca
Padrão ANSI C.
1 Uma das instruções da Linguagem C

1.3. Compilador C – GCC
Como muitas linguagens de programação são próximas da linguagem natural e as CPUs

executam apenas linguagem de máquina, as linguagens de programação precisam de um
tradutor de programa-fonte.
Os compiladores são programas que traduzem arquivos escritos em linguagem de pro-
gramação (programas-fonte) para a linguagem do processador (linguagem binária), criando
um arquivo capaz de executar suas instruções (programa executável).
O compilador C é um programa que traduz programas-fonte C para

a linguagem binária da CPU, gerando programas executáveis. Os pro-
gramas executáveis são independente dos programas-fonte e, uma vez
gerados, ficam disponíveis para serem executados. O GCC (GNU Compi-
ler Collection) é o compilador C mais usado e pode ser obtido gratuita-
mente no endereço gcc.gnu.org.
O primeiro passo de um compilador é analisar as instruções do programa-fonte, verifi-

cando se existem erros de sintaxe e, no caso de erro, a compilação é interrompida.
Sem erros no programa-fonte, o compilador o traduz para a linguagem da máquina;
acrescenta informações sobre alocação de memória, símbolos do programa (variáveis e fun-
ções), informações de depuração (debug); e cria o arquivo de código-objeto.
O compilador adiciona os códigos da BPC ao código-objeto e, por fim, cria o programa
executável, um arquivo que funciona independente capaz de executar as instruções do pro-
grama-fonte em uma CPU.
O GCC produz programas executáveis em três etapas:
1. Análise Sintática – o compilador analisa o programa-fonte e informa a existência de

erros de sintaxe. Feitas as correções necessárias, segue a próxima etapa;
2. Compilação – o programa-fonte é traduzido para a linguagem da máquina, o
compilador cria o aquivo código-objeto;
3. Linker – as funções da BPC são incluídas no código-objeto, o linker cria o programa
executável, que é capaz de executar as instruções do programa-fonte.
A análise sintática inclui o pré-processamento, uma etapa que processa as instruções

precedidas pelo caractere #, as chamadas diretivas de pré-processamento.
Ao compilar um programa-fonte, declarações suspeitas são indicadas com warning (ad-
vertência) e cabe ao programador avaliar cada advertência e tomar as providências cabíveis.
Por outro lado, a compilação é interrompida quando é encontrada uma ou mais declarações
com error (erro). Neste caso, é necessário corrigir cada erro antes de retomar a compilação.
Os erros de programas executáveis costumam ser mais difíceis de serem encontrados, mui-
tos deles são erros devido à operações matemáticas impróprias como divisão por zero. Ou -
tras fontes de tais erros serão apresentados ao longo deste texto.
O Quadro 1.3 exibe o Relatório Padrão da Compilação do programa AloMundo.c. Pode-se
destacar neste relatório as mensagens:
• Process terminated with status 0, 0 no GCC indica sem erros

• 0 error(s), 0 warning(s)
Quadro 1.3 Relatório Padrão da Compilação do programa AloMundo.c, feito pelo GCC
Relatório da Compilação
gcc -c /home/leal/AloMundo.c -o /home/leal/AloMundo.o

gcc -o /home/leal/AloMundo /home/leal/AloMundo.o
Process terminated with status 0 (0 minute(s), 0 second(s))

0 error(s), 0 warning(s) (0 minute(s), 0 second(s))
1.4. Estrutura Básica dos Programas
Os programas escritos na linguagem C possuem, principalmente, inclusões, definições,

funções, variáveis, expressões e instruções, além de comentários – itens opcionais.
Os programas C são organizados em funções; em geral, eles possuem muitas funções
organizadas em vários arquivos. Entretanto, todo programa C deve possui a função main,
que determina o seu início. O mais famoso e menor programa C é o Programa 1.1, denomina-
do AloMundo.c.
Programa 1.1 Primeiro programa C (AloMundo.c)

L Programa-Fonte (PF) Descrição Linha a Linha(DLL)
1 #include <stdio.h> cabeçalho da BPC para incluir a função printf
2 int main( void ) declara a função main, do tipo int e parâmetro void
3 { abre o bloco da função
escreve Alô mundo! na tela do computador usando a função
4 printf( "Alô mundo!");
printf
5 return 0; main retorna o valor int 0
fecha o bloco da função main
6 } encerra a função main
encerra o programa


Imagem da Execução
O fluxo de controle do programa-fonte do Programa 1.1 é a sequência definida pelas li-

nhas: 🌑 → 2 → 3 → 4 → 5 → 6 → 🌕
Todo e qualquer programa C inicia pela função main, neste caso, pela linha 2. Em geral,
o programa também é finalizado por return 0; – na linha 5. A função encerra o programa ao
retornar o valor int 0. A chave na linha 6 fecha o bloco da função main, finaliza a função main
e também encerra o programa.
Observe as aspas duplas de "Alô mundo!", elas indicam frases em C, são chamadas de
strings, uma sequência de caracteres delimitadas por aspas duplas.
A instrução #include é uma diretiva de pré-processamento, ela é utilizada para incluir
um cabeçalho da BPC.
A instrução #include <stdio.h> indica que o compilador deve buscar e incluir o arqui-
vo stdio.h, de forma que o programa-fonte possa fazer uso da função printf. A dupla <> in-
dica que é um cabeçalho da BPC.
A Figura 1.1 ilustra bem a composição básica de um programa escrito na Linguagem C,
com o seu identificador (nome), as inclusões, as declarações e suas instruções organizados
em estruturas.
programa.c identificador do programa
Inclusões cabeçalhos da BPC e definições
linhas com as declarações descrevendo os

Primeira Parte
dados que serão processados pelo programa
linhas com as estruturas e suas instruções

Segunda Parte
para o processamento dos dados
Figura 1.1 Composição básica de um programa escrito na Linguagem C.

Na Figura 1.1 estão definidas as principais regiões do programa-fonte. Começando pelo

seu nome, acrescido da extensão .c, seguido das inclusões. A Primeira Parte e a Segunda
Parte ficam dentro da função main.
1.5. Fluxo de Controle de Programa
O processo de programação da Linguagem C são organizados em apenas três estrutu-

ras: de sequência, de decisão e de iteração. É a chamada programação estruturada, discuti-
da no Comentário 1.2.
Comentário 1.2 Programação estruturada
A programação estruturada estabelece que os programas de computador podem ser

construídos com apenas três estruturas, quais sejam: sequência (ES), decisão (ED) e
iteração (EI). Estas estruturas são suficientes para gerenciar o fluxo de controle nos
programas de computador, pode-se afirmar que são os ingredientes básicos de todo e
qualquer programa C, como mostrado na Figura 1.2.
Figura 1.2 Estruturas da Linguagem C: Sequência, Decisão e Iteração.

A estrutura de iteração pode ser repetida após passar por um desvio condicional. Por outro
lado, a estrutura de decisão passa por um desvio condicional, sem poder ser repetida. Por
fim, a estrutura de sequência é, tão somente, uma lista encadeada de instruções, sem
desvio condicional e sem iteração.
As ES, ED e EI podem conter umas as outras, formando blocos compostos de estruturas.
Estas estruturas são agrupadas em funções para a produção de programas de
computadores de todos os tamanhos.
O fluxo de controle percorre o programa-fonte do início ao fim, executando suas instru-

ções conforme definido pelo programa-fonte. O início é único mas pode haver várias instru-
ções encerrando o programa.
Regra do Dedo – pode-se percorrer a lista de instruções dos programas-

fonte com um dedo e identificar seu fluxo de controle
As estruturadas de sequência, de decisão e de iteração podem ser agrupadas ou aninha-

das nas funções, ou seja, pode-se colocá-las estas estruturas umas dentro das outras, e as-
sim por diante, formando programas bastante complexos 2.
1.6. Comentários nos Programas-fontes
Comentar o programa-fonte é uma forma de documentação do código. É comum infor-

mar o histórico de desenvolvimento e evolução de um software, com explicações para cada
função do programa, seu processamento, seus parâmetros de entrada e seus possíveis retor -
nos.
Quaisquer textos colocados entre /* e */ são considerados comentários e são ignorados
pelo compilador. Comentários de uma linha são aqueles iniciados por //.
As linhas 2, 3, 4, 5, 6, 7, 8, 9 e 10 do Programa 1.2 perfazem um bloco de comentário do
programa pois elas estão entre /* e */; e as linhas 17, 18, 21 e 22 possuem comentários de
uma linha, pois iniciam com //.
Programa 1.2 Programa C com comentários (DeFparaC.c)

1 #include <stdio.h>
2 /*+------------------------------------------------+ início do bloco de comentário
3 | Converte temperatura de Farenheit para Celsius |
4 | Função: float DeFparaC( float F) | continuação do comentário
6 | Entrada: temperatura em graus Farenheit (°F) | continuação do comentário
7 | Saída: temperatura em graus Celsius (°C) | continuação do comentário
8 | Equação: C = (F-32.0) * 5.0 / 9.0 | continuação do comentário
9 | Exemplo: F = 55.5 → C = 13.06 | continuação do comentário
10 +------------------------------------------------+*/ fim do bloco de comentário
11 float DeFparaC( float F ){
12 return (F-32.0) * 5.0 / 9.0;
13 }
14 int main( void ){
15 float C, F;
16 printf( "Informe a temperatura Farenheit(°F): ");
17 scanf( "%f", &F ); // espaços são ignorados comentário de uma linha
18 C = DeFparaC( F ); // pelo compilador comentário de uma linha
19 printf( "Temperatura em Celsius: %5.2f °C", C );
20 return 0;
2 O excesso de aninhamento de estruturas pode tornar o programa-fonte ilegível, dificultando sua manutenção.
Programa 1.2 Programa C com comentários (DeFparaC.c)

21 // fim da função main comentário de uma linha
22 } // fim da função main e do programa comentário de uma linha
23
24
Fluxo de Controle do Programa 1.2: 🌑 → 14 → 15 → 16 → 17 → 18 → 11 → 12 → 13 → 18

→ 19 → 20 → 22 → 🌕.
1.7. Palavras Reservadas da Linguagem C
As palavras reservadas são componentes da linguagem C e cada uma delas tem sua
própria sintaxe. Uma palavra reservada é essencialmente uma instrução que determina o
que pode ser feito por meio da linguagem. O conjunto de palavras reservadas especificado
pelo padrão ANSI C são listadas no Quadro 1.4.
Quadro 1.4 Lista das palavras reservadas na linguagem C
auto break case char const continue default do

double else enum extern float for goto if
int long register return short signed sizeof static
struct switch typedef union unsigned void volatile while
Todas as palavras reservadas da linguagem C são grafadas em letras minúsculas, o

compilador C faz distinção entre maiúsculas e minúsculas.
No Quadro 10.2, do Anexo, estão listada as palavras reservadas da Linguagem C e suas
finalidades nos programas-fontes.
1.8. Espaço, Vírgula e Ponto e Virgula
A Linguagem C é semelhante às muitas outras linguagens, inclusive as linguagens natu-

rais, como a Língua Portuguesa. Nesta frase há espaço, ou espaços, e sua utilidade é separar
uma palavra da outra. Pode-se usar mais de um espaço, mas um já é suficiente.
Em C, os espaços tem a finalidade de separar os termos, tecnicamente chamados de
tokens, uns dos outros, com isso o compilador individualiza, identifica e processa cada termo
do programa-fonte conforme sua sintaxe.
As exceções serão apresentadas a seu tempo, como é o caso dos operadores, +-*/%&|
=!?->, e dos delimitadores, []""{}''()/**/;<>//.#:, usados para formatar o programa-fonte.
O uso de espaços também contribui com a legibilidade dos programas-fontes. Como re-
gra, as palavras-chave, os identificadores e os demais elementos dos programas-fontes em
linguagem C, devem ser separados por, pelo menos um, caractere espaço.
Nos programas-fonte C, o ponto e vírgula é um terminador de instrução, ou seja, cada
instrução individual deve ser terminada com um ponto e vírgula. Indica o fim de uma entida-
de lógica.
A vírgula é o separador de listas, ou seja, os elementos de uma lista devem ser separa -
dos uns dos outros por uma vírgula. Uma lista é terminada por um ponto e vírgula. Por exem -
plo, as instruções abaixo foram extraídos do Programa 1.2, das linhas 15 e 17, referente ao
programa DeFparaC.c. Ambas são finalizadas pelo ponto e vírgula e também faz uso da vír -
gula para sua lista de identificadores e sua lista de argumentos.
1. float C, F;
2. scanf( "%f", &F );
1.9. Exercícios e Questões

1.9.1. Questões Básicas
1. Existe diferença entre língua e linguagem?

2. O que é uma linguagem? Dê três exemplos.
3. O que é uma linguagem natural? Dê três exemplos.
4. O que é uma linguagem de máquina? Dê três exemplos.
5. O que é a linguagem C?
6. O que é Padrão ANSI?
7. O que é a linguagem C Padrão ANSI?
8. O que processo?
9. O que é processo de produção de programas executáveis?
10.O que é processo de produção de programas-fonte?
11.Compare programas-fontes e programas executáveis.
12.Cite três regras para a escrita de programas-fonte.
13.O que é um cabeçalho?
14.O que é biblioteca de uma linguagem de programação?
15.O que é BPC?
16.O que é compilador?
17.O que é compilador C?
18.O que é ASCII?
19.O que é ISO?
20.O que é GCC?
21.O que é GNU?
22.O que é GNU GCC?
23.O que tem no gcc.gnu.org?
24.O que é arquivo?
25.Compare algoritmo com programa-fonte.
26.Como se usa a Regra do Dedo nos fluxogramas?
27.O que é uma unidade léxica?
28.Qual a finalidade dos comentários?
29.Qual a finalidade dos identificadores?
30.Quais as diferenças e as semelhanças entre palavras reservadas e identificadores?
31.Qual é a utilidade da imagem da execução de programas?
32.Em que linguagem estão os programas executáveis?
33.Para que serve #include?
34.O que é warning?
35.O que é erro de compilação?
36.Porque é necessário compilar os programas-fontes C?
37.Qual finalidade da análise sintática?
38.Qual finalidade do linker?
39.O que é código-objeto?

40.Qual utilidade do fluxo de controle?
41.Qual utilidade da Descrição Linha a Linha?
42.O que significa o símbolo 🌑 no fluxo de controle?
43.O que significa o símbolo 🌕 no fluxo de controle?
44.Pode haver mais de um símbolo 🌑 no fluxo de controle?
45.Pode haver mais de um símbolo 🌕 no fluxo de controle?
46.Compare as estruturas da linguagem C: Sequência, Decisão e Iteração.
47.Como o fluxo de controle está relacionada à regra do dedo.
48.Quais são as regras da linguagem C para espaço, vírgula e ponto e vírgula?
49.O que são delimitadores? Cite três exemplos.
1.9.2. Exercícios
1. Considerando o Programa 1.3:

a) Faça a Descrição Linha a Linha
b) Faça o fluxo de controle
c) Identifique as unidades léxicas
d) Produza a imagem da execução para a = 5 e b = 1
e) Identifique as partes que o compõem
f) Identifique as palavras reservadas
g) Identifique os delimitadores
h) Identifique os elementos da BPC
Programa 1.3 Programa C para somar dois números
#include <stdio.h>
/*+----------------------------------------+
| Calcula a soma de dois números |
| Função: float soma( float a, float b) |
| Entrada: parcelas a e b |
| Saída: a+b |
+----------------------------------------+*/
float soma( float a, float b )
{
return a+b;
}
int main( void )
{
float a, b, c;
printf( "Informe a primeira parcela: " );

scanf ( "%f", &a );
printf( "Informe a segunda parcela: " );

scanf ( "%f", &b );
c = soma(a,b);
printf( "a+b = %5.2", c );

Programa 1.3 Programa C para somar dois números
return 0;
}
2. Para cada função abaixo, explique seu uso.
a) main
b) printf
c) scanf
3. Para cada item abaixo, explique seu uso.
a. void
b. int
c. float
d. return
e. {}
f. ()
g. ;
h. ,
i. /* */
j. //
k. DLL
l. 🌑
m. →
n. 🌕
o. <>
p. //
q. #
r.
2. Tipos de Dados Básicos
Os dados processados pelos computadores são dos mais diversos tipos,

formatos e tamanhos. Em linhas gerais, são números, letras, símbolos, textos,
imagens, sons. É necessário representá-los, armazená-los, recuperá-los e inter-
pretá-los usando apenas 0 e 1 e os limitados recursos da máquina.
Os tipos de dados são moldes para dados, dessa forma, um tipo de dado
define uma coleção de valores, quantos bits possuem, como são interpretados
e como é armazenado, além de um conjunto de operações pré-definidas sobre
estes valores. Eles também são usados para declarar variáveis ou funções.
Os tipos de dados básicos (void, bool, char, int, float e double) são intrín-
secos à linguagem C, são os tipos primitivos ou atômicos (indivisível – possui
um valor único). O Quadro 2.1 lista tipos básicos da linguagem C.
O tipo void é usado em funções, está associado ao conjunto vazio da matemática.

O tipo bool é usado na lógica básica, possui apenas dois valores, true/false ou verdadei-
ro/false.
O tipo de dados caractere (char) são valores alfanuméricos ou literais, podem armazenar
letras (A..Z, a..z), dígitos (0..9) e símbolos diversos (!"#$%&'()*+,–./:;<=>?`{|}~), apena um
caractere de cada vez. Este tipo está associado aos textos, símbolos e caracteres.
Os tipos de dados int, float e double são tipos aritméticos, estão associados aos conjun-
tos dos números inteiros e dos números reais da matemática, bem como às suas operações
numéricas e suas funções.
O tipo de dado inteiro (int) são valores numéricos que possuem apenas a parte inteira,
com valores máximos e mínimos bem definidos, ou seja, não são infinitos; estes valores po -
dem ser somados, subtraídos, multiplicados e divididos, entretanto, por serem finitos, os re-
sultados podem exceder seus limites, o que deve ser evitado. Por não possuírem a parte fra-
cionária, a divisão entre inteiros tem como resultado outro número inteiro, sem parte deci-
mal, o que pode resultar em valores imprecisos. A Computação criou uma operação de uso
exclusivo dos tipos de dados inteiros, a chamada divisão modular, que trata do resto de divi-
sões entre valores inteiros.
Os tipos de dados reais (float e double) são valores numéricos que possuem a parte in -
teira e também a parte fracionária, com valores máximos e mínimos bem definidos, ou seja,
não são infinitos; estes valores podem ser somados, subtraídos, multiplicados e divididos, en-
tretanto, por serem finitos, os resultados podem exceder seus limites, o que deve evitado. A
divisão inclui a parte fracionária.
Quadro 2.1 Tipos básicos da linguagem C
Tipo de Dado Básico Descrição
utilizado apenas em funções para indicar ausência de valor

void
retornado e ausência de parâmetro
utilizado para armazenar valores lógicos; armazena 0 (false) ou 1

bool
(true)
char utilizado para armazenar um único caractere
int utilizado para armazenar números inteiros
utilizado para armazenar números reais com até 6 casas decimais –

float
de menor precisão
utilizado para armazenar números reais com até 15 casas decimais

double
– de maior precisão
O tipo bool é usado para armazenar apenas true ou false, estão associados às expres-
sões lógicas. Em C qualquer valor ou resultado maior do que zero é true; qualquer valor ou
resultado menor do que zero é true; qualquer valor ou resultado exatamente igual a zero é
false. o uso do tipo bool requer o cabeçalho stdbool.h.
O tipo char são usados para armazenar caracteres ou literais, um único de cada vez,
desta forma ele pode armazenar letras, números e símbolos.
O tipo int pode assumir valores do conjunto dos números inteiros (ℤ), ou seja, inteiros
negativos, zero e inteiros positivos, respeitando a precisão do hardware.
Os tipos float e double podem assumir valores do conjunto dos números reais (ℝ), ou se-
ja, números reais negativos, zero e números reais positivos, respeitando a precisão do
hardware.
O Quadro 2.2 lista os tipos de dados básicos, tamanho em bytes (B), formato de leitura/
escrita e faixa de variação.
Quadro 2.2 Tipos básicos da Linguagem C, tamanho em bytes (B), formato de leitura/escrita
e faixa de variação
Tipo de Dado Tamanho (B) Formato Faixa de Variação
void - - -
Tipo de Dado Tamanho (B) Formato Faixa de Variação
bool 1 %d {0,1}
char 1 %c {–27, 27–1}
int 4 %d {–231, 231–1}
[±1.175494e-38,
float 4 %f
±3.402823e+38]
[±2.22507385850720e-308,
double 8 %lf
±1.79769313486232e+308]
A linguagem C possui, além do ipos de dados básicos, os tipos de dados derivados, eles
são muito úteis para tratar dos temas da Matemática Superior.
Os tipos derivados são montados pelo programador a partir dos tipos de dados básicos,
possuem mais de um valor associado a eles, como vetores, matrizes e strings.
O Comentário 2.1 discute a tabela ASCII e o tipo básico char.
Comentário 2.1 O tipo básico char e a tabela ASCII
O programa-fonte é escrito de forma simbólica, no formato de textos. A CPU lida apenas

com 0 e 1. Para relacionar os dados literais humanos com os números binários da CPU é
usada uma tabela relacionam números de caracteres. No caso da linguagem C, a tabela é
chamada Código ASCII.
O Código ASCII – American Standard Code for Information Interchange – Código Padrão
Americano para o Intercâmbio de Informação, em tradução livre – foi proposto como uma
solução para unificar a representação de caracteres alfanuméricos (letras, dígitos, acentos,
símbolos, sinais diversos e códigos de controle) em computadores.
O código ASCII descrito no Quadro 10.7, no Anexo, estabelece a associação entre os

valores numéricos e literais do tipo char. O tipo char é usado nos programas-fonte e nos
editores de textos mais simples.
O Quadro 10.7 contem os símbolos do código ASCII de 0 a 127. Os símbolos de 0 a 31 e

127 são códigos de controle e não são impressos. Já os de 32 a 126 podem ser impressos.
O código 32 corresponde ao caractere espaço.
2.1. Divisão Inteira
A divisão de números inteiros podem ser feita de duas formas, divisão (/) e módulo (%),
como mostrada na Figura 2.1. Desta forma, tem-se dois tipos de divisão de a por b, a e b in-
teiros e b ≠ 0:
• a / b – é igual ao quociente da divisão de a por b, indicado por q; e

• a % b – é igual ao resto da divisão de a por b, indicado por r.
Figura 2.1 Resultados r e q das divisões a % b e a / b, respectivamente.
Os valores de r = a % b e q = a / b são ambos inteiros. A expressão q = a / b é um valor

aproximado pois o resto da divisão é desprezado. A expressão r = a % b é o resto da divisão,
é um número inteiro, com 0 ≤ r < b.
Em notação matemática temos: ∀ a, b, r ∊ ℤ, r = a % b, r ∊ { 0, 1, 2,…, b-1 }.
Uma aplicação da divisão inteira é a decomposição de números inteiros, ou seja, separar
seus dígitos um a um. O Programa 2.1 discute o programa e apresenta o programa C, e seus
resultados, para a decomposição para o número inteiro 123, que é válido apenas para núme-
ros inteiros com até 3 dígitos. Este programa pode ser alterado para decompor números com
mais de 3 (três) dígitos.
Programa 2.1 Decompondo o número inteiro 123
Pensamento Computacional
Como n é do tipo inteiro, n/100 e n/10 são divisões inteiras, não tem parte fracionária, logo,
para decompor um número inteiro, por exemplo, n = 123, inicia-se pelo dígito da centena,
como mostrado a seguir:
• o dígito da centena (c) ➛ c = n/100 = 1

• o dígito da dezena (d) ➛ d = n/10 - c*10 = 2
• o dígito da unidade (u) ➛ u = n - c*100 - d*10 = 3
Os dígitos da dezena e da unidade são obtidos por sucessivas diferenças.
Programa-Fonte Imagem da Execução
#include <stdio.h>
int main( void ){
int c, d, u, n = 123;
c = n/100;
d = n/10 - c*10;
u = n - c*100 - d*10;
printf( "\n c = %d", c );

printf( "\n d = %d", d );
printf( "\n u = %d", u );
return 0;
}
A paridade de um número inteiro é uma aplicação da divisão modular. A verificação se

um número inteiro é par é feita pela divisão modular.
O Comentário 2.2 define a divisibilidade e seu uso em programação.
Comentário 2.2 Sobre o conceito de divisibilidade
Sejam m e n números naturais, n > 0. Na Teoria dos Números diz-se que:
• m é divisível por n
• n divide m
• n é múltiplo de m
Se m é divisível por n então m % n == 0, ou seja, a divisão de m por tem resto nulo.
O Programa 2.2 discute o programa e apresenta o programa C, e seus resultados, para

verificar se 2, 3, 4, 5, 6 e 7 são pares.
Programa 2.2 Verificar se um número inteiro é par
Como todo número par é divisível por 2, para verificar n é número par basta verificar se
divisão de n por 2 é zero, ou seja:
• 2 % 2 ➛ 0 (2 é par)
• 3 % 2 ➛ 1 (3 é ímpar)
• 4 % 2 ➛ 0 (4 é par)
• 5 % 2 ➛ 1 (5 é ímpar)
• 6 % 2 ➛ 0 (6 é par)
• 7 % 2 ➛ 1 (7 é ímpar)
Observe que ∀n ∊ ℕ, n % 2 ∊ {0,1}.
Conclusão: Se n % 2 = 0 então n é par, caso contrário n é ímpar.
#include <stdio.h>
int main( void ){
printf( "\n 2 %% 2 = %d", 2%2 );

printf( "\n 3 %% 2 = %d", 3%2 );
printf( "\n 4 %% 2 = %d", 4%2 );
printf( "\n 5 %% 2 = %d", 5%2 );
printf( "\n 6 %% 2 = %d", 6%2 );
printf( "\n 7 %% 2 = %d", 7%2 );
return 0;
}
2.2. BPC math.h
A Biblioteca Padrão C possui o cabeçalho math.h para as funções matemáticas. O Qua-

dro 2.3 apresenta algumas destas funções matemáticas, sua aplicação C e seu protótipo do
cabeçalhos math.h.
Quadro 2.3 Função matemática, aplicação C e protótipo do cabeçalhos math.h
Função Matemática Função C
y = ⌊x⌋ y = floor(x) double floor(double);
y = ⌈x⌉ y = ceil(x) double ceil(double);
y = cos(x) y = cos(x) double cos(double);
y = sen(x) y = sin(x) double sin(double);
y = tan(x) y = tan(x) double tan(double);
y = ex y = exp(x) double exp(double);
y = ab y = pow(a,b) double pow(double,double);
y = ln(x) y = log(x) double log(double);
y = log10(x) y = log10(x) double log10(double);
y = √x y = sqrt(x) double sqrt(double);
y = ∛x y = cbrt(x) double cbrt(double);
y = |x| y = abs(x) int abs(int);
y = |x| y = fabs(x) double fabs(double);
y = max{a,b} y = fmax(a,b) double fmax(double,double);
y = min{a,b} y = fmin(a,b) double fmin(double,double);
y = π y = M_PI y = 3.141592653589793115998;
Vale destacar que os argumentos das funções trigonométricas devem ser em radianos; a
função ceil arredonda para cima e a função floor arredonda para baixo.
Deve-se evitar, também na computação, divisão por zero, raiz quadrada de número ne-
gativo, dentre outras proibições matemáticas. As proibições matemáticas também são proibi-
das em programas-fonte e devem ser evitadas.
Consulte a referência <https://en.cppreference.com/w/c/numeric/math> para outras fun-
ções, explicações detalhadas e exemplos das funções matemáticas da BPC.
O Programa 2.3 mostra as diversas maneiras de se obter os valores de π.
Programa 2.3 Cálculos do valor de π e sua impressão
#include <stdio.h>
#include <math.h>
int main( void ){
printf("\n 1.PI = %.21lf", M_PI );
printf("\n 2.PI = %.21lf", acos(-1) );
printf("\n 3.PI = %.21lf", 2*asin(1 ) );

printf("\n 4.PI = %.21lf", 4*atan(1 ) );
return 0;
}
O Programa 2.4 mostra o uso de algumas funções matemáticas do cabeçalho math.h da

BPC, nele pode-se ver duas maneiras de se obter a raiz quadrada de um número x, com o
uso da função sqrt(x) e pow(x,0.5).
Programa 2.4 Cálculos de algumas funções matemáticas

#include <stdio.h>
#include <math.h>
int main ( void ){
double x = 2.0;
printf("\n\n\n" );
printf("\n Funções Matemáticas" );
printf("\n -------------------" );
printf("\n cos (x) = %lf", cos(x) );
printf("\n sin (x) = %lf", sin(x) );
printf("\n ln (x) = %lf", log(x) );
printf("\n log (x) = %lf", log10(x) );
printf("\n exp (x) = %lf", exp(x) );
printf("\n sqrt(x) = %lf", sqrt(x) );
printf("\n sqrt(x) = %lf", pow(x,0.5) );
printf("\n -------------------" );
printf("\n\n\n" );
return 0;
}
O Programa 2.5 verifica a validade da divisão, da raiz quadrada e do logaritmo de núme-

ro. A instrução if funciona como um filtro, é uma estrutura de decisão e será estudada a seu
tempo.
Programa 2.5 Validação da divisão, da raiz quadrada e do logaritmo
#include <stdio.h>
#include <math.h>
int main ( void ){
int a = 3, b = 4;
double x = -2.0, y = 0.0;
if( b != 0 ) printf("\n a/b válida" );

if( y != 0.0 ) printf("\n x/y válida" );
if( x >= 0.0 ) printf("\n sqrt(x) válida" );
if( x > 0.0 ) printf("\n log(x) válida" );
return 0;
}
O Comentário 2.3 discute os conceitos e a representação dos números na linguagem C.

Comentário 2.3 A representação dos números na linguagem C
O zero na Matemática é único, 0, na Computação há mais, são eles:
• false é o zero do tipo básico bool, equivale ao valor lógico false

• NULL é o zero do tipo básico char, equivale ao binário 00000000
• '0' é o zero do tipo básico char
• 0 é o zero do tipo básico int, sem casas decimais
• 0.0000000 é o zero do tipo básico float, baixa precisão
• 0.000000000000000 é o zero do tipo básico double, alta precisão
O número um na Matemática é único, 1, na Computação há mais, são eles:
• true é o um do tipo básico bool, equivale ao valor lógico true

• '1' é o um do tipo básico char
• 1 é o um do tipo básico int, sem casas decimais
• 1.0000000 é o um do tipo básico float, baixa precisão
• 1.000000000000000 é o um do tipo básico double, alta precisão
O número dois na Matemática é único, 2, na Computação há mais, são eles:
• '2' é o dois do tipo básico char

• 2 é o dois do tipo básico int, sem casas decimais
• 2.0000000 é o dois do tipo básico float, baixa precisão
• 2.000000000000000 é o dois do tipo básico double, alta precisão
E assim por diante, com os demais números.
2.3. Tipos de Dados Derivados
Os tipos de dados derivados são assim chamados pois são constituídos de tipos básicos
ou primitivos. São eles, o vetor, a string, a matriz e a enumeração, além das estruturas e ar-
quivos.
Um conjunto de dados numéricos agrupados em uma lista com um nome, este é o con-
ceito de vetor. Todos os elementos do vetor são do mesmo tipo básico de dado, são listas
homogêneas, pode-se ter vetores dos tipos int, float e double. Estes elementos ficam arranja -
dos, por simplicidade, em linhas.
Um conjunto de dados numéricos agrupados em uma tabela com um nome, este é o
conceito de matriz. Todos os elementos da matriz são do mesmo tipo básico de dado, são ta-
belas homogêneas, pode-se ter matrizes dos tipos int, float e double. Estes elementos ficam
arranjados em linhas e colunas.
Um conjunto de caracteres alfanuméricos agrupados em uma lista, terminada em NULL,
com um nome, este é o conceito de string C. Todos os elementos do vetor são do tipo char,
são listas homogêneas. Estes elementos ficam arranjados, por simplicidade, em linhas.
O Programa 2.6 mostra a leitura e a escrita da string nome de tamanho 23. O compila-
dor C requer que os tamanhos das strings sejam previamente conhecidos, incluindo o espaço
reservado para o caractere NULL; por exemplo, para armazenar 22 caracteres em uma string
C é necessário que ela tenha tamanho 23, o espaço extra é para o caractere NULL. O formato
de leitura/escrita de strings C é o %s.
Programa 2.6 Leitura e impressão string (frase.c)

2 int main( void ){
3 char nome[23]; declara a string nome de tamanho 23
4 printf( "Informe o nome: ");
Lê do teclado o valor da string nome, o formato é

5 scanf ( "%s", nome ); %s. O número de caracteres digitado deve ser menor
do que 23.
Escreve na tela o valor da string nome, o formato é

6 printf( "nome lido: %s", nome );
%s.
7 return 0;
8 }
Imagens da Execução
1. Para cada função abaixo, explique seu uso e dê três exemplos de cada uma.
double floor(double) double ceil(double) double pow(double,double)
double cos(double) double sin(double) double tan(double)
double exp(double) double log10(double) double log(double)
double sqrt(double) double cbrt(double) int abs(int)
double fabs(double) double fmin(double,double) double fmax(double,double)
2. Para cada função abaixo, explique seu uso e dê três exemplos de cada uma.
4. O que é arredondar para cima? Dê 10 exemplos – números positivos e negativos.

5. O que é arredondar para baixo? Dê 10 exemplos – números positivos e negativos.
6. Como identificar números inteiros ímpares na linguagem C? Dê cinco exemplos.
7. Como identificar números inteiros pares na linguagem C? Dê cinco exemplos.
8. Como identificar divisões inválidas usando a linguagem C? Dê cinco exemplos.
9. Como identificar logaritmos inválidas usando a linguagem C? Dê cinco exemplos.
10.Como identificar raízes cúbicas inválidas usando a linguagem C? Dê cinco exemplos.
11.'0' é igual a 0?
12.Existe o valor '1000'? E o valor '127'?
13.O que são tipos de dados derivados?
14.Qual a importância de math.h?
15.O que é string?
16.O que é NULL?
17.Como string e NULL estão relacionados?
2.4.2. Questões Avançadas
1. Quando usar o tipo void? Dê três exemplos.

2. Quando usar o tipo bool? Dê três exemplos.
3. Quando usar o tipo char? Dê três exemplos.
4. Quando usar o tipo int? Dê três exemplos.
5. Quando usar o tipo float? Dê três exemplos.
6. Quando usar o tipo double? Dê três exemplos.
7. Quais as diferenças entre os tipos básicos char e int? O que eles têm em comum?
8. Quais as diferenças entre os tipos básicos char e float? O que eles têm em comum?
9. Quais as diferenças entre os tipos básicos int e float? O que eles têm em comum?
10.Quais as diferenças entre os tipos básicos float e double? O que eles têm em comum?
11.Como o tipo char está relacionado à Tabela ASCII?
12.Quais as diferenças entre as divisões inteiras / e %? O que elas têm em comum?
13.Qual é o valor de 10 % 20?
14.Qual é o valor de 20 % 10?
15.Qual é o menor valor de a % b, a > b > 0?
16.Qual é o maior valor de a % b, a > b > 0?
17.Qual é o menor valor de a % b, b > a > 0?
18.Qual é o maior valor de a % b, b > a > 0?
19.Qual é o menor valor de a % b, a > 0, b > 0?
20.Qual é o maior valor de a % b, a > 0, b > 0?
21.Qual é o valor de 10 / 20 (divisão inteira)?
22.Qual é o valor de 20 / 10 (divisão inteira)?
23.Como a linguagem C representa números do tipo char?
24.Como a linguagem C representa números do tipo int?

25.Como a linguagem C representa números do tipo float?
26.Como a linguagem C representa números do tipo double?
27.O que é a Linguagem C?
28.O que é a Biblioteca Padrão da Linguagem C?
29.O que é GNU GCC?4 O que é programa fonte?
30.O que é programa executável?
31.Em que linguagem estão os programas executáveis?
32.O que são palavras reservadas de uma linguagem de programação?
33.O que são identificadores?
34.Quais são as regras da Linguagem C para nomear identificadores?
35. Quais os tipos primitivos da Linguagem C?
36. Quando usar o tipo bool?
37.Qual é o formato de entrada/saída dos tipos char, int, float e double?
38.Compare os tipos char, int, float e double quanto ao tamanho em bytes?
39.O que são constantes?
40.O que são variáveis?
41.O que são expressões em programas C?
42.O que são operadores em programas C?
43.O que é atribuição em programas C?
45.Para que serve #define?
46.Para que serve math.h?
47.Porque a divisão inteira em programas C é limitada?
48.Que resultado é atribuído a c = a % b ( a, b e c do tipo int )?
49.Que resultado é atribuído a c = a / b ( a, b e c do tipo int )?
50.Que resultado é atribuído a c = a / b ( a, b e c do tipo float )?
51.Qual é o valor lógico de (x > 10) && (y < 20) para x = 10 e y = 5?
52.O que é Biblioteca Padrão C?
53.O que é erro de compilação?
54.Porque é necessário compilar os programas-fontes C.
2.4.3. Exercícios Básicos
1. Faça a Descrição Linha a Linha do Programa 2.1.

2. Explique detalhadamente cada linha do Programa 2.1.
3. Explique detalhadamente a Figura 2.1, com exemplos.
4. Faça um programa que mostre o uso de todas as funções do Quadro 2.3.
5. Decomponha o número inteiro 32549.

8. Decomponha o número double 3259.274.
9. Decomponha o número double 32549.1274.
10.Preencha o quadro abaixo e avalie a precisão dos resultados por tipo de dado.
Soma da Fração Soma tipo int Soma tipo float Soma tipo double
1/8 + 6/8 = 7/8 0 0.8750000 0.875000000000000
1/9 + 7/9 = 8/9
1/10 + 8/10 = 9/10
1/11 + 9/11 = 10/11
1/12 + 10/12 = 11/12
1/13 + 11/13 = 12/13
1/14 + 12/14 = 13/14
1/15 + 13/15 = 14/15
1/16 + 14/16 = 15/16
1/17 + 15/17 = 16/17
3/7 - 2/7 = 1/7 0 0.1428571 0.142857143000000
3/9 - 2/9 = 1/9
3/11 - 2/11 = 1/11
3/13 - 2/13 = 1/13
3/15 - 2/15 = 1/15
3/17 - 2/17 = 1/17
3/19 - 2/19 = 1/19
3/21 - 2/21 = 1/21
3/23 - 2/23 = 1/23
3/25 - 2/25 = 1/25
8/2 + 8/3 = 20/3 6 6.6666667 6.66666666666667
9/2 + 9/3 = 15/2
10/2 + 10/3 = 25/3
11/2 + 11/3 = 55/6
12/2 + 12/3 = 10
13/2 + 13/3 = 65/6
14/2 + 14/3 = 35/3
15/2 + 15/3 = 25/2
16/2 + 16/3 = 40/3
17/2 + 17/3 = 85/6
13.…..
2.4.4. Exercícios Avançados

3. Identificadores, Contantes e Variáveis
A visão mais geral da computação envolve o processamento de dados, dados entram,

são processados e dados saem: entrada – processamento – saída. O processamento dos da -
dos requer realizar uma sequência de operações de forma a transformar dados de entradas
em dados de saídas. A a sequência de operações é descrita no programa-fonte e a transfor-
mação é feita pela CPU a partir do correspondente programa executável.
Os dados processados pela CPU são organizados e armazenados em uma região da me-
mória do computador, estas regiões são chamadas de variáveis. Dar nome a estas regiões da
memória permite gerenciar o processamento de dados no computador durante a execução
de um programa. As regiões não mudam mas os valores nelas armazenados mudam confor-
me a necessidade, ou seja, os valores variam. O conceito de variáveis está relacionado às re-
giões da memória do computador onde armazenados valores.
Comentário 3.1 Como as variáveis são criadas?
O conceito de variável é muito importante na elaboração de programas de computadores.
Na computação, o conceito de variável é muito parecido com o da matemática – a

matemática tem o famoso “x”, usado para representar um valor desconhecido ou
incógnito, oculto. O “x” da matemática é muito útil porque pode assumir qualquer valor, só
depende da ocasião.
As coisas do mundo tem muitos dados, por exemplo, uma pessoa tem nome, idade, altura,
salário, CPF, endereço – vamos para por aqui. Um programa de computador, que processa
dados de uma pessoa, precisa criar variáveis, neste caso, cria-se variáveis para as partes
que definem a pessoa, ou seja, variável para o nome, para a idade, para a altura, dentre
outros atributos – ou seja divide para conquistar.
Estas variáveis podem possuir dados de qualquer pessoa, pode-se ainda criar variáveis
para várias pessoas. O mais comum é criar as variáveis de uma pessoa para uso geral. Um
nome que pode ser “José” ou “Alberto” – não ao mesmo tempo; uma idade que pode ser 17
ou 65, e assim por diante. Estas variáveis representam os dados de uma pessoa específica,
elas podem ser armazenadas e processadas por computadores. Para processar os dados de
outra pessoa, basta atribuir os novos valores às variáveis já criadas, aquelas de uso geral –
isto é chamado de reutilização, parecido com o “x” da matemática.
Comentário 3.1 Como as variáveis são criadas?
Cada variável de um programa-fonte possui um tipo específico, que determina seu

tamanho em bytes, seu uso da memória, os valores que podem ser armazenados nessa
memória e suas operações.
A memória de um computador é um mapa de bits como ilustra a Figura 3.1. A CPU asso-
cia o nome de uma variável a uma região da sua memória RAM, na qual armazena o valor
desta variável, que pode ser modificado pelo programa durante sua execução. Cada variável
tem sua própria região demarcada na memória do computador – tecnicamente seu endereço
de memória.
Figura 3.1 Esquema da associação entre nome de variável de tipo char e a sua região da
memória do computador.
O tamanho do endereço na memória de uma variável depende do seu tipo. Por simplici -
dade, a Figura 3.1 mostra o esquema da variável c do tipo char, que requer endereço de 8
bits, após sua declaração.
As variáveis possuem nome, estrutura e conteúdo. O nome é dado pelo programador. A
estrutura é estabelecida pelo tipo de dado que a variável armazena. O conteúdo é o valor ar-
mazenado na variável.
A instrução de declaração realiza as seguintes ações:
1. cria um endereço para o identificador na memória do computador, isto é, reserva o

espaço na memória destinado ao identificador
2. associa o identificador ao seu endereço de memória
3. na falta de um valor inicial, o endereço do identificador conterá valores desconhecidos
(usualmente chamado de "lixo de memória")
4. associa operações permitidas com o identificador
3.1. Identificadores
Identificadores são os nomes criados pelos programadores, eles pode ter de um a 32 ca-
racteres alfanuméricos. São utilizados para dar nomes a constantes, variáveis, funções e vá -
rios outros itens definidos ou declarados pelo programador. As regras para formação dos
identificadores são:
1. o primeiro carácter é letra (a..z ou A..Z) ou um sublinhado (_)

2. após o primeiro carácter, pode conter apenas letras, sublinhados e dígitos (0..9)
3. não deve ser palavra reservada e nem nome de funções da Bibliotecas Padrão C
4. letras maiúsculas e minúsculas são tratadas de forma diferente
Exemplo 3.1 Identificadores válidos e inválidos
Identificadores válidos: Identificadores inválidos:
• NomeDoAluno • x$1 • viola a regra 2

• _val • =val • viola a regra 1
• v123 • -v#al • viola as regras 1 e 2
• char43 • 1val • viola a regra 1
• Char4 • char • viola a regra 3
• X_1 • printf • viola a regra 3
Os identificadores de programas C devem ser previamente declaradas, eles são declara-

das no topo do bloco de instruções, estas linhas iniciais do bloco são chamadas de seção de
declarações.
A declaração dos identificadores apenas define seus tipos de dados, não é necessário
atribuir-lhe valor nesta etapa.
Como cada identificadores armazena dados de um único tipo de dado, a declaração dos
seus identificadores é requerida pelo programa para que sejam definidas as operações que
podem ser feita com eles e seus usos de memória.
A declaração de um identificador consiste em definir seu tipo de dado, definir seu nome
(identificador) e, opcionalmente, seu valor inicial.
3.2. Constantes
Uma constante C pode ser criada de duas forma, por meio de uma definição (define) ou
por meio de uma declaração (const). A sintaxe da definição e da declaração de constante são
mostradas a seguir:
#define <identificador> valor

const <tipo de dado> <identificador> = valor;
Esta declaração tem apenas partes obrigatórias. A declaração const é encerrada pelo
ponto e vírgula (;).
O Programa 3.1 define as constantes:
• DEZENA, do tipo int, com valor 10;

• PI, do tipo double, com valor 3.14159265358979323846; e
• DISCIPLINA, do tipo string, com valor "Algoritmo e Programacao".
3 Nome válido mas não remendado

4 Nome válido mas não remendado
O Programa 3.1 também declara as constantes:
• OK, do tipo bool, com valor true;

• METRO, do tipo char, com valor 'm';
• DUZIA, do tipo intl, com valor 12;
• RAIO, do tipo float, com valor 6.371; e
• CARGA, do tipo double, com valor -1.602176565E-19.
Programa 3.1 Definições e declarações de constantes em Programas C
#include <stdio.h>
#include <stdbool.h> // tipo bool
#define DEZENA 10 // tipo int

#define PI 3.14159265358979323846 // tipo double
#define DISCIPLINA "Algoritmo e Programacao" // tipo string
const bool OK = true ;

const char METRO = 'm' ;
const int DUZIA = 12 ;
const float RAIO = 6.371; // raio da Terra em km
const double CARGA = -1.602176565E-19; // carga do elétron em C
int main( void ){

// seção de declarações de variáveis
// seção de instruções do programa
return 0;
}
3.3. Variáveis
A sintaxe da declaração de variável (o valor inicial é opcional):
<tipo de dado> <identificador> [= valor];
Esta declaração tem partes obrigatórias e parte opcional (indicada por []). Pode-se de-
clarar mais de uma variável, separadas por vírgula (,). A declaração é encerrada pelo ponto e
vírgula (;).
O Programa 3.2 define PI, constante double, com valor 3.14159265358979323846. Este
exemplo também declara:
• acabou, variável do tipo bool, capaz de armazenar um valor lógico (true ou false), não
atribui valor inicial, logo armazena o chamado lixo de memória;
• gen, variável do tipo char, capaz de armazenar um valor alfanumérico (ASCII), com
valor inicial 'M';
• DUZIA, constante do tipo int, com valor 12;

• idade, variável do tipo int, capaz de armazenar um valor inteiro, sem valor inicial;
• nota1 e nota2, variáveis do tipo float, capazes de armazenar valores reais de baixa
precisão, sem valores iniciais;
• media, variável do tipo double, capaz de armazenar um valor real de alta precisão,
sem valor inicial; e
• nome, variáveis do string, capazes de armazenar até 34 caracteres alfanuméricos,
com valor inicial "Jose do Egito".
Programa 3.2 Declarações de variáveis em Programas C
As linhas iniciais do programa são usadas para inclusões e definições. Elas compõem a
seção de inclusões e definições.
As linhas iniciais da função main são usadas para as declarações de variáveis e constantes.
Elas compõem a seção de declarações.
Como as variáveis foram apenas declaradas, sem valores iniciais, exceto nome, seus
endereços conterão o chamado "lixo de memória".
Observe o deslocamento das instruções da função main, esta técnica é a indentação, útil
para a legibilidade dos programas fontes.
Programa-Fonte
#include <stdio.h>
#include <stdbool.h> // tipo bool
#define PI 3.14159265358979323846
int main( void ){
bool acabou; // acabou – sim (true) ou não (false)
char gen = 'M'; // gênero de estudante
const int DUZIA = 12; // constante inteira DUZIA
int idade; // idade de estudante
float nota1, nota2; // notas de estudante
double media; // notas de estudante
string nome[35] = "Jose do Egito"; // nome de estudante
return 0;
}
As notas sobre variáveis, discutidas no Comentário 3.2, destaca que programar inclui cri-
ar variáveis, além de enfatizar as relações entre as variáveis nos programas-fonte e nos pro-
gramas executáveis, e suas relações com a CPU e a memória durante a execução dos pro-
gramas.
Comentário 3.2 Notas sobre variáveis
Durante o desenvolvimento de programas de computador é necessário criar variáveis, que

são compostas por quatro elementos básicos, a saber:
1. identificador – nome da variável, para possibilitar sua utilização

2. tipo de dado – tipo de dado da variável, que inclui suas operações
3. valor – quantidade atribuída à variável

4. endereço – região da memória alocada para a variável
Ao executar os programas, os nomes das variáveis são transformados em endereços de

memória e seus valores tornam–se conteúdos de memória. Ou seja, existem dois mundos
da programação, aquele do par {identificador, valor} e o outro par {endereço, conteúdo}.
O computador identifica cada variável por meio de um endereço e as linguagens de

programação permitem nomear cada endereço ou posição de memória, facilitando a
referência ao seu endereço.
Na programação, variáveis são capazes de reter e representar um valor ou expressão.

Tecnicamente falando, variável é uma região de memória de um computador previamente
identificada e cuja finalidade é armazenar dados de um programa por um determinado
espaço de tempo e também determinar todas as operações que podem ser feitas com ela.
Vale destacar que a memória pode armazenar um conteúdo por vez e, quando o
computador altera a memória, o conteúdo que antes estava armazenado é perdido ao dar
lugar ao novo.
A diferença entre variáveis e constantes é que as variáveis podem ter seus dados
alterados, já as constantes retém seu valor durante todo tempo de execução do programa;
mas ambas possuem {identificador, tipo de dado, valor, endereço}.
Como já visto, programas representam soluções para um problema escrito em linguagem

de computador e, assim, é comum dividir os problemas em partes 5 e, cada parte, ser
representado por uma variável. As variáveis são elementos básicos na programação, pois
são elas que armazenam os dados necessários para a sua elaboração. Dada a variedade de
problemas tratados por computador, é necessário criar muitas variáveis e ter muitos tipos
de dados para representar seus valores e suas operações.
A linguagem C exige a declaração prévia das variáveis dos seus programas.
Em resumo:
• toda variável tem um identificador, o programador precisa criar um nome para ela
• toda a variável tem um tipo de dado, o programador precisa escolher o tipo de dados
para ela
• o tipo de dado de uma variável determina o que ela é capaz de armazenar
• o tipo de dado de uma variável determina quais operações pode–se fazer com o valor
nela armazenado
• ao executar os programas, o computador reserva uma região na memória para
armazenar cada variável de acordo com seu tipo de dado
• as variáveis podem ter um valor inicial atribuído a ela
• as variáveis que não possuem valor diz–se que tem “lixo de memória”
• tecnicamente, declarar uma variável é alocar memória de máquina para seu tipo e
definir as operações desta variável e, opcionalmente, atribuir um valor à memória
5 Dividir para conquistar é uma técnica útil de resolução de problema, de origem militar; mas deve ser usada com cuidado
pois há muitos problemas que possuem sinergia entre suas partes e, nestes, o todo é maior que a soma de suas partes – e
esta técnica é de pouca utilidade.
alocada
O Programa 3.3 declara as variáveis:
• c1, c2 e c3, variáveis do tipo char, capazes de armazenar um valor alfanumérico

(ASCII), c1 não possui valor inicial, c2 e c3 possui valores iniciais;
• i1 e i2, variáveis do tipo int, capazes de armazenar um valor inteiro, i1 não tem valor
inicial e i2 possui valor inicial;
• f1 e f2, variáveis do tipo float, capazes de armazenar um valor real de baixa precisão,
f1 não tem valor inicial e f2 possui valor inicial; e
• d1 e d2, variáveis do tipo doble, capazes de armazenar um valor real de alta precisão,
d1 não tem valor inicial e d2 possui valor inicial.
Programa 3.3 Declaração de variáveis em programa C e sua impressão.
As variáveis c2 e a3 possuem o mesmo valor pois, em ASCII, 'A' é o inteiro decimal 65.
Todas as variáveis são ditas locais à função main. Este programa não tem variável global.
Foram declaradas duas variáveis de cada tipo de dado, uma sem valor inicial e a outra com
valor inicial. Veja que o tipo char permite valores iniciais da tabela ASCII, podendo ser seus
valores simbólico ou decimal. Vale lembrar que ‘A’ e o decimal 65 em ASCII.
Variável cujo valor é lixo de memória é de pouca ou nenhuma utilidade uma vez
que não pode produzir resultado confiável.
Observe os formatos usados para cada imprimir cada uma das variáveis. Variáveis do tipo
char pode ter valor inteiro ou literal e impressas como símbolo ou como número, só
depende do formato usado.
São detalhes importantes que, para nós humanos, são insignificantes.
Programa-Fonte
#include <stdio.h>
int main(void){
char c1, c2 = ‘A’, c3 = 65; // ASCII: 'A' ⇄ 65
int i1, i2 = 3;
float f1, f2 = 4.0;
double d1, d2 = 5.0;
// imprimindo valores
printf( "\n c1 = %c” , c1 ); // sem valor inicial, imprime “lixo da memória”
printf( "\n c2 = %c” , c2 );
printf( "\n c2 = %d” , c2 );
printf( "\n c3 = %c” , c3 );
printf( "\n i1 = %d” , i1 ); // sem valor inicial, imprime “lixo da memória”

printf( "\n i2 = %d” , i2 );
printf( "\n f1 = %f” , f1 ); // sem valor inicial, imprime “lixo da memória”

printf( "\n f2 = %f” , f2 );
printf( "\n d1 = %lf”, d1 ); // sem valor inicial, imprime “lixo da memória”

printf( "\n d2 = %lf”, d2 );
return 0;
}
3.4. Dicionário de dados
O Dicionário de Dados, discutido no item Capítulo 9.2.3, consiste em um quadro com as

variáveis, constantes e funções são dispostas nas linhas da tabela, sendo as colunas o nome
da variável, sus descrição, seu tipo de dados, seu valor inicial e o tipo de processo (Entra-
da➛Processamento➛Saída).
A título de exemplo, será feito o Dicionário de Dados do Programa 3.2, ele é bem sim-
ples e tem apenas o processo de Entrada. Neste caso, o Dicionário de Dados está feito no
Quadro 3.1.
Quadro 3.1 Dicionário de Dados do Programa 3.2, ordenado por nome
Nome Descrição Tipo de Dado Valor Inicial Processo
acabou indica fim bool - E
DUZIA constante const int 12 E
gen gênero de estudante char 12 E
idade idade de estudante int - E
media média de estudante double - E
nome nome de estudante string "Jose do Egito" E
nota1 nota de estudante float - E

Nome Descrição Tipo de Dado Valor Inicial Processo
nota2 nota de estudante float - E
PI constante double 3.14159... E
1. O que são constantes?

2. O que são variáveis?
3. Quais as diferenças e as semelhanças entre constante e variáveis?
4. O que é ponto fixo?
5. O que é dicionário de dados?
6. Qual é a utilidade do dicionário de dados?
7. Quais são as regras da Linguagem C para nomear identificadores?
8. Compare os tipos char, int, float e double quanto ao tamanho em bytes?
9. O que são constantes em programas C?
10.O que são variáveis em programas C?
12.Para que serve #define?
13.Para que serve math.h?
15.Porque é necessário compilar os programas-fontes C.
16.Faça a Descrição Linha a Linha do Programa 3.3.
17.Explique detalhadamente cada linha do Programa 3.3.
18.Faça o Dicionário de Dados do Programa 3.3.
4. Operações de Entrada e Saída (E/S)
A Linguagem C não possui meios para a entrada/saída de dados (E/S). Estes recursos, e
muitos outros, estão disponíveis na Biblioteca Padrão C.
Há várias funções para E/S à disposição do programador, as mais usadas são printf e
scanf:
printf( "string de controle", lista de parâmetros );

scanf ( "string de controle", lista de parâmetros );
A linguagem C estabelece o teclado como sua entrada padrão, e define a constante st-
din (standard input) para representar o teclado. Ela também o vídeo como sua saída pa-
drão, e define a constante stdout (standard output), para representar o vídeo. Ilustrado pe-
la Figura 4.1.
Figura 4.1 Relação entre E/S e as funções scanf/printf da Linguagem C.
No Quadro 4.1 estão as instruções para leitura e escrita dos tipos básicos da linguagem
C (bool, char, int, float e double). Tanto o printf quanto o scanf pode escreve/lê mais de uma
variável.
Quadro 4.1 instrução para leitura e escrita dos tipos de dados primitivos
Variável Escrita Leitura
bool u printf( "%d" , u ); scanf( "%d" , &u );
char x printf( "%c" , x ); scanf( "%c" , &x );
int y printf( "%d" , y ); scanf( "%d" , &y );

Variável Escrita Leitura
float w printf( "%f" , w ); scanf( "%f" , &w );
double z printf( "%lf", z ); scanf( "%lf", &z );
O Comentário 4.1 enfatiza alguns aspectos das funções de E/S da BPC, uma boa dica é
imprimir os valores lidos do teclado, muitos erros são de entrada de dados mal formatadas.
Comentário 4.1 Notas sobre as funções de E/S
• é necessário o caractere & antes das variáveis na função scanf.

• se a entrada padrão for o teclado, ao executar um printf, o computador aguarda a
digitação do valor da variável até que se tecle ENTER.
• a tecla ENTER finaliza a leitura pelo teclado
• é comum errar o formato de entrada dos tipos de dados, uma maneira de certificar–
se é a impressão dos dados lidos com o printf.
Na Figura 4.2.a a função printf que escreve os valores de h, m e s, separados por dois
pontos (:). A Figura 4.2.b a função scanf lê os valores de h, m e s, separados por espaço. No
scanf é obrigatório o uso do símbolo & antes da variável6.
(a)
(b)
Figura 4.2 Uso do printf/scanf para escrever/ler os valores de três variáveis.
No Quadro 4.2 estão listados os códigos para formatação das “strings de controle” das
funções printf e scanf. O mais usado é o \n, nova linha.
Quadro 4.2 Códigos básicos para formatação das “strings de controle” das funções printf e
scanf
Código Descrição
\0 nulo ou NULL
\a sinal sonoro
\b retrocesso
6 Tem exceções que serão vistas a seu tempo.

Código Descrição
\n nova linha
\t tabulação horizontal
4.1.1. E/S dos Tipos Básicos
O Programa 4.1 descreve as instruções para leitura/escrita dos tipos char, int, float e
double.
Programa 4.1 E/S de char, int, float e double em programas C
Lendo char e escrevendo-o na tela
#include <stdio.h>
int main ( void ){
char c;
printf( "Digite uma letra: " );
scanf ( "%c", &c );
printf( "Letra digitada: %c", c );
return 0;
}
Ao executar o programa, digite um caractere e tecle ENTER. Se for digitado mais de um

caractere, será lido apenas o primeiro, os demais serão desprezados. É necessário o
caractere de controle & para leitura dos tipos de dados primitivos.
Lendo inteiros separados por espaço e escrevendo–os na tela
#include <stdio.h>
int main ( void ){
int x, y;
printf( "Digite os valores de x e y : " );
scanf ( "%d %d", &x, &y );
printf( " x = %d", x );
printf( " y = %d", y );
return 0;
}
Ao executar o programa, digite dois números inteiros separados por espaço e tecle ENTER
Lendo inteiros, separados por vírgula, do teclado e escrevendo–os na tela
#include <stdio.h>
int main ( void ){
int x, y;
printf( "Digite os valores de x e y : " );
scanf ( "%d,%d", &x, &y );
printf( " x = %d", x );
printf( " y = %d", y );
return 0;
}
Programa 4.1 E/S de char, int, float e double em programas C
Ao executar o programa, digite dois números inteiros separados por vírgula e tecle ENTER
Lendo float e escrevendo-o na tela
#include <stdio.h>
int main ( void ){
float x;
printf( "Digite o valor de x : " );
scanf ( "%f", &x );
printf( " x = %f", x );
return 0;
}
Lendo double e escrevendo-o na tela
#include <stdio.h>
int main ( void ){
double x;
printf("Digite o valor de x : " );
scanf("%lf", &x );
printf(" x = %lf", x );
return 0;
}
Lendo char, int, float e double e escrevendo-os na tela
#include <stdio.h>
#include <stdbool.h>
int main ( void ){
bool b;
char c;
int i;
float f;
double d;
printf( "Digite o valor de b, c, i, f e d: " );
scanf ( "%d %c %d %f %lf", &b, &c, &i, &f, &d );
printf( "%d %c %d %f %lf", b, c, i, f, d );
return 0;
}
O Programa 4.2 lê valores de variáveis dos tipos de dados primitivos. O programa foi or-
ganizado em quatro funções, para facilitar o seu entendimento, a função main chama as de-
mais funções. Nas funções, exceto main, são declaradas uma variável de cada tipo, em se -
guida é feita a leitura de stdin e escrita em stdout.
O Programa 4.1 e Programa 4.2 servem de modelos para outros programas com E/S.
Programa 4.2 E/S de valores de variáveis dos tipos de dados primitivos
#include <stdio.h>
void Bool( void ){

bool b;
printf( "\n" );
printf( "De um valor bool {0,1}: " );
scanf ( "%c", &b );
printf( "Valor lido: %c", b );
}
void Char( void ){

char c;
printf( "\n" );
printf( "De um valor char: " );
scanf ( " %c", &c );
printf( "Valor lido: %c", c );
}
void Int( void ){

int i;
printf( "\n" );
printf( "De um valor int: " );
scanf ( "%d", &i );
printf( "Valor lido: %d", i );
}
void Float( void ){

float f;
printf( "\n" );
printf( "De um valor float: " );
scanf ( "%f", &f );
printf( "Valor lido: %f", f );
}
void Double( void ){

double d;
printf( "\n" );
printf( "De um valor double: " );
scanf ( "%lf", &d );
printf( "Valor lido: %lf", d );
}
int main( void ){

Bool();
Char();
Int();
Float();
Double();
return 0;
}
4.1.2. E/S do Tipo string
O tipo char é capaz de armazenar um único carácter alfanumérico, a linguagem C possui

o tipo derivado string que pode conter vários carácteres alfanuméricos, como frases e textos.
A declaração de uma string é feita usando o tipo char com o tamanho máximo do texto
armazenado entre colchetes. A linguagem C marca o fim da string com o caractere NULL (AS -
CII 0000 0000). O formato de leitura e escrita do tipo string é %s.
A sintaxe para declarar uma string de nome str de tamanho 25 e valor inicial "valor inici-
al de str" é mostrada abaixo:
char str[26] = "valor inicial de str"; // 26 = 25 + 1 (valor + NULL)
A instrução de E/S para leitura de str são:
printf( "%s", str );

scanf ( "%s", str );
Note que o formato de leitura e escrita do tipo string são iguais, o caractere de controle
& não é usado na leitura de variáveis do tipo string.
O Programa 4.3 declara, lê e escreve o valor de duas strings. Este programa serve de
modelos para outros programas com E/S de string.
Programa 4.3 E/S de textos
#include <stdio.h>
int main( void ){
char nome[35] = "Nome padrao",
profissao[35] = "Profissao padrao";
printf( "Digite o nome: " );

scanf ( "%s", nome );
printf( "Digite ao profissao: " );
scanf ( "%s", profissao );
Programa 4.3 E/S de textos
printf( "\n Nome : %s ", nome );

printf( "\n Profissao: %s ", profissao );
return 0;
}
O tipo string será visto em um capítulo específico, com mais detalhes.
4.1.3. Fluxograma da E/S
O Programa 4.4 declara, lê e escreve o valor da variável x. O fluxograma abaixo realiza o

mesmo processo. O fluxograma não faz do tipo de dado, qualquer que seja o tipo de x, o flu -
xograma é o mesmo. O Fluxograma é apresentado no item 9.5 do Anexo.
Programa 4.4 Programa e fluxograma das funções printf e scanf
Programa-Fonte Fluxograma
#include <stdio.h>
int main( void ){
int x;
scanf ( "%d", &x );
printf( "%d", x );
return 0;
}
4.1.4. Programa para Gerar Dados de Entrada
A BPC possui a função int rand( void ) que gera números inteiros aleatórios entre 0 e a
constante inteira RAND_MAX, requer #include <stdlib.h>. Pode-se usar o operador módulo
para limitar o valor a uma faixa menor. Esta função é muito útil para gerar dados de entrada,
evitando digitações enfadonhas.
O Programa 4.5 declara duas variáveis x y, gera um valor aleatório para x, um outro va -
lor aleatório para y e as imprime. Imprime também o valor de RAND_MAX pois ele depende
do hardware.
Programa 4.5 Programa para gerar dados de entrada
#include <stdio.h>
#include <stdlib.h> // para usar rand() e RAND_MAX
#define MAX 5
int main( void ){
int x, y;
x = rand() % MAX; // x na faixa para 0 a MAX-1

y = rand() ; // y na faixa para 0 a RAND_MAX
printf("\n x = %d", x );
printf("\n y = %d", y );
printf("\n RAND_MAX = %d", RAND_MAX );
return 0;
}
Este programa serve de modelos para outros programas que requerem dados gerados
de forma automática.
4.2.1. Questões
1. O que são entradas e saídas?

2. Qual é a utilidade das entradas e das saídas?
3. Qual é o formato de entrada/saída dos tipos char, int, float e double?
4. O que é lido quando o formato de entrada é %c mas a variável lida é do tipo int?
5. O que é lido quando o formato de entrada é %c mas a variável lida é do tipo float?
6. O que é lido quando o formato de entrada é %c mas a variável lida é do tipo double?
7. O que é lido quando o formato de entrada é %d mas a variável lida é do tipo char?
8. O que é lido quando o formato de entrada é %d mas a variável lida é do tipo float?
9. O que é lido quando o formato de entrada é %d mas a variável lida é do tipo double?
10.O que é lido quando o formato de entrada é %f mas a variável lida é do tipo char?
11.O que é lido quando o formato de entrada é %f mas a variável lida é do tipo int?
12.O que é lido quando o formato de entrada é %f mas a variável lida é do tipo double?
13.O que é escrito quando o formato de saída é %c mas a variável escrita é do tipo int?
14.O que é escrito quando o formato de saída é %c mas a variável escrita é do tipo float?
15.O que é escrito quando o formato de saída é %c mas a variável escrita é do tipo
double?
16.O que é escrito quando o formato de saída é %d mas a variável escrita é do tipo char?
17.O que é escrito quando o formato de saída é %d mas a variável escrita é do tipo float?
18.O que é escrito quando o formato de saída é %d mas a variável escrita é do tipo
double?
19.O que é escrito quando o formato de saída é %f mas a variável escrita é do tipo char?
20.O que é escrito quando o formato de saída é %f mas a variável escrita é do tipo int?
21.O que é escrito quando o formato de saída é %f mas a variável escrita é do tipo
double?
4.2.2. Exercícios
1. Leia três valores, dos tipos char, int e float. Veja o que acontece quando se escreve:
a) leia char com formato de int e escreva com formato de int.
b) leia char com formato de float e escreva com formato de char.
c) leia int com formato de char e escreva com formato de float.
d) leia int com formato de float e escreva com formato de int.
e) leia float com formato de char e escreva com formato de char.
f) leia float com formato de int e escreva com formato de float.
g) experimente outras combinações e explique os resultados.
a) rand
b) printf
c) scanf
3. Para cada item abaixo, explique seu uso.
a) %c
b) %d
c) %f
d) %lf
e) %s
f) &
g) \n
h) NULL
4. Faça o fluxograma do Programa 4.1.
5. Faça a Descrição Linha a Linha do Programa 4.2.
6. Explique detalhadamente cada linha do Programa 4.2.
7. Faça o Dicionário de Dados do Programa 4.2.
8. Faça o fluxo de controle do Programa 4.2.
5. Operadores e Expressões
Os operadores são símbolos que representam as operações básicas do computador, eles

são os meios pelos quais se realizam cálculos matemáticos ou manipulações lógicas envol-
vendo variáveis e constantes.
Há quatro tipos principais de operadores na linguagem C, os aritméticos, os relacionais,
os lógicos e a atribuição.
Cada tipo operadores possui um conjunto de operações que estão relacionados aos tipos
de dados das variáveis e constantes. Os operadores aritméticos estão relacionados aos tipos
int, float e double e suas operações que são, de modo geral, operações matemáticas, já co-
nhecidas pelos estudantes. Os operadores relacionais e os lógicos podem estar presentes nas
instruções que resultam valores lógicos (false ou true).
5.1. Operadores Aritméticos
Os operadores aritméticos da linguagem C estão listados no Quadro 5.1, eles são usados
para operações com valores numéricos constantes e variáveis. Exceto os operadores ++, -- e
%, os demais já são bem conhecidos.
O operador ++ adiciona uma unidade ao valor da variável, quer ela seja do tipo char,
int, float ou double. Seja x = 222 uma variável, x++ faz com o valor de x aumente de uma
unidade, e seu valor passa a ser 223. De forma isolada, tanto faz x++ ou ++x, o efeito é o
mesmo, exceto em expressões.
O operador -- subtrai uma unidade do valor da variável, quer ela seja do tipo char, int,
float ou double. Seja x = 222 uma variável, x-- faz com o valor de x diminuir de uma unidade,
e seu valor passa a ser 221. De forma isolada, tanto faz x-- ou --x, o efeito é o mesmo, exceto
em expressões.
O operador % é um tipo especial de divisão, ela devolve o resto da divisão entre inteiros.
Seja x = 10 e y = 6, duas variáveis do tipo int, x % y resulta 4.
Quadro 5.1 Operadores Aritméticos da linguagem C
Operador Ação Exemplo
– menos unário a = –b
+ mais unário a = +b
++ incremento (de 1) ++a, a++
–– decremento (de 1) ––a, a––
* multiplicação a=b*c
/ divisão inteira a=b/c
/ divisão real a=b/c
% resto da divisão inteira a=b%c
+ soma a=b+c
– subtração a=b–c
Embora a divisão entre variáveis do tipo int e a divisão entre variáveis dos tipos float e
double sejam diferentes, o mesmo operador / é usado para ambas. Ou seja, o mesmo opera-
dor / é tanto para a divisão entre variáveis do tipo int quanto entre variáveis dos tipos float e
double.
Como já é conhecido, a divisão inteira, envolvendo variáveis do tipo int resulta em um
valor do tipo int e, portanto, não possui parte fracionária. A divisão envolvendo variáveis do
tipo float e double resulta em um valor do tipo float ou double e, portanto, possui parte fraci-
onária. Como são resultados de tipos diferentes, requerem formatos de impressão diferentes.
5.2. Operadores Relacionais
Os operadores relacionais da linguagem C estão listados no Quadro 5.2, eles são usados
para operações com valores constantes e variáveis, retornando como resultado um valor ló-
gico (falso ou true). Exceto os operadores == e !=, os demais já são bem conhecidos.
Os operadores == e != comparam valores ou resultados de expressões, == compara se
são iguais e != compara se são diferentes. O uso de == pode gerar graves erros de progra-
mação pois é muito comum usar = quando deveria usar ==.
Quadro 5.2 Operadores Relacionai da linguagem C
> maior que a>b
>= maior ou igual a a >= b
< menor que a<b

<= menor ou igual a a <= b
== igual a a == b
!= diferente de a != b
5.3. Operadores Lógicos
Os operadores lógicos da linguagem C estão listados no Quadro 5.3, eles são usados na
comparação entre valores ou expressões, resultam um valor lógico (false ou true).
Quadro 5.3 Operadores lógicos da linguagem C
! não !a
&& e a && b
|| ou a || b
O Comentário 5.1 trata da origem da lógica da computação e seus operadores.
Comentário 5.1 A Álgebra Booleana
A função de Boole, é uma regra qualquer para transformar um certo número de dados
binários (sim ou não) em um resultado também binário (sim ou não).
O exemplo mais simples é a função de Boole Negação, que usa apenas um dado: se o valor
do dado é Sim, o resultado é Não; e se o valor do dado é Não, o resultado é Sim.
O matemático e filósofo inglês George Boole (1815-1864) publicou a chamada "Algebra de
Boole", no seu "As Leis do Pensamento", publicado em 1854. Nele, Boole formulou a
matemática da lógica. Nesta teoria, os valores binários podem ser Sim e Não, como no
nosso exemplo, ou Verdadeiro e Falso, ou até 1 e 0, usados na computação: não faz
diferença.
Ataulmente tem grande relevância, a Álgebra de Boole está na base da computação pois
tudo o que os computadores eletrônicos fazem é calcular funções de Boole.
Outros exemplos de funções de Boole são a Conjunção (e) e a Disjunção (ou) que, que faz
uso de dois e pode ser resolvida com o emprego da Tabela Verdade.
Tabela verdade é usada em lógica para determinar o valor lógico de uma expressão, o
Quadro 5.4 apresenta os resultados das tabelas verdade dos operadores lógicos !, && e ||,
em que A e B possui valor lógico false (0,F) ou true (diferente de 0,V). Neste caso, A && B
tem valor true se A e B forem ambos true; A !! B tem valor false se A e B forem ambos false;
e !A inverte o valor lógico de A.
Quadro 5.4 Tabela verdade dos operadores lógicos !, && e ||
A B A && B A || B !(A && B) !(A || B) !A !B
V V V V F F F F
V F F V V F F V
F V F V V F V F
F F F F V V V V
5.4. Operador Atribuição
Usado para atribuir valores para os identificadores, seu símbolo é o sinal de igual (=).
A sintaxe mais gral de uma atribuição é dada a seguir, e envolve uma variável e uma ex-
pressão.
<variável> = <expressão>;
O operador de atribuição divide a instrução em duas partes. A parte à sua direita é de-
nominada rvalue (right value em inglês) e a parte à sua esquerda é denominada lvalue (left
value em inglês).
lvalue = rvalue
O operador de atribuição opera na seguinte ordem:
1. a CPU processa o rvalue e armazena seu resultado

2. a CPU atribuí o resultado do rvalue, previamente armazenado, ao lvalue
Dessa forma, ao atribuir o valor de rvalue ao lvalue, o valor anterior do lvalue é perdi-
do. Isto tem muitas implicações nas técnicas de programação, em muitos casos é necessário
criar variáveis temporárias para armazenar o valor de um lvalue, antes de uma atribuição,
de forma que ele não se perca.
Ao fazer atribuições, a CPU grava na memória do computador o valor da variável a ela
atribuído.
O lado esquerdo do operador de uma atribuição (lvalue) deve ser uma variável. Por ou-
tro lado, o lado direito do operador de atribuição (rvalue) pode ser uma constante, uma vari-
ável, uma expressão ou uma função. Estas opções podem ser assim representadas:
<variável> = <constante>;
<variável> = <variável> ;
<variável> = <expressão>;
<variável> = <função> ;
No Programa 5.1 são mostrados exemplos de atribuições da linguagem C.
Programa 5.1 Atribuições em programas C
#include <stdio.h>
#include <math.h>
#define PI 3.14159265358979323846
int main( void ){
bool acabou; // acabou – sim (true) ou não (false)
char gen = 'M'; // gênero de estudante
const int DUZIA = 6; // constante inteira DUZIA
int idade; // idade de estudante
float nota; // nota de estudante
double y; // y = cos(PI) + sin(PI/2);
string nome[35] = "Jose do Egito"; // nome de estudante
nota = 9.5;
acabou = false;
idade = DUZIA;
y = cos(PI) + sin(PI/2);
return 0;
}
Ao fazer atribuições, o programa executável grava o novo valor da variável no seu ende-
reço de memória.
A linguagem C tem a opção de abreviar algumas instruções de atribuição. Por ser muito
comum expressões do tipo x = x + 1, incremento de 1, elas pode se abreviada para x++ ou
++x, conforme a necessidade. As abreviações de atribuição são opcionais. No Quadro 5.5 es-
tão outras abreviações do operador de atribuição.
Quadro 5.5 Abreviações de atribuição da linguagem C
Expressão Matemática Abreviação em linguagem C
a=a+1 a++
a=a–1 a––
a=a+x a += x
a=a–x a –= x
a=a*x a *= x
a=a/x a /= x
a=a%x a %= x
A ordem importa, x = i++ é diferente de x = ++i:
• x = i++, atribui e depois incrementa

• x = ++i, incrementa e depois atribui
Em expressões mais elaboradas, recomenda–se aplicar a regra e testar o programa.
5.5. Expressões
As expressões mais simples são formadas por operadores, constantes, variáveis e fun-
ções. Duas ou mais expressões simples podem ser reunidas para formar uma expressão
composta e assim sucessivamente.
As expressões da linguagem C podem ser aritméticas, relacionais, lógicas e mistas. O
Exemplo 5.1 mostram expressões matemáticas e suas correspondentes expressões aritméti-
cas em linguagem C.
Exemplo 5.1 Expressões aritméticas em C
Expressão Matemática Correspondência em linguagem C
c=a+b c = a + b;
d=c×(a+b) d = c * (a + b);
a
d= ×c d = (a/b) * c;
b
a c
e= + e = a/b + c/d;
b d
a
−c
b e = (a/b - c) / d;
e=
d
a mod b−c
e= e = (a % b - c) / d;
d
b
c=a c = pow(a,b)
d =√ (a +b) d = sqrt(a+b)
2 2
b=cos (a) +sen(a) b = pow(cos(a),2.0)+pow(sin(a),2.0)
f=
√ cos(a)+sen (b ) f = sqrt( cos(a) + sin(b) ) / ( exp(c) – log(d) )
c
e −ln(d )
Exemplo 5.1 Expressões aritméticas em C
Expressão Matemática Correspondência em linguagem C
b=|a| b = abs(a); // b, a int
b=|a| b = fabs(a); // b, a float ou double
É necessário #include <math.h> para usar abs, exp, fabs, log, cos, pow, sqrt e sin. É
uma boa prática testar expressões aritméticas para verificar se foram redigidas corretamen-
te.
O Quadro 5.6 mostra exemplos de expressões lógicas em matemática, em C e seus cor-
respondes valores lógicas.
Quadro 5.6 Exemplos de expressões lógicas em matemática, em linguagem C e seus

correspondes valores lógicos
Expressão lógica Expressão lógica em C Valores de x e y Valor lógico
x ≥ 10 x >= 10 x = 9 false
x > 10 e y < 20 (x > 10) && (y < 20) x = 11, y = 15 true
x + y = 5 ( x + y ) == 5 x = 1, y = 5 false
x + y ≠ 5 ( x + y ) != 5 x = 1, y = 5 true
x > 10 ou y < 20 (x > 10) || (y < 20) x = 11, y = 15 true
O Exemplo 5.2 tem grande valor didático porque mostra o quanto nossa linguagem na-
tural é diferente das linguagens de programação. Do lado direito deste exemplo estão elen-
cadas várias frases em português e, à direita, sua correspondente expressão lógica em C.
Exemplo 5.2 Condição em linguagem natural e sua correspondente expressão lógica em

linguagem C
Condição Expressão lógica em linguagem C
pessoa é de maior de idade no Brasil idade >= 18
pessoa é obrigada a votar no Brasil (idade >= 18) && (idade <= 70)
condição de existência de raiz quadrada x >= 0
condição de existência de logaritmo x>0
x é número par x % 2 == 0, x é int
x é número ímpar x % 2 != 0, x é int
cálculo da média de valores n > 0, n é o contador de parcelas
No lado direito do Exemplo 5.3 estão elencadas intervalos de números reais e, à direita,
sua correspondente expressão lógica em linguagem C.
Exemplo 5.3 Intervalo de números reais e sua correspondente expressão lógica C
Intervalo Expressão lógica C
[a,b] ➛ a ≤ x ≤ b ➛ fechado tanto à esquerda quanto à direita (a <= x) && (x <= b)
(a,b] ➛ a < x ≤ b ➛ aberto à esquerda e fechado à direita (a < x) && (x <= b)
[a,b) ➛ a ≤ x < b ➛ fechado à esquerda e aberto à direita (a <= x) && (x < b)
(a,b) ➛ a < x < b ➛ aberto tanto à esquerda quanto à direita (a < x) && (x < b)
O Programa 5.2 ajuda a entender as expressões mistas.
Programa 5.2 Qual o valor de w?
#include <stdio.h>
int main( void ){
bool w;
int x, y, z;
x = 2;
y = 5;
z = 9;
w = (x + y) > z;
return 0;
}
Como x+y = 2 + 5 = 7 e z = 9, o valor de w é falso.

Resposta: o valor de w é 0.
O Comentário 5.2 discute os operadores ++ e -- em expressões.
Comentário 5.2 Os operadores ++ e -- em expressões
A expressão ++a é chamada pré-incremento pois primeiro a é incrementado e depois seu

valor é atribuído a x, após executar a instrução x = ++a; o valor de a é igual a 4 e o valor
de x é igual a 4.
A expressão b++ é chamada pós-incremento pois primeiro o valor de b é atribuído a y e

depois seu valor é incrementado, após executar a instrução y= b++; o valor de b é igual a
5 e o valor de y é igual a 4.
O mesmo pensamento se aplica ao pré-decremento (--c) e ao pós-decremento (d--).

Comentário 5.2 Os operadores ++ e -- em expressões
#include <stdio.h>
int main( void ){
int a = 3, b = 4, c = 5, d = 6, x, y, z, w;
x = ++a;
y = b++;
z = --c;
w = d--;
printf( "\n a = %d", a );

printf( "\n b = %d", b );
printf( "\n c = %d", c );
printf( "\n d = %d", d );
printf( "\n x = %d", x );
printf( "\n y = %d", y );
printf( "\n z = %d", z );
printf( "\n w = %d", w );
return 0;
}
5.6. Precedência e Associatividade dos Operadores
Os operadores da linguagem C são numerosos, tratamos de alguns neste livro, não de

todos. Por ser em grande número, eles são organizados em um quadro, composto de linha e
colunas. A ordem das linhas é chamada de precedência e a ordem das colunas é chamada de
associatividade.
Os operadores são organizados em grupos de precedência e a associatividade determi-
na a ordem em que os operadores de cada grupo são processados, se da esquerda para a di -
reita ou se da direita para a esquerda. Juntas, a precedência e a associatividade dos operado-
res C determinam a ordem em que os operadores são processados em uma expressão.
No Quadro 5.7, a precedência dos operadores da linguagem C é representada pelas li-

nhas, em ordem decrescente de prioridade; por exemplo, os operadores de multiplicação (*),
de divisão (/) e módulo (%) possuem a mesma precedência, formam um grupo, estão na
mesma linha. Por outro lado, o operador de multiplicação (*) tem maior precedência do que o
operador de adição (+) pois estão em linhas diferentes, em grupos diferentes. Como o grupo
da multiplicação tem maior precedência do que o grupo da adição, a multiplicação será pro-
cessada antes da adição em uma operação com ambas presentes.
No Quadro 5.7, a associatividade dos operadores da linguagem C é representada pelas

colunas; por exemplo, os operadores de multiplicação (*), de divisão (/) e módulo (%) formam
um único grupo e, dentro do grupo, sua associatividade é da esquerda para a direita. Por
exemplo, em uma expressão com os operadores multiplicação (*) e divisão, que possuem a
mesma precedência, a multiplicação será processada antes da divisão pois o grupo de prece-
dência tem associatividade da esquerda para a direita.
No Quadro 5.7 está precedência dos operadores da linguagem C, representada pelas li-
nhas, em ordem decrescente de prioridade. Em uma expressão, os operadores da primeira li-
nha da tabela são executados primeiro e os operadores da última linha da tabela são execu -
tados por último. Na mesma linha, a ordem de execução é conforme a última coluna, a asso-
ciatividade dos operadores desta linha, que pode ser da esquerda para a direita (e→d) ou da
direita para a esquerda (d→e).
No Quadro 5.7, os operadores da segunda linha do quadro são todos unários (um só ope-
rando, -r, ++s, t++, --u, v--, !x); os operadores das demais linhas da tabela são binários (dois
operandos). Por exemplo, os parêntesis possui a maior prioridade dentre todos os operado-
res, pois está na primeira linha da tabela e, dentro desta da linha, a associatividade é e→d. O
operador vírgula (,) é o de menor prioridade dentre todos os operadores, pois está isolado na
última linha do quadro.
Quadro 5.7 Precedência e associatividade dos operadores da linguagem C
() [] e→d
- ++ -- ! d→e
* / % e→d
+ - e→d
< <= >= > e→d
== != e→d
&& e→d
|| e→d
= %= -= += /= *= d→e
, e→d
O Quadro 5.7 pode ser reorganizado, de forma a eliminar a associatividade, em um qua-

dro de duas colunas, Precedência (P) x Operador (O), mais fácil para o programador iniciante
aplicar estas regras nas expressões, como mostrado no Quadro 5.8.
Quadro 5.8 Precedência (P) de alguns operadores (O) da linguagem C
P 1 2 3 4 5 6 7 8 9 10 11 12 13
O () [] ! -- ++ - * / % + - < <=
P 14 15 16 17 18 19 20 21 22 23 24 25 26
O >= > == != && || *= /= += -= %= = ,
O Programa 5.3 discute a precedência dos operadores = , * / + e ().
Programa 5.3 Precedência dos operadores = , * / + e ().
Pode-se destacar o operador vírgula (,), na declaração das variáveis. A ordem de criação
das variáveis é da esquerda para a direita. Ao declarar a variável x, atribui-se o valor 3.0 a
ela, antes de declarar y, porque o operador = tem precedência maior do que o operador ,.
Os operadores * / + das expressões deste exemplo são binários. Os operadores * e / são da
terceira linha e o + é da quarta linha do Quadro 5.7, por isso a precedência de * e / é maior
do que a do +.
Como a precedência da terceira linha é e→d, a ordem de avaliação das expressões e1 e e2
deste exemplo são diferentes. Na expressão e1, o operador * vem primeiro, logo é avaliado
x * y. Na expressão e2, o operador / vem primeiro, logo é avaliado x / y.
Nas expressões e3 e e4, * e / tem precedência maior do que +, assim a adição é avaliada
por último.
Na expressão e5, os (), que tem a maior precedência dentre todos os operadores, faz com
que y + z, seja avaliada primeiro.
L Programa-Fonte
2 int main(void){
3 float x = 5.0, y = 10.0, z = 15.0, e1, e2, e3, e4, e5;
4
5 e1 = x * y / z;
6 e2 = x / y * z;
7 e3 = x * y + z;
8 e4 = x + y * z;
9 e5 = x *(y + z);
10
11 printf("\n e1 = x * y / z → e1 = %f", e1 );
12 printf("\n e2 = x / y * z → e2 = %f", e2 );
13 printf("\n e3 = x * y + z → e3 = %f", e3 );
14 printf("\n e4 = x + y * z → e4 = %f", e4 );
15 printf("\n e5 = x *(y + z) → e5 = %f", e5 );
16
17 return 0;
18 }
Programa 5.3 Precedência dos operadores = , * / + e ().
O Exemplo 5.4 mostra a prioridade entre os operadores da linguagem C.
Exemplo 5.4 Prioridade entre os operadores da linguagem C
Estabeleça a ordem de avaliação dos operadores na expressão:

(a+b) > (c+d) && (e==0)
prioridade 1 2 1 3 2
expressão (a + b) > (c + d) && (e == 0)
O Programa 5.4 ajuda a entender as expressões mistas.
Programa 5.4 Qual o valor de w?
#include <stdio.h>
int main( void ){
bool w;
char letra;
int x, y, z;
x = 2;
y = 5;
z = 9;
letra = 'M';
w = (x + y > z ) && ( letra == 'M' );
return 0;
}
A ordem de avaliação da expressão ( x+y > z ) && ( letra == 'M' ) é dada por
prioridade 1 2 3 2
expressão (x + y) > z
(letra == 'M')
7 > 7 &&
valor lógico false true
false
Resposta: o valor de w é 0.
5.7. Promoção de Tipos Básicos
A linguagem C permite a mistura de tipos de dados no rvalue de suas expressões. Em

uma mesma expressão pode haver constantes, variáveis e funções de diferentes tipos, como,
bool, char, int, float e double.
Como regra, o compilador C evita perdas de precisão ao avaliar expressões. Dados dois
operandos de tipos de dados diferentes, o compilador C escolherá o tipo de maior precisão e
converterá o valor do outro operando para o tipo escolhido. Isto é feito de operação a opera-
ção.
A seguir, é descrito a aplicação da regra de conversão para os tipos básicos:
1. se um dos operandos é double então o outro é promovido a double

2. se um dos operandos é float então o outro é promovido a float
3. se um dos operandos é int então o outro é promovido a int
4. se um dos operandos é char então o outro é promovido a char
A promoção de tipos em expressões é feita de forma automática pelo compilador C, ex-

pressões com vários termos, como mostrado na Figura 5.1, a promoção de tipos é feita termo
a termo, considerando a precedência dos operadores do Quadro 5.7
Se necessário, a promoção de tipos em uma expressão é feita repetidamente pelo com-
pilador C a cada simplificação da expressão, até o seu valor final. A Figura 5.1 ilustra este
processo usando o diagrama de conversão de tipos em expressões. O Comentário 5.3 tam-
bém discute o processo apresentada na Figura 5.1.
Comentário 5.3 A promoção de tipos na expressão r = (c/i) + (i*f) - (f+d) conforme a Figura
5.1
Na expressão r = ( c / i ) + ( i * f ) - ( f + d ), exemplificada na Figura 5.1, estão presentes

variáveis do tipo char, int, float e double.
A avaliação do rvalue desta expressão inicia por (c/i), em que o valor ('A') de c é promovido
para int e é feito o cálculo 65/5 = 13.
Avalia-se o próximo termo do rvalue, (i*f) em que o valor (5) de i é promovido para float e é
feito o cálculo 5.0 * 7.5 = 37.5.
Avalia-se o próximo termo do rvalue, (f+d) em que o valor (7.5) de f é promovido para
double e é feita o cálculo 7.5+4.7 = 12.2.
Na segunda etapa da avaliação, a expressão é r = 13 + 37.5 - 12.2, sendo 13 um valor int,

37.5 um valor float e 12.2 um valor double. Nesta etapa, a avaliação inicia por 13 + 37.5,
em que o valor 13 promovido para float e faz-se o cálculo 13 + 37.5 = 50.5.
Na terceira etapa da avaliação, a expressão é r = 50.5 - 12.2, sendo 50.5 um valor float e
12.2 um valor double. Avalia-se 50.5 – 12.2, em que o valor 50.5 é promovido para double
e faz-se o cálculo 50.5 – 12.2 = 38.3.
Na quarta etapa da avaliação, a expressão é r = 38.3, sendo 38.3 um valor double e r do
tipo int. A parte fracionária do valor 38.3 é desprezada e a parte inteira é atribuía a r.
Na quinta etapa, o valor de r é igual a 38, sendo 38 um valor int.
Comentário 5.3 A promoção de tipos na expressão r = (c/i) + (i*f) - (f+d) conforme a Figura
5.1
Figura 5.1 Diagrama de conversão de tipos em expressões.
5.8. Conversão de Tipos Básicos
A conversão de tipo ou modelagem de tipo ou typecast é um recurso da linguagem C

que permite a conversão de valores de um tipo para outro, de forma manual nos programa-
fonte. Ele pode ser aplicado à valores constantes, à variáveis, à expressões e a funções.
Sintaxe do typecast:
(tipo de dado) constante

(tipo de dado) variável
(tipo de dado) (expressão)
(tipo de dado) (função)
Como já visto, a divisão de dois números inteiros retorna um número inteiro. Em termos
matemáticos, o valor de 9/5 é exatamente igual a 1,8; tem termos computacionais, de f =
9/4 é aproximadamente igual a 1.000000, conforme mostrado no Programa 5.5.
Programa 5.5 Divisão de inteiros sem typecast
#include <stdio.h>
int main( void ){
int a = 9,
b = 5;
float f;
f = a/b;
printf( "\n f = %f", f );
return 0;
}
Ao dividir inteiros, ou expressões matemáticas que resultem em inteiros, programas C

truncam os resultados, desprezando a parte fracionária, ficando apenas com a parte inteira.
Para obter os resultados corretos é necessário converter o numerador ou o denomina-
dor, ou ambos, manualmente (explicitamente), o Programa 5.6 mostra a conversão manual
para o tipo float. O mesmo precedimento pode ser feito para o tipo double.
Programa 5.6 Divisão de inteiros com typecast
#include <stdio.h>
int main( void ){
int a = 9,
b = 5;
float r, s, t, u, v;
r = a/b;
s = (float)a/b;
t = a/(float)b;
u = (float)a/(float)b;
v = (float)(a/b);
printf( "\n r = %f", r );
printf( "\n s = %f", s );
printf( "\n t = %f", t );
printf( "\n u = %f", u );
printf( "\n v = %f", v );
return 0;
}
O valor de s é igual a 1.800000 porque o typecast é feito antes da divisão; o mesmo

ocorre no cálculo de t e u. A instrução v = (float)(a/b) tem como resultado v = 1.000000 por-
que a divisão é feita antes do typecast devido a maior precedência dos parêntesis.
5.9. Formatação e a Notação Científica
A Ciência lida com números dos mais diferentes tamanhos, gradezas que variam do ta-
manho das partículas subatômicas às das galáxias. A notação científica, nestes casos, é a
mais indicada.
A linguagem C usa E e e para representar números com potência de 10, assim:
▪ G = 6,6743✕10-11 → G = 6.6743E-11
▪ ML = 7,35✕10+22 → ML = 7.35E22
A Linguagem C possui os formatos %e e %g para E/S em notação com potência de 10.

O Programa 5.7 exemplifica o uso da notação científica em C.
Programa 5.7 Cálculo da energia cinética da Lua, em Joules, e da força de atração

gravitacional entre a terra e a Lua, em Newtons
Constante de gravitação universal, G = 6.6743E-11 m 3 kg-1 s-2

Massa da Lua, ML = 7.35E22 kg
Velocidade Orbital da Lua, VL = 1.03 Km/s = 1030 m/s
Massa da Terra, MT = 5.974E24 kg
Distância média entre a Lua e a Terra, r = 384400 km = 384400E3 m
1 2
Energia Cinética da Lua, E= mL v L J
2
m M
Força de atração gravitacional entre a Terra e a Lua, F=G L 2 T N.
r
#include <stdio.h>
#define G 6.6743E-11 // m3 kg-1 s-2

#define ML 7.35E22 // kg
#define VL 1030 // m/s
#define MT 5.974E24 // kg
#define r 384400E3 // m
int main( void ){

double E, F;
E = ML*VL*VL/2;
F = G*ML*MT/r/r;
printf( "\n 1.E = %lf J", E );
printf( "\n 2.F = %lf N", F );
printf( "\n --------------" );
printf( "\n 3.E = %g J", E );
printf( "\n 4.F = %g N", F );
printf( "\n --------------" );
printf( "\n 5.E = %e J", E );
printf( "\n 6.F = %e N", F );
return 0;
}
1. Dê um exemplo de fluxo de controle. Justifique sua resposta.

2. Compare programas-fonte e executáveis.
3. Faça um fluxograma para cada o cálculo dos dígitos verificadores de CPF.
4. Faça um fluxograma para cada para o MDC de dois números.

5. Como se usa a Regra do Dedo nos fluxogramas?
6. O que são operadores?
7. Qual é a utilidade dos operadores?
8. Descrevas os operadores C?
9. O que é atribuição?
10.Quando usar o operador atribuição?
11.O que são operadores decremento e incremento?
12.Quais são as utilidades dos operadores decremento e incremento?
13.O que são abreviações em C?
14.Quais são as utilidades das abreviações em C?
15.Compare os tipos char, int, float e double quanto ao tamanho em bytes?
16.O que são expressões em programas C?
17.O que são operadores em programas C?
18.O que é atribuição em programas C?
19.Que tipo resulta quando se opera char com int?
20.Que tipo resulta quando se opera char com double?
21.Que tipo resulta quando se opera int com char?
22.Que tipo resulta quando se opera int com double?
23.Que tipo resulta quando se atribui valor do tipo int a variável do tipo char?
24.Que tipo resulta quando se atribui valor do tipo float a variável do tipo char?
25.Que tipo resulta quando se atribui valor do tipo char a variável do tipo int?
26.Que tipo resulta quando se atribui valor do tipo char a variável do tipo float?
27.Que tipo resulta quando se atribui valor do tipo float a variável do tipo char?
28.Que tipo resulta quando se atribui valor do tipo float a variável do tipo int?
29.Que tipo resulta quando se opera int com double?
31.Que resultado é atribuído a c = a % b ( a, b e c do tipo int )?
32.Que resultado é atribuído a c = a / b ( a, b e c do tipo int )?
33.Que resultado é atribuído a c = a / b ( a, b e c do tipo float )?
34.Qual é o valor lógico de (x > 10) && (y < 20) para x = 10 e y = 5?
5.10.2. Questões Avançadas
1. Faça um programa para ler e escrever variáveis com o formato %e.

2. Faça um programa para ler e escrever variáveis com o formato %g.

1. Ler a massa e a aceleração de um corpo e escrever a sua força (F=m*a).

2. Ler a massa e a velocidade de um corpo e escrever a sua energia cinética (E=m*v 2/2).
3. Ler o salário de um funcionário e imprimi–lo com um aumento de 15%.
4. Ler o preço de um produto e imprimi–lo com um desconto de 15%.
5. Ler um valor float e escrever apenas a parte inteira deste número.
6. Ler um valor double e escrever apenas a parte decimal deste número.
7. Entrar com valores para a, b, c, imprimir o valor de x, sabendo–se que
b
x=a+ −2×(a−b−c ) .
a+ b
8. Entrar com valores para a, b, c, d, imprimir o valor de f, sabendo–se que
f=
√cos (a)+ sen(b) .
ec −ln(d )
9. Entrar com valores para a, b, c, imprimir o valor de x, sabendo–se que
−b− √ b 2−4 ac
x= .
2a
10.Embora por lei não possa obrigar o cliente a pagar gorjeta. Fazer um algoritmo que leia
o valor da despesa realizada em um restaurante e imprima o valor total com a gorjeta.
11.Alguns tributos usa a base de cálculo salário–mínimo. Fazer um algoritmo que leia o
valor do salário–mínimo e o valor do salário de uma pessoa. Calcular e imprimir quantos
salários–mínimos ela ganha.
12.Preencha o quadro abaixo:
Expressão Matemática Correspondência em Linguagem C

n
C=M (1+i)
r 2(1+ r−r 2 )
v=
(1−r )2
−b− √ b 2−4 ac
x=
2a
a1 +a 2+ a3 +a 4
m=
4
2
mv
Ec =
2
Qual o valor de w de cada um dos programas abaixo? Justifique as respostas.
13.Programa a 14.Programa b
int main( void ){ int main( void ){

bool ok, w; bool ok, w;
int x, y; int x, y, z;
x = 2; x = 2;
y = 5; y = 5;
ok = false; z = 9;
w = ok || y >= x; ok = false;
return 0; w = ! ok && z/y + 1 == x;
} return 0;
13.Programa a 14.Programa b
15.Programa c 16.Programa d

int x, y, z; int x, y, z;
x = 1; x = 1;
y = 4; y = 4;
z = 8; z = 8;
ok = true; ok = true;
w = ok && ! ok; w = ! ok || y % 2 == 0;
return 0; return 0;
} }
17.Programa e 18.Programa f

x = 1; x = 1;
y = 4; y = 4;
z = 8; z = 8;
w = ok || pow(x,3) > 1; w = ! (x+1 >= z/y && ok );
return 0; return 0;
} }
Que valores são impressos nos programas abaixo? Justifique as respostas.
19.Programa a
#include <stdio.h>
int main (void){
char a, b = 60, c = 7;
a = ++b;
c = ++a - c++;
a = ++b + c++;
printf( "\n a : %c b : %c c : %c", a, b, c );
printf( "\n a = %d b = %d c = %d", a, b, c );
return 0;
}
20.Programa b
#include <stdio.h>
int main (void){
int a, b = 11, c = 22;
a = ++b - c++;
printf( "\n a= %2d b= %2d c= %2d", a = b-- + c--, b, c );
printf( "\n a= %2d b= %2d c= %2d", a, b = ++a - --c, c );
printf( "\n a= %2d b= %2d c= %2d", a, b, c = a++ - c++ );
printf( "\n a= %2d b= %2d c= %2d", a, b, c );
return 0;
}
21.Programa c
#include <stdio.h>
int main(void){
int a = 2, b = 6, c = 12, e1, e2, e3, e4, e5;
e1 = -c/b/a;
e2 = a+c%b;
e3 = (a+c)%b;
e4 = ++a+b++;
e5 = a+++b;
printf("\n e1 = %d", e1 );
printf("\n e2 = %d", e2 );
printf("\n e3 = %d", e3 );
printf("\n e4 = %d", e4 );
printf("\n e5 = %d", e5 );
printf("\n a = %d", a );
printf("\n b = %d", b );
printf("\n c = %d", c );
return 0;
}
5.10.4. Exercícios Medianos
1. Entrar com valores para m, s, x, imprimir o valor de f, sabendo–se que

2
1 x−m
1 − ( )
.
f= e 2 s
√2 π s ²
2. Ler um valor x e imprimir cos2x+sen2x. Os resultados são iguais a 1?
3. Preencha o quadro abaixo:
1 1
x= 2 3
− 2 2
a (1−b) a (1−b)
a+b a−b
c=2 cos ( )sen ( )
a−b a+b
1
y= [cos (a +b)+cos (a−b)]
2
s=
√
(x 1−m)2+( x 2−m)2+(x 3−m)2 +(x 4−m)2
R2
4
1+
R1
V 2=V 1 ( )
1 R2
+ +1
G GR1
(x −h)2+( y−h)2 +(z−h)2
d=
a
2 2 2
x −h y−h z−h
d=( ) +( ) +( )
a a a
2 3 4
a+a +a + a
m= 2 3 4
a−a −a −a
1. Preencha o quadro abaixo:
√
n n
3+ 4+
2+n 2 3
(x 1−m) +(x2 −m) +(x 3−m)
u=
n
3+
3
2
1 x−m
1 − (
2 s
)
f= e
√2 π s ²
x
−
x a −1 e b
f= a b
b +a
x b
−( )
b−1 a
bx e
y= b
a
v p−1 (1−v )q−1
z=
(1+v ) p+ q
b
x
−( )
b−1 a
bx e
g= b
a
√ √ q2 3 q
2 3 +p −
−b 4 2
x= + 4
3a 2a
m= √
a− a2−√ a3 −√1−a 4
a+a 2+ a3 +a 4
m= 2 3
√ √√
3
a− a − a − √1−a
4
2 4 3 5 4
a+a + a +a
x=
√ π
a +b
180
+tan [a( π−
log[ π (a+b)]
b
a+1
)]
√
1
x=
1 1 1 1 1
+ + + +
a b a2 a b b2
(−1)n
y= 2 n +1
(x + y )2n −1
(2 n−1)
1
a+
1
a2 +
1
a3 + 4
a +1
m=
4
5.10.6. Exercícios sobre o Sistema Solar
Na Tabela 5.1 estão os dados dos planetas do nosso sistema solar, com eles é possível
calcular diversas grandezas físicas relacionadas a eles, conforme os exercícios a seguir.
Tabela 5.1 Dados do nosso Sistema Solar

Planeta
Dado
Mercúrio Vênus Terra Marte Júpiter Saturno Urano Netuno
Massa (kg) 3,285E23 4,839E24 5,974E24 6,571E23 1,900E27 5,686E26 8,453E25 1,024E26
Gravidade (m/s²) 3,727 8,434 9,807 3,727 24,518 10,788 10,788 10,788
Duração do dia (h) 1407,6 5832,24 23,93 24,62 9,92 10,67 17,23 16,12
Distância do Sol (km) 5,790E7 1,082E8 1,496E8 2,279E8 7,783E8 1,427E9 2,870E9 4,497E9
Velocidade (km/s) 47,89 35,03 29,79 24,13 13,06 9,64 6,81 5,43
Duração do ano (h) 2,111E3 5,393E3 8,766E3 1,647E4 1,039E5 2,581E5 7,359E5 1,444E6
1. Faça um programa C para calcular a energia cinética, em Joules, de cada um dos

1 2
planetas do nosso sistema solar, E= mv .
2
2. Faça um programa C para calcular a força de atração gravitacional, em Newtons, entre
mM
o sol e os planetas do nosso sistema solar, F=G 2 , M = 1,98892E30 kg (massa do
r
3 -1 -2
sol) e G = 6,6743E-11 m kg s (constante de gravitação universal).
3. Faça um programa C para calcular o peso (em Newtons) de uma pessoa de 75 kg em
cada um dos planetas do nosso sistema solar (P = m g).
4. Faça um programa C para calcula a idade equivalente, em anos de cada um dos
planetas do nosso sistema solar, de uma pessoa com 25 anos terrestres.
5.10.7. Exercícios sobre Micro-organismos
Tabela 5.2 Dados de tamanho de alguns micro-organismos

Micro-organismos Tamanho Aproximado

Vírus 50 nm
Bactéria isolada 1 μm
Bactéria em Colônia 5 μm
Fungo 60 μm
1. Faça um programa C para ler e imprimir o tamanho dos micro-organismos da Tabela

5.2 em metros.
2. Faça um programa C para ler e imprimir a área dos micro-organismos da Tabela 5.2 em
metros quadrados, supondo que sejam circulares.
3. Faça um programa C para ler e imprimir o volume dos micro-organismos da Tabela 5.2
em metros cúbicos, supondo que sejam esféricos.
em metros cúbicos, supondo que sejam elípticos.
em metros cúbicos, supondo que sejam cubos.
6. Funções C
As funções são as unidades básicas para construção de progra-

mas escritos em C. Um programa em C é um conjunto de uma ou
mais funções. Desta forma pode-se dividir um programa em várias
partes, no qual cada função realiza uma tarefa bem definida. Em
programas bem projetados, cada função realiza apenas uma tarefa,
a BPC é um exemplo, são dezenas funções especializadas.
6.1. Sintaxe das Funções C
A sintaxe das funções, descrita abaixo, determina a forma e a estrutura geral de toda e
qualquer função escrita em C.
tipo nome( lista de parâmetros ){

// bloco da função, lista ordenada de instruções
[return valor;]
}
A sintaxe das funções contém:
tipo tipo do valor retornado pela função;
nome identificador da função;
() delimitadores de inicio e de fim da lista de parâmetros da função;
lista de parâmetros sequência ordenada dos tipos e variáveis, separados por vírgula;
{} delimitadores do bloco da função;
bloco da função lista ordenada de instruções executadas pela função;
[] delimitadores que indicam instrução opcional;

return indica o retorno da função;
valor valor retornado pela função;
; delimitador de fim de instrução.
A lista de parâmetros de uma função é uma sequência ordenada de parâmetros, os pa-

râmetros das funções inclui os tipos e o nome de cada variável da lista, separados por vírgu -
la. A falta de parâmetro é indicada pela palavra reservada void. Dois ou mais parâmetros
são separados por vírgula.
A vírgula é o separador de itens de listas usadas nos programas-fontes escritos em C.
O Programa 6.1 foi o primeiro programa em linguagem C. Cada linha do programa é des-
crita ao lado, está é a técnica Descrição Linha a Linha (DLL). As linhas 6 e 7 são o Relatório
da Compilação e a Imagem do Programa Executável, respectivamente.
Programa 6.1 – Primeiro programa C (AloMundo.c)

2 int main( void ) declara a função main, do tipo int e parâmetro void
3 { abre o bloco da função
escreve Alô mundo! na tela do computador usando a

4 printf( "Alô mundo!");
função printf
5 return 0; main retorna o valor int 0
fecha o bloco da função main

6 } encerra a função main
encerra o programa

7

nhas: 🌑 → 2 → 3 → 4 → 5 → 6 → 🌕
Todo e qualquer programa C inicia pela função main, neste caso, na linha 2. Em geral, o
programa também é finalizado pela return 0; – na linha 5. A função encerra o programa ao
retorna o valor int 0. A chave na linha 6 fecha o bloco da função main, finaliza a função main
e também encerra o programa.
Observe as aspas duplas de "Alô mundo!", elas indicam frases, em C são chamas de
strings, uma sequência de caracteres delimitas por aspas duplas. Cuidados com as aspas da
linguagem C, da forma "…", e com as aspas de outros editores de textos, da forma “…”.
A instrução #include é uma diretiva de pré-processamento, ela é utilizada para incluir
um cabeçalho da BPC.
A instrução #include <stdio.h> indica que o compilador deve buscar e incluir o arqui-
vo stdio.h, de forma que o programa-fonte possa fazer uso de printf. A dupla <> indica que
é um cabeçalho da BPC.
O cabeçalho stdio.h, da BPC, vem da expressão inglesa standard input-output header,
que significa "cabeçalho padrão de entrada/saída". Ele possui definições de funções de entra -
da/saída (E/S), como leitura de dados digitados no teclado e exibição de informações na tela
do programa de computador. Dentre seus diversos recursos, tem-se printf – função que im-
prime valores na tela do computador e scanf – função que lê valores do teclado.
Vale destacar que main é uma palavra reservada da linguagem C. Todo programa C
precisa ter uma, e somente uma, função de nome main. A falta da função main em um pro-
grama resulta em erro de compilação. Se o programa possuir mais de uma função main tam-
bém resulta em erro de compilação.
O Comentário 6.1 descreve os objetivos educacionais da técnica Descrição Linha a Linha
(DLL) de programas-fonte.
Comentário 6.1 – Objetivos educacionais da Descrição Linha a Linha (DLL)
A Descrição Linha a Linha (DLL) é uma técnica para descrever cada linha de um programa-
fonte. Cada linha do programa-fonte é numerada e suas instruções são descritos ao lado.
Os objetivos educacionais desta técnica são:
• reforçar a compreensão do algoritmo
• destacar a ordem e sequência das instruções
• compreender o fluxo de controle
• detalhar a chamada de funções e seu retorno
• caracterizar definições, declarações, variáveis, expressões e estruturas do programa
• capacitar a escrita técnica
• estimular a atenção aos detalhes
• conceber os padrões, as regras e os pormenores
• desenvolver a metacognição do código.
O programa-fonte do Programa 6.2 escreve uma mensagem na tela do computador e

contém duas funções.
Programa 6.2 – Uso de funções em programa C (saida.c)

1 #include <stdio.h> cabeçalho da BPC para incluir printf
declara a função saida, do tipo void, sem return, e

2 void saida( void ){
parâmetro void; abre o bloco da função
escreve Alô mundo! na tela do computador usando a

3 printf("Alô mundo!");
função printf
4 } fecha o bloco da função saida; encerra a função saida
declara a função main, do tipo int e parâmetro void;

5 int main( void ){
abre o bloco da função
chama a função saida; os parêntesis () indicam que a

função saida tem parâmetro void; main transfere o
6 saida();
controle para função saida que, ao se encerrar, devolve
o controle a função main
7 return 0; a função main retorna o valor int 0
fecha o bloco da função main; encerra a função main;

8 }
encerra o programa.

nhas: 🌑 → 5 → 6 → 2 → 3 → 4 → 6 → 7 → 8 → 🌕. O nome da função saida aparece nas linhas
2 e 6. Na linha 2 a função saida é declarada. Na linha 2, que está dentro da função main, a
função saida e chamada. Embora os nomes seja os mesmos, o contexto e a interpretação
destas instruções são diferentes. Note o fluxo de controle da linha 6 para a linha 2, devido à
chamada da função saida, e depois da linha 6 para a linha 11, devido ao fim da função sai-
da.
As funções C podem ter ou não tipo de dado, a falta do tipo de dado nestas funções é in-
dicada por void, são ditas funções void, e não possuem return. Funções que possuem tipo
de dado são ditas funções tipadas e, neste caso, possuem return. As funções tipadas possu-
em um único tipo de dado, podendo ser bool, char, int, float ou double; não pode ser
void. Elas também podem retornar um único valor do mesmo tipo de dados da função, prefe-
rencialmente. Ocorre conversão de dados quando o tipo de dado da função e o tipo de dado
do return são diferentes, e isto deve ser evitado. O Quadro 6.1 ilustra estes dois casos com
exemplos bem simples.
As funções C podem ter ou não parâmetros, a falta de parâmetro nestas funções é indi-
cada por void. As funções podem possuir um ou mais parâmetros, cada parâmetro deve pos-
suir nome e tipo de dado, e são separado por vírgula. Os tipos de dados podem ser bool,
char, int, float ou double, não podem ser void. O Quadro 6.1 ilustra estes dois casos com
exemplos bem simples.
Quadro 6.1 Função C, seus tipos, parâmetros e exemplos
Função
tipo Parâmetro Exemplo
✗ ✗ void fim( void ){

printf("fim")
void void }
✗ ✔ void dobro( int x ){

printf( "2x=%d", 2*x );
void bool, char, int, float, double }
✔ ✗ double pi( void ){

return 3.14159265359;
bool, char, int, float, double void }
✔ ✔ double triplo( double z ){

return 3*z;
bool, char, int, float, double bool, char, int, float, double }
6.2. Funções que Retornam Valores
Em C, uma função pode retornar um valor para quem a chama, normalmente uma outra
função, e isto é feito usando a palavra reservada return.
A função aleatorio, descrita no Programa 6.3, retorna um valor do tipo int.
Programa 6.3 – Função C que retorna valor (aleatorio.c)

2 #include <stdlib.h> cabeçalho da BPC para incluir a função rand
declara a função aleatorio, do tipo int e parâmetro

3 int aleatorio( void ){
void; abre o bloco da função aleatorio
4 int x; declara x, variável do tipo int
o valor retornado pela chamada da função rand, sem

5 x = rand();
argumento, é atribuído à variável x
6 return x; a função aleatorio retorna o valor da variável x
7 } fecha o bloco da função soma; encerra a função soma
declara a função main, do tipo int e parâmetro void;

8 int main( void ){
abre o bloco da função main
9 int a; declara a, variável do tipo int

Programa 6.3 – Função C que retorna valor (aleatorio.c)

o valor retornado pela chamada da função aleatorio,

10 a = aleatorio();
sem argumento, é atribuído à variável a
escreve na valor da variável a, com formato do tipo

11 printf("aleatorio = %d", a);
int, na tela do computador usando a função printf
12 return 0; a função main retorna o valor 0

13 }
encerra o programa.
14

nhas: 🌑 → 8 → 9 → 10 → 3 → 4 → 5 → 6 → 7 → 10 → 11 → 12 → 13 → 🌕.
Observe o fluxo de controle da linha 10 para a linha 3 e depois da linha 6 para a linha
10.
Na linha 10 ocorre a chamada da função aleatorio, o fluxo de controle é transferido pa-
ra a linha 3 e, ao final da função aleatorio, ele retorna à linha 10.
O processo de chamada da função aleatorio está descrito no Quadro 6.2.
Quadro 6.2 Processo de chamada da função aleatorio do Programa 6.3
Fluxo de Controle Descrição
O fluxo de controle, que está na função main,

Chamada da função aleatorio
encontra o nome da função aleatorio na linha 10
Passagem de argumento Ocorre a identificação do argumento, que é void
Ocorre a transferência do fluxo de controle para a

Transferência do fluxo de controle
linha 3
Execução do bloco da função O bloco de instruções da função aleatorio é

aleatorio executado, linha a linha, e o valor de x é calculado
A função aleatorio executa a instrução return, que

Retorno da função aleatorio retorna o valor 6, no formato int, o fluxo de controle é
transferido para a linha 10
A função aleatorio transfere o fluxo de controle para

a linha 10, para a função main
O valor da variável x, retornado pela função

Atribuição do retorno da função
aleatorio, linha 6, é atribuído à variável a, linha 10.
Certifique-se de os tipos dos argumentos e dos respectivos parâmetros sejam os mes-

mos. Certifique-se também que a variável que recebe o valor de retorno de uma função seja
do mesmo tipo que o valor retornado pela função. Uma função pode ter mais de um return.
6.3. Funções com Argumentos
Argumentos de uma função é um conjunto ordenado de nome de constantes, variáveis

ou funções, separados por vírgula, que é passado para a função no momento em que ela é
chamada.
A função printf, no Programa 6.3 e no Programa 6.4, recebe um argumento. A função
soma declarada na linha 2 do Programa 6.4, é do tipo int, possui dois argumentos, de nomes
x e y, ambos do tipo int e retorna um valor de z, do tipo int.
Programa 6.4 – Função C com argumentos (soma.c)

1 #include <stdio.h> cabeçalho da BPC para incluir printf
declara a função soma, do tipo int e dois parâmetros do

2 int soma( int x, int y ){
tipo int; a chave abre o bloco da função
3 int z; declara z, variável do tipo int
o resultado da adição dos valores das variáveis x e y é

4 z = x + y;
atribuído à variável z
5 return z; soma retorna o valor da variável z
6 } fecha o bloco da função soma; encerra a função soma
declara a função main, do tipo int e parâmetro void; abre

7 int main( void ){
o bloco da função main
8 int a, b, c; declara a, b e c, variáveis do tipo int
9 a = 2; atribui o valor numérico 2 à variável a
10 b = 3; atribui o valor numérico 3 à variável b
o valor retornado pela chamada da função soma com os

11 c = soma(a,b);
argumentos a e b é atribuído à variável c
escreve na valor da variável c, com formato do tipo int,

12 printf("soma = %d", c);
na tela do computador usando a função printf
13 return 0; main retorna o valor 0

14 }
encerra o programa.
15
O fluxo de controle do programa-fonte do Programa 6.4 Erro: Origem da referência não

encontrada é a sequência definida pelas linhas: 🌑 → 7 → 8 → 9 → 10 → 11 → 2 → 3 → 4 → 5 →
6 → 11 → 12 → 13 → 14 → 🌕.
6.4. Chamada de Funções
Observe o fluxo de controle da linha 10 para a linha 2 e depois da linha 6 para a linha
11.
Na linha 11 ocorre a chamada da função soma, o fluxo de controle é transferido para a
linha 2 e, ao final da função soma, ele retorna à linha 11.
O processo de chamada da função soma está descrito no Quadro 6.3.
Quadro 6.3 Processo de chamada da função soma do Programa 6.4
Fluxo de Controle Descrição
O fluxo de controle, que está na função main,

Chamada da função soma
encontra o nome da função soma na linha 11
Ocorre a identificação dos argumentos da função

Passagem de parâmetros soma, que são dois, os valores das variáveis a = 2 e
b = 3, ambos do tipo int.
Ocorre a transferência do fluxo de controle da função

main para a função soma, da linha 11 para a linha 2
Ocorre a transferência dos argumentos de soma da

Transferência dos argumentos
função main, linha 11, para a função soma na linha 2
Os valores dos argumentos a e b de soma da função

Atribuição de valores dos main, linha 11, são atribuídos aos parâmetros da
parâmetros função soma na linha 2, de forma ordenada, x = 2 e
y = 3, ambos do tipo int
O bloco de instruções da função soma é executado,

Execução do bloco da função soma
linha a linha e o valor de z = 5 é calculado
A função soma executa a instrução return, que

Retorno da função soma retorna o valor 5, no formato int, o fluxo de controle
é transferido para a linha 11
A função soma transfere o fluxo de controle para a

linha 11, para a função main
O valor 5, retornado pela função soma, linha 5, é

Atribuição do retorno da função
atribuído à variável c, linha 11.
Associado às funções, há dois conceitos importantes: argumento e parâmetro.

Argumento é o valor usado para chamar uma função.
A função printf foi chamada com o argumento "Alô mundo!" tanto na linha 3 da fun-
ção main do Programa 6.1 quanto na linha 3 da função saida do Programa 6.2.
Parâmetro, ou parâmetro formal, é o nome dado a variável declarada na declaração
de uma função. As funções que possuem argumentos são chamados de funções parametri-
zadas. Os argumentos das funções são variáveis tipadas e elas recebem valores oriundos da
chamada da função.
A função soma, na linha 2 do Programa 6.2, foi declarada com dois argumentos, x do ti-
po int e y do tipo int. A função soma é um exemplo de função parametrizada; x e y são seus
parâmetros formais.
Comentário 6.2 – Vocabulário da linguagem C relacionado às funções
• chamada de função – ocorrência do nome de função dentro de outra função

• argumento – valor enviado para uma função ao ser chamada
• parâmetro – valor recebido por uma função
• passagem de argumentos – passagem de valores nas chamadas de função
• retorno de função – a função retorna um valor para a instrução de chamada
• função tipada – função que possui tipo diferente de void
• função parametrizada – função que possui parâmetro diferente de void
O Programa 6.5 faz uso da função int ler( void ) e garante que será lido um número intei-
ro positivo. Ela será chamada enquanto for lido um número inteiro negativo. Está função é
chamada de função recursiva pois a função ler é chamada por ela mesma.
As imagens da execução no OnlineGDB e do C Tutor são apresentadas. A linha 4 do pro-
grama-fonte deve ser usada no C Tutor, e as linhas 5 e 6 devem ser usadas no OnlineGDB.
Na imagem do C Tutor pode-se ver três (3) as chamadas da função ler, a primeira com n = -
7, a segunda com n = -4 e, por fim, a terceira com n = 7, quando então ele deixa de chamar
a si mesma e retorna o valor para a função main.
Programa 6.5 – Leitura de número inteiro positivo
2 int ler( void ){
3 int n;
4 // n = rand() % 20 – 10; C Tutor
5 printf( "digite um numero inteiro positivo: " ); // OnlineGDB
6 scanf ( "%d", &n );
7 if( n < 0 ) n = ler();
8 return n;
9 }
11 printf( " n = %d", ler() );
12 return 0;
13 }
OnLineGDB C Tutor
Programa 6.5 – Leitura de número inteiro positivo
6.5. Funções de Biblioteca Padrão C
A Biblioteca Padrão da Linguagem C (BPC) é projetada para fornecer um conjunto básico

de funções padronizadas para a Linguagem C, incluindo ISO C11. Ela consiste de 24 cabeça -
lhos, cada um contendo uma ou mais declarações de funções, tipos de dados e macros 7.
A BPC é uma caixa de ferramentas prontas para uso em programas C; é parte do projeto
GNU C Library e está em desenvolvimento desde 1988. Ela está disponível no sítio www.g -
nu.org/software/libc.
No Quadro 10.1 descreve os cabeçalhos da Biblioteca Padrão ANSI C.
1. Explique em detalhes a função printf e dê exemplos.

2. Explique em detalhes a função scanf e dê exemplos.
3. Explique em detalhes a função exit e dê exemplos.
4. O que é módulo?
5. O que é reutilização?
6. Como a modularização está relacionada com a reutilização?
7. O que é legibilidade?
8. Como a modularização está relacionada com a legibilidade?
9. O que é manutenção?
10.Como a modularização está relacionada com a manutenção?
7 Uma das instruções da Linguagem C

11.O que é função?

12.O que é protótipo de função?
13.Compare função com protótipo de função.
14.Quando usar protótipo de função?
15.O que é parâmetro de função?
16.O que é argumento de função?
17.O que é tipo de retorno?
18.Como o tipo void está relacionado com função?
19.Qual é a sintaxe de função em C?
20.Qual é a sintaxe de protótipo de função C?
21.Explique o fluxo de controle de programas-fonte que contenham funções.
22.O que é chamada de função?
23.O que é passagem de argumentos?
24.O que é escopo de variável?
25.O que é variável local?
26.O que é variável global?
1. Escreva um programa que leia o raio de uma circunferência e calcule, por meio de
funções, e imprima o diâmetro, o comprimento e área da circunferência.
2. Crie uma função que receba três números inteiros como parâmetros, representando
horas (h), minutos (min) e segundos (s), e os converta em segundos. Exemplo: 2 h, 40
min e 10 s correspondem a 9.610 s.
3. Faça uma função que receba um valor inteiro e verifique se ele é positivo ou negativo.
4. Crie uma função que receba como argumento a altura (h) e o sexo de uma pessoa e
retorne seu peso ideal. Para homens, deverá calcular o peso ideal usando a fórmula:
peso ideal = 72,7× h - 58; para mulheres: peso ideal = 62,1 × h - 44.7.
5. Elabore e teste uma função que retorna o número de segundos de x horas.
6. Elabore e teste uma função para verificar se um ano é bissexto.
7. Elabore e teste uma função que retorna o número dias um dado mês.
8. Escreva uma função para contar o número de primos menores do que 1000.
1. Faça um único programa para calcular as expressões do quadro abaixo, uma função
para cada expressão e seu respectivo plano de teste.
f Expressão Matemática f Expressão Matemática
√
n n
3+ 4+
2+n 2 3 2
(x 1−m) +(x2 −m) +(x 3−m) 1
1 x−m
− ( )
f1 u= f2 f= e2 s
3+
n √2 π s ²
3
√ √
2 x
q 3 q a −1
−
f3 2 3 +p − f4 x e b
−b 4 2 f=
x= + 4
a
b +a
b
3a 2a
x b
√
−( )
f5 a− a2−√ a3 −√1−a 4 f6 bx
b−1 a
e
m= y=
a+a 2+ a3 +a 4 b
a
f7 m= √ √√
3
a− a2− a3− √1−a4
4 5
f8 z=
v p−1 (1−v )q−1
a+a 2+ a3 +a 4 (1+v ) p+ q
√ √
a +b b 1
π +tan [a( π− )] x=
f9 180 a+1 f10 1 1 1 1 1
x= + + + +
log[ π (a+b)] a b a2 a b b2
b
x
−( )
b−1 a 1 1
f11 bx e f12 x= − 2
g= 2 3
a (1−b) a (1−b)
2
ab
1
a+
1
(−1)n a2 +
f13 y= (x + y )2n −1 f14 1
(2 n−1)2 n +1 a3 + 4
a +1
m=
4
f15 s=
√
(x 1−m)2+( x 2−m)2+(x 3−m)2 +(x 4−m)2
4
f16 c=2 cos (
a+b
a−b
)sen (
a−b
a+b
)
R2
1+
1 R1
f17 y= [cos (a +b)+cos (a−b)] f18 V 2=V 1 ( )
2 1 R2
+ +1
G GR1
(x −h)2+( y−h)2 +(z−h)2 x −h

2
y−h z−h
2 2
f19 d= f20 d=( ) +( ) +( )
a a a a
6.6.4. Exercícios do Sistema Solar
1. Resolva os exercícios do sistema solar, do capítulo anterior, usando funções.

7. Estruturas
As instruções dos programas escritos em C são organizados em apenas três estruturas:

de sequência, de decisão e de iteração. É a chamada programação estruturada.
A estrutura de sequência executa um bloco de instruções, ela executa estas instruções
na ordem em que foram declarados, do início ao fim. O fluxo de controle do programa é uma
sequência de instruções delimitadas por ponto e vírgula.
A estrutura de decisão, a mais importante é a instrução if/else, permite decidir dentre
duas alternativas. A decisão é baseada no valor lógico de uma condição. A instrução if/else
é constituída por uma condição e dois blocos de instruções, um bloco do é if e o outro é do
else; o bloco do if é executado quando a condição é true, já o bloco do else é executado
quando a condição é false. Apenas um dos blocos é executado, ou o do if ou o do else. O flu-
xo de controle do programa faz um desvio condicional.
As estruturas de iteração, as mais importantes são as instruções while e for, executam
um bloco de instruções reiteradas vezes até que sua condição seja falsa. As instruções while
e for são constituídas por uma condição e um bloco de instruções; o bloco é executado
quando a condição é true, estas instruções são finalizadas quando a condição é false. O flu-
xo de controle do programa é ciclo que se repete um número finito de vezes.
A linguagem C tem outras duas estruturas de decisão, a saber, a instrução switch/case
é e a instrução ?:; também tem uma outra estrutura de iteração, a instrução do/while. Estas
instruções são tratadas no Anexo.
Estas estruturas podem ser combinadas de variadas forma; em geral, um algoritmo ini-
cia com uma estrutura de sequência e nela são incluídas as de decisão e de iteração. Pode-se
combinar variados números destas estruturas de várias formas e de diversas maneiras. Qual-
quer uma destas estruturas podem conter variadas estruturas de sequência, de decisão e de
iteração, só depende do problema a ser resolvido com elas.
A Programação Estruturada (PE), criada no final de 1950, é um padrão ou paradigma de

programação da Engenharia de Software, com ênfase em sequência, decisão e iteração;

que são agrupadas em sub-rotinas, estruturas de iteração, de decisão e em bloco.
A PE ainda é muito influente pois grande parte das pessoas ainda aprende programação
através dela. Para a resolução de problemas simples e diretos, PE é bastante eficiente pois
ele exige formas de pensar relativamente simples, de fácil compreensão e bem-ordenada.
A Linguagem C, dentre outras, utiliza o PE, embora possuam suporte para outros
paradigmas de programação.
Na PE, os programas de computador são vistos como compostos das seguintes Estruturas
de Controle de Fluxo (ECFs):
1. Sequência: de instruções ou sub-rotinas executadas em sequência; cada tarefa é

executada logo após a outra;
2. Decisão: instruções são executadas ou não conforme o estado do programa (if, else,
if/else); a tarefa é executada após um teste lógico;
3. Iteração: instruções são executados até que o programa atinja um determinado
estado (for, while, do-while); a partir do teste lógico, um trecho do código pode ser
repetido um número finitas vezes.
4. Recursão: instruções executadas com chamadas auto-referenciadas até que certas
condições sejam satisfeitas.
A Linguagem C utiliza funções que são ECFs agrupadas e utilizadas através de uma única
instrução; e blocos que permitem que uma sequência de instruções seja tratada como uma
única instrução.
Uma ideia central na PE é o refinamento por passos, em que o programa é desenvolvido de

maneira top-down (de cima ou topo para baixo – do mais geral para o mais particular), por
exemplo:
1. Comece com o programa principal

a) use as ECs
b) escreva as chamadas para as funções (f1, f2, ...) quando necessário. Diz-se
“postule f1, f2 ...”.
2. Implemente f1, f2, ..., com chamadas para outras funções conforme conveniente.
3. Continue implementando as rotinas até que não sejam necessários procedimentos
adicionais.
Na prática, é usual iniciar a programação não exatamente do topo, até porque é comum
que haja vários topos, mas isso depende da complexidade e modularidade do software.
Críticas usuais à PE
Dentre as críticas à PE, constam:
1. A PE é orientada para a resolução de um problema em particular; um escopo mais

amplo é muitas vezes conveniente.

2. A PE é realizada pela decomposição gradual da funcionalidade; as estruturas
advindas de funcionalidade/ação/controle não são as partes mais estáveis de um
programa; foco em estruturas de dados em vez de estruturas de controle é uma
alternativa.
3. Sistemas reais não possuem um único topo; pode ser apropriado considerar
alternativas à abordagem top-down.
É importante conhecer mais de um paradigma de programação pois cada um deles

possuem vantagens e desvantagens. A melhor prática é aproveitar o que cada paradigma
tem de melhor. O foco é na resolução do problema e seu consequente resultado. O
computador é uma máquina que deve trabalhar com eficiência e eficácia, executando
nossos programas.
Adaptado da Wikipédia, 2021-05-21.
7.1. Estrutura de Sequência – ES
A estrutura de sequência executa uma lista predeterminado de instruções de forma or-

denada, da primeira até a última, como pode visto na Figura 7.1.a. O fluxo de controle do
programa é uma sequência de instruções delimitadas por ponto e vírgula, como mostrado na
Figura 7.1.b.
a b
Figura 7.1 Estrutura de sequência representada por: a) fluxograma e b) bloco de instruções e
seu fluxo de controle.
A estrutura de sequência mais simples consiste de Entrada de Dados, Processamento e

Saída de Dados, como mostrado no Programa 7.1.
Programa 7.1 Cálculo da massa molecular da clorofila (C 55H72O5N4Mg) sabendo que as

massas moleculares do Carbono (C), Hidrogênio (H), Oxigênio (O), Nitrogênio (N), e
Magnésio (Mg) são iguais a 12,011; 1,00784; 15,999; 14,0067; e 24,305 g/mol,
respectivamente
As massas atômicas são constantes da natureza e, nas linhas 2 a 6 elas estão

declaradas. Estas constantes, do tipo float, são as massas de átomos
individuais. Elas são classificadas como Constantes Globais porque estão
declaradas fora das funções.
A função mol calcula a massa de uma molécula a partir do número e tipo de
seus átomos.
L Programa-Fonte
2 const float mC = 12.011, // massa do átomo de Carbono, g/mol
3 mH = 1.00784, // massa do átomo de Hidrogênio, g/mol
4 mO = 15.999, // massa do átomo de Oxigênio, g/mol
5 mN = 14.0067, // massa do átomo de Nitrogênio, g/mol
6 mMg = 24.305; // massa do átomo de Magnésio, g/mol
7
8 float mol( int C, int H, int O, int N, int Mg ){
9 return mC*C + mH*H + mO*O + mN*N + mMg*Mg;
10 }
11
12 int main( void ){ // Clorofila (C55H72O5N4Mg)
13 int C = 55,
14 H = 72,
15 O = 5,
16 N = 4,
17 Mg = 1;
18 float mm = mol(C,H,O,N,Mg);
19 printf( "Massa Molecular da Clorofila = %.3f g/mol", mm );
20 return 0;
21 }
Programa 7.1 Cálculo da massa molecular da clorofila (C 55H72O5N4Mg) sabendo que as

massas moleculares do Carbono (C), Hidrogênio (H), Oxigênio (O), Nitrogênio (N), e
Magnésio (Mg) são iguais a 12,011; 1,00784; 15,999; 14,0067; e 24,305 g/mol,
respectivamente
7.1.1. Exercícios e Questões
7.1.1.1. Questões Básicas
Preencha o quadro abaixo com a correspondente expressão lógica C:
Item Intervalo de números reais Expressão Lógica C
1. (x >= a && x <= b) || (x > c && x <= b)
2.
3.
4.
5. Elabores o Plano de Testes e escreva o programa C correspondente aos fluxogramas
abaixo:
(a) (b)
7.1.1.2. Exercícios Básicos
1. Fazer o Plano de Teste e um programa para ler os valores de:

b
a) a, b, c, e imprimir o valor de x=a+ −2×(a−b−c ) .
a+ b
b) a, b, c, d, e imprimir o valor de x=
√cos (a)+ sen(b) .
ec −ln(d )
−b− √ b 2−4 ac
c) a, b, c, e imprimir o valor de x= .
2a
2
1 x−m
1 − ( )
d) m, s, x, e imprimir o valor de f = e 2 s .
√2 π s ²
e) a e b e imprimir o valor de x=1− 1−(
√ b−1 b3
a+1
a b
) .
1
f) a e b e imprimir o valor de x=sin [b ( π − )] .
a+1
1
a
g) a e b e imprimir o valor de x=sec a [b( π− )] .
a+1
h) a e b e imprimir o valor de x=
π
√
a +b
180
+tan [a( π−
log[ π (a+b)]
b
a+1
)]
.
√
1
i) a e b e imprimir o valor de x= .
1 1 1 1 1
+ + + +
a b a2 a b b2
j) m (massa) e a (aceleração) de um corpo e imprimir a força correspondente
(F=ma).
k) m (massa) e v (velocidade) de um corpo e imprimir a sua energia cinética (
1 2
E= mv ).
2
l) o salário de um funcionário e imprimi–lo com um aumento de 15%.
m) o preço de um produto e imprimi–lo com um desconto de 15%.
n) um valor real e escrever apenas a parte inteira deste número.
o) um valor real e escrever apenas a parte decimal deste número.
p) um valor real x e verificar se cos2x+sen2x = 1, teste para float e double.
q) o valor da despesa realizada em um restaurante e imprimir o valor total com e
sem gorjeta de 10%.
r) o valor do salário–mínimo e o valor do salário de uma pessoa. Calcular e imprimir
quantos salários–mínimos ela ganha.
2. Calcular e imprimir o valor do volume (V) de uma lata de óleo, utilizando a fórmula
2
V = A π R , em que A e R são a altura e o raio da base da lata.
3. Efetuar o cálculo da quantidade de litros de combustível gasta em uma viagem,
utilizando um automóvel que faz 12 Km/L. Para obter o cálculo, o usuário deve fornecer o
tempo gasto e a velocidade média durante a viagem.
4. Efetuar o cálculo e a apresentação do valor de uma prestação em atraso, utilizando a
fórmula Prestação = Valor + (Valor x Taxa/100) x Tempo).
5. Ler dois valores (inteiros, reais ou caracteres) para as variáveis A e B, e efetuar a troca
dos valores de forma que a variável A passe a possuir o valor da variável B e a variável B
passe a possuir o valor da variável A. Imprimir os valores trocados.
6. Ler quatro números inteiros e imprimir o resultado da: a) adição e b) multiplicação de
todos eles.
7. Elaborar um programa que calcule e apresente o volume de uma caixa retangular, por
meio da fórmula Volume = Comprimento x Largura x Altura.
8. Ler dois inteiros (variáveis A e B) e imprimir o resultado do quadrado da diferença do
primeiro valor pelo segundo.
9. Ler dois inteiros (variáveis A e B) e imprimir o resultado da diferença do quadrado do
primeiro valor pelo segundo.
10.Elaborar um programa que efetue a apresentação do valor da conversão em dólar de
um valor lido em real. O programa deve solicitar o valor da cotação do dólar e também a
quantidade de reais disponível com o usuário, para que seja apresentado o valor em
moeda americana.
11.Elaborar um programa que efetue a leitura de três valores (A, B e C) e apresente como
resultado final à soma dos quadrados dos três valores lidos.
12.Refaça os exercícios anteriores usando funções.
Qual o valor de w de cada um dos programas abaixo?
13.Programa 14.Programa
int main( void ){

int main( void ){
bool ok, w;
bool ok, w;
int x, y, z;
int x, y;
x = 2;
x = 2;
y = 5;
y = 5;
z = 9;
ok = false;
ok = false;
w = ok || y >= x;
w = ! ok && z/y + 1 == x;
return 0;
return 0;
}
}

x = 1; x = 1;
y = 4; y = 4;
z = 8; z = 8;
w = ok && ! ok; w = ! ok || y % 2 == 0;
return 0; return 0;
} }

x = 1; x = 1;
y = 4; y = 4;
z = 8; z = 8;
w = ok || pow(x,3) > 1; w = ! (x+1 >= z/y && ok );
return 0; return 0;
} }
7.1.1.3. Exercícios Avançados
1. Problema das Latas de Tinta

Faça um programa em C que calcule o custo financeiro (C) e a quantidade de latas de tinta
(Q) necessárias para pintar tanques cilíndricos de combustível de altura (H) e o raio da base
(R) do cilindro, ambos em metros, sabendo que:
a) a lata de tinta custa X unidades monetárias

b) cada lata contém Y litros de tinta
c) a cada litro de tinta pinta Z metros quadrados
Dados de entrada: X, Y, Z, H e R.
Dados de saída: C e Q.
Relações úteis:
a) custo é dado por quantidade de latas*X

b) quantidade de latas é dada por quantidade total de litros/Y
c) a quantidade total de litros é dada por área do cilindro/Z
d) área do cilindro é dada por área da base + área lateral
e) área da base é (PI*R2)
f) a área lateral é altura*comprimento: (2*PI*R*H)
g) PI é uma constante de valor conhecido: 3,14159265358979323846
Fonte: http://thiagoccampos.blogspot.com/2012/03/construa–um–algoritmo–que–calcule.html
2. Números Romanos: Escreva um programa que converta um número inteiro positivo

para a notação de números romanos. Símbolos utilizados para representar números
romanos: I, V, X, L, C, D, M.
3. Diz a lenda do Jogo de Xadrez que Lahur Sessa pediu a
seguinte recompensa por sua invenção: um grão de trigo para
a primeira casa do tabuleiro, dois para a segunda, quatro para
a terceira, oito para a quarta e assim sucessivamente até a
última casa de um total de 64 casas. Se a massa de um grão
de trigo é igual 3,855ˣ10-5 kg e sua densidade é de 7,55 kg/m3,
faça um programa em C para calcular a massa, o volume e o
número de conteiners Modelo HC8, mostrado na figura ao lado,
necessários para armazenar todo esse grão de trigo devido ao
brâmane.
8 Fonte: https://www.ativalocacao.com.br/curiosidades/medidas-container-atualizadas/
7.1.1.4. Exercícios das Estrelas e Galáxias
1. Faça um programa para listar a distância entre cada estrela da Tabela 7.1 e o nosso sol
em km, sabendo que um ano-luz = 299.792,458 km.
2. Faça um programa para listar o tempo de viagem de cada estrela da Tabela 7.1 ao
nosso sol em anos, feita por um jato comercial que viaja a 1.160 km/h.
Tabela 7.1 Distância entre algumas estrelas e o nosso Sol 9
Estrela Distância ao Sol

(anos-luz)
Alpha Centauri 4,2421
Luhman 16 6,5900
Sirius 8,5828
Gliese 866 11,266
Procyon 11,402
61 Cygni 11,403
Struve 2398 11,525
Groombridge 34 11,624
Epsilon Indi 11,824
Kruger 60 13,149
Ross 614 13,349
Wolf 424 14,312
Gliese 412 15,832
3. Faça um programa para listar a distância entre cada galáxia da Tabela 7.2 e a nossa
Via Láctea em km, sabendo que um parsec = 30.856.778.570.831 km.
4. Faça um programa para listar o tempo de viagem de cada galáxia da Tabela 7.2 a
nossa Via Láctea em anos, feita por um jato comercial que viaja a 1.160 km/h.
Tabela 7.2 Distância entre algumas galáxias e a nossa Via Láctea 10
Distância à Via Láctea

Galáxia
(parsec)
Grande Nuvem de Magalhães 50×103
Pequena Nuvem de Magalhães 60×103
9 Fonte: https://pt.wikipedia.org/wiki/Lista_de_estrelas_próximas
10 Fonte: https://pt.wikipedia.org/wiki/Lista_de_galáxias
Galáxia de Andrômeda 780×103
Galáxia do Triângulo 900×103
Centaurus A 4,2×106
Galáxia de Bode 3,6×106
Galáxia do Escultor 3,5×106
Messier 83 4,5×106
5. Faça um programa para listar a distância entre cada galáxia da Tabela 7.2 e a nossa
Via Láctea em km, sabendo que um parsec = 30.856.778.570.831 km.
6. Faça um programa para listar o tempo de viagem de cada galáxia da Tabela 7.2 a
nossa Via Láctea em anos, feita por um jato comercial que viaja a 1160 km/h.
7.1.1.5. Exercícios dos Aminoácidos
1. Faça um programa para listar a massa molecular de cada aminoácido do Quadro 7.1
sabendo que as massas moleculares do Carbono (C), Hidrogênio (H), Nitrogênio (N),
Oxigênio (O) e Enxofre (S) são iguais a 12,011; 1,00784; 14,0067; 15,999 e 32,065
g/mol, respectivamente.
Quadro 7.1 Aminoácidos e suas fórmulas moleculares11
Aminoácidos Fórmula Molecular
alanina C3H7NO2
arginina C6H14N4O2
asparagina C4H8N2O3
aspartato C4H7NO2
cisteína C3H7NO2S
fenilalanina C9H11NO2
glicina C2H5NO2
glutamato C5H9NO4
glutamina C5H10N2O3
histidina C6H9N3O2
isoleucina C6H13NO2
leucina C6H13NO2
lisina C6H14N2O2
metionina C5H11NO2S
prolina C5H9NO2
serina C3H7NO3
11 Fonte: http://plone.ufpb.br/ldb/contents/documentos/aminoviewer.pdf
tirosina C9H11NO3
treonina C4H9NO3
triptofano C11H12N2O2
valina C5H11NO2
7.2. Estrutura de Decisão – ED
Como é muito comum tomar decisões, fazer escolhas, as linguagens de programação

possui estruturas de tomada de decisão.
As estruturas de decisão (ED) da linguagem C são muito simples, elas permitem até du -
as escolhas de cada vez e usam condições lógicas para decidir qual delas executar. As con-
dições são avaliadas, podendo resultar em false ou true, resultando em duas opções.
A principal estrutura de decisão da linguagem C é a instrução if/else.
A instrução if/else permite selecionar uma decisão dentre duas alternativas. Ela é consti -
tuída pelas palavras reservadas if e else, uma condição e dois blocos de instruções, como
pode ser visto na Figura 7.2.
A sintaxe da instrução if/else é mostrada a seguir.
if( condição ){ // bloco do if – executado quando condição é true

[ lista de instruções do bloco do if; ]
{
else{ // bloco do else – executado quando condição é false
[ lista de instruções do bloco do else; ]
}
A ED if/else executa diferentes blocos de instruções a partir de uma lógica de compara-

ção. O fluxo de controle do programa é desviado seletivamente com base na condição boole-
ana, ou seja, condição cujo resultado é true ou false. As estruturas de decisão são também
conhecidas como estrutura de seleção.
if( condição ){
[ bloco do if; ]
}
else{
[ bloco do else; ]
}
(a) (b)
Figura 7.2 a) Sintaxe da instrução if/else; b) e seu fluxograma.
O else da instrução if/else é opcional e, desse forma, sua sintaxe se reduz a:
if( condição ){ // bloco do if – executado quando condição é true

[ lista de instruções do bloco do if; ]
{
As regras sintáticas da linguagem C determina que os delimitadores () da condição no

formato da instrução if/else são obrigatórios; que os delimitadores {} são obrigatórios
em blocos com mais de uma instrução e são opcionais em blocos com apenas uma instru-
ção.
A instrução if/else é lida em português da seguinte forma:
se condição é true então execute o “bloco do if” senão execute o “bloco do else”.
Quando o fluxo de controle do programa encontra a palavra reservada if ele avalia a

condição, que pode resultar em true ou false. Quando a condição é true, o bloco de código do
if é executado; o if é encerrado e não executa o eles e seu bloco. Quando a condição é false,
o fluxo de controle segue para a palavra reservada else e executa o bloco de código do else,
neste caso o bloco do if não é executado. Em ambos os casos, após a execução de um dos
blocos de instrução, o fluxo de controle do programa segue adiante.
O bloco do else é opcional e pode ser omitido, como discutido no Comentário 7.2.
Comentário 7.2 Estudo de caso da estrutura de decisão if, com a Regra do Dedo
Utilizando a Regra do Dedo, pode-se acompanhar o fluxo de controle da

instrução if como mostrado nas figuras ao lado.
As figuras ao lado apresentam o fluxo de controle da instrução if, o fluxo de

controle da figura de cima é caso em que a condição tem valor lógico true;
e o fluxo de controle da figura de baixo é o caso em que da condição tem
valor lógico false, o caso contrário.
No fluxo de controle da figura de cima, como x é igual zero (x == 0), o

valor da condição é true, o fluxo de controle segue para o bloco do if, a
instrução 1, instrução 2 e instrução 3 são executadas em sequência. Após a
instrução 3, o fluxo de controle sai do bloco do if e segue para a instrução 4
e instrução 5.
No fluxo de controle da figura de baixo, como x é igual dois (x == 2), o

valor da condição é false, o bloco de instrução do if não é executado, o
fluxo de controle segue para a instrução 4 e instrução 5.
O bloco do if/else é discutido no Comentário 7.3.
Comentário 7.3 Estudo de caso da estrutura de decisão if/else, com Regra do Dedo
Utilizando a Regra do Dedo, pode-se acompanhar o fluxo de controle da

instrução if/else mostrado nas figuras ao lado.
A figura ao lado apresenta o fluxo de controle da instrução if/else, o fluxo

de controle da figura de cima é o caso em que a condição tem valor lógico
true; e o fluxo de controle da figura de baixo é o caso em que da condição
tem valor lógico false, o caso contrário.
No fluxo de controle da figura de cima, como x é igual zero (x == 0), o

valor da condição é true, o fluxo de controle segue para o bloco do if, a
instrução 1, instrução 2 e instrução 3 são executadas em sequência. Após a
instrução 3, o fluxo sai do bloco do if e segue para a instrução 7 e instrução
8, o bloco do else não é executado.
No fluxo de controle da figura de baixo, como x é igual dois (x == 2), o
valor da condição é false, o bloco do if não é executado, o fluxo de controle
segue para o bloco do eles, a instrução 4, instrução 5 e instrução 6 são
executadas em sequência. Após a instrução 6, o fluxo sai do bloco do else e
segue para a instrução 7 e instrução 8.
O Programa 7.2 discute o if/else aplicado ao problema de identificar números pares,

apresenta o programa e também o seu fluxograma.
Programa 7.2 Programa C para ler um número inteiro do teclado e escrever na tela se ele é
para ou ímpar
Um número inteiro x é par se x % 2 == 0, caso contrário, x é ímpar.

O programa pode ser resolvido com um if/else, basta declarar uma variável inteira de nome
x, para armazenar o valor do número inteiro a ser lido pelo teclado e usar um if/else com a
condição: x % 2 == 0.
Abaixo estão apresentados o programa e sua representação em fluxograma.
Programa-fonte Fluxograma
#include <stdio.h>
int main( void ){
int x;
printf( "Digite um número inteiro: " );
scanf( "%d", &x );
if( x % 2 == 0 ){
printf(" x é par" );
}
else{
printf(" x é ímpar" );
}
return 0;
}
O Comentário 7.4 apresenta outra solução para o Programa 7.2.
Comentário 7.4 O programa abaixo também resolve o Programa 7.2?
#include <stdio.h>
int main( void ){
int x;
printf( "Digite um número inteiro: " );
scanf( "%d", &x );
if( x % 2 ) printf( "x é ímpar" );
else printf( "x é par" );
return 0;
}
Resposta: sim.
A sintaxe da instrução if/else não obriga os delimitadores de bloco {} para bloco com uma
única instrução.
A expressão x % 2 pode ter apenas dois resultados, 0 ou 1. Se x % 2 for igual a 0, seu valor
lógico é false, x é ímpar. Se x % 2 for igual a 1, seu valor lógico é true, x é par.
Assim, tanto a expressão x % 2 == 0 quanto a expressão x % 2 podem ser usadas como
condição da instrução if/esle.
O Programa 7.3 lê inteiros verifica sua paridade.
Programa 7.3 Programa C Programa C para ler um número inteiro do teclado e escrever na
tela se ele é para ou ímpar, usando funções
Programa 7.3 Programa C Programa C para ler um número inteiro do teclado e escrever na
tela se ele é para ou ímpar, usando funções
Um número inteiro x é par se x % 2 == 0, caso contrário, x é ímpar.

O programa pode ser resolvido com um if/else, basta declarar uma variável inteira de nome
x, para armazenar o valor do número inteiro a ser lido pelo teclado e usar um if/else com a
condição: x % 2 == 0.
Abaixo estão apresentados o programa e sua representação em fluxograma.
L Solução a Solução b
1 #include <stdio.h> #include <stdio.h>
2 int ler( void ){ int ler( void ){
3 int x; int x;
4 printf( "Digite um número inteiro: " ); printf( "Digite um número inteiro: " );
5 scanf( "%d", &x ); scanf( "%d", &x );
6 return x; return x;
7 } }
8 void par( int x ){ void par( int x ){
9 if( x % 2 == 0 ) printf(" número par" ); if( x % 2 == 0 ) printf(" número par" );
10 else printf(" número ímpar" ); else printf(" número ímpar" );
11 } }
12 int main( void ){ int main( void ){
13 int n = ler(); par( ler() );
14 par(n); return 0;
15 return 0; }
16 }
O Programa 7.4 ilustra o conceito de fluxo de controle com chamadas das funções par e
gerar usando dois programas-fonte.
Programa 7.4 Execute acada os programas-fontes a e b no C Tutor e identifique o fluxo de

controle de cada um deles
Abaixo está uma imagem montada com a execução do Programa-fonte a no C Tutor, uma
vez que as funções par e gerar não coexistem na memória do computador.
A função main chama as funções gera e par. Primeiramente, main chama gerar e seu é
passado como valor na chamada da função par. A função par classifica o parâmetro
recebido em par ou ímpar.
A imagem da execução do Programa-fonte a no C Tutor, mostra a sequência de chamadas

de funções. A função main chama par e par chama gerar, o retorno de gerar é usado na
condição da instrução if/else para classificar o retorno de gerar em par ou ímpar.
L Programa-fonte a Programa-fonte b
1 #include <time.h> // time #include <time.h>
2 #include <stdio.h> // printf #include <stdio.h>
3 #include <stdlib.h> // srand, rand #include <stdlib.h>
4 #include <stddef.h> // NULL #include <stddef.h>
5 #include <stdbool.h> // bool #include <stdbool.h>
6 int gerar( void ){ int gerar( void ){
7 int valor; int valor;
8 valor = rand() % 10; valor = rand() % 10;
9 return valor; return valor;
10 } }
11 void par( int x ){ void par( void ){
12 if( x % 2 ) printf("\n x é ímpar"); if( gerar() % 2 ) printf("\n x é ímpar");
13 else printf( "\n x é par" ); else printf( "\n x é par" );
14 } }
Programa 7.4 Execute acada os programas-fontes a e b no C Tutor e identifique o fluxo de

15 int main( void ){ int main( void ){
16 srand(time(NULL)); srand(time(NULL));
17 par( gerar() ); par();
27 return 0; return 0;
28 } }
29
Execução do Programa
O Programa 7.5 mostra o uso if/else como classificador de faixa de idade.
Programa 7.5 Classificar se um brasileiro é maior ou menor de idade.
Na legislação, a idade de um brasileiro define se ele de maior ou de menor, portanto idade

e a variável da condição.
A legislação estabelece que a maioridade é alcançada aos 18 anos – com isso pode–se
definir a condição booleana.
Logo é necessário ler a idade da pessoa em anos e compará–la com o valor 18. Se a idade
for maior ou igual a 18, a pessoa é de maior pois a comparação resulta em um valor lógico
true. Se a idade for menor do que 18, a pessoa é de menor pois a comparação resulta em
um valor lógico false.
Basta declarar uma variável para receber o valor da idade da pessoa, o tipo int é suficiente
e o mais adequando. Ler o valor da idade pelo teclado e compará–lo com o valor padrão
que é igual a 18, para isso utiliza–se a instrução if/else, como abaixo indicado.
Programa-fonte
#include <stdio.h>
int main( void ){
int idade;
Programa 7.5 Classificar se um brasileiro é maior ou menor de idade.
printf( "Digite a idade do cidadão brasileiro em anos: " );

scanf ( "%d", &idade );
if( idade >= 18 ){
printf(" o cidadão é de maior" );
}
else{
printf(" o cidadão é de menor" );
}
return 0;
}
A instrução if/else pode ser aninhada, ou seja, pode–se ter if/else dentro de if e if/else
dentro de else, permitindo fazer comparações complexas, como mostrado no Programa 7.6.
Programa 7.6 Classificar um brasileiro em voto obrigatório, voto facultativo e não vota
Pensamento computacional
Na legislação brasileira, o que define se um brasileiro vota é a sua idade, com quatro faixas
de decisão:
a) idade menor do que 16 anos – não vota
b) idade entre 16 e 18 anos – voto facultativo
c) idade entre 18 e 70 anos, ambas incluídas – voto obrigatório
d) idade maior do que 70 anos – voto facultativo
Logo é necessário saber a idade da pessoa em anos e enquadrá–la na faixa
correspondente.
Basta declarar uma variável para receber o valor da idade da pessoa, o tipo int é
adequando. Ler o valor dado pelo teclado e avaliar a qual faixa pertence, para isso utiliza–
se comandos if/else aninhados, como indicado a seguir:
se idade < 16 então não pode votar

senão se idade < 18 então voto facultativo
senão se idade < 71 então voto obrigatório
senão voto facultativo
O Plano de testes completo devem incluir valores do centro e dos extremos das faixas de
idades. Por exemplo, deve-se testar os valores: 10, 16, 17, 18, 50, 70 e 80 anos.
Programa-fonte
#include <stdio.h>
int main( void ){
int idade;
printf( "Digite a idade do cidadão brasileiro em anos: " );
scanf( "%d", &idade );
if( idade < 16 ) printf( "não pode votar" );
else if( idade < 18 ) printf( "voto facultativo" );
else if( idade < 71 ) printf( "voto obrigatório" );
else printf( "voto facultativo" );
Programa 7.6 Classificar um brasileiro em voto obrigatório, voto facultativo e não vota
return 0;
}
O Programa 7.7 encontra múltiplos usando o if/else.
Programa 7.7 Faça um programa em C que leia um número inteiro do teclado e verifique se
ele é múltiplo de 3 e de 4
Pode–se usar a técnica “dividir para conquistar”:
• condição para que x seja múltiplo de 3: x % 3 == 0

• condição para que x seja múltiplo de 4: x % 4 == 0
Proposta de uma condição para “múltiplo de 3 e 4”: (x % 3 == 0) && (x % 4 == 0)
Basta declarar uma variável para receber o valor do número inteiro, seja int x esta variável.
Ler o valor de x do teclado e avaliar a expressão (x % 3 == 0) && (x % 4 == 0) e decidir.
x Plano de Teste
0 0 é múltiplo de 3 e de 4
3 3 não é múltiplo de 3 e de 4
12 12 é múltiplo de 3 e de 4
Programa-fonte
#include <stdio.h>
int main( void ){
int x;
printf( "\n Digite o valor de x: " );
scanf ( "%d", &x );
if( (x % 3 == 0) && (x % 4 == 0) ){
printf( " Resposta: %d é múltiplo de 3 e 4", x );
}
else{
printf( " Resposta: %d não é múltiplo de 3 e de 4", x );
}
return 0;
}7
Programa 7.7 Faça um programa em C que leia um número inteiro do teclado e verifique se
ele é múltiplo de 3 e de 4
O Programa 7.7 discute problemas em condições que compara expressões com zero.
Comentário 7.5 Limitações dos tipos de dados
x k∗x
Em termos matemáticos, os valores de w= e z= são iguais, logo w−z=0 . No
y k∗ y
entanto, em termos computacionais pode ocorre que w−z=0 ou que w−z≠0 , depende
da máquina pois os tipos de dados da linguagem C são limitados pela precisão da máquina.
O programa abaixo tem como resultado w - z < 0, para k = 47. O resultado pode ser
diferente para outros valores de k.
#include <stdio.h>
int main( void ){
int k = 47;
double x = 10.9,
y = 0.4,
w = x/y,
z = (k*x)/(k*y);
printf( "\n w-z = %.21lf", w-z );
if( w-z != 0 ) printf( "\n diferente de zero" );
if( w-z == 0 ) printf( "\n igual a zero" );
printf( "\n\n\n" );
return 0;
}
O Programa 7.8 discute o Problema da Três Esferas.
Programa 7.8 O Caso das Três Esferas – imagine que se disponha de três esferas
numeradas 1, 2 e 3 iguais na forma, duas delas com pesos iguais e diferentes do peso da
outra. Escreva um algoritmo que, com duas pesagens numa balança de dois pratos,
determine a esfera de peso diferente.
Sejam as esferas 1, 2 e 3, com massas m1, m2 e m3, respectivamente. Duas das massas
devem ser iguais e a terceira deve ser diferente das outras duas.
int main( void ){

float m1 = 100.0, // massa da esfera 1
m2 = 120.0, // massa da esfera 2
m3 = 100.0; // massa da esfera 3
return 0;
}
Como os braços da balança são simétricos, o número de pesagens fica reduzida a três,
como mostra as figuras abaixo. A primeira pesagem usa as esferas 1 e 3; a segunda as
esferas 1 e 2; e a terceira as esferas 3 e 2.
Mas o problema permite apenas duas pesagens, logo são duas ED, uma para cada
pesagem:
if( m1 == m3 ){ // primeira pesagem

printf( "a esfera 2 é a diferente" );
}
else{
if( m1 == m2 ){ // segunda pesagem
}
else{
}
}
Dicionário de dados
Variável Descrição Tipo de Dado Valor Inicial Processo
m1 massa da esfera 1 float 100.0 E
Plano de Testes
Como duas massas devem ser iguais e a terceira deve ser diferente das outras duas, as
opções são:
1. m2 = m3 e m1 ≠ m2; por exemplo, m1 = 120.0, m2 = 100.0, m3 = 100.0
Programa-fonte
#include <stdio.h>
int main( void ){
float m1 = 100.0, // massa da esfera 1
m2 = 120.0, // massa da esfera 2
m3 = 100.0; // massa da esfera 3
if( m1 == m2 ){ // primeira pesagem
}
else{
if( m1 == m3 ){ // segunda pesagem
}
else{
}
}
return 0;
}
m1 = 120.0 m1 = 100.0 m1 = 100.0

m2 = 100.0 m2 = 120.0 m2 = 100.0
m3 = 100.0 m3 = 100.0 m3 = 120.0
1. Faça um programa em C que leia um número inteiro do teclado e verifique se é ímpar.

2. Faça um programa em C que leia um número inteiro do teclado e verifique se é positivo
e menor do que 100.
3. As maçãs custam M$ 0,75 cada se forem compradas menos do que uma dúzia, e M$
0,60 se forem compradas pelo menos doze. Escreva um programa que leia o número de
maçãs compradas, calcule e escreva o valor total da compra.
4. Escreva um programa para ler o número de lados de um polígono regular e a medida
do lado (em cm). Calcular e imprimir o seguinte: a) se o número de lados for igual a 3
escrever TRIÂNGULO e o valor da área; b) se o número de lados for igual a 4 escrever
QUADRADO e o valor da sua área; c) se o número de lados for igual a 5 escrever
PENTÁGONO; d) caso o número de lados seja inferior a 3 escrever NÃO É UM POLÍGONO.
5. Dados três segmentos de reta a, b e c, se a+b>c e a+c>b e b+c>a, estes podem
formar um triângulo. Faça um programa que dados os valores dos segmentos de reta a, b
e c, verifica se pode ser construído um triângulo com estes segmentos.
6. Dados três segmentos de reta a, b e c, se estes segmentos forem tais que a=b=c, o
triângulo formado com estes segmentos é chamado de equilátero. Se a=b≠c ou a≠b=c ou
b≠a=c, o triângulo é chamado isósceles e se a≠b≠c o triângulo é chamado escaleno.
Dados três segmentos de reta a, b e c, verifique se os segmentos podem formar um
triângulo, classifique o triângulo.
7. Escreva um programa que leia o valor de 2 ângulos de um triângulo e escreva se o
triângulo é Acutângulo, Retângulo ou Obtusângulo. Sendo que: a) Triângulo Retângulo:
possui um ângulo reto (igual a 90˚); b) Triângulo Obtusângulo: possui um ângulo obtuso
(maior que 90˚); e c) Triângulo Acutângulo: possui três ângulos agudos. (menor que 90˚).
8. Leia um ponto (x,y), coordenadas de um plano, e informar em qual quadrante ele está
situado, se está em um dos eixos ou localizado na origem.
9. Leia os coeficientes de uma equação do segundo o grau e escreva um programa para

calcular suas as raízes. Faça também o seu fluxograma.
10.Faça um programa em C que leia um número inteiro do teclado e verifique se é
divisível por 3 ou por 5 ou por 7.
múltiplo de 4 ou 6 ou 10.
múltiplo de 4 e 6 e 10.
múltiplo de 4 e 6 ou 10.
14.Faça um programa que receba três notas, calcule e mostre a média aritmética e a
mensagem conforme a descrição: a) média de 0,0 a 4,9: reprovado; b) média de 5,0 a 6,9:
exame; e c) média de 7,0 a 10: aprovado.
15.Faça um programa que receba dois números e mostre o menor.
16.Faça um programa que receba três números e mostre o maior.
17.Faça um programa que receba dois números e mostre–os em ordem crescente.
18.Faça um programa que receba três números e mostre–os em ordem crescente.
19.Uma empresa decide dar um aumento de 30% aos funcionários com salários inferiores
a M$ 5000,00. Faça um programa que receba o salário do funcionário e mostre o valor do
salário reajustado ou uma mensagem, caso ele não tenha direito ao aumento.
20.Escreva um programa que leia as medidas dos lados de um triângulo e escreva se ele é
equilátero, isósceles ou escaleno.
21.Escrever e teste um programa para indicar se n inteiro e positivo é divisível por 3, por 5
e por 7, mas não simultaneamente pelos três.
22.Faça um programa que receba quatro notas de um aluno, calcule e mostre a média
aritmética das notas e a mensagem de aprovado ou reprovado, considerando para
aprovação média 7.
24.Faça um programa que verifique a validade de uma senha fornecida pelo usuário. A
senha é 4531. O programa deve mostrar uma mensagem de permissão de acesso ou não.
25.Faça um programa que receba a idade de uma pessoa e mostre a mensagem de
maioridade ou não.
26.Faça um programa que receba a altura e o sexo de uma pessoa e calcule e mostre seu
peso ideal, utilizando as seguintes fórmulas (onde h é a altura): para homens: 72,7✕ h-58
e para mulheres: 62,1✕ h – 44,7.
27.Para doar sangue é necessário ter entre 18 e 67 anos. Faça um programa que pergunte
a idade de uma pessoa e diga se ela pode doar sangue ou não.
28.Faça um programa que receba o comprimento dos lados de um triângulo e escrever 1
se formam um triângulo equilátero, 2 se formam um triângulo se isósceles, 3 se formam
um triângulo se escaleno e 0 se não forma triângulo.
29.Escreva um programa que leia os valores correspondentes a três resistores elétricos e
um número que indica como estão associados esses resistores: “1” para associação em
série e “2” para associação em paralelo. O programa deve calcular a resistência
equivalente. O programa deve testar se os três valores lidos são positivos e, caso algum
não seja, informar o erro.
30.Escreva um programa que leia os valores correspondentes a três capacitores e um
número que indica como estão associados esses capacitores: “1” para associação em série
e “2” para associação em paralelo. O programa deve calcular a capacitância equivalente.
O programa deve testar se os três valores lidos são positivos e, caso algum não seja,
informar o erro.
31.Escreva um programa que leia o horário (horas e minutos) de início de um jogo de
futebol e informe o horário (horas e minutos) previsto para seu final, lembrando que o jogo
pode iniciar em um dia e terminar no dia seguinte.
32.Escreva um programa que receba como dados de entrada: a) a data de nascimento de
uma pessoa (dia, mês e ano) e b) a data atual (dia, mês e ano), em seguida, calcule e
informe a idade dessa pessoa. O programa deve informar ainda se essa pessoa tem idade
para votar (16 anos ou mais).
33.Faça um Programa que peça um número correspondente a um determinado ano e em
seguida informe se este ano e ou não bissexto.
34.Crie um programa que peça um número ao usuário e armazene ele na variável x.
Depois peça outro número e armazene na variável y. Mostre esses números. Em seguida,
faça com que x passe a ter o valor de y, e que y passe a ter o valor de x. Mostre esses
números novamente.
1. Faça um programa para calcular o Imposto de Renda de Pessoa Física (IRPF), consulte
na web as regras para este cálculo.
2. Faça um programa que informe se é possível comprar um produto de valor X unidades
monetárias (UM) com a quantidade de UM de uma carteira que contenha:
a) M1 moedas de UM$ 1,00
b) N1 notas de UM$ 2,00
c) N2 notas de UM$ 5,00
d) N3 notas de UM$ 10,00
e) N4 notas de UM$ 50,00
f) N5 notas de UM$ 100,00
3. Faça um programa que informe se é possível comprar um produto de valor X unidades
monetárias (UM) e Y centavos com a quantidade de UM de uma carteira que contenha:
a) M1 moedas de UM$ 0,01
b) M2 moedas de UM$ 0,05
c) M3 moedas de UM$ 0,10
d) M4 moedas de UM$ 0,50
e) M5 moedas de UM$ 1,00
f) N1 notas de UM$ 2,00
g) N2 notas de UM$ 5,00
h) N3 notas de UM$ 10,00
i) N4 notas de UM$ 50,00
j) N5 notas de UM$ 100,00
4. Matemática, Páscoa e Programação
O matemático Johann Friederich Carl Gauss propôs um método para determinar as datas de
Páscoa, cujas regras foram definidas no Concílio de Nicéia (325 E.C.).
Conforme definido, a Páscoa deve ser celebrada no domingo seguinte à primeira lua cheia
da Primavera (na Europa). Gauss desenvolveu uma regra prática para calcular a data da
Páscoa no calendário gregoriano, a partir de 1583.
Considere A como sendo o ano, e m e n dois números que variam ao longo do tempo de
acordo com a seguinte tabela:
Ano Valores
1583 – 1699 m = 22, n = 2
1700 – 1799 m = 23, n = 3
1800 – 1899 m = 23, n = 4
1900 – 2099 m = 24, n = 5
2100 – 2199 m = 24, n = 6
Considere também:
a = o resto da divisão de A por 19

b = o resto da divisão de A por 4
c = o resto da divisão de A por 7
d = resto da divisão de 19a+m por 30
e = o resto da divisão de 2b+4c+6d+n por 7
Então a Páscoa será no dia 22+d+e de março ou d+e–9 de Abril
Observações:
O dia 26 de abril deve ser sempre substituído por 19 de abril.

O dia 25 de abril deve ser substituído por 18 de abril se d = 28, e = 6 e a > 10.
Faça um programa em C para calcular a páscoa de qualquer ano no intervalo de 1583 a

2199.
Fonte: http://www.somatematica.com.br/mundo/pascoa.php
5. O caso das oito esferas: Imagine que se disponha de três esferas numeradas 1, 2, 3, …,
8 iguais na forma, sete delas com pesos iguais e diferentes do peso da outra. Escreva
um algoritmo que, com três pesagens numa balança de dois pratos, determine a esfera
de peso diferente.
7.3. Estrutura de Iteração – EI
Existem muitas tarefas repetitivas e as linguagens de programação possui estruturas de

iteração que permitem executar um bloco de instruções várias vezes.
As estruturas de iteração (EI) da linguagem C são muito simples, elas permitem a execu-
ção reiterada de um bloco de instruções e usam condições lógicas para decidir quando pa-
rar. As condições são avaliadas, podendo resultar em false ou true, false para o ciclo de repe -
tições do bloco de instruções.
As estruturas de iteração executam um único bloco de instruções a partir de uma lógica
de comparação. O fluxo de controle do programa repete um bloco de instruções com base
em uma condição booleana.

As principais estruturas de iteração da linguagem C são a instrução while e a instrução
for; também tem a instrução do/while que é tratada no Anexo.
7.3.1. Instrução while
A instrução while repete seu bloco de instruções um número finito de vezes, enquanto o
valor lógico da sua condição for true.
A sintaxe da instrução while é mostrada a seguir.
while( condição ){
[lista de instruções do bloco;]
}
A condição é uma expressão lógica, cujo resultado é true ou false.

Inicialmente, o while avalia a condição e, quando o valor da condição é true, o bloco de
instruções é executado; e, quando o valor da condição é false, o bloco de instruções não é
executado e a instrução while é finalizada. A cada avaliação do valor da condição em que ela
é true, o bloco de instruções é executado e a condição volta a ser avaliada; este ciclo se re -
pete até o valor da avaliação da instrução se torne false.
while( condição ){
[ bloco do while; ]
(a) (b)
Figura 7.3 a) Sintaxe da instrução while; b) e seu fluxograma.
As variáveis que compõem a expressão usada como condição devem ter sido declaradas
com valores válidos, inicializadas previamente, lidos pelo teclado ou calculados, pois a avalia-
ção da condição ocorre logo no início do while.

O while executa o seu bloco de instruções enquanto o valor da condição for true; de al-
guma forma, o bloco do while deve mudar o valor da condição para que ele se torne false de
modo o while seja finalizado.
As regras sintáticas da linguagem C determina que os delimitadores () da condição no
formato da instrução while são obrigatórios; que os delimitadores {} são obrigatórios em blo-
cos com mais de uma instrução e são opcionais em blocos com apenas uma instrução.
A instrução while é lida em português da seguinte forma:
Enquanto condição for true repita a execução o “bloco do while”.
O Programa 7.9 discute a contagem usando a instruçãowhile.
Programa 7.9 Programa para contar de 0 a 4 usando while (wconta.c)
O programa é inciado pela função main, linha 2.

É declarada a variável conta, do tipo int, com valor inicial 0, linha 3. A variável conta é
usada como condição do while.
O fluxo de controle executa o while, linha 4.
Como a variável conta é usada na condição do while, foi necessário atribuir um valor inicial
para conta, caso contrário condição seria avaliada com “lixo de memória” – erro de lógica
de programação.
O while avalia a condição, conta < 5, linha 4. O valor da condição, 0 < 5, é true e o bloco é
executado, linhas 5, 6, 7 e 8.
O valor de conta = 0 é impresso na tela, linha 5.
O valor de conta é incrementado, conta = 1, linha 6.
O bloco do while é encerrado, linha 7.
O fluxo de controle volta para a instrução while, linha 4.
O while avalia a condição 1 < 5 → true, imprime 1 e conta = 2.

O while avalia a condição 5 < 5 → false, o while é encerrado.
Após encerrar o while, o programa retorna 0 e também encerrado.

O while foi executado 6 vezes e imprime os números inteiros de 0 a 4 na saída padrão.
2 int main( void ){
3 int conta = 0; declara int conta com valor inicial 0
4 while( conta < 5 ) avalia o valor conta < 5
5 { inicio do bloco da instrução while
6 printf( " %d ", conta ); escreve o valor de conta na tela

Programa 7.9 Programa para contar de 0 a 4 usando while (wconta.c)

7 conta++; conta é incrementado
8 } fim do bloco da instrução while
9 return 0;
10 }
Imagens da execução
11
Fluxo de controle do programa-fonte
Fluxo de controle Iteração conta conta < 5 tela
🌑→2→3→ 0 -
→4→5→6→7→8→ 1a 0 true 0
→4→5→6→7→8→ 2a 1 true 01
→4→5→6→7→8→ 3a 2 true 012
→4→5→6→7→8→ 4a 3 true 0123
→4→5→6→7→8→ 5a 4 true 01234
→4→ 6a 5 false 01234
→ 9 → 10 → 🌕 5 01234
O Comentário 7.6 discute como ler dados do teclado e seu uso na condição da instrução
while.
Comentário 7.6 Ler e imprimir números inteiros positivos lidos do teclado.
Estrutura de iteração while com condição lida do teclado – o valor 0 (zero) encerra as
leituras
Números inteiros devem ser lidos do teclado e impressos na tela enquanto seus valores
forem diferentes de zero.
O programa é resolvido com o while pois não se sabe o número de repetições a serem
feitas.
A condição é dada pelo usuário.
O algoritmo é simples, inicialmente o primeiro número deve ser lido do teclado, antes de
entrar no while.
O algoritmo entra no while e verifica se o valor do número é igual a 0. Se for encerra e
nada é impresso. O programa é encerrado.
Se o primeiro valor lido é diferente de 0, o programa entra no while, imprime o valor do
número na tela. Lê um novo valor do teclado e testa a condição. O while será repetido
indefinidamente até que o valor lido seja 0.
Observe que a condição do while utiliza o valor lido do teclado e, por isso, são necessário
dois comandos de leitura. O primeiro, antes do while, para que ele tenha com o que testar
sua condição. O segundo, dentro do while, para que ele atualize o valor lido porque senão
ele entra em loop – laço eterno.
Comentário 7.6 Ler e imprimir números inteiros positivos lidos do teclado.
#include <stdio.h>
int main( void ){
int numero;
printf( "\n Digite um número inteiro positivo – 0 encerra " );

scanf ( "%d", &numero );
while( numero == 0 ){
printf("\n O número digitado foi %d ", numero );
printf("\n Digite um número inteiro positivo " );
scanf("%d", &numero );
}
return 0;
}
Como pode ser visto neste programa, para processar dados lidos do teclado cria–se uma
variável para controlar a estrutura de iteração (EI).
Antes de entrar na EI, o valor desta variável deve ser lida do teclado. Após esta primeira
leitura já se pode entrar na EI.
A EI avalia sua condição e, quando ela é true, seu bloco de instruções é executado, caso
contrário a EI é finalizada. Dentro do bloco da EI, em último lugar, o valor da variável deve
ser lido do teclado novamente, para atualizar o seu valor pois será utilizada na condição da
EI.
Vale destacar que, em alguma interação, o valor da variável deve modificar a condição
para finalizar o ciclo de repetições, dado fim a EI.
O Comentário 7.7 discute o uso da soma na condição da instrução while.
Comentário 7.7 Somar os números inteiros positivos, sequencialmente, de 1 até que o total
ultrapasse 100
É criada uma variável para controlar o while antes dele. Atribui–se a ela um valor tal que,
ao ser testado no while, seja VERDADE, caso contrário o while não será executado. Dentro
do while, o valor da variável deve, em alguma iteração, ser alterado de modo que, ao ser
avaliada pela condição do while, ela seja FALSO, encerrando o ciclo de iteração. Leia
atentamente os
#include <stdio.h>
int main( void ){
int numero, soma;
numero = 1;
Soma = 0;
while( Soma <= 100 ){

numero = numero + 1;
Soma = Soma + numero;
}
printf("\n Soma dos números = %d ", Soma );
printf("\n Ultimo numero somado = %d ", numero );
return 0;
}
7.3.2. Instrução for
Muitas classes de problemas possuem um padrão repetitivo previsível 12. Problemas de

contagem, somas, médias, máximos e mínimos, por exemplo. A estrutura de iteração for é
muito utilizada nos programas C para manipular os elementos de vetores, strings e matrizes.
O for deve se usado sempre que se souber, de antemão, quantas vezes o bloco de co-
mandos deverá ser executado como, por exemplo, os vetores e as matrizes.
De modo geral, a estrutura de iteração for possui:
1. um contador previamente declarado para controle do for, em geral do tipo int

2. um valor inicial do contador
3. uma condição para finalizar o for
4. um bloco de comandos
5. uma instrução para incrementar/decrementar o contador
O valor inicial do contador, em geral, é definido na instrução for, em seguida vem a con-
dição e, por fim o incremento/decremento do contador. Sua sintaxe é:
for( instrução inicial; condição; incremento ){
[ lista de instruções do bloco;]
A Figura 7.4.a é sintaxe da instrução for e a Figura 7.4.a é o seu fluxograma. Nestas figu-
ras estão indicados o fluxo de controle da estrutura, a partir da instrução valor inicial e, em
seguida avalia a condição, se false o for não é executado e o fluxo continua; se true o bloco
de comandos do for é executado, o fluxo de controle segue e executa o incremento e fe-
cha o ciclo, voltando à condição. Este ciclo se repete até que a condição mude para false e,
assim, ao avaliar a condição novamente, o fluxo de controle vai para a próxima instrução de -
pois do for.
12 O termo loop em inglês pode ser traduzido para laço em português e por isso as estruturas de iteração são chamadas de
laços de iteração.
for( instrução inicial; condição; incremento ){
[ bloco do for; ]
}
(a)
(b)
Figura 7.4 a) Sintaxe da instrução for; b) e seu fluxograma.
Observe na Figura 7.4.a que a instrução valor inicial é executado uma única vez; e
também que a estrutura de iteração for pode não ser executado, ou seja, ele pode ser execu-
tado zero vezes ou mais.
O Comentário 7.8 discute o fluxo de controle da estrutura de iteração for usando a Regra
do Dedo.
Comentário 7.8 Estudo de caso da estrutura de iteração for, com a Regra do Dedo
A figura ao lado apresenta o fluxo de controle da

estrutura de iteração for; seu contador é a variável i
(previamente declarada), sua condição é i < x (x é o
número de repetições do bloco de comandos); o
incremento é i++.
Utilizando a Regra do Dedo, pode-se acompanhar o

fluxo de controle desta estrutura. Nesta figura os fluxos
de controle estão coloridos:
1. o fluxo de controle azul executa a instrução i = 0
2. a condição é avaliada
3. a condição é false, o fluxo vermelho é executado –
o for é encerrado
4. a condição é true, o fluxo verde é executado – o
bloco de instrução é executado e o contador é
incrementado
5. retorna ao número 2
O Programa 7.10 mostra a contagem usando a instrução for.

Programa 7.10 Programa para contar de 0 a 4 usando for (fconta.c)
As linhas 4, 5 e 6 do programa-fonte foram separadas em três para que o fluxo de controle

fosse numerado de forma adequada. A primeira instrução do for é executada uma única
vez a cada execução desta estrutura de iteração. A segunda e a terceira instrução do for
não são executados na ordem em que se encontram nesta estrutura de iteração.
É declarada a variável conta, do tipo int, sem valor inicial, linha 3; ela é usada na condição
do for.
O fluxo de controle executa a primeira instrução do for, linha 4.
O for atribui 0 ao valor de conta, linha 4.
A condição do for é avalia, linha 5, o valor da condição, 0 < 5, é true e o bloco é executado,
linhas 7, 8 e 9.
O valor de conta = 0 é impresso na tela, linha 8.
O bloco do for é encerrado, linha 9.
O fluxo de controle volta para a instrução for, linha 6.
A instrução for incrementa o valor de conta, conta = 1.
A condição do for é avalia, 1 < 5 → true, imprime 1, incrementa conta, conta = 2.

A condição do for é avalia, 5 < 5 → false, o for é encerrado.
Após encerrar o for, o programa retorna 0 e também encerrado.

O for foi executado 6 vezes e imprime os números inteiros de 0 a 4 na saída padrão.
2 int main( void ){
3 int conta; declara int conta com valor inicial 0
4 for( conta = 0; instrução inicial, conta = 0
5 conta < 5; condição da instrução for
6 conta++ ) incremento de conta
7 { escreve o valor de conta na tela
8 printf( " %d ", conta ); conta é incrementado
9 } fim do bloco da instrução for
10 return 0;
11 }
11
Fluxo de controle do programa-fonte
Fluxo de controle Iteração conta conta < 5 tela

Programa 7.10 Programa para contar de 0 a 4 usando for (fconta.c)
🌑→2→3→4→ 0 -
→5→7→8→9→ 1a 0 true 0
→6→5→7→8→9→ 2a 1 true 01
→6→5→7→8→9→ 3a 2 true 012
→6→5→7→8→9→ 4a 3 true 0123
→6→5→7→8→9→ 5a 4 true 01234
→6→5→ 6a 5 false 01234
→ 10 → 11 → 🌕 5 01234
A técnica de Descrição Linha a Linha (DLL) de programas-fonte, usada no Programa

7.10, é tratada no Anexo.
Uma outra sintaxe da instrução for com decremento do contador.
for( instrução inicial; condição; decremento ){
[ lista de instruções do bloco;]
O Programa 7.11 imprime números inteiros do computador com decremento do conta-

dor da instrução for.
Programa 7.11 Programa para imprimir os números inteiros de 0 a 5 com decremento do

contador.
Seja c, o contador de instrução do for.

Neste caso o valor inicial de c é igual a 5 e vai diminuindo até 0 e, a cada iteração é
executado do bloco de instrução do for, no qual é impresso o valor de 5-c, para que
primeiro valor impresso seja 0 é necessário imprimir 5-c.
Desta forma, a instrução inicial do for é c = 5; sua condição é c >= 0; e o decremento é c--.
Programa-fonte
#include <stdio.h>
int main( void ){
int c;
for( c = 5; c >= 0; c-- ){
printf(" %d ", 5-c );
}
return 0;
}
O Programa 7.12 é um exercício sobre fluxo de controle usando a instrução for.

Programa 7.12 Execute acada os programas a e b no C Tutor e identifique o fluxo de

Os Programas-fonte a e b apresentam fluxos de controle similares, nos dois programas a

função par é chamada 10 vezes, a diferenças é que no Programa-fonte a isto é feito 10
vezes, das linhas 17 a 26; e no Programa-fonte b é usado a iteração for para chamar par 10
vezes, apenas na linha 19. Execute-os no C Tutor e verifique o processamento de cada um
deles.
Vale destacar que o resultado dos Programas-fonte a e b são os mesmos.
L Programa-Fonte a Programa-Fonte b
1 #include <time.h> // time
2 #include <stdio.h> // printf
3 #include <stdlib.h> // srand, rand
4 #include <stddef.h> // NULL
#include <time.h>
5 #include <stdbool.h> // bool
#include <stdio.h>
6 int gerar( void ){
#include <stdlib.h>
7 int valor;
#include <stddef.h>
8 valor = rand() % 10;
9 return valor;
int gerar( void ){
10 }
int valor;
11 void par( int x ){
valor = rand() % 10;
12 if( x % 2 ) printf("\n x é ímpar");
return valor;
13 else printf( "\n x é par" );
}
14 }
void par( int x ){
if( x % 2 ) printf("\n x é ímpar");
16 srand(time(NULL));
else printf( "\n x é par" );
17 par( gerar() );
}
18 par( gerar() );
int main( void ){
19 par( gerar() );
int i;
20 par( gerar() );
srand(time(NULL));
21 par( gerar() );
for( i = 0; i < 10; i++ )
22 par( gerar() );
par( gerar() );
23 par( gerar() );
return 0;
24 par( gerar() );
}
25 par( gerar() );
26 par( gerar() );
27 return 0;
28 }
O Programa 7.13 mostrada uma saída formatada.
Programa 7.13 Programa para imprimir a tabuada do 5 formatada
A impressão da tabuada do 5 formata tem três partes, o cabeçalho – que é fixa, as 10

linhas da tabuada – com largura fixa mas conteúdo variável, e o rodapé – que é fixo.
Cada linha da tabuada tem o formato 99 x 5 = 99, os 99 indicam números com até dois
algarismos. O primeiro 99 deve ser substituído por 1, 2, 3, …, 10 e o segundo por 5, 10, 15,
…, 50. Quando o número for menor do que 10 deve-se usar espaço em branco para manter
a largura 2.
Usando uma variável inteira, o formato %2d e a estrutura de iteração for, pode-se
preencher cada linha com os valores adequados e com largura fixa.
A largura do cabeçalho e do rodapé são ajustados por último.
Programa-fonte
Programa 7.13 Programa para imprimir a tabuada do 5 formatada
#include <stdio.h>
int main( void ){
int i;
printf( "\n ------------" );
printf( "\n Tabuada do 5" );
printf( "\n ------------" );
for( i = 1; i < 11; i++ )
printf( "\n %2d x 5 = %2d", i, i*5 );
printf( "\n ------------" );
return 0;
}
No Programa 7.14 foram usadas estruturas de iteração e de decisão.
Programa 7.14 Programa para imprimir os números inteiros pares de 0 a 100
Para imprimir apenas os números inteiros pares no intervalo de 0 a 100, é necessário usar
um filtro.
Para isso, percorre-se o intervalo usando uma estrutura de iteração, no caso a instrução for
é a mais indicada.
Como no intervalo há números pares e ímpares, é necessário decidir quando imprimir e
quando não imprimir dado número, ou seja, filtrar os números.
O filtro dos números pode ser feito com a estrutura de decisão if com a condição i % 2 ==
0, em que i é o número a ser filtrado.
Programa-fonte
#include <stdio.h>
#define MAX 100
int main( void ){
int i;
for( i = 0; i <= MAX; i++ )
if( i % 2 == 0 ) printf( "\n %d é par", i );
return 0;
}
7.3.3. Aplicações
As aplicações mais simples as estruturas de decisão e iteração são os cálculos de mé-

dias, de mínimos, de máximos e percentagens. Estes algoritmos básicos estão discutidos no
Anexo. O livro “Numerical Recipes in C” (Press, 1992) é uma coletânea vasta das mais diver -
suas aplicações de algoritmos na engenharia.
Os Programa 7.15, Programa 7.16, Programa 7.17, Programa 7.18, Programa 7.19 e Pro-
grama 7.20, a seguir, são aplicações que servem de modelos para a solução de a muitos pro-
blemas básicos.
O Programa 7.15 é uma aplicação das estruturas de decisão e iteração para o cálculo de
média, mínimo, máximo e percentagem.
Programa 7.15 Calcule a média, o mínimo, o máximo e percentagem de múltiplos de 3 de

números inteiros positivos lidos do teclado. Encerre com a leitura de um número negativo
A estrutura de iteração while é usada pois o número de leituras a serem feitos é

indeterminado, sua condição é n >= 0, onde n é o número inteiro lido do teclado.
Como n faz parte da condição do while, ele precisa ser lido antes dele, o que é feito nas
linhas 11 a 14.
O cálculo da média, do mínimo, do máximo e da percentagem são algoritmos básicos, mas

apenas os valores de n múltiplos de 3 devem ser considerados.
Os valores de n devem ser filtrados, para isso é usado a estrutura de decisão if com a
condição n % 3 == 0, filtro para n múltiplos de 3, linhas 18 a 23.
Como n faz parte da condição do while, ele precisa ser lido ao seu final, o que é feito nas
linhas 24 e 25.
A linha 28 evita divisão por zero, conta == 0, encerrando o programa com o return 1.
A linha 31 é uma divisão entre inteiros e, para garantir resultado fracionário, contamul é
convertido para float com a instrução (float) contamul.
Ao final, os valores são calculados e impressos na tela.
Dicionário de Dados
Tipo de
Variável Descrição Valor Inicial Processo
Dado
n número inteiro int input E
conta contador int 0 P
minimo valor mínimo int 1E7 P,S
maximo valor máximo int -1E7 P,S
contamul conta múltiplo de 3 int 0 P
soma soma/conta float 0.000000 P
media soma/conta float calculada S
percentagem contamul/conta float calculada S
Plano de testes
n conta minimo maximo contamul soma
0 1E7 -1E7 0 0.000000


12 1 12 12 1 12.000000
9 2 9 2 21.000000
3 3 3 3 24.000000
15 4 15 4 39.000000
17 5 39.000000
0 6 0 5 39.000000
-1
Estatísticas dos múltiplos de 3

mínimo 0
média 39/6 = 6,5
máximo 15
percentagem 100*5/6 = 83,33
L Programa-fonte
2 int main( void ){
3 int n, conta, minimo, maximo, contamul;
4 float soma, media, percentagem;
5
6 conta = contamul = 0;
7 minimo = 1E7;
8 maximo =-1E7;
9 soma = 0.0;
10
11 printf( "\n » número negativo encerra « " );
12 printf( "\n --------------------------- " );
13 printf( "\n digite um número inteiro: " );
14 scanf ( "%d", &n );
15
16 while( n >= 0 ){
17 conta++;
18 if( n % 3 == 0 ){
19 contamul++;
20 soma += n;
21 if( minimo > n ) minimo = n;
22 if( maximo < n ) maximo = n;
23 }
24 printf( " digite um número inteiro: " );
25 scanf ( "%d", &n );
26 }
27
28 if( conta == 0 ){ printf( "contagem inválida" ); return 1; }
29
30 media = soma / conta;
31 percentagem = (float)contamul / conta;
32

33 printf( "\n Estatísticas dos múltiplos de 3" );

34 printf( "\n mínimo: %d" , minimo );
35 printf( "\n média: %.2f" , media );
36 printf( "\n máximo: %d" , maximo );
37 printf( "\n percentagem: %.2f%%", 100*percentagem );
38
39 return 0;
40 }
O Programa 7.16 também é uma aplicação das estruturas de decisão e iteração para o
cálculo de média, mínimo, máximo e percentagem.

seis números inteiros positivos lidos do teclado.
A solução é similar ao do Programa 7.15 exceto que deve utilizar a estrutura de iteração for
com 6 repetições.
Programa-fonte
#include <stdio.h>
int main( void ){

int n, conta, minimo, maximo, contamul;

float soma, media, percentagem;
conta = contamul = 0;
minimo = 1E7;
maximo =-1E7;
soma = 0.0;
for( conta = 0; conta < 6; conta++ ){

printf( " %d.digite o número inteiro: ", conta+1 );
scanf ( "%d", &n );
if( n % 3 == 0 ){
contamul++;
soma += n;
if( minimo > n ) minimo = n;
if( maximo < n ) maximo = n;
}
}
media = soma / conta;

percentagem = (float)contamul / conta;
printf( "\n Estatísticas dos múltiplos de 3" );

printf( "\n mínimo: %d" , minimo );
printf( "\n média: %.2f" , media );
printf( "\n máximo: %d" , maximo );
printf( "\n percentagem: %.2f%%", 100*percentagem );
return 0;
}

O Programa 7.17 é uma aplicação um pouco mais elaborada das estruturas de decisão e
iteração envolvendo contagem, somas, média e máximo.
Programa 7.17 Para analisar o consumo mensal de energia elétrica em uma cidade, foram
levantados os valores do consumo (kWh) e tipo consumo (residencial, comercial, industrial)
dos últimos 12 meses. Faça um programa que, após obter esses dados, informe:
a) o número de consumidores de cada tipo
b) o total de consumo para cada tipo de consumidor no último mês
c) o maior consumo dos consumidores comerciais e o dos industriais, e o mês em que
ocorreu
d) a média geral de consumo comercial e industrial no ano
???
As linhas 4, 5 e 6 do programa foram separadas em três para que o fluxo de controle fosse
numerado de forma adequada. A primeira instrução do for é executada uma única vez a
cada execução desta estrutura de iteração. A segunda e a terceira instrução do for não são
executados na ordem em que se encontram nesta estrutura de iteração.
Após encerrar o for, o programa retorna 0 e também encerrado.

O for foi executado 6 vezes e imprime os números inteiros de 0 a 4 na saída padrão.
Mes Mês do ano int input E
Consumo Consumo de energia em kWh double input E

ocorreu
Tipo de Consumo, 1 – residencial, 2 –

Tipo input E
comercial, 3 – industrial
MesInicial Mês inicial int input E
MesFinal Mês final int input E
NC1 Número de consumidores do Tipo 1 int 0 P, S
Tcmf1 Total de consumo no mês final do Tipo 1 double 0.0 P, S
MC2 Maior consumo do Tipo Comercial double -1E10 P, S
MC3 Maior consumo do Tipo Industrial double -1E10 P, S
MOC2 Mês de ocorrência do MC2 int 0 P, S
MOC3 Mês de ocorrência do MC3 int 0 P, S
SGC2 Soma Geral do consumo do Tipo Comercial double 0.0 P
SGC3 Soma Geral do consumo do Tipo Industrial double 0.0 P
Média Geral do consumo do Tipo Comercial

MGC2 double 0.0 S
(SGC2/NC2)
Média Geral do consumo do Tipo Comercial

MGC3 double 0.0 S
(SGC3/NC3)
Plano de testes
Sejam MesInicial = 1 e MesFinal = 12; o algoritmo encerra com Consumo negativo.
Mes Consumo Tipo NC1 NC2 NC3 Tcumf1 Tcumf2 Tcumf3 MC2 MC3 MOC2 MOC3 SGC2 SGC3
1 300 1 1
1 2000 2 1 2000 1 2000
1 8000 3 1 8000 1 8000
1 400 1 2
1 2500 2 2 2500 1 4500

ocorreu
1 9000 3 2 9000 1 17000
2 230 1 3
2 3500 2 3 3500 2 8000
2 12000 3 3 12000 2 29000
2 450 1 4
2 2100 2 4 2100 2 10100
2 9500 3 4 38500
12 250 1 5 250
12 2700 2 5 2700 2700 12 12800
12 15000 3 5 15000 15000 12 43500
12 350 1 6 600
12 3500 2 6 6200 3500 12 16300
12 14500 3 6 29500 58000
Ao final, calcula-se MGC2 e MGC3.

O algoritmo abaixo está bem dividido e tem objetivo educacional. Ele pode ser feito de
forma mais compacta, agrupando os if(Tipo == 2) e if(Tipo == 3).
L Programa-fonte
2 int main( void ){
3 // variáveis de entrada
4 int Mes, Tipo, MesInicial, MesFinal;
5 double Consumo;
6
7 // variáveis de processamento
8 int NC1, NC2, NC3, MOC2, MOC3;
9 double Tcmf1, Tcmf2, Tcmf3, MC2, MC3, SGC2, SGC3;
10
11 // variáveis de saída (exclusivas)
12 double MGC2, MGC3;
13
14 NC1 = NC2 = NC3 = MOC2 = MOC3 = 0;
15 Tcmf1 = Tcmf2 = Tcmf3 = SGC2 = SGC3 = 0.0;
16 MC2 = MC3 = -1E10;
ocorreu
17
18 printf( " De o valor do MesInicial: " ); scanf( "%d" , &MesInicial );
19 printf( " De o valor do MesFinal: " ); scanf( "%d" , &MesFinal );
20
21 printf( " De o valor do Mes: " ); scanf( "%d" , &Mes );
22 printf( " De o valor do Consumo: " ); scanf( "%lf", &Consumo );
23 printf( "De o valor do Tipo (1,2,3): " ); scanf( "%d" , &Tipo );
24
25 while( Consumo >= 0.0 ){
26 if( Tipo == 1 ) NC1++; // resolução do item (a)
27 if( Tipo == 2 ) NC2++;
28 if( Tipo == 3 ) NC3++;
29
30 if( Mes == MesFinal ){ // resolução do item (b)
31 if( Tipo == 1 ) Tcmf1 += Consumo;
34 }
35
36 if( Tipo == 2 ){ // resolução do item (c)
37 if( MC2 < Consumo ){
38 MC2 = Consumo;
39 MOC2 = Mes;
40 }
41 }
42 if( Tipo == 3 ){ // resolução do item (c)
43 if( MC3 < Consumo ){
44 MC3 = Consumo;
45 MOC3 = Mes;
46 }
47 }
48 if( Tipo == 2 ) SGC2 += Consumo; // resolução do item (d)
49 if( Tipo == 3 ) SGC3 += Consumo;
50
51 printf( " De o valor do Mes: " ); scanf( "%d" , &Mes );
52 printf( " De o valor do Consumo: " ); scanf( "%lf", &Consumo );
53 printf( "De o valor do Tipo (1,2,3): " ); scanf( "%d" , &Tipo );
54 }
55
56 MGC2 = SGC2/NC2;
57 MGC3 = SGC3/NC3;
58
59 printf( "\n número de consumidores do tipo 1 = %d" , NC1 );
62
63 printf( "\n consumo do tipo 1 no ultimo mes = %.1lf", Tcmf1 );
66
67 printf( "\n maior consumo do tipo 2 = %.1lf", MC2 );
68 printf( "\n mes do maior consumo do tipo 2 = %d" , MOC2 );
69
70 printf( "\n maior consumo do tipo 3 = %.1lf", MC3 );
ocorreu
71 printf( "\n mes do maior consumo do tipo 3 = %d" , MOC3 );

72
73 printf( "\n media de consumo do tipo 2 = %.1lf", MGC2 );
74 printf( "\n media de consumo do tipo 3 = %.1lf", MGC3 );
75 return 0;
76 }
???
O Programa 7.18 é uma aplicação da estrutura de iteração para o cálculo do fatorial de

um número.
Programa 7.18 Função para calcular o fatorial de um número inteiro positivo
O fatorial de um número inteiro positivo é mostrado abaixo:
n n!
0 0! = 1
1 1! = 1
2 2! = 1 × 2
3 3! = 1 × 2 × 3
4 4! = 1 × 2 × 3 × 4
⋅⋅⋅ ⋅⋅⋅
n n! = 1 × 2 × 3 × 4 × ⋅⋅⋅ × n
O fatorial de n é o produto de n ✕ n-1 ✕ n-2 ✕ ··· ✕ 4 ✕ 3 ✕ 2 ✕ 1.
O algoritmo para calcular o fatorial de n é similar ao do algoritmo básico da soma de 1 a n,

neste caso troca-se a operação soma pela multiplicação, com o valor inicial do produto
igual a 1, como pode ser visto a seguir.
Solução para o produto de 1 a n:

• declarar um inteiro i, contador da instrução for
• declarar um inteiro n, limite superior do produto
• declarar p do tipo int, com valor inicial 1 (elemento neutro da multiplicação)
• usar a instrução for com i variando de 2 a n, ambos incluídos
• dentro do for, calcular p = p * i
Após encerrar o for, imprime-se p e n-1.
Programa 7.18 Função para calcular o fatorial de um número inteiro positivo
Plano de Testes
0! = 1
1! = 1
2! = 2
5! = 120
10! = 3628800
Programa-fonte
#include <stdio.h>
int fatorial( int n ){
int i, p = 1;
for( i = 2; i <= n; i++ )
p *= i;
return p;
}
int main( void ){
int n1 = 0,
n2 = 1,
n3 = 2,
n4 = 5,
n5 = 10;
printf("\n fatorial");
printf("\n ------------------------" );
printf("\n fatorial(%2d) = %9d", n1, fatorial(n1) );
printf("\n ------------------------" );
return 0;
}
O Programa 7.19 é uma aplicação da estrutura de iteração para o cálculo de somas em

série.
n
xi
Programa 7.19 Calcular o valor da série S=∑ para x = 5.0
i=0 i !
n
xi
i=0 i !
n
x i x1 x2 x3 x4 xn
Expandindo a série em parcelas: S=∑ = + + + +⋯+ .
i=0 i ! 1 ! 2 ! 3! 4 ! n!
Somar é um algoritmo básico, para sua solução:
• declarar um inteiro i, contador da instrução for
• declarar um inteiro n, limite superior da potência das parcelas da série
• declarar x do tipo double, com valor inicial 5.0
• declarar a soma S do tipo double, com valor inicial 0.0
• ler o valor de n, n >= 0;
• usar instrução for com i variando de 0 a n, ambos incluídos
• dentro do for, calcular cada parcela pow(x,i)/fat(i), em que fat(i) é uma função que
retorna o valor numérico do fatorial de i
Após encerrar o for, imprime-se S e n-1.
Plano de testes
Par n = 10 e x = 5,0, tem-se que:

1 2 3 4 5 6 7 8 9 10
5,0 5,0 5,0 5,0 5,0 5,0 5,0 5,0 5,0 5,0
S= + + + + + + + + +
1! 2! 3! 4! 5! 6! 7! 8! 9 ! 10 !
i pow(x,i) fat(i) xi/fat(i) S
0,000000000000
0 pow(5.0,0) = 1 1 1,000000000000 1,000000000000
1 pow(5.0,1) = 5 1 5,000000000000 6,000000000000
2 pow(5.0,2) = 25 2 12,500000000000 18,500000000000
3 pow(5.0,3) = 125 6 20,833333333333 39,333333333333
4 pow(5.0,4) = 625 24 26,041666666667 65,375000000000
5 pow(5.0,5) = 3125 120 26,041666666667 91,416666666667
6 pow(5.0,6) = 15625 720 21,701388888889 113,118055555556
7 pow(5.0,7) = 78125 5040 15,500992063492 128,619047619048
8 pow(5.0,8) = 390625 40320 9,688120039683 138,307167658730
9 pow(5.0,9) = 1953125 362880 5,382288910935 143,689456569665
10 pow(5.0,10) = 9765625 3628800 2,691144455467 146,380601025132
Programa-fonte
#include <stdio.h>
#include <math.h>
int fat( int n ){
int i, p = 1;
for( i = 2; i <= n; i++ )
p = p*i;
return p;
}
int main( void ){
n
xi
i=0 i !
int i, n;
double S = 0.0, x = 5.0;
printf( " digite o número inteiro positivo: " );

scanf ( "%d", &n );
for( i = 0; i <= n; i++ )

S += pow(x,i)/fat(i);
printf( "\n S = %lf", S );

printf( "\n n = %d ", n-1);
return 0;
}
O Programa 7.20 utiliza o for para imprimir um padrão.
Programa 7.20 Desenhe o padrão abaixo usando for

#####################
########## ##########
######### #########
######## ########
####### #######
###### ######
##### #####
#### ####
### ###
## ##
# #
Número de linhas => NL = 10

Número de colunas => NC = 2*NL
variável para linha => l (l vai varia de 0 (l = 0) a 9 (0 ≤ l < NL)

variável para coluna => c (c vai varia de 0 (c = 0) a 19 (0 ≤ c < NC)
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
0####################
1######### #########
2######## ########
3####### #######
4###### ######
5##### #####
6#### ####
7### ###
8## ##
9# #
O padrão é simétrico em relação às colunas, na posição NC/2, com o padrão:

• da esquerda, com NC/2-l, que diminui a medida que l cresce

• da direita, com l+NC/2, que aumentando a medida que l cresce
O filtro para imprimir o padrão (c < NC/2-l) || (c > l+NC/2-1).
Programa-fonte
#include <stdio.h>
#define NL 10
#define NC 2*NL
int main( void ){
int l, c;
for( l = 0; l < NL; l++ ){
for( c = 0; c < NC; c++ ){
if( (c < NC/2-l) || (c > l+NC/2-1) ) printf("#");
else printf(" ");
}
printf("\n");
}
return 0;
}
7.3.4.2. Questões Avançadas
1. Faça um programa que leia um conjunto não determinado de valores e mostre o valor
lido, seu quadrado, seu cubo e sua raiz quadrada. Finalize a entrada de dados com um
valor negativo ou zero.
2. Faça um programa que receba o salário de um funcionário chamado Carlos. Sabe–se
que outro funcionário, João, tem salário equivalente a um terço do salário de Carlos. Carlos
aplicará seu salário integralmente em um fundo que rende 2% ao mês, e João aplicará seu
salário integralmente em um outro fundo que rende 3% ao mês. O programa deverá
calcular e mostrar a quantidade de meses necessários para que o montante de João iguale
ou ultrapasse o montante de Carlos.

3. Antônio tem 1,50 m e cresce 2 cm por ano, enquanto José tem 1,10 m e cresce 3 cm
por ano. Faça um programa para calcular e imprimir quantos anos é necessário para que
José seja maior que Antônio.
4. Dois automóveis estão distantes 80 km um do outro em uma grande reta. Se um vai
em direção ao outro com velocidades de 50 e 60 km/h, faça um programa para calcular
onde e quanto tempo demoram para se encontrarem.
5. Uma caixa d’água, de 1000 L está vazia, e começa a recebe água com vazão de 5
L/minuto. Faça um programa que calcule o tempo necessário para enchê–la sabendo que é
feita uma descarga de 50 L a cada 30 minutos, uma lavagem de 100 L a cada 2 horas e
que tem um furo que perde água com vazão de 0,01 L/s. O que mudaria se consertasse o
furo?
6. Um relógio de pêndulo tem período T ( T =2 π

l
g √), sabendo que g = 9,80665 m/s², l =
17,23443 cm e que o pêndulo diminui o seu período de 0,01% a cada ano devido ao atrito,
g diminui 0,00005% por mês devido à deriva continental do lugar do pêndulo, faça um
programa para relatar perdas de período do pêndulo de 1,00000 s.
7. Faça um programa que leia um número não determinado de pares de valores [m,n],
todos inteiros e positivos, um par de cada vez, e que mostre todos os números inteiros
entre m e n (inclusive). A digitação de pares terminará quando m for maior ou igual a n.
8. Faça um programa que receba uma senha numérica e verifique se a senha está correta
e, caso não esteja, solicite novamente a senha. O programa deve informar "Senha
Correta", "Senha Incorreta" e, após, 10 tentativas, "Acesso Bloqueado".
9. A sequência de Fibonacci é dada por F = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,
233, 377, 610, 987, 1597, 2584, 4181, 6765, … }, cuja função geradora é F(n). Escreva um
programa C para imprimir o menor valor de n tal que F(n) > 1234567.
10.Elabore um programa que calcule um número inteiro que mais se aproxima da raiz
quadrada de um número fornecido pelo usuário.
11.Construa um algoritmo que verifique se um número fornecido pelo usuário é primo ou
não.
12.Faça um programa, e também o seu fluxograma, para imprimir os números inteiros
ímpares de 0 a n na tela do computador. O valor n deve ser lido do teclado.
13.Elabore soluções para os problemas abaixo e escreva um programa C para:
a)Como escrever os pares de 1 a 100?
b)Como escrever os ímpares de 1 a 100?
c)Como escrever os múltiplos de 3 de 1 a 100?
d)Como escrever os múltiplos de 3 e de 4 de 1 a 100?
e)Como identificar duplas de números inteiros, no intervalo de 1 a 100, cuja diferença
seja -7 ou 7.
f) Como identificar trincas de números inteiros, no intervalo de 1 a 1000, cuja soma
seja múltiplo de 20.
g) Como imprimir a sequência: 2, 1, 4, 3, 6, 5, …, 99, 98.
14.O número 3025 possui a seguinte característica: 30 + 25 = 55 e 55 2 = 3025. Escreva
um programa que escreva todos os números com quatro algarismos que possuem a citada
característica.
15.Escreva um programa que escreva todos os pares de números de dois algarismos que
apresentam a seguinte propriedade: o produto dos números não se altera se os dígitos são
invertidos. Por exemplo, 93 x 13 = 39 x 31 = 1209.
16.Escreva um programa que leia 10 valores de x. Para cada valor lido, calcule o valor de
y dado pela fórmula y = 2.5*cos |x/2|. Imprima os pares de valores x e y.
17.Escrever um programa para ler vários pares de números inteiros positivos e, para cada
par, calcular e imprimir o MMC (mínimo múltiplo comum) entre eles.

18.Fazer um programa que escreva no vídeo uma tabela para as funções: sin (x*p/180),
cos(x*p/180), tan(x*p/180) e log10(x), no intervalo [m,n] onde os limites m e n do intervalo
de x são inteiros e lidos do teclado.
19.Seja a equação Ax + By + Cz + D = 0, onde A, B, C e D são números inteiros. Fazer um
programa para encontrar todas as soluções inteiras [x,y,z] dessa equação, que obedecem
às restrições 0 ≤ x ≤ n, 0 ≤ n e 0 ≤ z ≤ n, onde n é inteiro e n > 0.
20.Escreva um programa que leia um número inteiro positivo N e em seguida imprima N
linhas do chamado triângulo de Floyd:
1
2 3
4 5 6
7 8 9 10
11 12 13 14 15
16 17 18 19 20 21
21.Escreva um programa que leia um número inteiro positivo N e em seguida imprima N
linhas do chamado triângulo de Floyd invertido:
1
3 2
6 5 4
10 9 8 7
15 14 13 12 11
21 20 19 18 17 16
22.Faça um algoritmo que leia um número positivo e imprima seus divisores. Exemplo: os
divisores do número 66 são: 1, 2, 3, 6, 11, 22, 33 e 66.
23.Uma livraria está fazendo uma promoção para pagamento à vista em que o comprador
pode escolher entre dois critérios de desconto. Critério A: M$ 0,25 por livro + M$ 7,50 fixo
e Critério B: M$ 0,50 por livro + M$ 2,50 fixo. Faça um programa em que o usuário digite a
quantidade de livros que deseja comprar e o programa diga qual é a melhor opção de
desconto.
24.Faça um programa para ler imprima N = 22 vezes a frase "Alo mundo!" usando
estrutura de sequência e a estrutura de iteração for. Como seria este programa se N =
222? Como seria este programa se N = 2222?
25.Faça um programa que receba um número, calcule e mostre a tabuada desse número.
26.Faça um programa que mostre a tabuada formatada dos números de 1 a 10.
27.Um funcionário de uma empresa recebe aumento salarial anualmente. Faça um
programa que determine o salário atual desse funcionário sabendo que: a) esse
funcionário foi contratado em 2010, com salário inicial de M$ 5.000,00; b) em 2011, ele
recebeu aumento de 1,5% sobre seu salário inicial; c) a partir de 2022 (inclusive), os
aumentos salariais sempre corresponderam ao dobro do percentual do ano anterior.
28.Faça um programa que leia um número de termos, determine e mostre os valores de
acordo com a série 2, 7, 3, 4, 21, 12, 8, 63, 48, 16, 189, 192, 32, 567, 768 …
29.Faça um programa que calcule o saldo de uma conta bancária tendo como entrada o
saldo inicial e dez lançamentos de operações de crédito e/ou débito. A saída são o total de
créditos, o total de débitos, os juros pagos ao banco (5% do total de débitos) e o saldo
final.
30.Escreva um programa que leia um número inteiro N, N > 5, em seguida imprima N
linhas com os seguintes padrões:
* * ************* ************* 1 2 3 4 5 6 7
** *** * * 2 3 4 5 6 7
*** ***** ************* ************* 3 4 5 6 7
**** ******* * * * 4 5 6 7
***** ********* ************* ************* 5 6 7

****** *********** * * * 5 6
******* ************* ************* ************* 6
(a) (b) (c) (d) (e)
7 # # # # # # # | # # # # # # # 7 | 7
7 6 # # # # # # | # # # # # # 7 6 | 6 7
7 6 5 # # # # # | # # # # # 7 6 5 | 5 6 7
7 6 5 4 # # # # | # # # # 7 6 5 4 | 4 5 6 7
7 6 5 4 3 # # # | # # # 7 6 5 4 3 | 3 4 5 6 7
7 6 5 4 3 2 # # | # # 7 6 5 4 3 2 | 2 3 4 5 6 7
7 6 5 4 3 2 1 # | # 7 6 5 4 3 2 1 | 1 2 3 4 5 6 7
(f) (g) (h)
31.Execute este programa e explique seu comportamento.

#include <stdio.h>
int main ( void ){
char c;
for( c = 0; c < 300; c++ ){
if( c % 16 == 0 ) printf("\n");
printf(" %+3c ", c );
}
return 0;
}
32.Execute este programa e explique seu comportamento.
#include <stdio.h>
int main ( void ){
int i;
for( i = 0; i < 120; i++ ){
if( i % 16 == 0 ) printf("\n");
printf(" %+3c ", i );
}
return 0;
}
7.3.4.4. Exercícios Intermediários
1. Faça um programa para ler imprima N = 22 vezes a frase "Alo mundo!" usando
estrutura de sequência e a estrutura de iteração for. Como seria este programa se N =
222? Como seria este programa se N = 22222222?
2. Faça um programa para ler um número inteiro positivo e informar se ele é triangular.
Um número natural n é triangular se é igual à soma dos k primeiros números naturais
consecutivos, a partir de 1. Por exemplo, 10 = 1 + 2 + 3 + 4 é triangular.
3. Faça um programa que receba duas notas de seis estudantes da Univasf. Calcule e
mostre:
a) a média de cada estudante
b) o percentual de estudantes aprovados
c) o percentual de estudantes de exame
d) o percentual de estudantes reprovados
e) a média da classe.
4. Foi feita uma pesquisa para determinar o índice de aprovação de estudantes da Univasf
em dado período. Faça um programa que:
a) leia o número de estudantes matriculados no período
b) leia a nota cada estudante matriculado e identifique seu sexo
O programa deve calcular e mostrar:
1. percentagem de estudantes aprovadas no período e do sexo feminino

2. percentagem de estudantes aprovados no período e do sexo masculino
3. percentagem de estudantes que tiveram nota menor do que 5
5. Faça um programa que receba um número, calcule e mostre a tabuada desse número.
6. Faça um programa que mostre as tabuadas dos números de 1 a 10. Com dois tipos de
saída:
a) impressas uma abaixo da outra
b) dispostas lado a lado.
7. Um funcionário de uma empresa recebe aumento salarial anualmente. Faça um
programa que determine o salário atual desse funcionário sabendo que:
a) esse funcionário foi contratado em 2010, com salário inicial de M$ 5.000,00.
b) em 2011, ele recebeu aumento de 1,5% sobre seu salário inicial.
c) a partir de 2012 (inclusive), os aumentos salariais sempre corresponderam ao
dobro do percentual do ano anterior.
8. Faça um programa que leia um número de termos, determine e mostre os valores de
acordo com a série 2, 7, 3, 4, 21, 12, 8, 63, 48, 16, 189, 192, 32, 567, 768 …
9. Em uma fábrica trabalham 15 operários, homens e mulheres divididos em três classes:
a) trabalhadores que fazem até 30 peças por mês — classe 1
b) trabalhadores que fazem de 31 a 50 peças por mês — classe 2
c) trabalhadores que fazem mais de 50 peças por mês — classe 3
A classe 1 recebe o salário–mínimo. A classe 2 recebe o salário–mínimo mais 2% deste
salário por peça, acima das 30 das peças iniciais. A classe 3 recebe o salário–mínimo
mais 3% desse salário por peça, acima das 30 peças iniciais. Faça um programa que
receba o código do operário, o número de peças fabricadas no mês, o sexo do operário, e
que também calcule e mostre:
a) o código do operário e seu salário;
b) o total da folha de pagamento da fábrica;
c) o número total de peças fabricadas no mês;
d) a média de peças fabricadas pelos homens;
e) a média de peças fabricadas pelas mulheres; e
f) o código do operário de maior salário, seu salário e se é homem ou mulher.
10.Faça um programa que calcule o saldo de uma conta bancária tendo como entrada o
saldo inicial e dez lançamentos de operações de crédito e/ou débito. A saída são o total de
créditos, o total de débitos, os juros pagos ao banco (5% do total de débitos) e o saldo
final.
11.Foi feita uma estatística de cinco turmas de Linguagem C, da Univasf, para verificar a
aprendizagem dos estudantes. Foram obtidos os seguintes dados:
a) código da turma
b) número de estudantes por turma
c) número de estudantes com nota maior do que 7.0
Deseja–se saber:
a) qual é a média das notas, das cinco turmas juntas
b) qual é a média das notas menores ou iguais a 7.0, das cinco turmas juntas
c) qual é a média das notas maiores do que 7.0, de cada turma
12.Entrar com um valor e dizer a qual mês do ano.

13.Leia um ponto (x,y), coordenadas de um plano, e informar em qual quadrante ele está
situado, se está em um dos eixos ou localizado na origem.
14.Leia os seus coeficientes de uma equação do segundo o grau e escreva um programa
para calcular suas as raízes. Faça também o seu fluxograma.
15.Faça um programa em C que leia um número inteiro do teclado e verifique se é:
a) positivo e menor do que 100

b) divisível por 3 ou por 5 ou por 7
c) múltiplo de 4 ou 6 ou 10
d) múltiplo de 4 e 6 e 10
e) múltiplo de 4 e 6 ou 10
f) ı́mpar
16.Faça um programa que receba quatro notas de um aluno, calcule e mostre a média
aritmética das notas e a mensagem de aprovado ou reprovado, considerando para
aprovação média 7.
17.Faça um programa que receba três notas, calcule e mostre a média aritmética e a
mensagem conforme descrição abaixo:
a) média de 0,0 a 4,9: reprovado
b) média de 5,0 a 6,9: exame
c) média de 7,0 a 10: aprovado
18.Faça um programa que receba dois números e mostre o menor.
19.Faça um programa que receba três números e mostre o maior.
20.Faça um programa que receba quatro números e mostre o maior.
21.Faça um programa que receba dois números e mostre–os em ordem crescente.
22.Faça um programa que receba três números e mostre–os em ordem crescente.
23.Faça um programa que receba quatro números e mostre–os em ordem crescente.
24.Faça um programa para calcular o Imposto de Renda de Pessoa Física (IRPF), consulte
na web as regras para este cálculo.
25.Faça um programa que receba dois números e execute as operações listadas a seguir,
de acordo com a escolha do usuário. Se a opção digitada for inválida, mostre uma
mensagem de erro e termine a execução do programa. Lembre–se de que não há divisão
por zero.
a) escolha a: média dos números
b) escolha b: diferença do maior pelo menor
c) escolha c: produto dos números
d) escolha d: divisão do primeiro pelo segundo.
26.Faça um programa que receba dois números e execute uma das operações listadas a
seguir, de acordo com a escolha do usuário. Se for digitada uma opção inválida, mostre
mensagem de erro e termine a execução do programa. As opções são:
a) o primeiro número elevado ao segundo número
b) raiz quadrada de cada um dos números
c) raiz cúbica de cada um dos números.
28.Faça um programa que receba a altura e o sexo de uma pessoa e calcule e mostre seu
peso ideal, utilizando as seguintes fórmulas: a) para homens: 72.7 h – 58, b) para
mulheres: 62.1 h – 44.7; onde h é a altura.
29.Faça um programa que receba a altura e o “peso” de uma pessoa e calcule e mostre
seu Índice de Massa Corporal IMC.
30.Escreva um programa que leia as medidas dos lados de um triângulo e escreva se ele é
equilátero, isósceles ou escaleno.
31.Faça um programa que leia um conjunto não determinado de valores e mostre o valor
lido, seu quadrado, seu cubo e sua raiz quadrada. Finalize a entrada de dados com um
valor negativo ou zero.
32.Somar os números naturais de 1 até que o total seja maior do que 100.
33.Faça um programa que receba o salário de um funcionário chamado Carlos. Sabe–se

que outro funcionário, João, tem salário equivalente a um terço do salário de Carlos. Carlos
aplicará seu salário integralmente em um fundo que rende 2% ao mês, e João aplicará seu
salário integralmente em um outro fundo que rende 3% ao mês. O programa deverá
calcular e mostrar a quantidade de meses necessários para que o montante de João iguale
ou ultrapasse o montante de Carlos.
34.Faça um programa que leia um número não determinado de pares de valores [m,n],
todos inteiros e positivos, um par de cada vez, e que calcule e mostre a soma de todos os
números inteiros entre m e n (inclusive). A digitação de pares terminará quando m for
maior ou igual a n.
35.Faça um programa para ler o código, o sexo e o número de horas/aula dadas
mensalmente pelos professores de uma universidade, sabendo–se que cada hora/aula vale
M$ 70,00. Emita uma listagem contendo o código, o salário bruto e o salário líquido
(desconto de 10% para homens e de 5% para mulheres) de cada professor. Mostre
também a média dos salários líquidos dos professores do sexo masculino e a média dos
salários líquidos dos professores do sexo feminino. As informações terminarão quando for
lido o código 99999.
36.Faça um programa que receba vários números inteiros, calcule e mostre:
a) a soma dos números digitados
b) a quantidade de números digitados
c) a média dos números digitados
d) o maior número digitado
e) o menor número digitado
f) a média dos números pares
g) a porcentagem dos números ímpares entre todos os números digitados
37.Faça um programa que receba uma senha numérica e verifique se a senha está correta
e, caso não esteja, solicite novamente a senha. O programa deve informar "Senha
Correta", "Senha Incorreta" e, após, 10 tentativas, "Acesso Bloqueado".
38.A sequência de Fibonacci é dada por F = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,
233, 377, 610, 987, 1597, 2584, 4181, 6765, … }, cuja função geradora é F(n). Escreva um
programa C para imprimir em stdout o valor de n tal que F(n) > 1234567.
39.Escreva um programa para calcular o maior valor da sequência de Fibonacci utilizando
variáveis do tipo: a) unsigned char, b) unsigned short int, c) unsigned int, d) unsigned long
int, f) float, g) double e h) long double.
40.Escreva um programa para calcular o maior valor do fatorial utilizando variáveis do
tipo: a) char, b) int, c) float e d) double.
41.Uma empresa decidiu fazer um levantamento em relação aos candidatos que se
apresentarem para preenchimento de vagas em seu quadro de funcionários. Faça um
programa que leia, para cada candidato, a idade, o sexo e a experiência no serviço (com e
sem experiência). Para encerrar a entrada de dados, digite zero para a idade. O programa
deve calcular e mostrar:
a) o número de candidatos do sexo feminino
b) o número de candidatos do sexo masculino
c) a idade média dos homens que já têm experiência no serviço
d) a porcentagem dos homens com mais de 45 anos entre o total dos homens
e) o número de mulheres com idade inferior a 21 anos e com experiência no serviço
f) a menor idade entre as mulheres que já têm experiência no serviço.
42.Antônio tem 1,50 m e cresce 2 cm por ano, enquanto José tem 1,10 m e cresce 3 cm
por ano. Faça um programa para calcular e imprimir quantos anos é necessário para que
José seja maior que Antônio.
43.Dois automóveis estão distantes 80 km um do outro em uma grande reta. Se um vai
em direção ao outro com velocidades de 50 e 60 km/h, faça um programa para calcular
onde e quanto tempo demoram para se encontrarem.
44.Uma caixa d’água, de 1000 L está vazia, e começa a recebe água com vazão de 5
L/minuto. Faça um programa que calcule o tempo necessário para enchê–la sabendo que é
feita uma descarga de 50 L a cada 30 minutos, uma lavagem de 100 L a cada 2 horas e
que tem um furo que perde água com vazão de 0,01 L/s. O que mudaria se consertasse o
furo?
45.Faça um programa que leia números inteiros não-nulos do teclado e calcule a soma e
subtração alternadamente destes números. Exemplo: a sequência {5, 7, 1, 4, 9} será
calculada como 5 - 7 + 1 - 4 + 9.
46.Somar os números naturais de 1 até que o total seja menor do que 100.
47.Faça um programa que leia números positivos de stdin e mostre, no final, a soma dos
números lidos.
48.Escreva um programa financeiro com quatro opções: a) consultar saldo, (b) sacar
numerário, c) depositar numerário e d) encerrar. O saldo deve iniciar em M$ 0,00. A cada
saque ou depósito o valor do saldo deve ser informado. Elabore um programa que calcule
70 69 68 67
e informe o valor de 50 parcelas da série S= + + + +⋯ .
7 14 21 28
49.Elabore um programa que calcule e informe o valor de 50 parcelas da série
33 31 29 27
S= 2 + 2 + 2 + 2 +⋯ .
1 2 3 4
50.Faça um programa que calcule e escreva a soma dos n primeiros termos da série
100 99 98 97
S= + + + +⋯ , sendo n fornecido pelo usuário.
(1×2) (2×3) (3×4) (4×5)
51.Um número perfeito é aquele cuja soma de seus divisores, exceto ele próprio, é igual a
esse número. Escreva um programa que leia n valores inteiros positivos e informe quais
dos valores lidos são números perfeitos. Ex.: 6 = 1 + 2 + 3.
52.O número 3025 possui a seguinte característica: 30 + 25 = 55 e 552 = 3025. Escreva
um programa que escreva todos os números com quatro algarismos que possuem a citada
característica. Dica: veja a função modf da biblioteca math.h.
53.Escreva um programa que escreva todos os pares de números de dois algarismos que
apresentam a seguinte propriedade: o produto dos números não se altera se os dígitos são
invertidos. Por exemplo, 93x13 = 39x31 = 1209.
54.Um número primo é um inteiro positivo que é divisível só por si mesmo e por 1. Escreva
um programa que calcule e imprima os primeiros n números primos.
55.Escreva um programa que leia vários valores de x. Para cada valor lido, calcule o valor
de y dado pela fórmula y = 2,5 * cos |x/2|. Informe todos os pares de valores x e y.
56.Uma fábrica tem 10 representantes. Cada um recebe uma comissão calculada a partir
do número de itens de um pedido, segundo os seguintes critérios:
a) para menos de 20 itens vendidos, a comissão é de 10% do valor total do pedido;
b) para pedidos de 20 a 49 itens, a comissão é de 15% do valor total do pedido;
c) para pedidos de 50 a 74 itens, a comissão é de 20% do valor total do pedido; e
d) para pedidos iguais ou superiores a 75 itens, a comissão é de 25%.
Faça um programa que processe alguns pedidos. Para cada pedido o programa deve
ler o código do representante (1 a 10), o total de itens do pedido e o valor total da venda.
O programa deve informar:
a) o valor da comissão de cada pedido;
b) o total de vendas dos pedidos processados;
c) o total de comissões para cada representante;
d) o total de comissões que a companhia pagou aos seus representantes.
57.Uma sorveteria vende cinco produtos diferentes, com preços de acordo com a tabela a
seguir:
Código Produto Preço (M$)

A Refrigerante 3,50
B Casquinha simples 4,00
C Casquinha dupla 5,00
D Sundae 6,00
E Banana split 8,50
Faça um programa que processe diversas vendas. O programa deverá apresentar um
menu indicando os preços dos produtos. Cada venda efetuada pode ser composta por
diversas unidades de diversos produtos. Os produtos são identificados através de seus
códigos. A cada venda efetuada informe o preço a pagar. No final do dia, o programa
deverá emitir um relatório com as seguintes informações:
a) número total de itens vendidos de cada produto;
b) total pago para cada produto;
c) total arrecadado (somando todos os produtos);
d) média de valor pago por pedido.
58.Uma confecção fabrica os produtos da tabela a seguir, identificados pelo seu código e
com o preço correspondente:
Código Produto Preço (M$)

1 Camiseta branca 17,50
2 Camiseta colorida 24,90
3 Moleton 25,90
4 Calça 59,90
5 Abrigo 38,50
6 Boné 12,00
Faça um programa que processe diversos pedidos feitos a essa confecção. Em cada
pedido, deve ser solicitado somente um produto, identificado por seu código, e
especificada a quantidade de unidades desejada. Informe o valor a pagar ao final de cada
pedido. Repita o processamento de pedidos até que seja fornecido um código de produto
= 9 (marca de parada). Ao final do processamento, emita um relatório de vendas com as
seguintes informações:
a) número de unidades vendidas de cada produto
b) total de unidades vendidas no período
c) total vendido em M$
d) número de pedidos processados.
59.Modifique o exercício anterior considerando que, em cada pedido feito à confecção,
possam ser especificados tantos produtos e quantidades quantos o cliente queira (ex: um
pedido = 2 camisetas coloridas, 3 moletons, 1 camiseta colorida, 1 camiseta branca).
Continue calculando e informando o valor de cada pedido, e acrescente ao relatório de
totais, emitido ao final do processamento, o valor médio dos pedidos (em M$). Observe
que neste exercício deverão ser definidas duas marcas de fim: uma para sinalizar que um
pedido acabou e outra para sinalizar que todo o processamento está encerrado.
60.Em pesquisa feita no Restaurante Universitário, perguntou-se a cada aluno quantas
refeições ele fez no mês anterior. Faça um programa que forneça:
a) o número de alunos entrevistados;
b) o número de alunos que fez menos de 10 refeições no mês;
c) o número de alunos que fez entre 10 e 20 refeições;
d) o número de alunos que fez mais de 20 refeições.
Foram entrevistados 500 alunos de uma universidade. De cada um deles foram
colhidas as seguintes informações: o código do curso que frequenta (1-engenharia; 2-
computação; 3-administração) e sua idade. Faça um programa que processe esses dados
e que forneça as seguintes informações:
a) número de alunos por curso;

b) número de alunos com idade entre 20 e 25 anos, por curso;
c) qual o curso com a menor média de idade.
61.Faça um programa que calcule o resultado final das eleições para a presidência de um
clube, sabendo-se que:
a) três chapas estão concorrendo;
b) os eleitores votaram fornecendo o número da chapa escolhida: 1 – chapa 1; 2 –
chapa 2; 3 – chapa 3; 0 – voto em branco; e qualquer número diferente de 0, 1, 2 e
3 – voto inválido;
c) votaram ao todo 200 membros do clube.
O programa deverá processar os votos recebidos e fornecer o total de votos de cada
uma das chapas, o total de votos em branco e o total de votos nulos (número de chapa
inválido). Além disso, o programa deverá apresentar uma mensagem informando se a
chapa mais votada é vencedora no primeiro turno da eleição (mais de 50% dos votos
válidos, ou seja, dos votos em chapas mais os brancos) ou se deverá ocorrer um segundo
turno.
62.Foi realizada uma pesquisa em Porto Alegre, com um número desconhecido de
pessoas. De cada entrevistado foram colhidos os seguintes dados:
a) qual seu clube de futebol de preferência (1-Grêmio; 2-Internacional; 3-Outros);
b) qual seu salário;
c) qual a sua cidade natal (0-Porto Alegre; 1-Outras).
Escreva um programa que informe:

a) número de torcedores por clube;
b) média salarial dos torcedores do Grêmio e do Internacional;
c) número de pessoas nascidas em Porto Alegre que não torcem por qualquer dos dois
primeiros clubes;
d) número de pessoas entrevistadas.
63.Uma pesquisa coletou os seguintes dados relativos a algumas características físicas

dos habitantes de uma determinada região:
a) sexo (masculino, feminino);
b) cor dos olhos (azuis, verdes, castanhos);
c) cor dos cabelos (louros, castanhos, pretos);
d) peso e altura;
e) idade em anos;
f) escolaridade (nenhuma, básica, superior).
Faça um programa que leia os dados obtidos nessa pesquisa e informe:
a) o número de habitantes entrevistados e sua média de idade;
b) quantos habitantes do sexo feminino têm idade entre 18 e 35 anos;
c) a percentagem de habitantes de olhos azuis e cabelos louros;
d) a média de altura e de peso dos habitantes entrevistados;
e) o número de homens e o de mulheres que têm peso acima da média;
f) o percentual de homens e de mulheres em cada faixa de escolaridade.
64.Foi feita uma pesquisa de audiência de canais de TV aberta em várias casas de uma
cidade num determinado dia. Para cada casa visitada, foi anotado o número do canal (10,
12, etc.) e o número de pessoas que o estavam assistindo na casa. Quando a televisão
estava desligada, nada era anotado, ou seja, esta casa não entrava na pesquisa. Faça um
programa que:
a) leia um número indeterminado de dados, sendo o valor final o canal igual a zero;
b) calcule a percentagem de audiência para cada emissora.
c) O programa deve informar o número de cada canal e sua respectiva percentagem.
65.Calcule a soma das séries:
12
xi
a) S=∑ , para x = 0.1
i =1 i
50
x 2 i+1
b) S=∑ (−1)i , para x = 0.75
i=0 2i+1
20 2i
i x
c) S=∑ (−1) , para x = 0.75
i =1 2i
10
ix i
d) S=∑ i , para x = 0.5
i=0 3
22
x i +1
e) S=∑ 2
, para x = 1.5
i=0 (i+1)
64
f) S=∑ i x i , para x = 1.5
i=0

2. ……………..
3. ……………….
4. ……………….
5. ……………….
6. ……………….
7. ……………….
8. Tipos de Dados Derivados
Pode-se agrupar dados de muitas formas, dentre elas, as

tabelas e planilhas. A linguagem C possui tipos de dados deri-
vados que permitem agrupar dados de elementos do mesmo
tipo básico, de forma sequencial e utilizando um ou mais índi-
ces para acessar cada um destes elementos.
Os tipos de dados derivados são assim chamados pois são constituídos de tipos básicos
ou primitivos. São eles, o vetor, a string e a matriz.
Um conjunto de dados numéricos agrupados em uma lista com um nome, este é o con-
ceito de vetor. Todos os elementos do vetor são do mesmo tipo básico de dado, são listas
homogêneas, pode-se ter vetores dos tipos int, float e double. Estes elementos ficam arranja -
dos, por simplicidade, em linhas.
Um conjunto de dados numéricos agrupados em uma tabela com um nome, este é o
conceito de matriz. Todos os elementos da matriz são do mesmo tipo básico de dado, são ta-
belas homogêneas, pode-se ter matrizes dos tipos int, float e double. Estes elementos ficam
arranjados em linhas e colunas.
Um conjunto de caracteres alfanuméricos agrupados em uma lista, terminada em NULL,
com um nome, este é o conceito de string C. Todos os elementos do vetor são do tipo char,
são listas homogêneas. Estes elementos ficam arranjados, por simplicidade, em linhas.
Os tipos derivados são usados para processar dados em listas numéricas (vetores), em
listas de caracteres (string) e tabelas numéricas (matriz). Estes tipos de dados derivados são
muito especializados, eles são ordenados e indexados. Os vetores e matriz, ambos numéri-
cos, são muito similares aqueles da Matemática, suas propriedades algébricas são as mes-
mas.
As strings são textos, similares aqueles da Linguagem Natural, suas propriedades al-
gébricas são as mesmas. A BPC possui um cabeçalho string.h, exclusivo para o processa-
mento de strings.
As variáveis dos tipos de dados derivados, possuem tipo de dado básico, nome e tama -
nho para indicar a quantidade de elementos que elas podem conter. Para localizar um ele-
mento de vetores e strings, é declarado um índice. As matrizes requerem dois índices para
localizar seus elementos, pois são bidimensionais.
Os vetores e matrizes podem ser do tipo básico int, float ou double. A string é sempre do
tipo básico char. O índice, ou índices, usado para localizar elementos nas strings, vetores e
matrizes é sempre do tipo int. Os tipos de dados derivados homogêneos, embora possam
possuir muitos elementos, todos eles são do mesmo tipo básico.
8.1. Vetores
O vetor é uma lista de valores do mesmo tipo básico, e que necessita de um índice para
localizar seus elementos.
Para declarar um vetor são necessários três atributos, a saber: o tipo de dado básico
que vai ser armazenado nele, seu nome e o seu tamanho.
Para manipular um vetor são necessários, pelo menos, dois recursos da linguagem C, a
saber: um índice – uma variável do tipo int; e uma estrutura de iteração – a instrução for é a
mais usada.
A sintaxe da declaração de vetores, sem e com valores iniciais, é mostrada a seguir.
<tipo de dado> <nome do vetor>[<tamanho>];

<tipo de dado> <nome do vetor>[<tamanho>] = { lista de valores };
Por exemplo, int V[6] = { 4, 2, 8, 1, 3, 7 }; é a declaração de um vetor do tipo básico int,

com nome V, tamanho 6 e armazena apenas valores inteiros. O vetor V pode ser representa-
do de forma gráfica como é mostrada a seguir.
índice 0 1 2 3 4 5
V[6] 4 2 8 1 3 7
Todo vetor é indexado a partir de zero. No exemplo acima, o vetor V tem tamanho 6,
seus elementos são indexados a partir de zero, ou seja, tem-se V[0] = 4, V [1] = 2, V [2] =
8, V[3] = 1, V[4] = 3 e V[5] = 7. Embora o vetor V tenha tamanho 6, não existe V[6],
V[7], …. Fazer uso de V[6], V[7], … é grave erro de programação pois extrapola o espaço de
memória reservado para a variável vetor V, alguns compiladores C indicam o erro outros não.
O Programa 8.1 permite visualizar os elementos de vetores int, float e double por meio
do C Tutor.
Programa 8.1 Visualização de vetores como conjunto de elementos
Foram declarados três vetores tamanho 5: Vi do tipo int, Vf do tipo float e Vd do tipo
double. Todos eles foram inicializados com o mesmo conjunto de valores numéricos.
A execução do programa-fonte no C Tutor permite visualizar estes três vetores, seus

nomes, seus tipos, seus tamanhos e valores iniciais.
O C Tutor, além de indicar o tipo de cada vetor, mostra também os tamanhos relativos de
cada um deles, Vd é maior comparado aos demais vetores porque é do tipo double requer
mais memória para armazenar seus valores; Vf é segundo maior porque é do tipo float e,
por fim, Vi é que menos ocupa memória de máquina.
Programa-fonte
#include <stdio.h>
int main( void ){
int Vi[5] = { 1, 2, 3, 4, 5 };
float Vf[5] = { 1, 2, 3, 4, 5 };
double Vd[5] = { 1, 2, 3, 4, 5 };
return 0;
}
Imagem da Execução com o C Tutor
Para fins práticos, os vetores serão tratados como colunas. As colunas ou elementos ou
células são ordenadas horizontalmente, são numeradas da esquerda para direita, e são indi -
cadas pelo índice que varia de 0 a n–1, Figura 8.1.
índice 0 1 2 ... n-2 n-1
V[n] V[0] V[1] V[2] ... V[n-2] V[n-1]

primeiro índice último índice
Figura 8.1 Representação de um vetor de tamanho n.
Na linguagem C a contagem começa em zero (0) e assim, o índice do vetor V varia de 0

até n–1. Pode–se reescrever V, de modo econômico, como V[c], 0 ≤ c < n.
O Programa 8.2 discute as duas as operações mais básicas feitas com vetores, ler valo-
res de um vetor do teclado e escrevê-los na tela. Estas operações são feitas elemento a ele-
mento dos vetores, por meio dos seus índice.
Programa 8.2 Ler e escreve, formatado, um vetor do tipo float de tamanho 5
Foram declarados o vetor V, do tipo float e de tamanho constante MAX, a variável i, do tipo
int, índice para o vetor.
Utilizou-se a instrução for para acessar os elementos de V, de um em um. O for é repetido
fazendo i variar de 0 até i < MAX e, a medida que i varia, é solicitado ao usuário que digite
o valor de V[i], em seguida o valor de V[i] é lido.
Semelhante processo é realizado, em seguida, para imprimir os valores de V,
acrescentado-lhes os formatos de forma adequada.
L Programa-fonte
2 #define MAX 5
3 int main( void ){
4 int i;
5 float V[MAX];
6 printf("\n Lendo V" );
7 printf("\n ------------------\n" );
8 for( i = 0; i < MAX; i++ ){
9 printf(" Valor de V[%d]: ", i );
10 scanf ("%f", &V[i] );
11 }
12 printf("------------------" );
13 printf("\n Escrevendo V " );
14 printf("\n +----+-------+" );
15 printf("\n | i | V[i] |" );
16 printf("\n +----+-------+" );
17 for( i = 0; i < MAX; i++ )
18 printf ("\n | %2d | %5.2f |", i, V[i] );
19 printf("\n +----+-------+" );
20 return 0;
21 }
Fluxo de controle Iteração i i < MAX V[i]

🌑→3→4→5→7→ - - -
→ 8 → 9 → 10 → 11 → 1 a
0 true V[0] = 11
→ 8 → 9 → 10 → 11 → 2 a
1 true V[1] = 12
→ 8 → 9 → 10 → 11 → 3a 2 true V[2] = 13
→ 8 → 9 → 10 → 11 → 4a 3 true V[3] = 1 4
→ 8 → 9 → 10 → 11 → 5a 4 true V[4] = 15
→8→ 6a 5 false
→ 12 → 13 → 14 → 15 → 16 →
→ 8 → 12 → 13 → 14 → 15 → 16 → 1a 0 true 0;11.00
→ 17 → 18 → 2a 1 true 1; 2.00
→ 17 → 18 → 3a 2 true 2;13.00
→ 17 → 18 → 4a 3 true 3;14.00
→ 17 → 18 → 5a 4 true 4;15.00
→ 17 → 6a 5 false
→ 19 → 20 → 21 → 🌕
O Comentário 8.1 discute os vetores C e sua associação com a EI for.
Comentário 8.1 Vetores e a Linguagem C
A linguagem C exige que o tamanho do vetor seja uma constante inteira 13 – não pode ser
uma variável, por isso é denominado de vetor estático. O tamanho dos vetores C são pré-
definidos e fixos em todo programa-fonte.
É comum a seguinte declaração na linguagem C para um vetor:
13 Alguns compiladores C, os mais recentes, podem ter flexibilizado esta regra.

#define n 20 // facilita mudanças

float V[n]; // n é constante e V possui 20 elementos do tipo float
Para fazer referência a um dos valores do vetor, basta usar o nome do vetor e indicar o
índice desejado, lembre–se que o índice varia de 0 a n–1, em que n é o tamanho do vetor.
Na declaração anterior, V[0] é o primeiro elemento de V, V[1] é o seu segundo elemento, e

assim por diante, até V[19], que é seu último elemento. Não existe o elemento V[20] pois a
contagem começa em zero (0).
Observe que o padrão usado para percorrer o vetor V: V[0], V[1], V[2], …, V[19], ou seja,
V[c], 0 ≤ c < n, é similar ao padrão da instrução for.
Vetores podem ser manipulados na linguagem C por meio de instrução for, eles foram
feitos um para o outro, da seguinte forma:
#define n 20
int c;
float V[n];
for( c = 0; c < n; c++ ){

// instruções para manipular cada elemento V[c] do vetor V
}
E também
const int n = 20;

int c;
float V[n];
for( c = 0; c < n; c++ ){

}
Na estrutura de iteração acima, a instrução for varia o seu contador de iteração de 0 a n–1.
O contador do for é usado como índice para os elementos do vetor V. A medida que c
aumenta de um em um, o bloco é executado e percorre–se os elementos de V, de um em
um, do início ao fim.
Nas partes de programa acima, o uso de n, e não o seu valor 20, é uma boa prática de
programação – as instruções não mudam ao mudar o valor de n.
Por vezes, digitar valores de vetores e uma tarefa enfadonha, o Programa 8.3 discute
uma forma de gerar valores de vetores escrevê-los na tela.
Programa 8.3 Gerar e escreve um vetor do tipo float de tamanho 5, formatado
Os valores do vetor V não são lidos do teclado, eles são gerados com a expressão rand() %
MAX, que retorna um valor inteiro entre 0 e MAX-1, neste caso V[i] ∊ [0,MAX-1]. Depois
foram escritos formatados na tela de saída.
A imagem produzida pelo C Tutor permite associar o vetor armazenado na memória da
máquina com o vetor impresso na tela.
Programa-fonte
#include <stdio.h>
#include <stdlib.h>
#define MAX 5
int main( void ){
int i;
float V[MAX];
printf("\n Gerando V" );
for( i = 0; i < MAX; i++ )
V[i] = rand() % 100;
printf("\n Escrevendo V" );
printf("\n +----+-------+" );
printf("\n | i | V[i] |" );
printf("\n +----+-------+" );
for( i = 0; i < MAX; i++ )
printf ("\n | %2d | %5.2lf |", i, V[i] );
printf("\n +----+-------+" );
return 0;
}
8.1.1. Vetor como Parâmetro de Função
Funções C podem receber vetores como parâmetros. Seja int V[5] um vetor, como decla-
rado abaixo.
int V[5] = { 4, 5, 1, 3, 6 };
A forma mais geral de receber vetor como parâmetro de função é mostrada abaixo.
void f( int V[5] ); // protótipo
A forma mais geral de passar vetor como argumento de função é mostrada abaixo.
int V[5] = { 4, 5, 1, 3, 6 };
f(V);
O Programa 8.4 mostra o uso de vetor como parâmetro de funções e o uso de vetores
como argumentos nas chamadas de funções.
Programa 8.4 Uso de funções para gerar e escrever um vetor do tipo double de tamanho 5,
formatado
O programa contém as funções gerar, escrever e main.

A função gerar, recebe o vetor X como parâmetro, e fornece valores numéricos aleatórios
para serem armazenados em cada elemento de X, para cada elemento de X[i], para i
variando de 0 a MAX-1, é gerado um número inteiro, rand() % 100, que é atribuído a X[i].
A função escrever, recebe o vetor X como parâmetro, e formata e imprime dos valores dos
elementos de X, uma a um.
Em main é declarado o vetor V double com tamanho constante MAX; nela são chamadas as
funções ler e escrever o argumento V.
Temos uma função para cada operação do vetor.
As imagens da execução, feitas, com o C Tutor, mostra a relação entre o argumento e o
parâmetro entre chamadas de funções. Nestas imagens pode-se notar como a chamada
das funções gerar e escrever, com a variável V do programa main como argumento, cria
uma associação com os parâmetros das funções chamadas. Isto pode ser visto na função
gerar e na função escrever. De modo geral, pode-se afirmar que os dados produzidos em
gerar são impressos por escrever via variável V do vetor main.
L Programa-fonte
2 #include <stdlib.h>
3 #define n 5
4 void gerar( double X[n] ){
5 int c;
6 printf("\n Gerando V" );
7 for( c = 0; c < n; c++ )
8 X[c] = rand() % 100;
9 }
10 void escrever( double X[n] ){
11 int c;
12 printf("\n Escrevendo V" );
13 printf("\n +----+-------+" );
14 printf("\n | c | V[c] |" );
15 printf("\n +----+-------+" );
16 for( c = 0; c < n; c++ )
17 printf ("\n | %2d | %5.2lf |", c, X[c] );
18 printf("\n +----+-------+" );
19 }
21 double V[n];
22 gerar(V);
23 escrever(V);
24 return 0;
25 }
Fluxo de controle Iteração c c<n V[c]
🌑 → 20 → 21 → 22 → 4 →
→ 4 → 5 → 6 →
→ 7 → 8 → 1a 0 true V[0] = 83.0
→ 7 → 8 → 2a 1 true V[1] = 86.0
→ 7 → 8 → 3a 2 true V[2] = 77.0
→ 7 → 8 → 4a 3 true V[3] = 15.0
→ 7 → 8 → 5a 4 true V[4] = 93.0
→ 7 → 8 → 6a 5 false
→ 9 → 22 →
→ 23 → 10 →
→ 23 → 10 →
→ 10 → 11 → 12 → 13 → 14 → 15 →
→ 16 → 17 → 1a 0 true 83.0
→ 16 → 17 → 2a 1 true 86.0
→ 16 → 17 → 3a 2 true 77.0
→ 16 → 17 → 4a 3 true 15.0
→ 16 → 17 → 5a 4 true 93.0
→ 16 → 17 → 6a 5 false
→ 18 → 19 → 23 →
→ 23 → 24 → 25 → 🌕
Imagens da Execução com o C Tutor
O Programa 8.5 faz uma comparação entre programa sem e com uso de funções para
manipular vetores.
Programa 8.5 Leitura e impressão dos valores de um vetor float.
O programa é inciado pela função main; nela O programa contém as funções ler, imprimir
são declaradas a variável inteira c e o vetor e main.
V, do tipo float e de tamanho constante n. A A função ler faz a leitura dos valores dos
variável c é usada para controle do for e elementos do vetor X, nela é declarada uma
também como índice do vetor V. variável inteira c, para controle do for e
também índice do vetor X. Com o for são
Usando um for, os valores de V são lidos um lidos os valores dos elementos de X, uma a
a um. um.
Usando um outro for, os valores de V são
impressos um a um. A função imprimir faz a impressão dos
valores dos elementos do vetor X, nela é
Pede-se enunciar uma regra básica: um for declarada uma variável inteira c, para
para cada operação com vetor. controle do for e também índice do vetor X.
Com o for são impressos os valores dos
Um for para cada operação do vetor; um for elementos de X, uma a um.
para leitura e outro for para impressão.
Em main é declarado o vetor V com
Po vezes é mais simples escrever pequenos tamanho constante n; nela são chamadas as
programas sem uso de funções. Também é funções ler e imprimir com o argumento V.
possível reestruturá-los com uso de funções
com um pequeno retrabalho14. Temos uma função para cada operação do
vetor e um for em cada função.
Programa-fonte
Sem uso de Funções Com uso de Funções

#include <stdio.h>
#define n 10
void ler( float X[n] ){
int c;
#include <stdio.h>
for( c = 0; c < n; c++ ){
#define n 10
printf( " Valor de V[%d]: ", c );
int main( void ){
scanf ( "%f", &X[c] );
int c;
}
float V[n];
}
printf("\n Leitura de V\n" );
void imprimir( float X[n] ){
for( c = 0; c < n; c++ ){
int c;
printf( " Valor de V[%d]: ", c );
for( c = 0; c < n; c++ ){
scanf ( "%f", &V[c] );
printf("\n V[%d] = %f", c, V[c] );
}
}
printf("\n Impressao de V: " );
}
for( c = 0; c < n; c++ ){
int main( void ){
printf("\n V[%d] = %f", c, V[c] );
float V[n];
}
printf("\n Leitura de V\n" );
return 0;
ler(V);
}
printf("\n Impressao de V: " );
imprimir(V):
return 0;
}
8.1.2. Operações Básicas com Vetores
8.1.2.1. Álgebra de Vetores
Dentre as operações com vetores, destacam–se a soma, a subtração e a multiplicação
14 Não estou aqui defendendo retrabalho, que deve ser sempre evitado, o melhor remédio para retrabalho é planejamento.
por um número.
Dados os vetores A[n] = { a 0 a1 a2 … an-1 } e B[n] = { b 0 b1 b2 … bn-1 }, a soma de A e B é
um outro vetor C, dado por C[n] = { a0+b0 a1+b1 a2+b2 … an-1+bn-1 }.
A subtração de A[n] e B[n] é um outro vetor S, dada por S[n] = { a 0-b0 a1-b1 a2-b2 … an-1-
bn-1 }. E o produto de um número real k pelo vetor A é um outro vetor P, dado por P[n] =
{ ka0 ka1 ka2 … kan-1 }. Estes cálculos são feitos no Exemplo 8.1.
Exemplo 8.1 Sejam A4 = [ -1 0 3 1 ] e B4 = [ 1 2 0 -2 ], calcule C4 = A4+B4, S4 = A4-B4, P4 =

5A4-3B4.
C4 = [-1+1 0+2 3+0 1-2] = [0 2 3 -1]

S4 = [-1-1 0-2 3-0 1+2] = [-2 -2 3 3]
P4 = [ 5x(-1)-3x1 5x0-3x2 5x3-3x0 5x1-3x(-2)] = [-8 -6 15 11]
Sejam os vetores A = [ac] e B = [bc], para 0 ≤ c < n. Sejam C = A + B, S = A – B e P = k

A, para k real, logo, pode–se escrever C = [ac+bc], S = [ac-bc] e P = [kac], para 0 ≤ c < n.
Estas operações com vetores podem ser escritas em C usando o for, como mostrado no
Programa 8.6.
Programa 8.6 Leitura de A e B vetores de tamanho n, cálculo e impressão de C = A + B, S

= A – B e P = k A, k número float. Teste este algoritmo com A =[ 2.5 -3.3 4.0 1.2 ], B =
[ 0.5 -1.5 2.2 -2.0] e k = 4.0.
O programa contém as funções leitura, imprime e main.
Os valores dos vetores são lidos de teclado pela função leitura, esta função lê valores tanto
do vetor A quanto do vetor B, um de cada vez.
A função imprime faz a impressão dos valores dos elementos dos vetores A, B, C, S, e P.
A função main determina o fluxo de controle do programa, declara os vetores A, B, C, S e P,

chama a função leitura duas vezes, a primeira vez com a argumento A e a segunda com o
argumento B. Em seguida lê o valor de K e calcula C, S e P usando uma EI for.
Ao final, imprime os todos os vetores, um de cada vez, e o valor de k.
Plano de Testes
A = [ 2.5 -3.3 4.0 1.2 ]

B = [ 0.5 -1.5 2.2 -2.0]
k = 4.0
C = A + B = [ 3.0 -4.8 6.2 -0.8 ]
S = A – B = [ 2.0 -1.8 1.8 3.2 ]
P = k × A = [ 10.0 -13.2 16.0 4.8 ]
L Programa-fonte
2 #define n 4
3 void leitura( float X[n] ){
4 int c;
5 for( c = 0; c < n; c++ ){
6 printf(" V2.5alor de X[%d]: ", c );

7 scanf("%f", &X[c] );
8 }
9 }
10 void imprime( float X[n] ){
11 int c;
12 for( c = 0; c < n; c++ )
13 printf( " %.3f ", X[c] );
14 }
16 int c;
17 float A[n], B[n], C[n], S[n], P[n], k;
18 printf( "\n Leitura de A\n" ); leitura(A);
19 printf( "\n Leitura de B\n" ); leitura(B);
20 printf( "\n De o valor de k: " );
21 scanf ( "%f", &k );
22 printf( "\n Calculo de C, S e P" );
23 for( c = 0; c < n; c++ ){
24 C[c] = A[c] + B[c];
25 S[c] = A[c] - B[c];
26 P[c] = k*A[c];
27 }
28 printf( "\n Impressao de A: " ); imprime(A);
29 printf( "\n Impressao de B: " ); imprime(B);
30 printf( "\n Impressao de k: %.3f", k );
31 printf( "\n Impressao de C: " ); imprime(C);
32 printf( "\n Impressao de S: " ); imprime(S);
33 printf( "\n Impressao de P: " ); imprime(P);
34 return 0;
35 }
Fluxo de controle Iteração c c<n A[i], B[i], k, C[i], S[i], P[i]
🌑 → 15 → 16 → 17 → 18 → 3 - - -
-
→3→4→ - -
→5→6→7→8→ 1a 0 true A[0] = 2.5
a
→5→6→7→8→ 2 1 true A[1] = -3.3
→5→6→7→8→ 3a 2 true A[2] = 4.0
→5→6→7→8→ 4a 3 true A[3] = 1.2
a
→5→9→ 5 4 false
→ 18 → 19 → 3 →
→5→6→7→8→ 1a 0 true B[0] = 0.5
a
→5→6→7→8→ 2 1 true B[1] = -1.3
→5→6→7→8→ 3a 2 true B[2] = 2.2
a
→5→6→7→8→ 4 3 true B[3] = 2.0
→5→9→ 5a 4 false
→ 19 → 20 → 21 → 4.0
→ 22 →
→ 23 → 24 → 25 → 26 → 27 → 1a 0 true C[0] = 3.0; S[0] = 2.0; P[0] = 10.0
→ 23 → 24 → 25 → 26 → 27 → 2a 1 true C[1] = -4.8; S[1] = -1.8; P[1] = -13.2
a
→ 23 → 24 → 25 → 26 → 27 → 3 2 true C[2] = 6.2; S[2] = 1.8; P[2] = 16.0
→ 23 → 24 → 25 → 26 → 27 → 4a 3 true C[3] = -0.8; S[3] = 3.2; P[3] = 4.8
a
→ 23 → 28 → 5 4 false
→ 10 → 11 →
→ 12 → 13 → 1a 0 true 2.5
→ 12 → 13 → 2a 1 true -3.3
a
→ 12 → 13 → 3 2 true 4.0
a
→ 12 → 13 → 4 3 true 1.2
→ 12 → 14 → 29 → 5a 4 false
→ 10 → 11 →
→ 12 → 13 → 1a 0 true 0.5
→ 12 → 13 → 2a 1 true -1.3
a
→ 12 → 13 → 3 2 true 2.2
→ 12 → 13 → 4a 3 true 2.0
→ 12 → 14 → 29 → 5a 4 false
→ 30 → 4.0
→ 31 →
→ 10 → 11 →
→ 12 → 13 → 1a 0 true 3.0
→ 12 → 13 → 2a 1 true -4.8
a
→ 12 → 13 → 3 2 true 6.2
→ 12 → 13 → 4a 3 true -0.8
→ 12 → 14 → 31 → 5a 4 false
→ 32 →
→ 10 → 11 →
→ 12 → 13 → 1a 0 true 2.0
a
→ 12 → 13 → 2 1 true -1.8
→ 12 → 13 → 3a 2 true 1.8
→ 12 → 13 → 4a 3 true 3.2
a
→ 12 → 14 → 32 → 5 4 false
→ 33 →
→ 10 → 11 →
→ 12 → 13 → 1a 0 true 10.0
→ 12 → 13 → 2a 1 true -13.2
a
→ 12 → 13 → 3 2 true 16.0
→ 12 → 13 → 4a 3 true 4.8
→ 12 → 14 → 33 → 5a 4 false
→ 34 → 35 → 🌕
8.1.2.2. Valores Extremos de Vetor
Os valores extremos de um vetor são seus valores mínimo e máximo.

As operações envolvendo valores extremos de vetores incluem determinar estes valores
e também o índice destes valores.
O Quadro 8.1 estabelece os procedimentos computacionais para a obtenção dos valores
extremos de vetores.
Quadro 8.1 Algoritmo para obtenção dos valores mínimo e máximo de vetores
Valor Extremo Procedimento

Seja V[n] o vetor. Cria-se uma variável Xn. O valor inicial de Xn deve ser o do
primeiro elemento do vetor, Xn = V[0]. Percorrer o vetor com uma estrutura
Mínimo
de iteração (EI) e a instrução if( Xn > V[i] ) Xn = V[i], 0 ≤ i < n. Ao sair da EI,
o valor de Xn é o valor mínimo do vetor.
Seja V[n] o vetor. Cria-se uma variável Xx. O valor inicial de Xx deve ser o do
primeiro elemento do vetor, Xx = V[0]. Percorrer o vetor com uma estrutura
Máximo
de iteração (EI) e a instrução if( Xx < V[i] ) Xx = V[i], 0 ≤ i < n. Ao sair da EI,
o valor de Xx é o valor máximo do vetor.
Observe que, no caso de vetores, tanto seu valor máximo quanto seu valor mínimo po-
dem ser iguais ao primeiro elemento do vetor. E, se estes valores não forem seus valores ex-
tremos, serão trocados dentro da EI.
O Programa 8.7 calcula os valores mínimo e máximo de um vetor usando os procedi-
mentos do O Quadro 8.1.
Programa 8.7 Obtenha os valores mínimo e máximo do vetor A de 6 elementos lidos to

teclado
Os dados de entrada são os valores do vetor A do tipo float.

Os dados de saída são os valores mínimo e máximo do vetor A, sejam eles Vn e Vx, ambos
float – mesmo tipo de A.
Inicialmente, devem ser lidos os valores do vetor.
Fazer Vn = Vx = A[0], esta instrução deve ser colocada após a leitura dos valores de A, e
não antes.
Dentro do for serão colocados as instruções conforme o Quadro 8.1.
Ao sair do for, serão impressos os valores Vn e Vx.
N Tamanho de Vetor int 6 E
A Vetor A float input E
c Contador do for int 0, feito no for P
Vn Valor mínimo de A float A[0] S
Vx Valor máximo de A float A[0] S
L Programa-fonte
2 #define N 6
3 int main( void ){
4 int c;
5 float A[n], Vn, Vx;
6 printf("\n Leitura de A\n" );
7 for( c = 0; c < N; c++ ){
8 printf(" De o valor de A[%d]: ", c );
9 scanf("%f", &A[c] );
10 }
11 Vn = A[0];
12 Vx = A[0];
13 printf("\n Atualizando Vn e Vx" );
14 for( c = 0; c < N; c++ ){
15 if( Vn > A[c] ) Vn = A[c];
16 if( Vx < A[c] ) Vx = A[c];
17 }
18 printf( "\n menor valor: %f ", Vn );
19 printf( "\n maior valor: %f ", Vx );
20 return 0;
21 }
Fluxo de controle c c<N Vn > A[c] Vn < A[c] A Vn Vx
🌑→3→4→5→6→
→ 7 → 8 → 9 → 10 → 0 true A[0] = 3.0
→ 7 → 8 → 9 → 10 → 1 true A[1] = 2.0
→ 7 → 8 → 9 → 10 → 2 true A[2] = 9.0
→ 7 → 8 → 9 → 10 → 3 true A[3] = 7.0
→ 7 → 8 → 9 → 10 → 4 true A[4] = 1.0
→ 7 → 8 → 9 → 10 → 5 true A[5] = 8.0
→7→ 6 false
→ 11 → 3.0
→ 12 → 3.0
→ 14 → 0 true
→ 15 → false
→ 16 → false
→ 17 →
→ 14 → 1 true
→ 15 → true 2.0
→ 16 → false
→ 17 →
→ 14 → 2 true
→ 15 → false 2.0
→ 16 → true 9.0
→ 17 →
→ 14 → 3 true
→ 15 → false 2.0
→ 16 → false
→ 17 →
→ 14 → 4 true
→ 15 → true 1.0
→ 16 → false
→ 17 →
→ 14 → 5 true
→ 15 → false
→ 16 → false
→ 17 →
→ 14 → 6 false
→ 18 →
→ 19 →
→ 20 →21 → 🌕
8.1.2.3. Pesquisa em Vetor
Dado um vetor de V[n], como verificar se um determinado valor x é elemento deste ve-
tor?
Seja c o índice de V, a solução mais simples para verificar se x ∈ V é a chamada pesqui-
sa sequencial: fazer c variar de 0 até n-1 e verifica se V[c] == x.
Criando as variáveis:
#define n 7
bool pertence = false;
int c = 0;
int x = 5, V[n] = { 7, 9, 2, 4, 0, 2, 9 };
Algoritmo da pesquisa sequencial:
for( c = 0; c < n; c++ ){

if( V[c] == x ) pertence = true;
}
Avaliação da pesquisa sequencial:
if( pertence ) printf( "\n Valor encontrado" );

else printf( "\n Valor não encontrado" );
O problema de pesquisa em vetores é muito estudado e possui muitas soluções. O Pro-

grama 8.8 é uma aplicação simples de pesquisa em vetor.
Programa 8.8 Busca em Vetor – verificar se o vetor contém o número 5
Os dados de entrada são os valores do vetor V do tipo int e o valor a ser pesquisado x, do
mesmo tipo de V.
O dado de saída é o índice de x em V, se x for encontrado em V e, caso contrário, a
mensagem informando que x não foi encontrado em V.
Cria-se uma variável pertence, do tipo bool, com valor incial false.
É usado um for, com o índice c, com c variando de 0 a n-1, verificar se V[c] == x para cada
valor de c; em caso afirmativo atribuir true à variável pertence e encerrar ao EI.
Ao final do for, se x pertencer ao vetor V, o for foi interrompido no índice c, que

corresponde a posição de x em V, e a variável pertence assumiu o valor true. Se x não
pertencer ao vetor V, o for não foi interrompido e a variável pertence continua com valor
false.
Desta forma, imprime-se que x pertence a V na posição c, caso contrário, imprime-se que x
não pertence a V.
Programa-fonte
#include <stdio.h>
#define n 7
int main( void ){
int c = 0, x = 4,
V[n] = { 7, 9, 2, 4, 0, 2, 9 };
for( i = 0; i < n; i++ ){
if( V[c] == x ){
pertence = true;
break;
}
}
printf( "\n Busca do valor %d", x );
if( pertence ) printf( "\n Valor encontrado na posição %d", c );

return 0;
}
8.1.2.4. Ordenação de Vetor
Um método simples para ordenar vetores consiste em percorrer o vetor e verificar para,
cada elemento do vetor, se à sua direita há elemento menor do que ele e, se houver, fazer a
troca utilizando uma variável auxiliar. Neste caso, a ordem é crescente.
Se trocar pelo maior é decrescente.
Um método simples para ordenar vetores consiste em percorrer o vetor e, para cada
elemento deste vetor, trocar pelo elemento menor à sua direita. Neste caso, a ordem é cres -
cente, coo está explicado no Programa 8.9.
Se trocar pelo maior é decrescente.
Programa 8.9 Ordenação de vetor em ordem crescente
O dado de entrada é o vetor A do tipo double. O dado de saída é o vetor A ordenado em

ordem crescente.
Para percorre o vetor, do início ao fim, é usado o primeiro for com o índice c, para 0 ≤ c <
n. Para percorre o vetor, a partir de i ao fim, é usado o segundo for com o índice i, para c ≤ i
< n, e trocar V[c] com V[i] quando V[c] > V[i].
O vetor está ordenado de forma crescente ao final do primeiro for.
L Programa-fonte
2 #define n 5
3 int main( void ){
4 int c;
5 double V[n] = { 4.1, 1.1, 5.1, 6.1, 3.1 };
6 for( c = 0; c < n; c++ ){
7 int i;
8 for( i = c; i < n; i++ )
9 if( V[c] > V[i] ){
10 double aux = V[c];
11 V[c] = V[i];
12 V[i] = aux;
13 }
14 }
15 printf("\n V: " );
16 for( c = 0; c < n; c++ )
17 printf(" %.1lf ", V[c] );
18 return 0;
19 }
8.1.3. Outras Operações com Vetores
Pode-se ainda embaralhar os elementos de vetores de diversas formas para fins de jo-
gos digitais. Outros algoritmos envolvendo vetores pode vistos no livro “Numerical Recipes in
C” (Press, 1992).

7. ……………..
8. ……………….
9. ……………….
10. ……………….
11. ……………….
8.1.4.2. Questões Avançadas

2. ……………..
3. ……………….
4. ……………….
5. ……………….
6. ……………….
7. ……………….
8. ……………….
1. Ler N elementos de um vetor A. Construir um vetor B de mesma dimensão de A tal que

B = 3A. Imprimir A e B, para N = 10.

2. Ler o vetor A com 5 elementos e B com 7 elementos. Construir um vetor C, sendo esta
a junção de A e B. Desta forma, C deverá ter a capacidade de armazenar 12 elementos.
3. Faça um programa que preencha um vetor com N elementos inteiros. Para N = 20,
calcule e mostre:
a) todos os números pares;
b) a quantidade de números pares;
c) todos os números ímpares;
d) a quantidade de números ímpares.
4. Faça um programa que preencha um vetor com N elementos inteiros e verifique a
existência de elementos iguais a N/2, mostrando as posições em que apareceram. Teste
seu programa para N = 21.
5. Faça um programa que preencha um vetor com N números reais, calcule e mostre a
quantidade de números negativos e a soma dos números positivos desse vetor, para N =
20.
6. Faça um programa que preencha um vetor com os códigos de N estudantes e outro
vetor com as respectivas médias finais destes estudantes. Calcule e mostre: a) o código
do estudante com maior média (desconsiderar empates); b) para cada estudante não
aprovado, isto é, com média menor que 7, mostrar quanto ele precisa tirar na prova de
exame final para ser aprovado. Considerar que a média para aprovação no exame é 5.
Teste seu programa para N = 25.
7. Faça um programa que leia N números inteiros e armazene-os em um vetor. Calcule e
mostre dois vetores resultantes: o primeiro com os números pares e o segundo, com os
números ímpares. Teste seu programa para N = 25.
8. Faça um programa que receba o código de N produtos e seus respectivos preços.
Calcule e mostre: a) a quantidade de produtos com preço inferior a M$ 50,00; b) o código
dos produtos com preço entre M$ 50,00 e M$ 100,00; c) a média dos preços dos produtos
com preço superior a M$ 100,00. Teste seu programa para N = 12.
9. Faça um programa que preencha dois vetores de N posições cada, determine e mostre
um terceiro contendo os elementos dos dois vetores anteriores ordenados de maneira
decrescente. Teste seu programa para N = 20.
10. Faça um programa que preencha um vetor com N números, determine e mostre: a) o
maior número e a posição por ele ocupada no vetor; b) o menor número e a posição por
ele ocupada no vetor. Teste seu programa para N = 50.
11.Faça um programa que leia dois vetores de N posições e faça a multiplicação dos
elementos de mesmo índice, colocando o resultado em um terceiro vetor. Mostre o vetor
resultante. Teste seu programa para N = 40.
12.Faça um programa que leia um vetor com N posições para números inteiros e mostre
somente os números positivos.
13.Faça um programa que leia um vetor com N posições para números inteiros. Crie um
segundo vetor, substituindo os valores nulos por 1. Mostre os dois vetores. Teste seu
programa para N = 15.
14.Faça um programa que leia dois vetores (A e B) com N posições para números inteiros.
O programa deve, então, subtrair o primeiro elemento de A do último de B, acumulando o
valor, subtrair o segundo elemento de A do penúltimo de B, acumulando o valor e assim
por diante. Ao final, mostre o resultado de todas as subtrações realizadas. Teste seu
programa para N = 12 e N= 13.
15.Faça um programa que leia um vetor com N posições para números inteiros. Depois da
leitura, divida todos os seus elementos pelo maior valor do vetor. Mostre o vetor após os
cálculos. Teste seu programa para N = 10.
16.Faça um programa que receba o código de N clientes e armazene-os em um vetor. Em
um segundo vetor, armazene a quantidade de livros comprados em 2021 por cada um dos
N clientes. Sabe-se que, para cada dez livros comprados, o cliente tem direito a um livro
grátis. Faça um programa que mostre o código de todos os clientes, com a quantidade de
livros grátis a que ele tem direito. Teste seu programa para N = 12.
17. Uma escola deseja saber se existem alunos cursando, simultaneamente, as disciplinas
Lógica e Linguagem de Programação. Coloque os números das matrículas dos alunos que
cursam Lógica em um vetor, N alunos. Coloque os números das matrículas dos alunos que
cursam Linguagem de Programação em outro vetor, M alunos. Mostre o número das
matrículas que aparecem nos dois vetores. Teste seu programa para N = 8 e M = 12.
18.Faça um programa que receba o total das vendas de cada vendedor de uma loja e
armazene-as em um vetor. Receba também o percentual de comissão a que cada
vendedor tem direito e armazene-os em outro vetor. Receba os códigos desses
vendedores e armazene-os em um terceiro vetor. Existem N vendedores na loja. Calcule e
mostre: a) um relatório com os códigos dos vendedores e os valores a receber referentes à
comissão; b) o total das vendas de todos os vendedores; c) o maior valor a receber e o
código de quem o receberá; d) o menor valor a receber e o código de quem o receberá.
Teste seu programa para N = 12.
19.Faça um programa para controlar o estoque de mercadorias de uma empresa.
Inicialmente, o programa deverá preencher dois vetores com N posições cada, onde o
primeiro corresponde ao código do produto e o segundo, ao total desse produto em
estoque. Logo após, o programa deverá ler um conjunto indeterminado de dados contendo
o código de um cliente e o código do produto que ele deseja comprar, com a quantidade.
Código do cliente igual a zero indica fim do programa. O programa deverá verificar: a) se o
código do produto solicitado existe. Se existir, tentar atender ao pedido; caso contrário,
exibir mensagem Código inexistente; b) cada pedido feito por um cliente só pode ser
atendido integralmente. Caso isso não seja possível, escrever a mensagem Não temos
estoque suficiente dessa mercadoria. Se puder atendê-lo, escrever a mensagem Pedido
atendido. Obrigado e volte sempre; c) efetuar a atualização do estoque somente se o
pedido for atendido integralmente; d) no final do programa, escrever os códigos dos
produtos com seus respectivos estoques já atualizados. Teste seu programa para N = 15.
20.Uma maneira de embaralhar um vetor de tamanho N par é aplicar sucessivas
operações E1 e E2, como apresentado na tabela abaixo para N = 10. A primeira operação
troca as metades do vetor e a segunda gira o vetor uma posição à esquerda como se ele
fosse circular. Faça um programa em C que crie, atribua valores a um vetor e aplique nele
as operações E1 e E2, nessa sequência. Imprima os resultados formatados a cada etapa
como a tabela abaixo.
i 0 1 2 3 4 5 6 7 8 9
v[i] 1 2 3 4 5 6 7 8 9 10
E1 6 7 8 9 10 1 2 3 4 5
E2 7 8 9 10 1 2 3 4 5 6
21.Escreva uma função recursiva para validar o número de CPF.
22.Escreva uma função recursiva para validar o número de CNPJ.
23.Dados dois vetores A e B de tamanho N, faça um programa que calcule a soma dos
produtos de ai pelos demais elementos de A e atribua este resultado a b i, e imprima estes
vetores.
24.Escreva um programa em C que identifique e imprima o valor do índice k de um vetor
V, qualquer, tal que a soma Sa = ΣV[i] (i≤k) seja maior ou igual a soma Sb = ΣV[i] (i>k).
Teste seu programa com o vetor abaixo:
1 9 6 8 9 8 5 7 8 4 8 9
25.Explique a saída do programa:
#include <stdio.h>
#define N 4
int main( void ){

char c[N], *pc = &c;
int i[N], *pi = &i;
long l[N], *pl = &l;
float f[N], *pf = &f;
double d[N], *pd = &d;
int k;
for( k = 0; k < N; k++ ){
printf("\n Interacao %d", k );
printf("\n ----------------------------");
printf("\n endereco pc = %p", pc );
printf("\n endereco pi = %p", pi );
printf("\n endereco pl = %p", pl );
printf("\n endereco pf = %p", pf );
printf("\n endereco pd = %p", pd );
printf("\n\n");
pc++;
pi++;
pl++;
pf++;
pd++;
}
return 0;
}
#include <stdio.h>
#define N 4
int main( void ){
int k, P[N], Q[N], *p;
p = Q;
for( k = 0; k < N; k++ ){
P[k] = k+1;
*(p+k) = k+1;
}
printf("\n P: " );
for( k = 0; k < N; k++ )
printf(" %d ", P[k] );
printf("\n Q: " );
for( k = 0; k < N; k++ )
printf(" %d ", Q[k] );
return 0;
}
27.Explique a saída do programa, compare-o com o programa anterior:
#include <stdio.h>
#define N 4
int main( void ){
int k, P[N], Q[N], R[N], *p;
p = Q;
for( k = 0; k < N; k++ ){
P[k] = k+1;
*(p+k) = k+1;
}
p = R;
for( k = 0; k < N; k++ ){
*p = k+1;
p++;
}
printf("\n P: " );
for( k = 0; k < N; k++ )

printf(" %d ", P[k] );
printf("\n Q: " );
for( k = 0; k < N; k++ )
printf(" %d ", Q[k] );
printf("\n R: " );
for( k = 0; k < N; k++ )
printf(" %d ", R[k] );
return 0;
}
#include <stdio.h>
#define n 5
int main( void ){
int c, v[n] = { 4, 5, 1, 3, 6 };
printf("\n");
for( c = 0; c < n; c++ )
printf(" %d ", v[c] );
printf("\n");
for( c = 0; c < n; c++ )
printf(" %d ", *(v+c) );
return 0;
}
#include <stdio.h>
#define n 5
int main( void ){
int c, v[n] = { 4, 5, 1, 3, 6 };
for( c = 0; c < 2*n; c++ )
printf(" %d ", v[c] );
return 0;
}
30.O somatório dos elementos de um vetor pode ser calculado recursivamente utilizando a
n n−1
fórmula ∑ x [i]=x [n]+∑ x [i] . Faça um programa que: a) preencha um vetor de N
i=0 i=0
elementos reais; b) imprima este vetor; c) imprima o resultado do somatório dos
elementos desse vetor, calculado por uma função recursiva. Teste seu programa para N =
12.
31.Escreva uma função recursiva para calcular o produto dos elementos de um vetor.
32.Escreva um subprograma recursivo que inverta a ordem dos elementos de uma lista
armazenada em um vetor. Ao final da execução, o conteúdo do primeiro elemento deverá
estar no último, o do segundo no penúltimo, e assim por diante. Dica: troque os conteúdos
das duas extremidades do vetor e chame o subprograma recursivamente para fazer o
mesmo no subvetor interno.
33.Sendo o vetor V = [2 6 8 3 10 9 1 21 33 14] e as variáveis x = 2 e y = 4, escreva o
valor correspondente de:
a) V[x+1] + V[x+2] - V[x+3]
b) V[x*1] / V[x*2] * V[x*3]
c) V[V[4]] + V[x+y]-V[V[1] * V[4]]
d) V[8-V[2]]/V[x*4] > V[V[x+y]]
e) V[V[V[7]]] == V[x+4]
34.Altere a soma de vetores para que esta realize a operação: o produto do primeiro vetor
pelo inverso do segundo é armazenado a partir do centro para as bordas; de modo
alternado, o vetor é de float e possui 20 posições.
35.Desenvolva um algoritmo que leia um vetor de tamanho n e o coloque em ordem

crescente.
36.Desenvolva um algoritmo que leia um vetor de tamanho n e o coloque em ordem
decrescente.
1. Escreva um programa em C para sortear N valores de um vetor, sem valores repetidos.

Teste seu programa para N = 9, como no exemplo abaixo.
7 8 6 5 1 4 2 3 9
2. …
8.1.4.5. Exercícios do Sistema Solar
1. Preencha o quadro abaixo com as menores distância entre os planetas utilizando os

dados da Tabela 5.1, utilizando funções, vetores e matrizes.
Planeta Mercúrio Vênus Terra Marte Júpiter Saturno Urano Netuno

Mercúrio 0.0
Vênus 0.0
Terra 0.0
Marte 0.0
Júpiter 0.0
Saturno 0.0
Urano 0.0
Netuno 0.0
2. Preencha o quadro abaixo com as maiores distância entre os planetas utilizando os

Mercúrio 0.0
Vênus 0.0
Terra 0.0
Marte 0.0
Júpiter 0.0
Saturno 0.0
Urano 0.0
Netuno 0.0
3. Preencha o quadro abaixo com a maior força de atração gravitacional, em Newtons,
entre os planetas utilizando os dados da Tabela 5.1, funções, vetores, matrizes e
mM
F=G 2 , sendo G = 6,6743E-11 m3 kg-1 s-2 (constante de gravitação universal).
r
Mercúrio 0.0
Vênus 0.0
Terra 0.0
Marte 0.0
Júpiter 0.0
Saturno 0.0
Urano 0.0
Netuno 0.0
4. Preencha o quadro abaixo com a menor força de atração gravitacional, em Newtons,
mM
r
Mercúrio 0.0
Vênus 0.0
Terra 0.0
Marte 0.0
Júpiter 0.0
Saturno 0.0
Urano 0.0
Netuno 0.0
8.2. Matrizes
A matriz é uma tabela de valores do mesmo tipo básico e que necessita de dois índice
para localizar seus elementos, um para a linha e o outro para a coluna.
Para declarar uma matriz são necessários quatro atributos: o tipo de dado básico que
vai ser armazenado nela, seu nome, seu número de linhas e seu número de colunas.
Para manipular uma matriz necessários, pelo menos, quatro recursos da linguagem C:
dois índices – duas variáveis do tipo int; e duas estruturas de iteração – a instrução for é a
mais usada.
A sintaxe da declaração de matrizes, sem e com valores iniciais, é mostrada a seguir.
<tipo de dado> <nome da matriz>[<linhas>][<colunas>];

<tipo de dado> <nome da matriz>[<linhas>][<colunas>] = { {lista de valores},
{lista de valores}, …, {lista de valores} };
Por exemplo, int M[3][4] = { {4, 2, 8, 6}, { 1, 3, 7, 0}, { 5, 9, 4, 1} }; é a declaração

de uma matriz do tipo básico int, com nome M, com 3 linhas e 4 colunas e que armazena
apenas valores inteiros. Esta matriz M pode ser representado de forma gráfica como é mos-
trada a seguir.
linha/coluna 0 1 2 3
0 4 2 8 6
M[3][4] 1 1 3 7 0
2 5 9 4 1
Toda matriz é indexado a partir do par [0][0]. No exemplo acima, a matriz M tem 3 li-
nhas e 4 colunas, com o total de 12 elementos, que são indexados como:
• M[0][0] = 4, M[0][1] = 2, M[0][2] = 8 e M[0][3] = 6, na primeira linha ou linha 0;
• M[1][0] = 1, M[1][1] = 3, M[1][2] = 7 e M[1][3] = 0, na segunda linha ou linha 1; e
• M[2][0] = 5, M[2][1] = 9, M[2][2] = 4 e M[2][3] = 1, na terceira linha ou linha 2.
O Programa 8.10 permite visualizar a disposição dos elementos de matrizes int, float e
double por meio do C Tutor.
Programa 8.10 Visualização de matrizes como tabela de elementos
Foram declarados três matrizes, de 3 linhas e 4 colunas: Mi do tipo int, Mf do tipo float e Md
do tipo double. Todas eles foram inicializados com o mesmo conjunto de valores
numéricos.
A execução do programa-fonte no C Tutor permite visualizar estas três matrizes, seus
nomes, seus tipos, seus tamanhos e valores iniciais.
O C Tutor, além de indicar o tipo de cada matriz, mostra também os tamanhos relativos de
cada um deles, Md é a maior comparado as demais matrizes porque é do tipo double,
requer mais memória para armazenar seus valores; Mf é a segundo maior porque é do tipo
float e, por fim, Mi é que a menos ocupa memória de máquina.
Programa-fonte
#include <stdio.h>
int main( void ){
int Mi[3][4] = { { 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 0, 1, 2 }
};
float Mf[3][4] = { { 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 0, 1, 2 }
};
double Md[3][4] = { { 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 0, 1, 2 }
};
return 0;
}
Imagem da Execução com o C Tutor
Na linguagem C a contagem começa em zero (0) e assim, a matriz M[m][n] possui dois
índices, um para linhas que varia de 0 a m-1 e outro para coluna que varia de 0 a n-1. Pode–
se reescrever m, de modo econômico, como M[l][c], 0 ≤ l < m e 0 ≤ c < n.
O Programa 8.11 discute as duas operações mais básicas feitas com matrizes, ler valo-
res de uma matriz do teclado e escrevê-los na tela. Estas operações são feitas elemento a
elemento da matriz, por meio dos seus índices.
Programa 8.11 Ler e escreve, formatado, uma matriz do tipo double com 3 linhas e 4
colunas
Declara-se M, matriz tipo double com número de linhas de tamanho constante LIN e
com número de colunas de tamanho constante COL, as variáveis l e c, ambas do tipo int,
índices para a matriz e contadores dos das duas instruções for, necessárias para acessar
cada um dos elementos da matriz.
Utilizou-se duas instruções for para acessar os elementos de M, um a um. O primeiro for,
referente às linhas de M, faz l variar de 0 até l < LIN. O segundo for, referente às colunas
de M, faz c variar de 0 até c < COL.
A medida que l e c variam, é solicitado ao usuário que digite o valor de M[l][c], em seguida
esse valor é lido e atribuído a M[l][c].
Semelhante processo é realizado, em seguida, para imprimir os valores de M,
acrescentado-lhes os formatos de forma adequada.
Programa-fonte
#include <stdio.h>
#include <stdlib.h>
#define LIN 3
#define COL 4
int main( void ){
int l, c;
double M[LIN][COL];
printf("\n Lendo M" );
printf("\n ---------------------\n" );
for( l = 0; l < LIN; l++ ){
for( c = 0; c < COL; c++ ){
printf(" Valor de M[%d][%d]: ", l, c );
scanf ("%lf", &M[l][c] );
}
}
printf("---------------------" );
printf("\n Escrevendo M " );
printf("\n +-----+-------+-------+-------+-------+" );
printf("\n | l/c |" );
for( c = 0; c < COL; c++ )
printf( " %2d |", c );
printf("\n +-----+-------+-------+-------+-------+" );
for( l = 0; l < LIN; l++ ){
printf( "\n | %2d |", l );
for( c = 0; c < COL; c++ )
printf( " %5.2lf |", M[l][c] );
}
printf("\n +-----+-------+-------+-------+-------+" );
return 0;
}
O Comentário 8.2 discute as matrizes C e sua associação com a EI for.
Comentário 8.2 Matrizes e a Linguagem C
A linguagem C exige que o número de linhas e o número de colunas das matrizes sejam
constantes inteiras – não podem ser variáveis, por isso são denominadas matrizes
estáticas. O tamanho das matrizes C são pré-definidos e fixos em todo programa-fonte.
É comum a seguinte declaração na linguagem C para uma matriz:
#define LIN 20 // constante

#define COL 20 // constante
float M[LIN][COL]; // M possui 400 elementos do tipo float
Para fazer referência a um dos valores da matriz, basta usar o nome da matriz e indicar a
linha e a coluna desejados, lembre–se que a linha varia de 0 a LIN–1, em que a coluna varia
de 0 a COL–1.
Observe que o padrão usado para percorrer a matriz M:
M[0][0], M[0][1], M[0][2], …, M[0][19],

M[1][0], M[1][1], M[1][2], …, M[1][19],
M[2][0], M[2][1], M[2][2], …, M[2][19],
M[19][0], M[19][1], M[12][2], …, M[19][19], ou seja, M[l][c], 0 ≤ l < LIN-1 e 0 ≤ c < COL-1,
é similar ao padrão de duas instruções for.
Matrizes podem ser manipulados na linguagem C por meio de duas instruções for, eles
foram feitos um para o outro, da seguinte forma:
#define LIN 20 // número de linhas – valor fixo

#define COL 20 // número de colunas – valor fixo
int l, c; // contadores para for

double M[LIN][COL];
for( l = 0; l < LIN; l++ ){ // percorre as linhas

for( c = 0; c < COL; c++ ){ // percorre as colunas da linha l
// instruções para manipular cada elemento M[l][c]
}
}
E também
const int LIN = 20,

COL = 20;
int l, c;
double M[LIN][COL];
for( l = 0; l < LIN; l++ ){
for( c = 0; c < COL; c++ ){
// instruções para manipular cada elemento M[l][c] da matriz M
}
}
Nas estruturas de iteração acima, a primeira instrução for varia o seu índice de iteração de
0 a LIN–1, este contador é usado como índice das linhas da matriz M. A medida que l
aumenta de um em um, o bloco é executado e percorre–se as linhas da matriz M, uma a
uma, do início ao fim.
A segunda instrução for varia o seu contador de iteração de 0 a COL–1, este contador é
usado como índice das colunas dos elementos da linha l matriz M. A medida que c aumenta
de um em um, o bloco é executado e percorre–se as colunas da linha l da matriz M, uma a
uma, do início ao fim.
Os dois for em conjunto, ao variar seus contadores de iteração, percorre as linhas da matriz
A de cima para baixo e as colunas de cada linha são percorridas da esquerda para a direita,
permitindo operar cada elemento A[l][c], um a um.
Por vezes, digitar valores de vetores e uma tarefa enfadonha, o Programa 8.12 discute
uma forma de gerar valores de vetores escrevê-los na tela.
Programa 8.12 Gerar e escreve uma matriz do tipo double de 3 linhas e 4 colunas,
formatada
A solução do Programa 8.12 é similar ao Programa 8.11, exceto que o valor de M[l][c]
gerado aleatoriamente, com a instrução M[l][c] = rand() % 100, que gera valores de 0 a 99.
Programa-fonte
#include <stdio.h>
#include <stdlib.h>
#define LIN 3
#define COL 4
int main( void ){

int l, c;
double M[LIN][COL];
printf("\n Gerando M" );
for( l = 0; l < LIN; l++ )
for( c = 0; c < COL; c++ )
M[l][c] = rand() % 100;
printf("\n Escrevendo M" );
printf("\n +-----+-------+-------+-------+-------+" );
printf("\n | l/c |" );
for( c = 0; c < COL; c++ )
printf( " %2d |", c );
printf("\n +-----+-------+-------+-------+-------+" );
for( l = 0; l < LIN; l++ ){
printf( "\n | %2d |", l );
for( c = 0; c < COL; c++ )
printf( " %5.2lf |", M[l][c] );
}
printf("\n +-----+-------+-------+-------+-------+" );
return 0;
}
8.2.1. Matriz como Parâmetro de Função
Funções C podem receber matrizes como parâmetros. Seja int M[3][4] uma matriz, como
declarada abaixo.
#define LIN 3
#define COL 4
int M[LIN][COL] = { {1, 2, 3, 4}, {1, 3, 5, 7}, {2, 4, 6, 8} };
A função f é a forma mais geral de receber matriz como parâmetro de função.
void f( int M[LIN][COL] );
No Programa 8.13 a função escrever recebe uma matriz como parâmetro.
Programa 8.13 Escrevendo matriz usando funções
A função Escrever do tipo void e parâmetro int X[LIN][COL] é declada. Na função main é
criada a matriz int M[LIN][COL], com os valores conforme mostrado abaixo. A função main
chama Escrever com argumento M, o fluxo de controle é transferido para função Escrever e
os valores de X são escritos na tela do computador.
Programa-Fonte
#include<stdio.h>
#define LIN 3
#define COL 4
void Escrever( int X[LIN][COL] ){
int l, c;
printf("\n M ");
for( l = 0; l < LIN; l++ ){
printf( "\n" );
for( c = 0; c < COL; c++ )
printf( " %d ", X[l][c] );
}
}
int main( void ){
int M[LIN][COL] = { { 1, 2, 3, 4 },
{ 1, 3, 5, 7 },
{ 2, 4, 6, 8 } };
Escrever(M);
return 0;
}
No Programa 8.14 permite a leitura e a impressão matrizes usando funções.
Programa 8.14 Leitura e impressão dos valores de uma matriz double usando funções
A solução do Programa 8.14 é similar ao Programa 8.13, reescrito na forma de função.
Programa-fonte
#include<stdio.h>
#define M 3
#define N 4
void Leitura( double X[M][N] ){
int l, c;
for( l = 0; l < M; l++ ){
for( c = 0; c < N; c++ ){
printf( " De o valor de X[%d][%d]: ", l, c );
scanf ( "%lf", &X[l][c] );
// X[l][c] = rand() % 100;
}
}
}
void Impressao( double X[M][N] ){
int l, c;
printf("\n M\n----------------------------");
for( l = 0; l < M; l++ ){
printf( "\n" );
for( c = 0; c < N; c++ )
printf( " %6.2lf", X[l][c] );
}
}
int main( void ){
double A[M][N];
printf("\n Leitura de M\n" );
Leitura(A);
printf("\n Impressao formatada de M" );
Impressao(A);
return 0;
}
No Programa 8.15 gera e imprime matrizes usando funções.
Programa 8.15 Gerando e imprimindo dos valores de uma matriz double usando funções
A solução do Programa 8.15 é similar aos do Programa 8.12 e Programa 8.14.
Programa-Fonte
#include <stdio.h>
#include <stdlib.h>
#define M 3
#define N 4
void Gerar( double X[M][N] ){

int l, c;
for( l = 0; l < M; l++ ){
for( c = 0; c < N; c++ ){
X[l][c] = rand() % 100;
}
}
}
void Imprimir( double X[M][N] ){
int l, c;
printf("\n M\n----------------------------");
for( l = 0; l < M; l++ ){
printf( "\n" );
for( c = 0; c < N; c++ )

printf( " %6.2lf", X[l][c] );
}
}
int main( void ){
double A[M][N];
printf("\n Gerando M\n" );
Gerar(A);
printf("\n Imprimindo M formatada" );
Imprimir(A);
return 0;
}
8.2.2. Álgebra de Matrizes
Sejam as matrizes A, B, C = A+B, S = A-B e P = kA, k real. Estas operações com matri-
zes podem escritas em C usando dois for, como está destacado no Programa 8.16.
Programa 8.16 Leitura de A e B matrizes de tamanho mxn, cálculo e impressão de C = A +

B, S = A – B e P = k A, k número float.
Este programa ilustra o uso e o reúso de funções, nele são declaradas três
funções, leitura, calculo e impressao, além de main; leitura é chamada duas
vezes, calculo uma e impressao cinco.
Programa-Fonte
#include <stdio.h>
#define m 3
#define n 4
void leitura( float X[m][n] ){
int l, c;
for( l = 0; l < m; l++ ){
for( c = 0; c < n; c++ ){
printf( " Valor de X[%d][%d]: ", l, c );
scanf ( "%f", &X[l][c] );

}
}
}
void calculo( float k, float A[m][n], float B[m][n],
float C[m][n], float S[m][n], float P[m][n] ){
int l, c;
for( l = 0; l < m; l++ ){
for( c = 0; c < n; c++ ){
C[l][c] = A[l][c] + B[l][c];
S[l][c] = A[l][c] - B[l][c];
P[l][c] = k*A[l][c];
}
}
}
void impressao( float X[m][n] ){
int l, c;
for( l = 0; l < m; l++ ){
printf( "\n" );
for( c = 0; c < n; c++ ){
printf(" %5.1f ", X[l][c] );
}
}
}
int main( void ){
int l, c;
float A[m][n], B[m][n], C[m][n], S[m][n], P[m][n], k;
printf( "\n Leitura de A\n" ); leitura( A );

printf( "\n Leitura de B\n" ); leitura( B );
printf( "\n Valor de k: " );
scanf ( "%f", &k );
printf( "\n Calculo de C, S e P" ); calculo(k,A,B,C,S,P);
printf( "\n Impressao de A" ); impressao(A);

printf( "\n Impressao de B" ); impressao(B);
printf( "\n Impressao de C" ); impressao(C);
printf( "\n Impressao de S" ); impressao(S);
printf( "\n Impressao de P" ); impressao(P);
return 0;
}

8.2.2.1. Operações com Linhas, Colunas e Diagonais de Matriz
Antes de seu uso em Computação, a Matemática já usava matrizes e o Comentário 8.3

tratar destes conceitos que são úteis para o elaboração de programas C.
Comentário 8.3 Conceitos relacionados às matrizes
Matriz Quadrada – matriz quadrada tem número de linhas igual ao número de colunas, ou
seja, Am×n é quadrada se m = n.
Matriz Transposta – dada a matriz Am×n, com A = [al,c], 0 ≤ l < m e 0 ≤ c < n, sua
transposta é a matriz Tn×m, com T=[tc,l], 0 ≤ l < m e 0 ≤ c < n.
Matriz Simétrica – a matriz quadra Am×m, com A = [al,c], 0 ≤ l < m e 0 ≤ c < m, é simétrica
al,c = ac,l.
Seja a matriz A[m][n], a seguir estão definidos as operações com linha, coluna e as
diagonais desta matriz e seu algoritmo.
Operações com Linhas
Pode-se processar uma única linha da matriz A. Seja k a linha da matriz Am,n a ser
processada. Os elementos desta linha são ak,0 ak,1 ak,2 … ak,c … ak,n-1, para 0 ≤ c < n.
Para processar todos os elementos da linha k é suficiente um for que varie o índice da
coluna e que faça a operação desejada sobre cada elemento da linha k e coluna c.
Operações com Colunas
Pode-se processar uma única coluna da matriz A. Seja k a coluna da matriz Am,n a ser
processada. Os elementos desta coluna são a 0,k a1,k a2,k … al,k … am-1,k, para 0 ≤ l < m.
Para processar todos os elementos da coluna k é suficiente um for que varie o índice da
linha e que faça a operação desejada sobre cada elemento da linha l e coluna k.
Operações com a Diagonal Principal
A diagonal principal de uma matriz quadrada é constituída pelos elementos que possuem
índice da linha igual ao índice da coluna. Os elementos da diagonal principal de uma matriz
quadrada Am,m são a0,0 a1,1 a2,2 … al,l … am-1,m-1, para 0 ≤ l < m.
Para processar todos os elementos da diagonal principal é suficiente um for que varie o
índice da linha e que faça a operação desejada sobre cada elemento da linha l e coluna l.
Operações com a Diagonal Secundária
A diagonal secundária de uma matriz quadrada é constituída pelos elementos que a soma
dos índices da linha da coluna seja igual a m-1. Os elementos da diagonal secundária de
uma matriz quadrada Am,m são a0,m-1 a1,m-2 a2,m-3 … al,m-1-l … am-1,0, para 0 ≤ l < m.
Para operar sobre todos os elementos da diagonal secundária é suficiente um for que varie
o índice da linha e que faça a operação desejada sobre cada elemento da linha l e coluna
m-1-l.
O Programa 8.17 usa funções para calcular a soma de uma única linha ou de uma única
coluna de uma matriz.
Programa 8.17 Obtenção da soma das linhas e das colunas de uma matriz
Os dados de entrada são os valores gerados para a matriz A pela função Gerar.
Os dados de saída são as somas de cada linha e cada coluna da matriz A.

São necessário declara a matriz A[M][N], e seus contadores l e c, ambos do tipo int. As
constantes M e N são declaradas como #define.
Para obter a soma das linhas de A, será usada um for para percorrer as linhas de A,
nomeado for linha. Dentro do for linha será declarada a variável S para a soma das linhas,
ela será to tipo for e valor inicial zero (0.0). Ainda dentro for linha, será usada um for para
percorrer as colunas de A, nomeado for coluna. Dentro do for coluna será adicionado a
instrução para soma S com o valor de cada elemento A[l][c]. Ao encerrar o for coluna,
imprime-se S que corresponde a soma da linha l.
Os dois for em conjunto permite somar linha a linha de A. Inicialmente, o for linha tem l =
0. A variável S é declarada e tem valor S = 0.0. O for coluna percorre a linha l = 0 e soma
todos os valores A[0][c]. Encerrado o for coluna o valor de S é impresso e corresponde a
soma da linha 0.
O for linha avança para a próxima linha, l = 1. A variável S é declarada e tem valor S = 0.0.
O for coluna percorre a linha l = 1 e soma todos os valores A[1][c]. Encerrado o for coluna o
valor de S é impresso e corresponde a soma da linha 1. E assim por diante até a linha n-1.
No algoritmo abaixo o for linha está destacado com fundo vermelho e o for coluna com
fundo azul.
O algoritmo para calcular as somas das colunas é similar ao das linhas, exceto que devem
ser trocadas as posições dos for linha e for coluna.
No algoritmo abaixo o for linha está destacado com fundo verde e o for coluna com fundo
azul.
m Linhas da matriz int 3 E
n Colunas da Matriz int 4 E
A Matriz m x n float - P
X Matriz m x n float - P
l Índice para linha int 0, for P
c Índice para coluna int 0, for P
k Índice para linha ou coluna int - P
S Acumulador float 0.0 P
Dicionário de Funções
Função Descrição Tipo Parâmetros
Gerar Gera dados aleatórios void X
Imprimir Imprime dados void X
SomaLinha Soma linha float k, X
SomaColuna Soma coluna float k, X
Programa-fonte
#include <stdio.h>
#include <stdlib.h>
#define m 3
#define n 4
void Gerar( float X[m][n] ){

int l, c;
for( l = 0; l < m; l++ )
for( c = 0; c < n; c++ )
X[l][c] = rand() % 10;
}
void Imprimir( float X[m][n] ){
int l, c;
for( l = 0; l < m; l++ ){
printf( "\n" );
for( c = 0; c < n; c++ ){
printf(" %5.1f ", X[l][c] );
}
}
}
float SomaLinha( int k, float X[m][n] ){
int c;
float S = 0.0;
for( c = 0; c < n; c++ )
S = S + X[k][c];
return S;
}
float SomaColuna( int k, float X[m][n] ){
int l;
float S = 0.0;
for( l = 0; l < m; l++ )
S = S + X[l][k];
return S;
}
int main( void ){
int l, c;
float A[m][n];
printf("\n Gerando A" );
Gerar(A);
printf( "\n Imprimir A" ); Imprimir(A);
printf( "\n\n Soma das linhas de A" );
for( l = 0; l < m; l++ )
printf( "\n Soma da linha %d = %5.1f", l, SomaLinha (l,A) );
printf( "\n\n Soma das colunas de A" );
for( c = 0; c < n; c++ )
printf( "\n Soma da coluna %d = %5.1f", c, SomaColuna(c,A) );
return 0;
}
O Programa 8.18 usa funções para calcular a soma das diagonais principal e secundária
de uma matriz.
Programa 8.18 Obtenha e imprima a soma das diagonais principal e secundária da matriz A
de dimensão 4 x 4
Os dados de entrada são os valores do vetor A – sejam ele do tipo float.

Os dados de saída são as somas e os valores máximo e mínimo das diagonais da matriz A.
São necessário declara a matriz A[M][M], e seus contadores l e c, ambos do tipo int. A
constante M será declarada como #define.
Para a diagonal principal serão declaradas:
• a variável Sdp do tipo float para sua soma, com valor inicial zero (0.0)
• a variável DPmin do tipo float para seu mínimo, com valor inicial A[0][0]
• a variável DPmax do tipo float para seu máximo, com valor inicial A[0][0]
Para a diagonal secundária serão declaradas:
• a variável Sds do tipo float para sua soma, com valor inicial zero (0.0)
• a variável DSmin do tipo float para seu mínimo, com valor inicial A[0][N-1]
• a variável DSmax do tipo float para seu máximo, com valor inicial A[0][N-1]
Serão usados apenas um for para os cálculos com as instruções descritos no Comentário
8.3. A final deste do for serão impressos os valores solicitados.
As instruções para os valores iniciais para DPmin, DPmax, DSmin e DSmax devem ser
colocados após a leitura dos valores de A e não antes.
Programa-fonte
#include <stdio.h>
#include <stdlib.h>
#define m 5
void Gerar( float X[m][m] ){

int l, c;
for( l = 0; l < m; l++ )
for( c = 0; c < m; c++ )
X[l][c] = rand() % 20;
}
void Imprimir( float X[m][m] ){
int l, c;
for( l = 0; l < m; l++ ){
printf( "\n" );
for( c = 0; c < m; c++ ){
printf(" %5.1f ", X[l][c] );
}
}
}
float SomaDp( float X[m][m] ){
int l;
float S = 0.0;
for( l = 0; l < m; l++ )
S = S + X[l][l];
return S;
}
float SomaDs( float X[m][m] ){
int l;
float S = 0.0;
for( l = 0; l < m; l++ )
S = S + X[l][m-1-l];
return S;
}
int main( void ){
int l, c;
float A[m][m];
printf("\n Gerando A" );
Gerar(A);
printf( "\n Imprimir A" ); Imprimir(A);
printf( "\n\n Soma das Diagonais de A" );
printf( "\n Principal = %5.1f", SomaDp(A) );
printf( "\n Secundária = %5.1f", SomaDs(A) );
return 0;
}
8.2.2.2. Valores Extremos de Matriz
Os valores extremos de uma matriz são os valores mínimo e máximo de todos os ele-
mentos da matriz. Pode-se também obter os valores extremos de linhas, colunas, diagonais e
outras partes da matriz.
As operações envolvendo valores extremos de matrizes incluem determinar estes valo-
res e também seus índices (linha e coluna). O Quadro 8.2 estabelece os procedimentos com-
putacionais para a obtenção dos valores extremos de matrizes.
Quadro 8.2 Algoritmo para obtenção dos valores mínimo e máximo de matrizes
Valor Extremo Procedimento

Seja M[m][n] uma matriz. Cria-se uma variável Xn. O valor inicial de Xn deve
ser o do primeiro elemento da matriz, Xn = M[0][0]. Percorrer a matriz com
Mínimo duas estruturas de iteração (EI), uma para a linha(0 ≤ l < m) e outra para
coluna(0 ≤ c < n), e acrescentar a instrução if( Xn > M[l][c] ) Xn = M[l]. Ao
sair das EIs, o valor de Xn é o valor mínimo da matriz.
Seja M[m][n] uma matriz. Cria-se uma variável Xx. O valor inicial de Xx deve
ser o do primeiro elemento da matriz, Xx = M[0][0]. Percorrer a matriz com
Máximo duas estruturas de iteração (EI), uma para a linha(0 ≤ l < m) e outra para
coluna (0 ≤ c < n), e acrescentar a instrução if( Xx < M[l][c] ) Xx = M[l][c]. Ao
sair das EIs, o valor de Xx é o valor máximo da matriz.
O Programa 8.19 calcula os valores extremos de uma matriz como descrito no Quadro
8.2.
Programa 8.19 Obtenha os valores mínimo e máximo de uma matriz
Os dados de entrada são os valores da matriz A do tipo float.

Os dados de saída são os valores mínimo e máximo da matriz A, sejam eles Xn e Xx, ambos
float – mesmo tipo de A.
Inicialmente, devem ser gerados os valores da matriz.
Fazer Xn = X[0][0], linha 22.
Fazer Xx = X[0][0], linha 30.
Dentro do for serão colocados as instruções conforme o Quadro 8.2.
Ao sair do for, serão impressos os valores Xn e Xx, retornados pelas funções Minimo e
Maximo, respectivamente.
Tipo de Valor
Variável Descrição Processo
Dado Inicial
m Linhas da matriz int 3 E
n Colunas da Matriz int 4 E
A Matriz m x n float - P
X Matriz m x n float - P
l Índice para linha int 0, for P
c Índice para coluna int 0, for P
Xn Valor mínimo de X float X[0][0] S
Xx Valor máximo de X float X[0][0] S
Dicionário de Funções
Função Descrição Tipo Parâmetros
Gerar Gera valores aleatórios para X void X
Imprimir Imprime os valores de X void X
Minimo Retorna o valor mínimo de X float X
Maximo Retorna o valor mínimo de X float X
L Programa-fonte
3 #define m 4
4 #define n 6
5 void Gerar( float X[m][n] ){
6 int l, c;
7 for( l = 0; l < m; l++ )
8 for( c = 0; c < n; c++ )
9 X[l][c] = rand() % 100;
10 }
11 void Imprimir( float X[m][n] ){
12 int l, c;
13 for( l = 0; l < m; l++ ){
14 printf( "\n" );
15 for( c = 0; c < n; c++ ){
16 printf(" %5.1f ", X[l][c] );
17 }
18 }
19 }
20 float Minimo( float X[m][n] ){
21 int l, c;
22 float Xn = X[0][0];
23 for( l = 0; l < m; l++ )
24 for( c = 0; c < n; c++ )
25 if( Xn > X[l][c] ) Xn = X[l][c];

26 return Xn;
27 }
28 float Maximo( float X[m][n] ){
29 int l, c;
30 float Xx = X[0][0];
31 for( l = 0; l < m; l++ )
32 for( c = 0; c < n; c++ )
33 if( Xx < X[l][c] ) Xx = X[l][c];
34 return Xx;
35 }
37 float A[m][n];
38 printf("\n Gerando A" );
39 Gerar(A);
40 printf( "\n Imprimir A" ); Imprimir(A);
41 printf( "\n Mínimo de A = %5.1f", Minimo(A) );
42 printf( "\n Máximo de A = %5.1f", Maximo(A) );
43 return 0;
44 }
8.2.2.3. Pesquisa em Matriz
Dado uma matriz M[m][n], como verificar se um determinado valor x é elemento desta
matriz?
Sejam l e c índices de M, a solução mais simples para verificar se x ∈ M é a chamada
pesquisa sequencial: fazer l variar de 0 até m-1, c variar de 0 até n-1 e verifica se M[l][c] ==
x.
Criando as variáveis:
#define m 3
#define n 4
int l, c;
int x = 9, M[m][n] = { { 1, 2, 3, 4 }{ 2, 4, 6, 8 }, { 3, 6, 9, 0 } };
Algoritmo da pesquisa sequencial:

for( l = 0; l < m; l++ ){

for( c = 0; c < n; c++ ){
if( M[l][c] == x ) pertence = true;
}
Avaliação da pesquisa sequencial:
if( pertence ) printf( "\n Valor encontrado" );

O problema de pesquisa é muito estudado e possui muitas soluções, o Programa 8.20 é

uma solução bem simples deste problema.
Programa 8.20 Busca em matriz – verificar se a matriz contém o número 9
Os dados de entrada são os valores da matriz M, de m linhas e n colunas, com os valores

iniciais definidos abaixo. T também o valor de x a ser encontrado.
Os dados de saída são os índices de x em M, se x for encontrado em M e, caso contrário, a

mensagem informando que x não foi encontrado em M.
Cria-se uma variável pertence, do tipo bool, com valor incial false.
São usados dois for, o primeiro com o índice l, com l variando de 0 a m-1, e o segundo com
o índice c, com c variando de 0 a n-1; dentro destes dois for verificar se M[l][c] == x para
cada valor de l e c; em caso afirmativo atribuir true à variável pertence e encerrar ao EI
com a instrução break.
Ao final do for, se x pertencer à matriz M, o for foi interrompido nos índices l e c, que
corresponde a posição de x em M, e a variável pertence assumiu o valor true. Se x não
pertencer à matriz M, o for não foi interrompido e a variável pertence continua com valor
false.
Desta forma, imprime-se que x pertence a M na posição l,c, caso contrário, imprime-se que
x não pertence a M.
Programa-fonte
#include <stdio.h>
#define m 3
#define n 4
int main( void ){
int l, c,
x = 9,
M[m][n] = { { 1, 2, 3, 4 },
{ 2, 4, 6, 8 },
{ 3, 6, 9, 0 } };
for( l = 0; l < m; l++ )

for( c = 0; c < n; c++ )
if( M[l][c] == x ){
pertence = true;
break;
}
printf( "\n Busca do valor %d", x );

if( pertence ){
printf( "\n Valor encontradona" );
printf( "\n linha %d", l );
printf( "\n coluna %d", c );
}
return 0;
}
8.2.3. Outras Operações com Matrizes
Além das operações usuais com matrizes, a computação permite maneiras do manipular
matrizes como, por exemplo, as imagens que podem ser tratadas como matrizes. Além das
temos as tabelas dos bancos de dados e ainda seus vários usos na Álgebra Linear, Equações
Diferenciais e na Física. Outras soluçãoes de engenharia envolvendo matrizes podem ser
consultados no livro “Numerical Recipes in C” (Press, 1992).
O Programa 8.21 é uma aplicação mas ilustra bem o que se pode fazer com matrizes. Os
exercícios complementam este tópico.
Programa 8.21 Implemente um programa para calcular e mostrar a soma dos elementos da
área hachurada da matriz abaixo.
Para M = 7, o problema requer a soma dos elementos das posições com asterisco na matriz
abaixo, em que P e S indicam os elementos das diagonais principal e secundária,
respectivamente.
0 1 2 3 4 5 6
0 P ⋅ ⋅ ⋅ ⋅ ⋅ S
1 * P ⋅ ⋅ ⋅ S ⋅
2 * * P ⋅ S ⋅ ⋅
3 * * * P ⋅ ⋅ ⋅
4 * * S ⋅ P ⋅ ⋅
5 * S ⋅ ⋅ ⋅ P ⋅
6 S ⋅ ⋅ ⋅ ⋅ ⋅ P
As posições marcadas com asterisco estão abaixo da diagonal principal (l > c) e acima da
diagonal secundária (c < M-l-1).
A condição para identificar os números hachurados é (l > c) && (c < M-l-1) em que l e c são
índices das linhas e das colunas da matriz, respectivamente.
Plano de Teste
Seja a matriz 7 x 7 abaixo, a soma dos elementos hachurados é S = 514.
[ ]
S = 92 + 63 + 26 + 68 + 67 + 29 + 67 + 35 + 67 = 514
83 86 77 15 93 35 86
92 49 21 62 27 90 59
63 26 40 26 72 36 11
A 7 x7 = 68 67 29 82 30 62 23
67 35 37 12 22 58 69
67 93 56 11 42 29 73
21 19 84 37 98 24 15
Programa-fonte
#include <stdio.h>
#define M 7
int main (void ){

int l, c;
double A[M][M] = {
{ 83.0, 86.0, 77.0, 15.0, 93.0, 35.0, 86.0 },
{ 92.0, 49.0, 21.0, 62.0, 27.0, 90.0, 59.0 },
{ 63.0, 26.0, 40.0, 26.0, 72.0, 36.0, 11.0 },
{ 68.0, 67.0, 29.0, 82.0, 30.0, 62.0, 23.0 },
{ 67.0, 35.0, 37.0, 12.0, 22.0, 58.0, 69.0 },
{ 67.0, 93.0, 56.0, 11.0, 42.0, 29.0, 73.0 },
{ 21.0, 19.0, 84.0, 37.0, 98.0, 24.0, 15.0 },
};
double S = 0.0;
for( l = 0; l < M; l++ ){

printf( "\n" );
for( c = 0; c < M; c++ )
printf( " %3.1lf ", A[l][c] );
}
for( l = 0; l < M; l++ )

for( c = 0; c < M; c++ )
if( (l > c) && (c < M-l-1) ) S += A[l][c];
printf("\n\nSoma dos elementos da area hachurada = %.1lf", S );

return 0;
}
1. Faça um programa que preencha uma matriz M x N com números inteiros, calcule e
mostre a quantidade de elementos entre 15 e 20. Teste seu programa com M = 6 e N = 4.
2. Crie um programa que preencha uma matriz M x N com números inteiros, calcule e
mostre: a) a quantidade de elementos entre 12 e 20 em cada linha; b) a média dos
elementos pares da matriz. Teste seu programa com M = 6 e N = 4.
3. Ler k elementos de uma matriz A. Construir uma matriz B de mesmo tipo, com a
seguinte lei de formação: todo elemento da matriz B deverá ser o quadrado do elemento
de A correspondente. Teste seu programa k = 4 x 3.
4. Elabore um programa que preencha uma matriz M x N, calcule e mostre: a) o maior
elemento da matriz e sua respectiva posição, ou seja, linha e coluna; b) o menor
elemento da matriz e sua respectiva posição, ou seja, linha e coluna. Teste seu programa
com M = 4 e N = 3.
5. Faça um programa que receba: a) as notas de M alunos em N provas diferentes e
armazene-as em uma matriz M x N; b) os nomes dos M alunos e armazene-os em um
vetor de M posições. O programa deverá calcular e mostrar: a) para cada aluno, o nome,
a média aritmética das cinco provas e a situação (aprovado, reprovado ou exame); b) a
média da classe. Teste seu programa com M = 15 e N = 5.
6. Elabore um programa que preencha uma matriz M x N com os valores das vendas de
uma loja, em que cada linha representa um mês do ano e cada coluna representa uma
semana do mês. O programa deverá calcular e mostrar: a) o total vendido em cada mês
do ano, mostrando o nome do mês por extenso; b) o total vendido em cada semana
durante todo o ano; c) o total vendido pela loja no ano. Teste seu programa com M = 12 e
N = 4.
7. Faça um programa que preencha uma matriz M x N com números inteiros, e some cada
uma das colunas, armazenando o resultado da soma em um vetor. A seguir, o programa
deverá multiplicar cada elemento da matriz pela soma da coluna e mostrar a matriz
resultante. Teste seu programa com M = 20 e N = 10.

8. Elabore um programa que preencha uma matriz A de ordem M x N e uma segunda
matriz B de ordem N x M, calcule e imprima a soma das linhas de A com as colunas de B.
Teste seu programa com M = 6 e N = 4.
9. Crie um programa que preencha duas matrizes M x N com números inteiros, calcule e
mostre: a) a soma das duas matrizes, resultando em uma terceira matriz também de
ordem M x N; b) a diferença das duas matrizes, resultando em uma quarta matriz também
de ordem M x N. Teste seu programa com M = 6 e N = 4.
10.Faça um programa que preencha uma matriz M x N com números reais e outro valor
numérico digitado pelo usuário. O programa deverá calcular e mostrar a matriz resultante
da multiplicação do número digitado pelos elementos da matriz. Teste seu programa com
M = 6 e N = 4.
11.Crie um programa que preencha uma matriz M x M com números inteiros, calcule e
mostre a soma: a) dos elementos da linha 2; b) dos elementos da coluna 1; c) dos
elementos da diagonal principal; c) dos elementos da diagonal secundária; d) de todos os
elementos da matriz.
12.Elabore um programa que: receba a idade de oito alunos e armazene-as em um vetor;
armazene o código de cinco disciplinas em outro vetor; armazene em uma matriz a
quantidade de provas que cada aluno fez em cada disciplina. O programa deverá calcular
e mostrar: a) a quantidade de alunos com idade entre 18 e 25 anos que fizeram mais de
duas provas em determinada disciplina cujo código é digitado pelo usuário. O usuário
poderá digitar um código não cadastrado; nesse caso, o programa deverá mostrar uma
mensagem de erro; b) uma listagem contendo o código dos alunos que fizeram menos que
três provas em determinada disciplina, seguido do código da disciplina; c) a média de
idade dos alunos que não fizeram nenhuma prova em alguma disciplina. Cuidado para não
contar duas vezes o mesmo aluno.
13.Elabore um programa que preencha uma matriz M x N; recalcule a matriz digitada,
onde cada linha deverá ser multiplicada pelo maior elemento da linha em questão; mostre
a matriz resultante. Teste seu programa com M = 8 e N = 6.
14.Faça um programa que preencha uma matriz M x N, calcule e mostre a quantidade de
elementos da matriz que não pertencem ao intervalo [5,15]. Teste seu programa com M =
4 e N = 3.
15.Crie um programa que preencha uma matriz M x N e divida todos os elementos de cada
linha pelo maior elemento em módulo daquela linha. O programa deverá escrever a matriz
lida e a modificada. Teste seu programa com M = 6 e N = 4.
16.Elabore um programa que preencha uma matriz M x M e crie dois vetores de M
posições cada um, que contenham, respectivamente, as somas das linhas e das colunas
da matriz. O programa deverá escrever a matriz e os vetores criados. Teste seu programa
com M = 8.
17.Faça um programa que preencha e mostre a média dos elementos da diagonal
principal de uma matriz M x M. Teste seu programa com M = 8.
18.Crie um programa que preencha uma matriz M x M de números reais, calcule e mostre
a soma dos elementos da diagonal secundária. Teste seu programa com M = 5.
19.Faça um programa que preencha uma matriz M x N de inteiros, calcule e mostre a
média dos elementos das linhas pares da matriz. Teste seu programa com M = 8 e N = 6.
20.Elabore um programa que preencha uma matriz M x N com números reais e encontre o
maior valor da matriz. A seguir, o programa deverá multiplicar cada elemento da diagonal
principal pelo maior valor encontrado e mostrar a matriz resultante após as multiplicações.
Teste seu programa com M = .
21.Faça um programa que preencha uma matriz M x M de números reais. A seguir, o
programa deverá multiplicar cada linha pelo elemento da diagonal principal daquela linha
e mostrar a matriz após as multiplicações. Teste seu programa com M = 6.
22.Crie um programa que preencha uma matriz M x N, some as colunas individualmente e

acumule as somas na linha M+1 da matriz. O programa deverá mostrar o resultado de
cada coluna. Teste seu programa com M = 6 e N = 10.
23.Uma empresa trabalha com M produtos e N armazéns localizados de modo estratégico.
Faça um programa de modo a permitir responder às questões: a) a quantidade de itens
armazenados em cada armazém; b) qual armazém possui menor estoque; c) qual o custo
total de cada produto; d) qual o custo total de cada armazém. Teste seu programa com M
= 3 e N = 5.
24.Crie um programa que: a) receba o preço de dez produtos e armazene-os em um vetor;
b) receba a quantidade estocada de cada um desses produtos, em cinco armazéns
diferentes, utilizando uma matriz 5 x 10. O programa deverá calcular e mostrar: a) a
quantidade de produtos estocados em cada um dos armazéns; b) a quantidade de cada
um dos produtos estocados, em todos os armazéns juntos; c) o preço do produto que
possui maior estoque em um único armazém; d) o menor estoque armazenado; e) o custo
de cada armazém.
25.Dada uma matriz Amxn, faça um algoritmo que calcule o desvio padrão dos elementos a ij
√
N
em que i = 2×j. O desvio padrão (s) é ∑ (x i− x̄ )2 1

N
.
s= i=1
, x̄= ∑ x i
N−1 N i=1
26.Tem-se uma matriz de dados contendo altura e sexo, faça um programa em C que
calcule e escreva a maior e a menor altura do grupo, a altura média das mulheres e o
número de homens.
27.Escreva uma função em C para imprimir na saída padrão a tabuada da soma de 1 a 5
formatada:
a + b = s a + b = s a + b = s a + b = s a + b = s
1 + 1 = 2 2 + 1 = 3 3 + 1 = 4 4 + 1 = 5 5 + 1 = 6
1 + 2 = 3 2 + 2 = 4 3 + 2 = 5 4 + 2 = 6 5 + 2 = 7
1 + 3 = 4 2 + 3 = 5 3 + 3 = 6 4 + 3 = 7 5 + 3 = 8
1 + 4 = 5 2 + 4 = 6 3 + 4 = 7 4 + 4 = 8 5 + 4 = 9
1 + 5 = 6 2 + 5 = 7 3 + 5 = 8 4 + 5 = 9 5 + 5 = 10
1 + 6 = 7 2 + 6 = 8 3 + 6 = 9 4 + 6 = 10 5 + 6 = 11
1 + 7 = 8 2 + 7 = 9 3 + 7 = 10 4 + 7 = 11 5 + 7 = 12
1 + 8 = 9 2 + 8 = 10 3 + 8 = 11 4 + 8 = 12 5 + 8 = 13
1 + 9 = 10 2 + 9 = 11 3 + 9 = 12 4 + 9 = 13 5 + 9 = 14
1 + 10 = 11 2 + 10 = 12 3 + 10 = 13 4 + 10 = 14 5 + 10 = 15
28.Dados duas matrizes A e B de tamanho M x N, faça um programa que calcule a soma
dos produtos de aij pelos demais elementos da A e atribua este resultado a bij, e imprima
A e B formatadas.
29.Um estudante registrou as notas abaixo nas disciplinas. Todas as avaliações possuem o
mesmo peso. Calcule a média de cada disciplina. A menor nota de cada disciplina. A maior
nota de cada disciplina. A menor nota dentre todas as disciplinas. A maior nota dentre
todas as disciplinas. A menor nota dentre todas as avaliações. A maior nota dentre todas
as avaliações. A média das médias das disciplinas.
Disciplina Avaliação 1 Avaliação 2 Avaliação 3 Avaliação 4
CCMP0057 6,1 7,3 7,9 8,7
CCMP0077 9,2 9,8 9,7 7,1
CCMP0080 7,3 6,0 9,3 8,3
CCMP0084 7,9 8,0 6,2 6,9
CCMP0088 7,6 7,6 9,8 7,1
CCMP0092 9,6 9,0 8,9 6,4

30.Dada uma matriz Amxn, faça um programa C para calcular a matriz Bmxn tal que
k l
b k, l=∑ ∑ ai , j para 0 ≤ k < m e 0 ≤ l < n. Teste seu programa com as matrizes
[ ] [ ]
i=0 j=0
4 4 −6 −1 1 2 3 4 5
0 −7 7 8 6 7 8 9 10
A= −5 2 −1 7 e B= 11 12 13 14 15 .
3 9 −8 0 16 17 18 19 20
5 −8 −1 −1 21 22 23 24 25
31.Escreva um programa em C para ler números inteiros (n) da entrada padrão. Um valor
negativo indicar o fim dos dados de entrada. Calcular e imprimir a tabuada formatada de n
na saída padrão, como no exemplo abaixo, para n = 10.
n 10 10 10 10 10 10 10 10 10 10
p 1 2 3 4 5 6 7 8 9 10
+ 11 12 13 14 15 16 17 18 19 20
- 9 8 7 6 5 4 3 2 1 0
* 10 20 30 40 50 60 70 80 90 100
32.Escreva um programa em C para ler números inteiros (n) da entrada padrão. Um valor
negativo indicar o fim dos dados de entrada. Calcular e imprimir os valores formatados das
combinações C(n,p), p = 0,1,2,...,n, como no exemplo abaixo, para n = 10.
n 10 10 10 10 10 10 10 10 10 10 10
p 0 1 2 3 4 5 6 7 8 9 10
C(n,p) 1 10 45 120 210 252 210 120 45 10 1
33.
8.2.4.3. Exercícios Intermediários 1
1. Encontre o padrão das matrizes A, B e C e faça uma função para calcular cada uma as
questões: a) A+B; b) A+B+C; e c) A-B-C. Faça um programa considerando matrizes
M✕N, e teste seu programa com as matrizes abaixo (4✕5) e x = 0,5.
[ ]
1 2 3 4
0
x x2 x3 x4
[ ] [ ]
1 x x2 x3 x4 x x 1/2 x 1 /3 x 1/ 4 x 1/5 5 6 7 8 9
x x2 x3 x 4 x5 x 2 x x 2 /3 x 1 /2 x 2/5
x
5
x
6
x
7
x
8
x
9
A= 2 3 , B= 3 e C=
x x x4 x5 x6 x x 3/2 x x 3/ 4 x 3/5 10 11 12 13 14
x3 x4 x5 x6 x7 x 4 x 2 x 4 /3 x x 4 /5 x 10 x 11 x 12 x 13 x 14
15 16 17 18 19
x 15 x 16 x 17 x 18 x 19
2. Faça um programa C para calcular a média dos elementos da matriz de mesma cor de
fundo, uma função para cada cor. Faça um programa considerando uma matriz M✕M,
M > 1. Teste seu programa com a matriz abaixo (M=6). Teste seu programa com uma
matriz M=7 também. Teste seu programa gerando valores aleatoriamente para A.
1 2 3 4 5 6
7 8 9 1 2 3
A = 4 5 6 7 8 9
1 2 3 4 5 6
7 8 9 1 2 3
4 5 6 7 8 9
3. Faça um programa C para calcular a média dos elementos da matriz de mesma cor,
uma função para cada cor. Faça um programa considerando uma matriz M✕2M, M > 1.
Teste seu programa com a matriz abaixo (M=6). Teste seu programa com uma matriz
M=7 também. Teste seu programa gerando valores aleatoriamente para A.
[ ]
1 2 3 4 5 6 7 8 9 1 2 3
4 4 5 6 7 8 9 1 2 3 4 5
A= 6 7 8 9 1 2 3 4 5 6 7 8
9 1 2 3 4 5 6 7 8 9 1 2
3 4 5 6 7 8 9 1 2 3 4 5
6 7 8 9 1 2 3 4 5 6 7 8
4. ...
O conceito de filtro de uma matriz mais simples consiste em substituir o valor de um ele-
mento pelo valor da media de seus elementos vizinhos. O número de vizinhos a considerar é
definido por uma máscara, ou seja, a matriz de vizinhos que circunda o elemento a tratar (in -
cluindo ele mesmo):
O tamanho da máscara é um inteiro positivo ímpar (2q+1). O default (padrão) é a más-
cara de 3×3 elementos, ou seja, q = 1.
A matriz A, abaixo, ilustra o elemento al,c e seus vizinhos para q = 2, a máscara 5x5.
l-2,c-2 l-2,c-1 l-2,c l-2,c+1 l-2,c+2
l-1,c-2 l-1,c-1 l-1,c l-1,c+1 l-1,c+2
l,c-2 l,c-1 l,c l,c+1 l,c+2
l+1,c-2 l+1,c-1 l+1,c l+1,c+1 l+1,c+2
l+2,c-2 l+2,c-1 l+2,c l+2,c+1 l+2,c+2
Os elementos nas bordas da matriz que não têm todos os vizinhos não são filtrados.
No problema abaixo, considere as matrizes Am,n e Bm,n e faça funções para:
a) definir m e n, dimensões das matrizes

b) gerar valores aleatórios para A
c) imprimir A
d) definir q, o tamanho da máscara (2q+1)x(2q+1)
q+1 q +1
1
e) calcular B, filtro de A, em que bl , c = 2 ∑ ∑ al +i ,c+ j para q ≤ l < m-q e q ≤ c < n-q
q i=q−1 j=q−1
f) validar seus algoritmos
g) imprimir a matriz B
h) verificar seus resultados
Faça o Plano de Teste de cada um destes exercícios.
1. Dada uma matriz M x M, elabore um algoritmo que imprima:

a) a diagonal principal;
b) o triângulo superior à diagonal principal;
c) o triângulo inferior à diagonal principal;
d) tudo exceto a diagonal principal;
e) a diagonal secundária;
f) o triângulo superior à diagonal secundária;
g) o triângulo inferior à diagonal secundária;
h) tudo exceto a diagonal secundária;
2. Prepare um algoritmo que seja capaz de ler números inteiros para uma matriz M x M e
depois gire seus elementos em 90° no sentido horário, ou seja, a primeira coluna passa a
ser a primeira linha, e assim por diante. Repita para o sentido anti-horário.
3. Elabore um algoritmo que preencha uma matriz M x M de inteiros e depois faça:
a) trocar a segunda e a terceira linha;
b) trocar a primeira e a quarta coluna;
c) trocar a diagonal principal e a secundária;
d) escrever como ficou a matriz.
4. Implemente um programa que gera uma matriz AMxM e calcule e mostrar a soma dos
elementos de cada área hachurada. Faça o Plano de Teste para M = 8 e M= 9.
a b c d e
f g h i j
5. O tempo que um determinado avião dispensa para percorrer o trecho entre duas
localidades distintas está disponível através da tabela abaixo, elabore o Pensamento
Computacional, um Plano de Teste e Implemente um algoritmo que:
1 2 3 4 5 6 7
1 02 11 06 15 11 01
2 02 07 12 04 02 15
3 11 07 11 08 03 13
4 06 12 11 10 02 01
5 15 04 08 10 05 13
6 11 02 03 02 05 14
7 01 15 13 01 13 14
a) leia a tabela anterior e informe ao usuário o tempo necessário para percorrer duas
cidades por ele fornecidas, até o momento em que ele fornecer duas cidades iguais
(origem e destino).
b) permita ao usuário informar várias cidades, até inserir uma cidade '0', e que
imprima o tempo total para cumprir todo o percurso especificado entre as cidades
fornecidas.
c) auxilie um usuário a escolher um roteiro de férias, sendo que o usuário fornece
quatro cidades: a primeira é sua origem, a última é seu destino obrigatório e as
outras duas caracterizam as cidades alternativas de descanso (no meio da viagem).
Por isso, o algoritmo deve fornecer ao usuário qual das duas é a melhor opção, ou
seja, qual fará com que a duração das duas viagens (origem para descanso,
descanso para destino) seja a menor possível.
6.
8.2.4.6. Exercícios Avançados 1
1. Considerando a matriz Am,m faça funções para:

a) definir o valor de m
b) gerar valores aleatórios para A
c) imprimir A
d) identificar as faces externas de A
e) imprimir as faces externas de A
f) identificar as diagonais das faces externas de A
g) imprimir as diagonais das faces externas de A
h) identificar as diagonais entre os vértices de A
i) imprimir as diagonais entre os vértices de A
j) identificar a diagonal de A que possui a maior soma dos seus elementos
k) proponha testes para validar os algoritmos acima
2. Crie um vetor V[MxN] e leia-o e escreva-o como se fosse uma matriz V[M][N].
3. Na matriz de A20x20 abaixo, quatro números ao longo de uma linha diagonal foram
marcado. O produto desses números é 26 x 63 x 78 x 14 = 1788696.
[ ]
8 2 22 97 38 15 0 40 0 75 4 5 7 78 52 12 50 77 91 8
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 4 56 62 0
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 3 49 13 36 65
52 70 95 23 4 60 11 42 69 24 68 56 1 32 56 71 37 2 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 3 45 2 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 2 62 12 20 95 63 94 39 63 8 40 91 66 49 94 21
24 55 58 5 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 9 75 0 76 44 20 45 35 14 0 61 33 97 34 31 33 95
A 20 x 20=
78 17 53 28 22 75 31 67 15 94 3 80 4 62 16 14 9 53 56 92
16 39 5 42 96 35 31 47 55 58 88 24 0 17 54 24 36 29 85 57
86 56 0 48 35 71 89 7 5 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 5 94 47 69 28 73 92 13 86 52 17 77 4 89 55 40
4 52 8 83 97 35 99 16 7 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 3 46 33 67 46 55 12 32 63 93 53 69
4 42 16 73 38 25 39 11 24 94 72 18 8 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 4 36 16
20 73 35 29 78 31 90 1 74 31 49 71 48 86 81 16 23 57 5 54
1 70 54 71 83 51 54 69 16 92 33 48 61 43 52 1 89 19 67 48
Qual é o maior produto de quatro números adjacentes em qualquer direção (vertical,

horizontal e diagonal) da matriz de 20x20?
4. Um jogo de palavras-cruzadas pode ser representado por uma matriz A mxn onde cada
posição da matriz corresponde a um quadrado do jogo, sendo que 0 indica um quadrado
branco e -1 indica um quadrado preto. Indicar na matriz as posições que são início de
palavras horizontais e/ou verticais nos quadrados correspondentes (substituindo os
zeros), considerando que uma palavra deve ter, pelo menos, duas letras. Para isso,
numere consecutivamente tais posições.
Exemplo: Dada a matriz
A saída deverá ser
5. Implemente um programa que gera as matrizes AMx2M e AMx3M e calcule e mostre a

média dos elementos das áreas hachuradas. Faça o Plano de Teste para M = 8 e M= 9.
a b
c d
6.
8.2.4.7. Exercícios Avançados 2
1. Faça um programa C para calcular a média dos elementos da matriz de mesma cor,
uma função para cada cor. Faça um programa considerando uma matriz 2M✕2M, M > 1.
Teste seu programa com a matriz abaixo (M=6). Teste seu programa com uma matriz
[ ]
M=7 também. Teste seu programa gerando valores aleatoriamente para A.
1 2 3 4 5 6 7 8 9 1 2 3
4 5 6 7 8 9 1 2 3 4 5 6
7 8 9 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 1 2 3 4 5 6
7 8 9 1 2 3 7 8 9 1 2 3
4 5 6 7 8 9 4 5 6 7 8 9
A=
1 2 3 4 5 6 1 2 3 4 5 6
7 8 9 1 2 3 7 8 9 1 2 3
4 5 6 7 8 9 4 5 6 7 8 9
1 2 3 4 5 6 1 2 3 4 5 6
7 8 9 1 2 3 7 8 9 1 2 3
4 5 6 7 8 9 4 5 6 7 8 9
2. ….
8.2.4.8. Exercícios do Sistema Solar
1. Preencha o quadro abaixo com as menores distância entre os planetas utilizando os


Mercúrio 0.0
Vênus 0.0
Terra 0.0
Marte 0.0
Júpiter 0.0
Saturno 0.0
Urano 0.0
Netuno 0.0
2. Preencha o quadro abaixo com as maiores distância entre os planetas utilizando os

Mercúrio 0.0
Vênus 0.0
Terra 0.0
Marte 0.0
Júpiter 0.0
Saturno 0.0
Urano 0.0
Netuno 0.0
3. Preencha o quadro abaixo com a maior força de atração gravitacional, em Newtons,
mM
r
Mercúrio 0.0
Vênus 0.0
Terra 0.0
Marte 0.0
Júpiter 0.0
Saturno 0.0
Urano 0.0
Netuno 0.0
4. Preencha o quadro abaixo com a menor força de atração gravitacional, em Newtons,
mM
r
Mercúrio 0.0
Vênus 0.0
Terra 0.0
Marte 0.0
Júpiter 0.0
Saturno 0.0
Urano 0.0
Netuno 0.0
8.3. String
A string C é uma lista de elementos do tipo char, com o terminador nulo ao seu final,
que necessita de um índice para localizar seus elementos. As strings armazenam texto e ca-
racteres alfanuméricos.
Para declarar uma string são necessários quatro atributos: o tipo char, seu nome, o seu
tamanho, o terminador nulo ao seu final.
Para manipular uma string são necessários, pelo menos, dois recursos da linguagem C, a
saber: um índice – uma variável do tipo int; e uma estrutura de iteração – while e for são usa-
das.
A sintaxe da declaração de strings, sem e com valores iniciais, é mostrada a seguir.
char <nome da string>[<tamanho>];

char <nome da string>[<tamanho>] = { lista de caracteres };
char <nome da string>[<tamanho>] = "<texto da string>";
Por exemplo, char sz[8] = "exemplo"; é a declaração de uma string, com nome sz, ta-
manho 8 e armazena 7 valores char e o NULL ou '\0'. A string sz pode ser representado de
forma gráfica como é mostrada a seguir.
índice 0 1 2 3 4 5 6 7
sz[8] 'e' 'x' 'e' 'm' 'p' 'l' 'o' '\0'
Toda string é indexada a partir de zero. No exemplo acima, sz tem tamanho 8, seus ele-
mentos são indexados a partir de zero, ou seja, tem-se sz[0] = 'e', sz[1] = 'x', sz[2] =
'e', sz[3] = 'm', sz[4] = 'p', sz[5] = 'l', sz[6] = 'o' e V[7] = '\0'.
São duas sintaxes da declaração de strings com valores iniciais, elas são mostradas no
exemplo a seguir.
char sz[8] = "exemplo";
char sz[8] = { 'e','x','e','m','p','l','o' };
O Programa 8.22 permite visualizar strings como conjunto de elementos por meio do c
tutor.
Programa 8.22 Visualização de strings como conjunto de elementos
Foram declaradas quatro strings, de tamanhos variados e valores iniciais variados.

A execução do programa-fonte no C Tutor permite visualizar estas strings, seus nomes,
seus tipos, seus tamanhos, valores iniciais e seus valores NULL.
Pode observar o erro de lógica cometido ao atribuir valores iniciais à string s1, ao não
deixar espaço para o valor NULL – fim da string.
Programa-fonte
#include <stdio.h>
int main( void ){
char s1[11] = "***********";
char s2[12] = "";
char s3[13] = "exemplo 1";
char s4[14] = { 'e', 'x', 'e', 'm', 'p', 'l', 'o', ' ', '2' };
return 0;
}
Para fins práticos, as strings serão tratados como colunas. As colunas ou elementos ou
células são ordenadas horizontalmente, são numeradas da esquerda para direita, e são indi -
cadas pelo índice que varia de 0 a n–2, o índice n-1 é reservado para o NULL ou '\0' Figura
8.2.
índice 0 1 2 ... n-2 n-1
sz[n] sz[0] sz[1] sz[2] ... sz[n-2] '\0'

primeiro índice último índice
Figura 8.2 Representação de uma string de nome sz e tamanho n.
Ao declarar uma string é necessário declará-la com um tamanho capaz de armazenar a

maior quantidade de caracteres. Elas são flexíveis no sentido de pode reposicionar o termina-
dor NULL em qualquer índice válido da string.
O Programa 8.23 discute as duas as operações mais básicas feitas com strings, ler uma
string do teclado e escrevê-la na tela.
Programa 8.23 Ler e escreve, formatado, uma string de tamanho 5
Foi declarada a string sz, do tipo char, e de tamanho constante n.

A leitura é feita com scanf, função da BPC, com formato é %s e sem o símbolo &.
A escrita é feita com printf, função da BPC, com formato é %s e sem o símbolo &.
Programa-fonte
#include <stdio.h>
#include <string.h>
#define n 5
int main( void ){
char sz[n];
printf("------------------" );
printf("\n Lendo sz" );
printf(" Valor de sz: " );
scanf ("%s", sz );
printf("------------------" );
printf("\n Escrevendo sz " );
printf("\n sz = %s", sz );
printf("------------------" );
return 0;
}
O Comentário 8.4 discute os vetores C e sua associação com a EI for.
Comentário 8.4 Strings e a Linguagem C
A linguagem C exige que o tamanho da string seja uma constante inteira 15 – não pode ser
uma variável, por isso é denominada de string estática. O tamanho das strings C são pré-
definidos e fixos em todo programa-fonte.
É comum a seguinte declaração na linguagem C para um vetor:
#define n 20 // facilita mudanças

char str[n]; // n é constante e str pode possuir 19 elementos do tipo char
Para fazer referência a um dos valores da string, basta usar o nome da strng e indicar o
índice desejado, lembre–se que o índice varia de 0 a n–1, em que n é o tamanho da string e
que a posição n-1 é do NULL.
Na declaração anterior, str[0] é o primeiro elemento de str, str[1] é o seu segundo

elemento, e assim por diante, até str[18], que é seu último caractere, o str[1]9 é reservado
para conter NULL. Não existe o elemento str[20] pois a contagem começa em zero (0).
Observe que o padrão usado para percorrer a string str: str[0], str[1], str[2], …, str[19], ou
seja, str[c], 0 ≤ c < n, é similar ao padrão da instrução for.
Os muitos modos de escrever strings na tela do computador:
1. A função permite escrever string com o uso do formato %s.
Strings podem ser manipulados na linguagem C por meio das instruções for e while.
#define n 20
int c;
char str[n];
15 Alguns compiladores C, os mais recentes, podem ter flexibilizado esta regra.

for( c = 0; c < n; c++ ){

}
E também
const int n = 20;
int c;
float V[n];
for( c = 0; c < n; c++ ){

}
Na estrutura de iteração acima, a instrução for varia o seu contador de iteração de 0 a n–1.
O contador do for é usado como índice para os elementos do vetor V. A medida que c
aumenta de um em um, o bloco é executado e percorre–se os elementos de V, de um em
um, do início ao fim.
Nas partes de programa acima, o uso de n, e não o seu valor 20, é uma boa prática de
programação – as instruções não mudam ao mudar o valor de n.
Como listado no Programa 8.24 há muitas formas de escrever strings na tela do compu-
tador.
Programa 8.24 Os muitos modos de escrever strings na tela do computador
Os muitos modos de escrever strings na tela do computador:
1. A função printf permite escrever string com o uso do formato %s.

2. A função puts é especializada em escrever string, requer #include <string.h>.
3. Usando while pode-se escrever strings, caractere a caractere.
4. Usando for pode-se escrever strings, caractere a caractere, mas requer o uso da função
strlen para localizar o índice NULL da string, requer #include <string.h>..
A função escrever3, do programa abaixo, percorre a string, do começo até encontrar o

caractere NULL que tem valor lógico false pois é igual a zero (0). Ao encontrar o NULL, a
condição do while é false e encerra a instrução e a função.
A função escrever4, do programa abaixo, percorre a string, do começo até encontrar o

caractere NULL. A primeira posição NULL da string s é fornecida pela função strlen(s).
Ao encontrar o NULL, a condição do for é false e encerra a instrução e a função.
Programa-fonte
#include <stdio.h>
#include <string.h>
#define n 12
void escrever3( char s[n] ){
int c = 0;
while( s[c] ){
printf( "%c", s[c] );
c++;
}
}
void escrever4( char s[n] ){

int c;
for( c = 0; c < strlen(s); c++ )
}
int main( void ){
char sz[n] = "String C";
printf("\n 1.Escrevendo sz: %s", sz );
printf("\n 2.Escrevendo sz: " ); puts(sz);
printf("\n 3.Escrevendo sz: " ); escrever3(sz);
printf("\n 4.Escrevendo sz: " ); escrever4(sz);
return 0;
}
Por vezes, digitar valores de strings e uma tarefa enfadonha, o Programa 8.25 discute
uma forma de gerar valores de strings escrevê-los na tela.
Programa 8.25 Gerar e escrever um strings
A função gerar usa um for para gerar aleatoriamente n caracteres maiúsculos

(veja o Comentário 10.7) e atribui à NULL à posição n-1.
A função escrever usa um for para escrever os n caracteres da string,

elemento a elemento – ela trata a string como um vetor de caracteres.
A string pode ser escrita toda de uma só vez, com printf, como consta na
função main.
A imagem produzida pelo C Tutor permite visualizar a string como um vetor de char e sua
impressão na tela das maneiras acima referidas.
Programa-fonte
#include <stdio.h>
#include <stdlib.h>
#define n 12
void gerar( char s[n] ){
int c;
for( c = 0; c < n; c++ )
s[c] = 97 + rand() % 26;
s[n-1] = '\0';
}
void escrever( char s[n] ){

int c;
for( c = 0; c < n-1; c++ )
}
int main( void ){
char sz[n];
printf("\n Gerando sz" );
gerar(sz);
printf("\n 1.Escrevendo sz: " );
escrever(sz);
printf("\n 2.Escrevendo sz: %s", sz );
return 0;
}
8.3.1. String como Parâmetro de Função
Funções C podem receber strings como parâmetros. Seja char sz[9] uma string, como
declarada abaixo.
char sz[9] = "String C";
A forma mais geral de receber string como parâmetro de função é mostrada abaixo.
void f( char sz[9] ); // protótipo
A forma mais geral de passar vetor como argumento de função é mostrada abaixo.
char sz[9] = "String C";

f(sz);
O Programa 8.26 mostra o uso de string como parâmetro de funções e o uso de string
como argumentos nas chamadas de funções.
Programa 8.26 Uso de funções para gerar e escrever uma string
Este programa e muito semelhante ao Programa 8.25, com destaque para a associação
entre sz e s, em que sz é o argumento chamada da função gerar, feita por main, e o
parâmetro da declaração da função gerar, visto no C Tutor.
L Programa-fonte
3 #define n 9
4 void gerar( char s[n] ){
5 int c;
6 printf("\n Gerando sz" );
7 for( c = 0; c < n; c++ )
8 s[c] = 97 + rand() % 26;
9 s[n-1] = '\0';
10 }
12 char sz[n];
13 gerar(sz);
14 printf( "sz: %s", sz );
15 return 0;
16 }
O Programa 8.27 concatena duas strings por meio de uma função.

Programa 8.27 Passando string para função.
Este programa e muito semelhante ao Programa 8.26, com destaque para a associação
entre as strings sz1 e sz2, argumentos e parâmetros função unir, visto no C Tutor.
Programa-fonte
#include<stdio.h>
#include <string.h>
void unir( char sz1[10], char sz2[10] ){
char sz[25]; //strlen(sz) ≥ strlen(sz1) + strlen(sz2) + 2 (espaço e NULL)
strcpy( sz, sz1 );
strcat( sz, " " );
strcat( sz, sz2 );
puts(sz);
}
int main( void ){
char sz1[10] = "Ola" ,
sz2[10] = "mundo";
unir(sz1,sz2);
return 0;
}
8.3.2. BPC string.h
Como as strings não são tipos de dados primitivos, é sim estruturas de dados homogê-
neas, elas não podem ser copiadas ou comparadas diretamente, a Biblioteca Padrão C possui
funções para a manipulação de strings, definidas em <string.h>, as mais comuns são lista-
das a seguir.
8.3.2.1. Entrada e Saída de Strings
As principais funções de entrada de string são: gets, fgets e scanf. O uso de gets foi des-
continuado (deprecated) por razões de segurança; gets lê apenas uma string por instrução; e
scanf lê uma string até encontrar espaço ou o fim da string, e pode ler mais de uma string na
mesma instrução.
A melhor função para leitura de string do teclado é fgets, é segura pois lê um número pre-
definido de caracteres, incluindo espaço, embora leia apenas uma string na mesma instru -
ção.
As principais funções de saída: puts e printf; a função puts escreve apenas uma string por
instrução e não permite formatação; a printf pode escrever mais de uma string por instrução
e permite formatação, como usadas no Programa 8.28.
Programa 8.28 E/S de String

Como pode ser visto na Imagem da Execução, a função gets é considerada perigosa e
não deve ser usada; já fgets é confiável; e scanf não lê a string sz3 totalmente, a leitura
encerra ao encontrar um caractere espaço, ou seja, o espaço e os caracteres depois do
espaço são ignorados. As funções de saída não possuem restrições.
gets( sz ) lê sz do teclado
fgets( sz, n, stdin ) lê até n-1 caracteres do teclado e armazenando em sz
scanf( "%s %s", sz1, sz2 ) lê sz1 e sz2 do teclado
puts( sz ) escreve sz na tela
printf( "%s %s", sz1, sz2 ); escreve sz1 e sz2 na tela
Programa-Fonte
#include<stdio.h>
#include<string.h>
#define n 32
int main(void){
char sz1[n], sz2[n], sz3[n];
puts( "E.string 1: " ); gets ( sz1 );

puts( "E.string 2: " ); fgets( sz2, n-1, stdin );
puts( "E.string 3: " ); scanf( "%s", sz3 );
puts( "S.string 1: " ); puts ( sz1 );

puts( "S.string 2: " ); printf( "%s", sz2 );
puts( "S.string 3: " ); printf( "%s", sz3 );
return 0;
}
Programa 8.28 E/S de String
8.3.2.2. Manipulação de Strings
As principais operações sobre strings são copiar, concatenar e comparar.

Adicionalmente, tem função strlen que retorna o número de caracteres da string; ela con-
ta os caracteres da string, da esquerda para direita, até encontrar NULL, e retorna o valor da
contagem.
Pode-se copiar em outra, strcpy( sz1, sz2 ) copia sz2 para sz1. O tamanho declarado de
sz1 deve maior ou igual ao tamanho de sz2. O valor de sz1 é substituído pelo de sz2.
A função strncpy( sz1, sz2, n ) copia n caracteres de sz2 para sz1. O tamanho declarado
de sz1 deve maior do que n. Os n caracteres de sz2 são copiados para sz1 da esquerda para
direita.
A função strcat( sz1, sz2 ) concatena, ou seja, anexa sz2 a sz1. O tamanho declarado de
sz1 deve maior do que a soma do número de caracteres de sz1 e de sz2.
A função strcmp( sz1, sz2 ) compara lexicograficamente as strings sz1 e sz2, retornando:
• -1 se sz1 for menor do que sz2

• 0 se sz1 for igual a sz2
• 1 se sz1 for maior do que sz2
A comparação lexicográfica utiliza a Tabela ASCII (Quadro 10.7) para comparar caracte-
res, ela leva em conta o valor decimal para comparar dois caracteres porque a CPU usa ape-
nas números. A Linguagem C usa a Tabela ASCII, nela 'A' é diferente de 'a', com 'a' > 'A', por -
que 'a' equivale a 97 e 'A' equivale a 65. Desta forma "Amor" < "amor", como mostrado no
Programa 8.29.
Programa 8.29 Manipulação de String

O uso das funções strcpy, strncpy e strcat devem ser feito com cuidado e atenção pois é
necessário garantir que o tamanho da strings envolvidas nestas operações sejam
suficientes.
Os códigos abaixo podem ser usados para evitar operações inválidas:
if( sizeof(sz1) > sizeof(sz2) ) strcpy( sz1, sz2 );

if( sizeof(sz1) > strlen(sz1)+strlen(sz2) ) strcat( sz1, sz2 );
O sizeof(sz1) retorna o tamanho declarado de sz1, já strlen(sz1) retorna a contagem de

caracteres até encontrar NULL.
O termo tamanho de string é vago, pode-se pensar em tamanho máximo de string, que
pode ser obtido com sizeof; mas também pode-se pensar em ocupação de string que pode
ser obtido com strlen.
strcpy( sz1, sz2 ) copia sz2 em sz1
strncpy( sz1, sz2, n ) copia até n caracteres de s1 para s2
strcat( sz1, sz2 ) concatena s2 no final de s1
strlen( sz ) retorna o tamanho de sz
strcmp( sz1, sz2 ) retorna -1 se s1 < s2; 0 se s1==s2; e +1 se s1> s2
Programa-Fonte
#include <stdio.h>
#include <string.h>
#define n 12
int main( void ){
char sz1[n] = "", sz2[n] = "", sz3[n] = "", sz4[n] = "";
int r;
strcpy ( sz1, "sz1" );

strcpy ( sz2, "sz2" );
strcat ( sz3, sz1 );
strcat ( sz3, sz2 );
strncpy( sz4, sz3, 4 );
r = strcmp( "Amor", "amor" );

printf( "\n strcmp( \"Amor\" , \"amor\" ) = %d", r );
r = strcmp( "amor", "amor" );

printf( "\n strcmp( \"amor\" , \"amor\" ) = %d", r );
r = strcmp( "amores", "amor" );

printf( "\n strcmp( \"Amores\", \"amor\" ) = %d", r );
printf( "\n sz1: %s ", sz1 );

return 0;
}
A função sprintf é usada para escrever valores de variáveis em uma string, da mesma for-
ma que printf escreve na tela, sprintf escreve em uma string, como usadas no Programa
8.30.
Programa 8.30 Uso do sprintf

A função sprintf é derivada da já conhecida printf, no programa-fonte abaixo a data
formatada por printf é escrita em sz.
sz = sprintf( sz, … ) Escreve em sz usando printf
Programa-Fonte
#include <stdio.h>
#include <string.h>
#define n 22
int main( void ){
char sz[n] = "";
int dia = 5, mes = 9, ano = 2022;
sprintf( sz, "data: %02d/%02d/%04d", dia, mes, ano );
puts(sz);
return 0;
}
8.3.2.3. Pesquisa em Strings

A pesquisa em strings é feita por meio de funções da biblioteca padrão, abaixo relacio-
nadas.
strchr(sz, c) retorna um ponteiro para a primeira ocorrência de c em s

strstr(sz1, sz2) retorna um ponteiro para a primeira ocorrência de s2 em s1
strrchr(sz, c) retorna um ponteiro para a última ocorrência de c em s
Pode-se pesquisar um caractere em uma string de duas formas. A primeira é comparan-

do cada caractere da string com o caractere pesquisado, usando uma estrutura de iteração –
é a maneira mais simples. A segunda é com as funções strchr (para frente) ou strrchr (para
trás).
A pesquisa de uma (sub)string em uma string com a função strstr. O Programa 8.31
mostra a técnica de pesquisa de (sub)string em string.
Programa 8.31 Contar o número de ocorrência da string sz2 na string sz1
A pesquisa de string em string requer o uso do conceito de apontador, como mostrado na

linha 6 do programa-fonte abaixo e na segunda imagem das Imagens da Execução.
Antes do while (linha 9), a variável achou precisa ter um valor válido e, para isso, é usado a
função strstr como mostrado na linha 8, nesta instrução o primeiro argumento é sz1 e o
segundo é sz2.
Dentro do while, a variável achou é novamente calculada, novamente com a função strstr
como mostrado na linha 11 mas, nesta instrução o primeiro argumento é achou+1 e o
segundo continua sendo sz2.
Na linha 11 é usado achou+1 para não pesquisar posições posteriores a posição achou.
O valor de achou é NULL (false) se sz2 não for encontrada em sz1, assim o while é
encerrado.
Plano de Teste
1 2 3
sz1: "Gosto de aula, muitas aulas e mais aulas"
sz2: "aula"
contagem: 3
L Programa-fonte
1 #include <string.h>
3 int main( void ){
4 char sz1[] = "Gosto de aula, muitas aulas e mais aulas",
5 sz2[] = "aula",
6 *achou; // armazena posição de sz2 em sz1
7 int conta = 0;
8 achou = strstr(sz1,sz2);
9 while( achou ){
10 conta++;
11 achou = strstr(achou+1,sz2);
12 }
13 printf("\contagem = %d", conta );
14 return 0;
15 }
8.3.2.4. Outras Operações com Strings
Há muitos algoritmos para string como, por exemplo, no livro “Numerical Recipes in C”
(Press, 1992); os Algoritmos de Boyer-Moore também tratam de strings – veja na internet.
Entretanto, para os cursos introdutórios, são usados algoritmos mais simples, que usam con-
ceitos usuais. O Programa 8.32 ordena uma string.
Programa 8.32 Ordenação de strings
A ordenação é um algoritmo básico, no programa-fonte abaixo todos os caracteres da

string são comparados e trocados de modo que os caracteres da string fiquem em ordem
crescente.
Programa-fonte
#include<stdio.h>
#include<string.h>
int main( void ){
char sz[9] = "546372819";
int c, i;
printf( "\n string: %s", sz );
for( c = 0; c < strlen(sz); c++ )
for( i = c; i < strlen(sz); i++ )
if( sz[c] > sz[i] ){
char ch = sz[c];
sz[c] = sz[i];
sz[i] = ch;
}
printf( "\n string: %s", sz );
return 0;
}
O Programa 8.33 inverte uma string.
Programa 8.33 Imprimindo uma string de forma invertida
O programa-fonte abaixo imprime os caracteres da string do final para o início.
Programa-fonte
#include<stdio.h>
#include<string.h>
#define N 21
int main( void ){
char sz[N];
int n, c;
printf("\n string: " );
fgets ( sz, N-1, stdin );
n = strlen(sz);
printf( "\n strlen(sz): %d", n );
printf( "\n string invertida: " );
for( c = n; c >= 0; c-- )
printf("%c", sz[c]);
return 0;
}
8.3.3. Vetor de Strings
Pode-se implementar um vetor de strings simplesmente como uma matriz de strings, da

forma:
char Texto[numero_de_strings][tamanho_das_strings];
O Programa 8.34 mostra o uso de vetores de strings e sua manipulação.

Programa 8.34 Vetor de strings e sua manipulação
O vetor dia do tipo char (string) com o nome de cinco dias da semana é declarado no
programa-fonte abaixo, o tamanho máximo da string é 13 + NULL. Os valores de dia são
atribuídos na sua declaração. A impressão é feita como mostrado, usando uma estrutura de
iteração.
Programa-fonte
#include <stdio.h>
int main( void ){
char dia[5][14] = { "domingo",
"segunda-feira",
"terça-feira",
"quarta-feira",
"quinta-feira" };
int c;
for( c = 0; c < 5; c++ )
printf("\n dia %d: %s", c, dia[c] );
return 0;
}
1. Compare as funções fgets com scanf. Dê três aplicações de cada uma.

2. Compare as funções strlen com sizeof. Dê três aplicações de cada uma.
3. O que é comparação lexicográfica?
4. Como a Tabela ASCII está relacionada com a função strcmp?
5. Porque gets não é confiável?
6. Qual o tamanho máximo de uma string C?
7. Explique o código if( sizeof(sz1) > sizeof(sz2) ) strcpy( sz1, sz2 ). Dê quatro aplicações
dele.
8. Explique o código if( sizeof(sz1) > strlen(sz1)+strlen(sz2) ) strcat( sz1, sz2 ). Dê
quatro aplicações dele.
9. Porque tamanho de string pode ter duas interpretações?
1. Escreva um programa em C que leia uma data, determine e imprima se ela é válida. Ou
seja, verifique se o mês está entre 1 e 12, e se o dia existe naquele mês. Note que
fevereiro tem 29 dias em anos bissextos, e 28 dias em anos não bissextos 16.
2. Faça um programa que lê nome e sobrenome e imprime o número de letras de cada
um.
3. Faça um programa para criptografar uma frase dada pelo usuário. Na criptografia, a
frase deverá ser invertida e as consoantes deverão ser trocadas por #. Exemplo: Frase: EU
ESTOU NA ESCOLA. Saída: A#O##E A# UO##E UE.
4. Faça um programa que receba uma frase e gere uma nova, retirando seus espaços.
5. Faça um programa que receba uma frase e gere uma nova frase, duplicando cada
caractere da frase digitada. Exemplo: Frase: PROGRAMAR É BOM. Saída:
PPRROOGGRRAAMMAARR ÉÉ BBOOMM.
6. Faça um programa que receba uma frase e um caractere e verifique se o caractere
digitado é encontrado na frase ou não.
7. Faça um programa que receba uma frase e um caractere e verifique em que posição da
frase o caractere digitado aparece pela última vez.
8. Faça um programa que receba uma frase e mostre quantas vezes cada palavra
aparece na frase digitada.
9. Faça um programa que receba uma data no formato DD/MM/AAAA e a mostre com o
mês por extenso: DD/mês por extenso/AAAA.
10.Faça um programa que receba uma cadeia de caracteres e o número de repetições
(limitado a 5) e gere uma nova cadeia. Exemplo: Cadeia = Ui! Número = 3 Nova cadeia =
Ui! Ui! Ui!
11.Faça um programa que receba uma frase e converta suas vogais para maiúsculo e as
consoantes para minúsculo.
12.Faça um programa que receba uma frase e, cada vez que aparecer nela um algarismo
entre 0 e 9, substitua-o, escrevendo-o por extenso. Exemplo: Frase: EU ESTOU NA
POLTRONA 5. Saída: EU ESTOU NA POLTRONA CINCO.
13.Faça um programa que receba uma frase e mostre quantas letras, quantos números e
quantos espaços existem nela.
14.Faça um programa que criptografe cada palavra de uma frase, substituindo por ? a
última metade de seus caracteres. Exemplo: A aula é boa mas poderia ser mais curta. ?
au?? ? b?? m?? pod???? s?? ma?? cu???.
15.Faça um programa que receba uma frase e faça a criptografia dela, substituindo as
vogais pelos seguintes números: a = 1, e = 2, i = 3, o = 4 e u = 5.
16.Faça um programa que receba uma frase e faça a criptografia dela, utilizando a
representação ASCII de cada caractere mais um espaço, e depois proceda à sua
descriptografia.
17.Faça um programa que receba uma frase e realize a criptografia dela, trocando a
primeira e a última palavra de lugar. Exemplo: Frase: ESTRELAS E LUA ESTÃO NO CÉU.
Saída: CÉU E LUA ESTÃO NO ESTRELAS.
18.A busca por subcadeias dentro de grandes cadeias de caracteres é um problema
clássico na computação, especificamente em bancos de dados. Faça um programa que
receba uma cadeia de caracteres e uma subcadeia, determine e mostre quantas vezes a
16 Um ano é bissexto se ele for divisível por 4, 100 e 400; desta forma, 1964 e 2000 são bissextos, mas 1900 não é
bissexto.
subcadeia aparece dentro da cadeia.
1. Faça um programa que receba uma frase e um caractere e verifique se o caractere

digitado é encontrado na frase ou não e, se for encontrado, quantas vezes isso
acontece.
2. Faça um programa que receba uma frase e mostre quantas letras diferentes ela
contém.
3. Construa uma função que receba um texto de até 80 caracteres, ela deverá identificar
as unidades léxicas da Linguagem C e listá-las, na forma de uma tabela, identificando
os seus tipos. Devem ser consideradas as seguintes unidades léxicas: a) identificadores
– iniciam por uma letra, seguida por letras e/ou dígitos; b) inteiros – formados somente
por dígitos; c) palavras reservadas – if, else, for, while, do; d) símbolos especiais –
qualquer caractere diferente de letra, dígito e espaço em branco.
4. Faça um programa que receba uma frase e, a cada duas palavras dela, realize uma
criptografia, ou seja: a primeira letra da primeira palavra da frase concatenada com a
última letra da segunda palavra, concatenada com a segunda letra da primeira palavra
e com a penúltima letra da segunda palavra e assim por diante. No caso de quantidade
de palavras ímpares, a última palavra deve simplesmente ser invertida. Exemplos:
Frase: Aula com bola. Saída: Amuolca alob. Frase: Casa com janelas coloridas. Saída:
Cmaosca jsaandeilraosloc.
5. Considere uma string composta por várias subsequências, por exemplo,
cccaaaabbbbxdddddddddaaannn. A menor subsequência é a da letra x, com apenas
um elemento; a maior subsequência é a da letra d, com nove elementos. Faça um
programa para ler uma string e mostrar qual é a letra que ocorre na maior
subsequência e o tamanho dessa subsequência. Exemplo: Entrada: aaabbbbaaa. Saída:
maior b, tamanho 4.
6. Escrever uma função recursiva para calcular o valor de uma base x elevada a um
expoente y.
7. Escrever uma função recursiva que retorna o tamanho de uma string, int tamstr(char*).
8. Fazer uma função recursiva que conta o número de ocorrências de um determinado
caractere, int nocorchar( char c, char* ).
9. Escreva uma função recursiva que produza o reverso de uma string, char
*reverse( char*).
10. Elabore um algoritmo que, dados dois vetores inteiros de 20 posições, efetue as
respectivas operações indicadas por outro vetor de 20 posições de caracteres também
fornecido pelo usuário, contendo as quatro operações aritméticas em qualquer
combinação e armazenando os resultados em um terceiro vetor.
9. Resolvendo Problemas Usando Computadores
A Engenharia de Software é uma especialidade voltada para o desenvolvimento de

software, normalmente grandes projetos envolvendo equipes de especialistas.
Cada indivíduo possui sua forma de resolução de problema. Na área científica, a solução
dos problemas deve ser padronizada para facilitar o entendimento por outras pessoas e tam-
bém possibilitar a reprodução destas soluções.
A Figura 9.1 mostra um diagrama de processos que começa no problema e termina na
solução. O Pensamento Computacional permite a análise do problema e a elaboração de um
dicionário de dados. O Dicionário de dados são os nomes das entradas, variáveis, constantes
e saídas do algoritmo. A análise divide o problema em partes, divide o problema em instru-
ções bem definidas e permite propor o algoritmo que junto com as entradas, programa-fonte
e saídas. Como saber se a solução do problema está correta? Neste ponto entra o plano de
teste, feito de forma independente do algoritmo, usando as entradas para produzir as saídas.
Figura 9.1 Diagrama de processos problema-solução.

A Figura 9.2 mostra um diagrama de recursos que inicia com o problema e termina da
CPU. A solução simbólica, como o pensamento computacional, forja um algoritmo para uso
computacional. O programa-fonte é o algoritmo escrito em uma linguagem de programação
que, após ser compilado gera um programa executável em uma CPU.
Figura 9.2 Diagrama de recursos problema-CPU.
As Figura 9.1 e Figura 9.2 ajudam a entender como resolver problemas para uso em
computadores. No entanto, são apenas visões, a prática é que vai consolidá-las em nossa
mente. É preciso criar nosso próprio pensamento computacional do desenvolvimento de pro -
gramas de computador como solução de nossos problemas.
9.1. Desenvolvimento de Programas de Computador
O matemático George Polya propõe um método estruturado para a resolução de proble-

mas baseado em quatro etapas:
1. Entender – deve-se obter a melhor compreensão do problema, identificando quais são

as questões e variáveis existentes e verificando se existem informações suficientes
para entendê-lo, e buscar uma solução.
2. Planejar – consiste em estudar a melhor forma de resolver o problema. É basicamente
identificar o melhor método a ser aplicado; geralmente o método da divisão em
problemas menores auxilia nesse processo. Algumas técnicas comuns a serem
utilizadas nessa etapa são: intuição, lista ordenada, eliminação de possibilidades,
simetria e semelhança com outros casos, causa e efeito, análise sistêmica,
estruturação de uma equação, desenhos, busca por padrões etc.
3. Executar – consiste em executar o plano realizado na etapa anterior e efetivamente
solucionar o problema.
4. Verificar – deve-se verificar a solução encontrada. Para isso, necessário validar todas
as entradas possíveis apresentadas no problema e identificar possíveis pontos de
falhas.
De forma muito simplificada, a construção de algoritmos envolve passos similares, como

os abaixo relacionados:
1. Compreender o problema a ser resolvido, destacando os pontos importantes e sua

composição
2. Definir os dados de entrada e os demais dados que fazem parte do problema
3. Definir o processamento, os cálculos a serem efetuados para transformar dados de
entrada em dados de saída
4. Definir os dados de saída, os dados a serem gerados pelo processamento
5. Conceber testes para verificar e validar o algoritmo
9.2. Entrada, Processamento e Saída
Segundo a Teoria da Computação, a Computação pode ser definida como a busca de

solução para um problema a partir de entradas (inputs), de forma a obter resultados (out-
puts) depois de processada a informação através de um algoritmo. Este conceito está resu -
mido na Figura 9.3.
Figura 9.3 Entrada-Processamento-Saída (EPS).
A Computação tem status de Ciência. A Ciência da Computação é uma área do co-

nhecimento humano relacionada à produção de software e à Matemática. Tem grande impor-
tância pois os algoritmos computacionais estão cada vez mais presentes na sociedade.
A Computação e os três conceitos da Figura 9.3 se aplicam, em geral, a todo programa
de computador. A solução dos problemas são da responsabilidade dos programadores, ca-
bendo a eles identificar cada um destes processos e propor seus algoritmos. Os processos de
entrada (E) e saída de dados (S), abreviado por E/S, são feitos por funções padronizadas.
Os dados e o seu processamento dependem do problema, requerendo conhecimento pa-
ra elaborar seus algoritmos. Como computadores não podem fazer julgamentos e nem resol-
ver ambiguidades, os algoritmos devem ser capazes de comunicar instruções de forma preci -
sa. Deve-se assegurar que a entrada seja feita de modo correto, usar os algoritmos adequa-
dos para o processamento e gerar as saídas esperadas. É necessário testar os programas,
identificar situações que podem levar a erros e evitá-los.
Enfim, pode-se redefinir o conceito de algoritmo. Algoritmo de um problema define e de-
termina todas as trajetórias possíveis entre suas entradas possíveis e suas saídas desejadas,
incluídas todas aquelas que conduzem a erros. Um algoritmo é a solução universal de um
problema, aquelas trajetórias que são corretas e também as que evitam as incorretas.
A expressão “entra lixo, sai lixo” é comum da nossa área. Como bons programadores é
importante mudá-la “entra lixo, sai aviso que entrou lixo”.
9.2.1. Dividir para Conquistar
A construção de algoritmos complexos requer o uso de estratégias simplificadoras como

“Planejamento Reverso” e “Dividir para Conquistar”, descritas abaixo.
Planejamento Reverso
O planejamento enquanto ação intencional com foco em atividades,

é uma etapa fundamental na programação. Neste sentido, o
Planejamento Reverso consiste em projetar soluções a partir dos
resultados. Ou seja, a partir da saída (S) desejada, deve-se
determinar, de modo reverso, quais são o processamento (P) e a
entrada de dados (E) necessários.
Estratégia Dividir para Conquistar
A estratégia Dividir para Conquistar busca resolver um problema

grande, de difícil solução, dividindo-o em problemas menores, de
solução mais fácil. Se necessário, pode-se dividir novamente as
partes não compreendidas.
Esse método pode ser esquematizado nos seguintes passos:
1. Dividir o problema em partes

2. Analisar a divisão e garantir a coerência entre as partes
3. Reaplicar o método, se necessário
Em termos de ideias, por um lado, o Planejamento Reverso permite criar uma visão ge-
ral de onde chegar e qual é o caminho até lá. Por outro lado, Dividir para Conquistar permite
detalhar cada passo a ser dado ao longo do caminho.
9.2.2. Pensamento Computacional
O método de George Polya pode ser aplicado ao domínio do computador. Existem quatro
estágios principais para o pensamento computacional:
1. Decomposição – dividir o problema em partes menores

2. Generalização – identificar a solução que resolve o problema mas que também
resolva outros problemas similares; o mesmo que propor uma solução padronizada
3. Abstração – transformar as partes do problema em conceitos gerais, aplicáveis a
outros problemas de ordem mais geral
4. Algoritmos – sequência ordenada das etapas para resolver o problema e avaliar sua
eficácia.
Estes passos podem ser especificados ao identificar as operações e ações a serem exe-
cutadas sobre os dados para obter o resultado final esperado. Os algoritmos mais simples
possuem um conjunto de ações como os da Tabela 9.1. Cada uma destas ações são desdo-
bradas em um ou mais instruções para definir o fluxo de controle e compor os programas de
computador. Além de poderem ser combinadas entre si como decisões dentro de iterações e
iterações dentro de iterações em vários níveis.
Tabela 9.1 Principais ações dos algoritmos mais simples
• início
▪ declaração das variáveis e constantes
▪ entradas de dados
▪ cálculos de expressões e atribuições
▪ decisões por meio de comparações
▪ iterações por meio de comparações
▪ saídas de dados
• fim
O Comentário 9.1 apresenta a definição operacional de pensamento computacional ela-

borada por organizações científicas internacionais.
Comentário 9.1 Definição Operacional de Pensamento Computacional, segundo a

International Society for Technology in Education (ISTE) em conjunto com a Computer
Science Teachers Association (CSTA) em 2011
Os elementos do Pensamento Computacional (PC) pode resumido pelos chamados “Quatro

Pilares do Pensamento Computacional”, sendo eles: Decomposição, Reconhecimento de
Padrões, Abstração e Algoritmos, já comentados.
O PC é um processo de resolução de problemas que inclui (mas não está limitado) as
seguintes características:
• Formulação de problemas de forma que nos permita usar um computador e outras
ferramentas para nos ajudar a resolvê-los;
• Organização e análise lógica de dados;
• Representação de dados através de abstrações, como modelos e simulações;
• Automatização de soluções através do pensamento algorítmico (uma série de etapas
ordenadas);
• Identificação, análise e implementação de possíveis soluções com o objetivo de
alcançar a combinação mais eficiente e efetiva de etapas e recursos;
• Generalização e transferência deste processo de resolução de problemas para uma
grande variedade de problemas (classes de problemas).
Essas habilidades são apoiadas e reforçadas por uma série de qualidades ou atitudes que
são dimensões essenciais do PC. Essas qualidades ou atitudes incluem:
• Confiança em lidar com a complexidade;
• Persistência ao trabalhar com problemas difíceis;
• Tolerância para ambiguidades;
• A capacidade de lidar com os problemas em aberto;
• A capacidade de se comunicar e trabalhar com outros para alcançar um objetivo ou
solução em comum.
9.2.3. Dicionários de Dados
O Dicionário de Dados é uma técnica simples e pode ser aplicada no desenvolvimento

de algoritmo e programas de pequeno porte. Ele é organizado na forma de uma tabela. As
variáveis, constantes e funções são dispostas nas linhas da tabela, sendo as colunas o nome
da variável, sus descrição, seu tipo de dados, seu valor inicial e o tipo de processo (Entra-
da➛Processamento➛Saída).
A título de exemplo, será feito o Dicionário de Dados no Programa 9.1.
Programa 9.1 Programa C para calcular f=

√ cos(a)+sen (b)
c
e −ln(d)
Usando a técnica de Dividir para Conquistar, faz-se:
f = v/(w+z)
v = sqrt(x+y)
x = cos(a)
y = sin(b)
w = exp(c)
z = log(d)
Variáveis de entrada: a, b, c, d
Variáveis auxiliares: v, x, y, w, z
Variável de saída: f
a dado da fórmula double input E
b dado da fórmula double input E
c dado da fórmula double input E
d dado da fórmula double input E
x x = cos(a) double calculada P
y y = sin(b) double calculada P
w w = exp(c) double calculada P
z z = log(d) double calculada P
v v = sqrt(x+y) double calculada P
f f = v/(w-z) double calculada S
Programa-fonte
#include <stdio.h>
#include <math.h>
int main(void){
double a, b, c, d, f, v, x, y, w, z;
printf( "\n Valores de a, b, c, d: " );

scanf ( "%lf %lf %lf %lf", &a, &b, &c, &d );
x = cos(a);
y = sin(b);
w = exp(c);
z = log(d);
v = sqrt(x+y);
f = v/(w-z);
printf( "\n x = %lf ", x ); // para conferir os cálculos

printf( "\n y = %lf ", y ); // para conferir os cálculos
printf( "\n w = %lf ", w ); // para conferir os cálculos
printf( "\n z = %lf ", z ); // para conferir os cálculos
printf( "\n v = %lf ", v ); // para conferir os cálculos
printf( "\n f = %lf ", f );
printf( "\n\n\n" );
return 0;
}
9.2.4. Plano de Testes
O Plano de Testes é organizado na forma de uma tabela e consiste de atribuir valores às

variáveis de entrada e calcular as demais variáveis do programa (variáveis auxiliares e de sa -
ída). Deve-se buscar identificar os possíveis erros e inconsistências do programa de forma a
adicionar instruções no programa-fonte para evitá-las, para que o programa não tenha erros.
A título de exemplo, será feito o Dicionário de Dados no Programa 9.2.
Programa 9.2 Programa C para calcular f=

√ cos(a)+sen (b )
c
e −ln(d )
Usando a técnica de Dividir para Conquistar, faz-se:
f = v/(w+z)
v = sqrt(x+y)
x = cos(a)
y = sin(b)
w = exp(c)
z = log(d)
Variáveis de entrada: a, b, c, d
Variáveis auxiliares: v, x, y, w, z
Variável de saída: f
a dado da fórmula double input E
b dado da fórmula double input E
c dado da fórmula double input E
d dado da fórmula double input E
x x = cos(a) double calculada P
y y = sin(b) double calculada P
w w = exp(c) double calculada P
z z = log(d) double calculada P
v v = sqrt(x+y) double calculada P
f f = v/(w-z) double calculada S
Plano de Testes
Variável Teste 1 Teste 2 Teste 3
a 1 2 9
b 2 3 8
c 3 4 3
d 4 5 2
x 0,5403023 -0,4161468 -0,9111303
y 0,9092974 0,1411200 0,9893582
w 20,0855369 54,5981500 20,0855369
z 1,3862944 1,6094379 0,6931472
v 1,2039932 erro 0,2796927
f 0,0643873 erro 0,0144228
Programa-fonte
#include <stdio.h>
#include <math.h>
int main(void){
double a, b, c, d, f, v, x, y, w, z;
printf( "\n Valores de a, b, c, d: " );

scanf ( "%lf %lf %lf %lf", &a, &b, &c, &d );
x = cos(a);
y = sin(b);
w = exp(c);
z = log(d);
v = sqrt(x+y);
f = v/(w-z);
printf( "\n x = %lf ", x ); // para conferir os cálculos

printf( "\n y = %lf ", y ); // para conferir os cálculos
printf( "\n w = %lf ", w ); // para conferir os cálculos
printf( "\n z = %lf ", z ); // para conferir os cálculos
printf( "\n v = %lf ", v ); // para conferir os cálculos
printf( "\n\n\n" );
return 0;
}
Teste 1 Teste 2 Teste 3
9.2.5. Descrição Linha a Linha
A Descrição Linha a Linha (DLL) de programas-fonte é uma técnica e seus objetivos edu-
cacionais estão descritos no Comentário 9.2.
Comentário 9.2 – Objetivos educacionais da Descrição Linha a Linha (DLL)
A Descrição Linha a Linha (DLL) é uma técnica para descrever cada linha de um programa-
fonte. Cada linha do programa-fonte é numerada e suas instruções são descritos ao lado.
• reforçar a compreensão do programa

• compreender o fluxo de controle
• detalhar a chamada de funções e seu retorno

• caracterizar definições, declarações, variáveis, expressões e estruturas do programa
• capacitar a escrita técnica
9.2.6. Mapeamento Variável Valor
É uma maneira listar as variáveis do programa-fonte e seus valores considerando o seu

fluxo de controle. Um exemplo do Mapeamento Variável Valor (MVV) é mostrado no Quadro
9.1.
Quadro 9.1 Mapeamento Endereço Variável Valor (MEVV) do Teste 1 do Programa 9.3
Variável Valor
a 1,0000000
b 2,0000000
c 3,0000000
d 4,0000000
x 0,5403023
y 0,9092974
w 20,0855369
z 1,3862944
v 1,2039932
f 0,0643873
Os compiladores C possuem a opção de debug, que permite marcar e acompanhar vari-

áveis do programa-fonte e monitorar seus valores durante a execução dos programas execu-
táveis. O C Tutor além de fazer o MVV muito bem, mostra também o fluxo de controle.
O Programa 9.3 mostra o Mapeamento Variável Valor feito pelo do C Tutor.
Programa 9.3 Mapeamento Variável Valor do Programa 9.2 por meio do C Tutor
Programa-fonte
#include <stdio.h>
#include <math.h>
int main(void){
double a = 1, b = 2, c = 3, d = 4, f, v, x, y, w, z;
x = cos(a);
y = sin(b);
w = exp(c);
z = log(d);
v = sqrt(x+y);
f = v/(w-z);
printf( "\n x = %lf ", x );

printf( "\n y = %lf ", y );
printf( "\n w = %lf ", w );
printf( "\n z = %lf ", z );
printf( "\n v = %lf ", v );
printf( "\n\n\n" );
return 0;
}
9.3. Algoritmo
Hoje em dia, tornaram-se comuns frase como: “Os algoritmos nos ajudam muito” ou “Os
algoritmos conhecem nossas necessidades melhor do que nós mesmos” ou “A inteligência
artificial vai controlar nosso mundo”.
A ideia de algoritmo é um conceito popular.
Aqui vamos discutir o conceito de algoritmo de forma científica. A Ciência requer concei -
tos e definições dos seus objetos de estudo e pesquisa.
Não há um único conceito científico de algoritmo, vários autores – vários conceitos, po -
rém a ideia geral é comum a todos os autores.
Pode-se definir algoritmo computacional como uma sequência ordenada e finita de ins -
truções para a solução de um problema a ser feita por computador. Este conceito se restrin -
ge à computação, mas nem todo algoritmo se destina aos computadores, como é o caso d o
Exemplo 9.1.
Exemplo 9.1 Receita de bolo simples.
Ingredientes Modo de Preparo
a) 2 xícaras (chá) de açúcar a) Bata as claras em neve e reserve

b) 3 xícaras (chá) de farinha de trigo b) Misture as gemas, a margarina e o
c) 4 colheres (sopa) de margarina açúcar até obter uma massa
d) 3 ovos homogênea
e) 1 e 1/2 xícara (chá) de leite c) Acrescente o leite e a farinha de trigo
f) 1 colher (sopa) bem cheia de fermento aos poucos, sem parar de bater.
em pó d) Por último, adicione as claras em
neve e o fermento
e) Despeje a massa em uma forma
grande de furo central untada e
enfarinhada
f) Asse em forno médio 180 °C,
preaquecido, por aproximadamente
40 minutos ou ao furar o bolo com
um garfo, este saia limpo
Fonte: https://www.tudogostoso.com.br/receita/29124–bolo–simples.html
Esta receita é um exemplo de algoritmo. Pode–se observar algumas características deste

algoritmo:
1. Temos duas partes, os ingredientes e as instruções (modo de preparo)

2. Tanto os ingredientes quantos as instruções são em número finito; temos 6
ingredientes e 6 instruções
3. Tem início e fim
4. É completo o suficiente para fazer o bolo simples a partir dos ingredientes
5. É detalhado o suficiente para fazer o bolo simples a partir dos ingredientes; nem mais
nem menos – pelo menos para seres humanos
6. Cada instrução é bem definida
Ouso afirmar que, de posse dos ingredientes, qualquer ser humano é capaz de fazer o
citado bolo a partir do algoritmo.
O Exemplo 9.2 é um exemplo de algoritmo computacional, ele busca resolver um proble-

ma bem especificado por meio de computador (calculadora eletrônica).
Exemplo 9.2 Algoritmo para somar dois números usando uma calculadora comum.
1. Digite o primeiro número com o teclado da calculadora

2. Comprimir a tecla referente à operação somar
3. Digite o segundo número com o teclado da calculadora
4. Comprimir a tecla referente ao igual
5. Leia o resultado no visor da calculadora
Algoritmos envolvendo cálculos e fórmulas matemáticas são mais fáceis de desenvolver

pois há muito menos ambiguidade na redação das tarefas. Elas tem a clareza da matemáti-
ca.
Para que o computador resolva nossos problemas, é necessário que a mente humana
(de um ou mais seres humanos) transforme o problema em algoritmo, conforme a Figura 9.4.
O ser humano é o meio, é ele que estabelece o passo a passo dos algoritmos.
Figura 9.4 Relação entre Problema, Solução Simbólica e Algoritmo.
De modo geral, os algoritmos executam três processos: a entrada de dados, o processa-

mento de dados e a saída de dados, resumidos na Figura 9.5.
Figura 9.5 Entrada → Processamento → Saída (EPS).
Os dados e o seu processamento dependem do problema, requerendo conhecimento pa-

ra elaborar seus algoritmos. Com base na Figura 9.5, pode-se redefinir o conceito de algorit-
mo.
O algoritmo para a resolução de um problema define e determina todas as trajetórias
possíveis entre suas entradas possíveis e suas saídas desejadas, incluídas todas aquelas que
conduzem a erros, para evitá-los.
Um algoritmo é a solução geral para um problema, que inclui aquelas trajetórias que são
corretas e também as que evitam as incorretas, desdo o seu início até o seu fim. Em termos
de algoritmo, não basta saber o que fazer, é necessário saber também o que não fazer, ou
seja, o que conduz ao erro. Em geral, existem vários algoritmos para a resolução de uma
classe de problemas. A criatividade, a imaginação e as necessidades humanas são capazes
de muitas realizações.
Pelo exposto, algoritmo requer dados e regras bem definidas para se chegar a resulta -
dos objetivos. Isto envolve o Pensamento Computacional, discutido no Comentário 9.3.
Comentário 9.3 Algoritmos Computacionais
Os algoritmos computacionais descrevem instruções a serem executadas por computador,

sua lógica é baseada em comparação.
Os algoritmos computacionais especificam ações claras e precisas que, a partir de um
estado inicial, após um conjunto de operações de tempo finito, produzem um estado final
previsível e bem definido. Eles estabelecem um padrão de comportamento a ser seguido,
uma norma de execução a ser trilhada, com vistas a alcançar, como resultado final, a
solução de um problema, garantindo que sempre que executado, sob as mesmas

condições, produza o mesmo resultado.
Os componentes fundamentais dos algoritmos computacionais são a Entrada – conjunto de
dados que deve ser fornecido ao algoritmo, a Saída – conjunto de dados produzidos pelo
algoritmo e o Processamento – transformação de dados de entrada em dados de saída,
ilustrado pela Figura 9.5.
O algoritmo deve sempre ser construído para resolver todas as possíveis ocorrências de um
problema. Um algoritmo é dito correto se ele sempre termina e produz a resposta correta
para todas as ocorrências de um dado problema.
A capacidade para resolver problemas pode ser entendida como a associação de
conhecimentos e habilidades. Conhecimento é adquirido pelo estudo. Habilidade,
adquirida pela prática, é experiência no uso do conhecimento
9.4. Conceito de Fluxo de Controle
O fluxo de controle percorre o programa do início ao fim, executando suas instruções

conforme definido pelo programador. O início é único mas pode haver várias instruções en-
cerrando esses programas.
O fluxo de controle pode ser entendido coma a execução linha a linha ou execução ins-
trução a instrução, a sequência da execução pode ser feita com um dedo. O conceito de Re-
gra do dedo é apresentado a seguir.
Regra do Dedo – pode-se percorrer os programas de computador

com um dedo e identificar seu fluxo de controle
O Comentário 9.4 discute os objetivos educacionais do fluxo de controle.
Comentário 9.4 – Objetivos Educacionais do Fluxo de Controle
O Fluxo de Controle é uma técnica para descrever a sequência da execução das instruções
de um programa-fonte. Cada linha do programa-fonte é numerada e suas instruções e a
sequência é iniciada na linha da função main e finalizada na linha do fim bloco da função
main.
• reforçar a compreensão do programa

• destacar os desvios nas chamadas de funções e seu retorno
9.5. Fluxograma
Fluxogramas representam gráfica e sequencialmente as instruções que compõem um al-

goritmo. Os Fluxogramas são menos detalhista do que os programas-fonte. Tem a vantagem
de serem gráficos e indicar com grande clareza o fluxo de controle do algoritmo.
Seus principais objetivos:
• padronizar a representação de algoritmos

• facilitar a leitura e o entendimento de programas de computador
• analisar algoritmos
O fluxograma não fornece detalhes e apresenta as tarefas sequencialmente, desde seu

início até o seu final, as setas indicam o fluxo de controle e as instruções são representadas
graficamente.
Existem muitos símbolos para representar fluxogramas. O programador pode também
criar seus próprios símbolos. O Quadro 9.2 lista os símbolos das principais instruções de um
fluxograma e o Comentário 9.5 mostra seu uso.
Quadro 9.2 Símbolos das principais instruções de um fluxograma
Símbolo Instrução
Terminal (início e fim do algoritmo)
Entrada de dados (via teclado)
Processamento de dados (cálculos)
Saída de dados (via vídeo)
Estrutura de decisão (condição)
Ponto de conexão
O Comentário 9.5 ilustra o usa das principais instruções de um fluxograma, descritas no

Quadro 9.2.
Comentário 9.5 Fluxograma para o cálculo da média de duas notas
9.6. Questões
1. Dê um exemplo de fluxo de controle. Justifique sua resposta.

2. Como se programa computadores?
3. Compare algoritmo com programa de computador.
4. Como se resolve um problema por meio de computadores?
5. Faça um fluxograma para cada o cálculo dos dígitos verificadores de CPF.
6. Faça um fluxograma para cada para o MDC de dois números.
7. Como se usa a Regra do Dedo nos fluxogramas?
8. Comente as etapas do método de George Polya para a resolução de problemas.
9. Qual a importância da verificação?
10.Faça um fluxograma do método de George Polya.
11.Faça um algoritmo para calcular as raízes da equação do segundo grau.
12.Faça um algoritmo para caminhar 200 m com passos de 0,8 m.
13.Relação entre Algoritmos, Programa de Computador e Linguagem de Programação
Computador.
10. Anexos
10.1. Instrução switch
A instrução switch é uma estrutura de decisão, é maneira simplificada de tomar decisão

com múltiplas escolhas. Ela possui uma expressão, uma lista de opções (case) que inclui a
opção default. A expressão é do tipo int ou do tipo char e as opções são constantes do tipo
int ou do tipo char. A expressão é comparada com as opções da lista e, quando é true, o blo-
co de comando correspondente é executado, quando todas as comparações são false, o blo-
co da opção default é executado e o switch é finalizado. A sintaxe da instrução switch é mos -
trada a seguir.
switch( expressão ){
case <case 1> : <bloco de instruções do case 1>
break;
case <case 2> : <bloco de instruções do case 2>
break;
...
case <case n> : <bloco de instruções do case n>
break;
default : <bloco de instruções default >
}
O switch é finalizado ao executar uma instrução break.

A Figura 10.1 ilustra o fluxograma da instrução de decisão s Quadro 9.2witch.
Figura 10.1 Fluxograma da instrução switch.
O switch aceita apenas expressões cujo resultado sejam do tipo char ou do tipo int.
O Comentário 10.1 aplica a Regra do Dedo a instrução switch.
Comentário 10.1 Estudo de caso da estrutura de decisão switch, com a Regra do Dedo
A figura ao lado apresenta o fluxo de controle da instrução

switch para a condição n = 2.
Utilizando a Regra do Dedo, pode-se acompanhar o fluxo

de controle do switch que, neste caso, avalia os casos
para os valores de n = 0, n = 1 e segue para n = 2 e,
então, executa apenas a instrução 21, instrução 22,
instrução 23 e break. A instrução break encerra o switch.
O fluxo de controle segue para a instrução 4 e, depois,
apara a instrução 5.
O Programa 10.1 usa a instrução switch para identifica o nome do dia da semana a partir
do seu número.
Programa 10.1 Identifica o nome do dia da semana a partir do seu número
Ao encontrar a instrução switch, o programa executará a instrução que for igual a valor da
variável dia corresponde ao de alguma constante do case, a instrução break encerra o
switch. Caso contrário será executado a instrução default que é o printf( "dia invalido" ) e
encerra o switch.
Cada instrução case do switch deve ser encerrado pelo break. A instrução default não
possui break, e deve ser o último do switch.
Sempre alguma opção de switch é selecionada, na falta de opções validas, o default é
executado – corresponde ao nosso Plano B.
Nas implementações acima, o uso do switch é o mais indicado pois apresenta melhor
legibilidade comparado a dos if’s aninhados.
A instrução switch é mais limitado que a instrução if/else.

O switch somente verifica se uma variável do tipo char ou do tipo int é ou não igual a um
certo valor constante.
O uso do switch, quando aplicável, torna o código mais legível do que o uso de vários if/ese
aninhados, como pode ser visto no Programa-fonte b.
Programa-fonte a Programa-fonte b
#include <stdio.h>
#include <string.h>
int main( void ){
int dia; #include <stdio.h>
puts ("Digite um valor de 1 a 7:"); #include <string.h>
scanf( "%d", &dia );
switch( dia ){ int main( void ){
case 1 : puts("domingo"); int dia;
break; puts ( "Digite um valor de 1 a 7: " );
case 2 : puts("segunda–feira"); scanf( "%d", &dia );
break;
case 3 : puts("terca–feira"); if( dia == 1 ) puts("domingo");
break; else if( dia == 2 ) puts("segunda–feira");
case 4 : puts("quarta–feira"); else if( dia == 3 ) puts("terca–feira");
break; else if( dia == 4 ) puts("quarta–feira");
case 5 : puts("quinta–feira"); else if( dia == 5 ) puts("quinta–feira");
break; else if( dia == 6 ) puts("sexta–feira");
case 6 : puts("sexta–feira"); else if( dia == 7 ) puts("sabado");
break; else puts("dia inválido");
case 7 : puts("sabado");
break; return 0;
default: puts("dia inválido"); }
}
return 0;
}
10.2. Instrução ternária
A instrução ternária ?:, ou operador ternário, é uma forma abreviada para escrever a
instrução if/else nas situações em que o lvalue é o mesmo tanto no if quanto no else.
A sintaxe da instrução ?: é mostrada a seguir.
lvalue = condicao ? <instrucao condicao true> : <instrucao condicao false>;
O Programa 10.2 mostra um uso do operador ternário.
Programa 10.2 Operador ternário
Os Programas-fonte a e b são equivalentes, como os lvalues (z) da instrução

if/else são iguais, pode-se usar a instrução ternária.
#include <stdio.h>
#include <stdio.h>
#include <math.h>
#include <math.h>
int main( void ){
int main( void ){
double x, z;
double x, z;
printf( "Digite um numero: " );
printf( "Digite um numero: " );
scanf( "%lf", &x );
scanf( "%lf", &x );
if( x > 0.0 ) z = sqrt(x);
z = x > 0.0 ? sqrt(x) : 0.0;
else z = 0.0;
return 0;
return 0;
}
}
10.3. Instrução do/while
A instrução do/while é uma estrutura de iteração da linguagem C, sua sintaxe e seu flu-
xograma estão apresentados na Figura 10.2.
do{
[ bloco do do/while; ]
}while( condição );
(a) (b)
Figura 10.2 a) Sintaxe da instrução do/while; b) e seu fluxograma.
O bloco da instrução do/while é executado ao menos uma vez pois sua condição é avali-
ada no final da instrução, como mostrado na Figura 10.2.
O bloco da instrução do/while é executado a primeira vez, sua condição é avaliada, o
bloco da instrução é executado novamente quando ela é true; a instrução do/while é encerra -
da quando ela é false. Ou seja, o bloco da instrução é executado a primeira vez e o do/while
repetirá seu bloco de instrução enquanto a condição for verdadeira.
No Programa 10.3 o bloco de instruções do do/while é repetido indefinidamente até que
seja lido zero (0) do teclado.
Programa 10.3 Leitura de caracteres alfanuméricos com do/while
O bloco de instruções do/while é executado ao menos uma vez, como a variável ch é lida
dentro da estrutura de iteração é desnecessário dar um valor inicial a ela.
Programa-fonte
#include <stdio.h>
int main( void ){
char ch;
do{
printf("\n digite um caractere diferente de zero: " );
scanf ( " %c", &ch );
}while( ch != '0' );
return 0;
}
No Comentário 10.2 discute a Regra do Dedo e o fluxo de controle da estrutura de ite-

ração do/while.
Comentário 10.2 Fluxo de controle da estrutura de iteração do/while com a Regra do

Dedo
A figura ao lado apresenta o fluxo de controle da

estrutura de iteração do/while com a condição x < y.
Utilizando a Regra do Dedo, pode-se acompanhar o

fluxo de controle desta estrutura. Nesta figura, o fluxo de
controle está colorido:
1. o fluxo de controle azul é o início do/while

2. o bloco de instrução é executado
3. a condição é avaliada
4. a condição é false, o fluxo vermelho é executado –
o do/while é encerrado
5. a condição é true, o fluxo verde é executado
6. retorna ao número 2
O Programa 10.4 aplica a instruções do/while em um circuito em malha aberta de um

amplificador.
Programa 10.4 Uso do do/while para listar os valores de V 1 e V2 de um circuito em malha

aberta de um amplificador operacional
O Amplificador Operacional genérico possui duas entradas e uma saída, quando a saída é
conectada à entrada inversora, após passar por um divisor de tensão, a equação abaixo
calcula o valor da saída V2 em função da entrada V1 e das resistências R1 e R2, e G é o
ganho em malha aberta do amplificador operacional.
R2
1+
R1
V 2=V 1 ( )
1 R2
+ +1
G G×R 1
Plano de Teste
Dados V1 = 1.0 V, G = 2.6, R1 = 500.0 Ω e R2 = 300.0 Ω, o programa-fonte calcula e

imprime o valor de V2 enquanto ele for menor do que 3.0 V.
A estrutura de iteração usada é a do/while que não requer o valor inicial de V2, uma vez
que ela é calculada dentro do bloco da estrutura.
Programa-fonte
#include <stdio.h>
int main( void ){
double V1, V2, R1, R2, G;
V1 = 1.0;
G = 2.6;
R1 = 500.0;
R2 = 300.0;
printf("\n V1 | V2 " );
printf("\n-------------" );
do{
V2 = V1*(1.0 + R1/R2)/(1.0/G + R2/G/R1 + 1.0);
printf("\n %.2lf | %.2lf", V1,V2 );
V1 += 0.25;
}while( V2 < 3.0 );
printf("\n-------------" );
return 0;
}
10.4. Instruções break e continue
As instruções break e continue alteram o fluxo de controle da estrutura de iteração on-

de se encontra. Blocos de instruções de estrutura de iteração podem conter uma ou mais ins-
truções break e também uma ou mais instruções continue.
A instrução break encerra a estrutura de iteração na qual ela está contida, como ilustra -
do no Comentário 10.3.
Comentário 10.3 Estudo de caso da instrução break, com a Regra do Dedo.
A figura o fluxo de controle da instrução break das estruturas de iteração for, while e
do/while.
Utilizando a Regra do Dedo, pode-se acompanhar o fluxo de controle deste instrução e

verificar que a execução do break e encerrar a estrutura de iteração.
Dentro de uma estrutura de iteração, a instrução continue ignora todas as instruções

abaixo dele e volta ao for, while ou do/while, como ilustrado no Comentário 10.4.
Comentário 10.4 Estudo de caso da instrução continue, com a Regra do Dedo.
A figura o fluxo de controle da instrução continue das estruturas de iteração for, while e
do{}while.
Utilizando a Regra do Dedo, pode-se acompanhar o fluxo de controle deste instrução e
verificar que a execução da instrução continue desvia o fluxo de controle para o
incremento do contador no for e para a condição nos casos do while e do/while.
O Programa 10.5 cria uma calculadora de quatro operações fazendo uso da estrutura de
iteração do/while para repetir um conjunto de escolhas {+ - * / 0 l } que são processadas pe -
la estrutura de decisão switch.
Programa 10.5 Calculadora de quatro operações
A calculadora de quatro operações faz uso da estrutura de iteração do/while para repetir
um conjunto de escolhas {'+' '-' '*' '/' '0' 'l'} que são processadas pela estrutura de
decisão switch.
O fluxo de controle do programa é definido pela variável op, do tipo char, que identifica as
opções para as operações da calculadora, op ∊ {'+' '-' '*' '/'}; para “limpar” a saída
padrão, op == 'l'; e para encerrar o do/while op == '0'.
Este programa faz uso da instrução continue, que é usada para alterar o fluxo de controle
se op ∊ '0' 'l'}; e da instrução break, no switch, para ignorar as operações não
selecionada e, se necessário, informar que o valor lido de op não é válido.
L Programa-fonte
2 int main( void ){
3 char op;
4 do{
5 float a, b;
6 printf("\n ---------------" );
7 printf("\n Calculadora" );
8 printf("\n ---------------" );
9 printf("\n + Somar" );
10 printf("\n - Subtrair" );
11 printf("\n * Multiplicar" );
Programa 10.5 Calculadora de quatro operações
12 printf("\n / Dividir" );
13 printf("\n ---------------" );
14 printf("\n 0 Encerrar" );
15 printf("\n l limpar" );
16 printf("\n ---------------" );
17 printf("\n escolha sua opção: " );
18 scanf ( "\n%c", &op ); // \n para evitar ler o caractere ENTER
19 if( (op == 'l') || (op == '0') ){
20 system("cls || clear");
21 continue;
22 }
23 printf("\n digite o primeiro número: " );
24 scanf( "%f" , &a );
25 printf("\n digite o segundo número: " );
26 scanf( "%f" , &b );
27 switch( op ){
28 case '+': printf("\n %f + %f = %f", a, b, a+b );
29 break;
30 case '-': printf("\n %f - %f = %f", a, b, a-b );
31 break;
32 case '*': printf("\n %f * %f = %f", a, b, a*b );
33 break;
34 case '/': printf("\n %f / %f = %f", a, b, a/b );
35 break;
36 default : printf("\n :: opção invalida :: \n" );
37 }
38 }while( op != '0' );
39 return 0;
40 }
O Programa 10.6 usa uma estrutura de iteração while e sua condição é sempre true, ela
nunca termina. No entanto, o while possui a instrução break que é executada com a entrada
de um denominador nulo (variável b) e, assim, finaliza o while.
Programa 10.6 Evitando divisão por zero com break
#include <stdio.h>
int main( void ){
double a, b;
while(1){ // condição == true
printf("\n digite o numerador: " );
scanf( "%lf" , &a );
printf("\n digite o denominador: " );
scanf( "%lf" , &b );
if( fabs(b) > 0.0 ){
printf("\n %lf / %lf = %lf", a, b, a/b );
}
else{
printf("\n :: divisão por zero :: operação inválida \n");
break;
}
}
return 0;
}
O Programa 10.7 é uma outra forma de imprimir números pares, neste caso é usado a
instrução continue, que é executada sempre que c % 2 for true, que ocorre quando c é ím-
par e seu valor não é impresso.
Programa 10.7 Imprimindo números pares com continue
#include <stdio.h>
int main( void ){
int c;
printf("\n números pares: " );
for( c = 0; c < 10; c++ ){
if( c % 2 ) continue;
printf("%3d", c );
}
printf("\n" );
return 0;
}
O Comentário 10.5 apresenta conceitos adicionais da instrução break e sua aplicação

em programas usando for.
Comentário 10.5 Conceitos adicionais da instrução break e sua aplicação em programas

usando for
A instrução break da instrução switch comporta-se do mesmo modo que o break das
estruturas de iteração (for, while e do/while). Em qualquer uma delas a execução do break
encerra tanto o switch quanto uma destas estruturas.
Se a instrução break estiver dentro de um bloco de comandos interno, a execução do break
encerrará este bloco e o fluxo de controle vai para a próxima instrução do bloco de
comandos externo.
Os quatro programas abaixo são equivalentes
#include <stdio.h> #include <stdio.h>

int i; int i = 0;
for( i = 0; i < 5; i++ ){ // padrão for(; i < 5; i++ ){
printf(" %d ", i ); printf(" %d ", i );
} }
return 0; return 0;
} }


int i; int i;
for( i = 0;; i++ ){ for( i = 0; i < 5;){
if( !(i < 5) ) break; printf(" %d ", i );
printf(" %d ", i ); i++;
} }
return 0; return 0;
} }
10.5. Tópicos de Função
10.5.1. Programação Modular
Quando os programas possuem poucas linhas de código, eles não precisam de módulos.
Entretanto, à medida que os programas crescem, eles podem ser difíceis de serem mantidos,
testados e depurados se não forem bem estruturados por causa da quantidade de interação
que ocorre entre o próprio código.
A tecnologia é marcada pela crescente complexidade e, para que ela possua robustez
sistêmica, a modularidade é uma maneira de dividir para conquistar, como o nome sugere, é
a existência de subunidades capaz de compor a estrutura geral.
Módulos são partes individuais de um programa que podem ser testados em separado e
reutilizados em outros programas. Eles são usados para melhorar, organizar e estruturar os
programas-fonte. Dividir programas-fonte em módulos é útil para:
• reutilização – podem ser reutilizados em outros programas, eliminando a necessidade

de uma reescrita completa, acelerando assim o trabalho de desenvolvimento
• legibilidade – escrever todo o programa-fonte em um único módulo pode, no futuro,
ser difícil e entendê-lo, tendo em vista que softwares evoluem
• manutenção – a medida que os softwares são usados, novos recursos são requeridos
e programas-fonte estruturados em módulos, permitem adicionar e modificar com mais
simplicidade
Como mencionado, a Linguagem C é utilizada para desenvolvimento de grandes siste-

mas. Por exemplo, o kernel17 Linux versão 2.6.0 contém por volta de 5,93 milhões de linhas
de código.
Como organizar todo este código, compilar e produzir o Linux para uso nas máquinas?
Todo este código é organizado em vários arquivos-fontes. Os arquivos-fontes, por sua
vez, são organizados em funções. E tudo isso é reunido em um único projeto, que possui um
arquivo-fonte com a função main. Para compilar/recompilar o projeto, todo ele ou apenas um
arquivo-fonte, é utilizado o utilitário GNU make (cria e manter grupos de programas, e outros
tipos de arquivos, a partir do código-fonte.
O principal componente estrutural da Linguagem C é a função – a unidade autônoma de
C. Em C, as funções são os blocos de construção em que todas as atividades do programa
ocorrem. Elas permitem que se defina e codifique individualmente as tarefas separadas em
um programa, permitindo assim que os programas sejam modulares. Após codificar uma
função, ela funcionará corretamente, sem produzir efeitos colaterais em outras partes do
programa. A modularização em projetos maiores, onde o código de um programador não de -
ve afetar acidentalmente o de outro, é extremamente importante.
17 Kernel ou núcleo é o componente central de um sistema operacional, ele serve de ponte entre os programas do usuário e
o processamento feito pelo hardware, que inclui gerenciar os recursos do sistema (CPU, memória e dispositivos de
entrada/saída).
O fluxo de controle da chamada de funções por programas é apresentado na Figura

10.3. A sequência deste fluxo é organizada em quatro etapas, descritas a seguir:
1. Ao encontra uma função, o programa faz a chamada desta função passando seus
argumentos
2. O fluxo de controle é transferido para a função; ela atualiza seus parâmetros com os
argumentos recebidos e processa os seus comandos até encontrar a instrução return.
3. O fluxo de controle é transferido para o programa com o resultado do return.
4. O programa atribui o resultado ao nome da função e passa para o próximo comando.
Figura 10.3 Esquema da chamada de função por um programa.
A Figura 10.3 representa o fluxo de controle da chamada de funções por programas. Es-
te raciocínio pode ser ampliado para funções chamando funções, e assim por diante. É assim
que Programa C funcionam, a função main chama várias funções que, por sua vez, chamam
várias funções que, por sua vez, chamam várias funções … até, talvez, chegar às funções da
Biblioteca Padrão.
As funções da Linguagem C usam apenas as memórias da Stack, elas e seus recursos
são gerenciadas pelo Sistema Operacional.
É importante ter clareza dos conceitos da Linguagem C abaixo relacionados:
• chamada de função – referência do nome de uma função feita por outra função ou pelo
programa, o fluxo de controle é transferido para a função referenciada
• argumento – valor, apontador ou endereço enviado para uma função ao ser chamada
• parâmetro – valor, apontador ou endereço recebido por uma função após sua chamada
• passagem de argumentos – os argumentos são passados na chamada de função
• passagem por valor – o argumento é um valor
• passagem por referência – o argumento é apontador ou endereço
• retorno da função – a função retorna para ao ponto de chamada, o fluxo de controle é
transferido para o ponto de chamada da função
10.5.2. Protótipo de Função
Na linguagem C o protótipo de uma função indica o tipo da função, seu nome e os tipos
e quantidades de parâmetros entre parêntesis e o delimitador ponto e vírgula.
O protótipo de uma função não possui o bloco de comando, um ponto e vírgula está no
seu lugar. O protótipo é um recurso que informa a existência da função para o compilador
mas que seu código está implementado em outro local do programa. O linker une tudo no
programa executável.
Sabendo o protótipo de uma função é o suficiente para usá–la. Neste caso, o corpo da
função é, ou está feito, em outro lugar.
O protótipo de uma função C tem a sintaxe:
<tipo> identificador( <parâmetros> );
Nos protótipos basta os tipos dos parâmetros separados por vírgula, como no exemplo
abaixo, os nomes dos parâmetros são opcionais.
void escreva( void );

void divide ( float, int );
float saida ( void );
int soma ( int , int );
O Programa 10.8 faz uso de protótipo.
Programa 10.8 Implementação da função SomaInt em C com uso de protótipo
#include <stdio.h>
int SomaInt( int, int ); // protótipo de SomaInt
int main( void ){

int s, a = 5, b = 7;
s = SomaInt(a,b);
printf("\n soma = %d ", s );
return 0;
}
int SomaInt( int x, int y ){ // implementação de SomaInt

int soma;
soma = x + y;
return soma;
}
O Biblioteca Padrão apresenta apenas os protótipos de suas funções, já que o nome dos
parâmetros é dado pelo programador.
10.5.3. Passagem de Argumentos por Valor
Quando se chama uma função C, o Sistema Operacional cria a função numa região da
Stack. Ao chamar a função, são feitas cópias dos argumentos requeridos pela função e envia-
dos para seus respectivos parâmetros da Stack, desta forma funções não podem alterar os
argumentos de quem as chama, podem alterar apenas os valores dos seus parâmetros, que
são apenas cópias. Este processo é denominado passagem de argumentos por valor, e neste
caso, a função processa as cópias recebidas e, ao ser encerrada, o Sistema Operacional libe-
ra os recursos destinados à função.
O tipo de retorno das funções podem ser void (o return é opcional), bool, char, int, float,
double e seus modificadores. O mesmo é válido para a lista de parâmetros formais; void indi -
ca que a função não recebe parâmetros, pode ter um ou mais parâmetros de tipos de dados
válidos, separados por vírgula. Uma função pode receber parâmetros de diversos tipos e po-
de possuir muitos retornos.
A Figura 10.4 apresenta os quatro formatos básicos das funções e seu uso quanto ao ti -
po, parâmetros, passagem de argumentos por valor e seu retorno.
Figura 10.4 Os quatro formatos básicos das funções e seu uso quanto ao tipo, parâmetros,
passagem de argumentos por valor e seu retorno.
O Programa 10.9 é uma aplicação de função para imprimir faixa de números inteiros.
Programa 10.9 Programas C com funções para imprimir e somar faixa de números
Tanto a função Imprimir quanto a função Somar recebem dois parâmetros do tipo int. A
função Imprimir é do tipo void, não tem a instrução return. A função Somar é do tipo int,
tem a instrução return seguido da variável S, também do tipo int.
Na função main, as funções são chamadas e passados os argumentos para cada função. O
primeiro argumento da chamada vai para o primeiro parâmetro da função, o segundo
argumento da chamada vai para o segundo parâmetro da função.
Na função main, a chamada da função Imprimir não retorna valor, ela é do tipo void.
Na função main, a chamada da função Somar retorna valor que é atribuído à variável s.
Programa-fonte
Programa 10.9 Programas C com funções para imprimir e somar faixa de números
#include <stdio.h>
void Imprimir( int, int );
int Somar ( int, int );
int main( void ){
int s;
Imprimir(1,5);
Imprimir(1,9);
s = Somar(1,5);
printf("\n Somar(1,5) = %d", s );
s = Somar(1,9);
return 0;
}
void Imprimir( int i, int f ){
int n;
for( n = i; n <= f; n++ )
printf("%4d", n );
}
int Somar( int i, int f ){
int n, S = 0;
for( n = i; n <= f; n++ )
S += n;
return S;
}
O Programa 10.10 soma faixa de números, usando uma função, envolve conversões na
chamada da função, os valores int dos argumentos são convertidos para float nos parâme-
tros; e conversão do retorno da função de float para int em main.
Embora a linguagem C permita estas misturas de tipos, elas devem ser usadas com mui-
to cuidado, não sendo recomendada.
Programa 10.10 Programas C com funções para somar faixa de números, outra versão
A função Somar tem dois parâmetros do tipo float, ela é do tipo int mas retorna valor do
tipo float, neste caso o valor retornado é convertido para int.
Os parâmetros da função Somar são do tipo float mas, na função main a chamada da
função Somar é feita com argumentos do tipo int, neste caso, os valores passados são
convertidos para float antes de serem recebidos pela função Somar.
Programa-fonte
Programa 10.10 Programas C com funções para somar faixa de números, outra versão
#include <stdio.h>
int Somar( float i, float f ){
int n;
float S = 0;
for( n = i; n <= f; n++ )
S += n;
return S;
}
int main( void ){
int s, a = 1, b = 5;
s = Somar(a,b);
return 0;
}
10.5.4. Recursividade
A recursividade ou recursão é uma técnica usada para resolver problemas de computa-

dor criando uma função que chama a si mesma até o resultado seja alcançado.
Em muitos problemas complexos como ordenação e busca em textos, a solução é ine-
rentemente recursiva e a solução iterativa pode não existir ou ser difícil de ser encontrada.
O Programa 10.11 mostra dois programas, um com a função void prn( void ) não recur-
siva e outro com função void prnr( int ) recursiva. Observe que a função recursiva chama a
si mesmo, ou seja, dentro de prnr tem um instrução prnr.
Programa 10.11 Programas C para imprimir os números inteiros de 0 a 5 com recursividade

e sem recursividade
Embora diferentes, os programas-fonte a e b exibem os mesmos resultados.

O programa-fonte a faz uso da função não recursiva void prn( void ). Já O programa-fonte b
faz uso da função recursiva void prnr( int ). A função prnr chama a si mesma até que i >
5. Toda função recursiva requer uma condição para ser encerrada; no caso da prnr é if( i
<= 5 ) ser false.

void prn( void ){ void prnr( int i ){
int i; if( i <= 5 ){
for( i = 0; i <= 5; i++ ) printf("%4d", i );
printf("%4d", i ); prnr(i+1);
}
}
}
int main(void){
int main(void){
prn();
prnr(0);
return 0;
return 0;
}
}
Uma função recursiva deve ter, pelo menos, uma condição para que ela pare de chamar
a si mesma. Caso contrário a função recursiva chama a si mesma indefinidamente, até que o
computador esgote seus recursos e o sistema operacional fique inoperante 18. Neste caso é
necessário reiniciar a máquina.
Programa 10.12 As funções fat e Fib, para calcular fatorial e a série de Fibonacci,
respectivamente
As funções fat e Fib calculam o fatorial e a série de Fibonacci de um número inteiro,

respectivamente. Elas são funções recursivas pois chamam a si mesmas. Acompanhe a
execução de cada uma delas por meio do C Tutor considerando o Comentário 10.6.
Programa-fonte
#include <stdio.h>
int fat(int n){
if( n == 0 ) return 1;
else return n*fat(n–1);
}
int Fib(int n){
if( (n == 0) || (n == 1) ) return n;
else return Fib(n-2) + Fib(n-1);
}
int main( void ){
printf( "\n fat(5) = %d", fat(5) );
printf( "\n Fib(5) = %d", Fib(5) );
return 0;
}
O Comentário 10.6 discute o consumo da Pilha do Sistema Operacional (Stack) do pro-

grama por funções recursivas.
Comentário 10.6 Funções recursivas podem consumir muita memória da máquina pois
fazem uso intensivo da RAM, especificamente, da Pilha do Programa (Stack)
18 Também conhecido como loop infinito – termo em inglês.

A figura ao lado representa a Pilha do Programa (Stack) de

um programa ao chamar a função Fib(5).
A chamada recursiva desta função usa a Stack do programa

para armazenar os valores intermediários de Fib(4), Fib(3),
Fib(2), Fib(1) e Fib(0). Estas chamadas podem ser
organizadas em uma árvore, vista ao lado.
Foi usado Fib(5) porque é mais fácil de visualizar.
É uma fonte de erro do tipo “Estouro do Stack”, que pode

travar a máquina ou torná-la extremamente lenta.
A imagem abaixo, mostra uma parte da execução de Fib(5)

no C Tutor.
Uma função recursiva pode ser reescrita com o uso de iteração, e vice–versa. O exemplo
a seguir calcula a soma de um vetor de forma recursiva. O Programa 10.13 discute a soma
de um vetor de forma recursiva.
Programa 10.13 A soma dos elementos de um vetor de forma recursiva
A função Soma tem os parâmetros V, um vetor do tipo int; e n, do tipo int – tamanho de V.
Ela é chamada pela função main com os argumentos {1,2,3,4,5} e 5. A função Soma é
recursiva e, como toda função recursiva possui uma estrutura de decisão, neste caso a
instrução if/else com a condição n > 0. Quando n == 0 a função Soma retorna 0 – elemento
neutro da adição – que é adicionado às parcelas de Soma previamente calculadas
recusivamente. Soma chama a si mesma sucessivamente, e a cada chamada tem
argumentos V e n-1, de forma que, em algum momento n == 0 e a recursividade é
encerrada.
Observe que:
1. Soma(V,0) retorna 0;
Programa 10.13 A soma dos elementos de um vetor de forma recursiva
E também que Soma(V,-1), Soma(V,-2), ... retornam 0. Já Soma(V,6), Soma(V,7), … é erro
de lógica de programação.
Programa-fonte
#include <stdio.h>
int Soma( int V[], int n ){
if( n > 0 ) return V[n-1] + Soma(V,n-1);
else return 0;
}
int main( void ){
int V[] = {1,2,3,4,5};
printf(" Soma = %d", Soma(V,5));
return 0;
}
Para toda função recursiva tem, pelo menos, uma função não recursiva alternativa, con-
tendo alguma estrutura de iteração.
Uma função recursiva, comumente, não é fácil de entender à primeira vista.
10.5.5. Recursividade x Interatividade
Como calcular Tn, soma dos pontos dos números triangulares de ordem n?
Os números triangulares são números naturais e são os obtidos através de sucessivos
triângulos equiláteros, formados pelo triângulo equilátero unitário.
O primeiro número triangular é número 1.
O segundo é o triângulo equilátero unitário, com três pontos.
O terceiro é o triângulo equilátero formado por 4 triângulos unitários, com seis pontos.
O quarto é o triângulo equilátero formado por 9 triângulos unitários, com 10 pontos.
A série é 1, 3, 6, 10, ···, ou seja, Tn = n(n+1)/2
Figura 10.5 Números triangulares.
Os valores de Tn, podem ser escritos de duas maneiras:
Maneira 1 Maneira 2
T1 = 1 T1 = 1
T2 =1+2 T2 = T1 + 2
T3 =1+2+3 T3 = T2 + 3
T4 =1+2+3+4 T4 = T3 + 4
··· ···
Tn = 1 + 2 + 3 + ··· + n-1 + n Tn = Tn-1 + n
A Maneira 1 é chamada de solução interativa, basta a última equação.

A Maneira 2 é chamada de solução recursiva, a última equação depende da equação an-
terior, e assim por diante, até T1 = 1, que não tem antecedente.
Pode-se elaborar dois algoritmos, com diferentes técnicas, para resolver o mesmo pro-
blema. A técnica interativa (Algoritmo da Maneira 1) usa a estrutura de iteração for como so-
lução. A técnica recursiva (Algoritmo da Maneira 2) usa a recursividade como solução. O
mesmo problema, duas soluções.
Algoritmo da Maneira 1 Algoritmo da Maneira 2

int M1( int n ){ int M2( int n ){
int i, T = 0; if( n == 1 ) return n;
for( i = 0; i <= n; i++ ) else return n + M2(n-1);
T += i; }
return T;
}
Tanto a técnica interativa quanto a recursiva fazem uso do Stack. A técnica recursiva faz
uso intensivo do Stack, como pode ser visto no Erro: Origem da referência não encontrada.
Embora Algoritmo não tenha concurso de beleza, meu senso estético admira uma solução re-
cursiva – o complexo se apresentando como simples.
O Algoritmo da Maneira 2, que usa recursividade, exige mais imaginação. E, embora se-
jam apenas letras, ele é portador de uma dinâmica que lhe é própria, que se tornará presen -
te ao ser executado e, quem programa, deve antecipá–la em detalhe no ato da escrita.
10.5.6. Escopo de Nomes e Tempo de Vida de Variáveis
Os parâmetros das funções e as variáveis declaradas no seu bloco de instrução são cha -
madas variáveis locais. As variáveis locais são conhecidas apenas nas funções que as decla-
ram. Quando as funções são chamadas, elas criam suas varáveis – todas locais; quando a
função é encerrada, suas variáveis são destruídas.
As variáveis globais são declaradas fora das funções, normalmente abaixo das inclusões
de bibliotecas e das constantes. O Programa 10.14 discute este conceito.
Programa 10.14 Implementação da função Soma em C – variáveis globais.
O SO carrega o programa executável na memória e cria as variáveis a e b e a função main

e tudo relacionado a ela e, ao fim do programa, o SO destrói tanto main e seus recursos
quanto as variáveis a e b.
O programa possui as variáveis a e b, que são variáveis globais – são variáveis do

programa e não de uma função – elas podem ser usadas em todas funções do programa –
tem visibilidade global ou escopo global.
A função Soma possui uma variável local: s – é uma variável da função Soma e não pode
ser usada em outra função do programa – tem visibilidade local ou escopo local.
A função main, ao chamar Soma, envia void como argumento. O SO cria Soma na Stack. As
instruções do corpo da função são executados e, ao encontrar return s, o SO faz uma cópia
do valor de s e envia para main. O SO destrói Soma e tudo a ela relacionado. A função
main recebe a cópia de s e envia para a função printf.
Vale ressaltar que as variáveis a e b podem ter seus valores alterados por Soma pois a e b
são globais.
Ao finalizar o programa executável, o SO destrói tanto main e seus recursos quanto as

variáveis a e b.
Programa-fonte
#include <stdio.h>
float a = 5, b = 7; // a e b são variáveis globais

// a e b são visíveis em todo programa
int Soma( void ){
int s; // s é variável local – visível apenas na função Soma
s = a + b;
return s;
}
int main( void ){
printf("\n soma = %d ", Soma() );
return 0;
}
Outra implementação para a função Soma, com variáveis locais, está no Programa
10.15.
Programa 10.15 Implementação da função Soma em C – variáveis locais.

As variáveis a, b são globais, são acessíveis em qualquer lugar do programa, abaixo de

suas declarações.
A função main faz uso de a e b como argumentos para a função Soma.
A função Soma possui dois parâmetros: x e y.
A função Soma possui três variáveis locais: x, y e s.
A função main, ao chamar Soma, envia os valores de a e b como argumentos. O SO cria
Soma na Stack e os parâmetros x e y para receber cópia dos valores de a e b. As
instruções do corpo da função são executados e, ao encontrar return s, o SO faz uma cópia
do valor de s e envia para main. O SO destrói Soma e tudo a ela relacionado. A função main
recebe a cópia de s e envia para a função printf.
Programa-fonte
#include <stdio.h>
float a = 5, b = 7;
int Soma( int x, int y ){

int s;
s = x + y;
return s;
}
int main( void ){

printf("\n soma = %d ", Soma(a,b) );
return 0;
}

1. O programa abaixo está correto?

#include <stdio.h>
int main( void ){
int x;
printf( "Digite um numero inteiro: " );
scanf( "%d", &x );
x % 2 ? printf("x e impar") : printf("x e par");
return 0;
}
2. …
1. Elabore uma função que leia um número não determinado de valores positivos e
retorne a média aritmética desses valores. Terminar a entrada de dados com o valor zero.
2. Faça uma função que receba um valor inteiro e positivo, calcule e mostre seu fatorial.
3. Elabore uma função que receba como parâmetro um valor n (inteiro e maior ou igual a
1 1 1 1
1) e determine o valor da soma S=1+ + + +⋯+ .
2 3 4 n
4. Faça uma função que receba como parâmetro um valor inteiro e positivo n, indicando a
2
1 2 5 10 17 26 n +1
quantidade de parcelas de uma soma S= + + + + + +⋯+ .
3 4 5 6 7 8 n+3
5. Foi realizada uma pesquisa entre M habitantes de uma região. Os dados coletados de
cada habitante foram: idade, sexo, salário e número de filhos. Faça uma função que leia
esses dados armazenando–os em vetores. Depois, crie funções que recebam esses vetores
como parâmetro e retornem a média de salário entre os habitantes, a menor e a maior
idade do grupo e a quantidade de mulheres com três filhos que recebem até M$ 2.500,00
(utilize uma função para cada cálculo). Teste o programa para M = 15.
6. A prefeitura de uma cidade fez uma pesquisa entre seus habitantes, coletando dados
sobre o salário e o número de filhos. Faça uma única função que leia esses dados para um
número não determinado de pessoas e imprima a média de salário da população, a média
do número de filhos, o maior salário e o percentual de pessoas com salário inferior a M$
4.200,00.
7. Crie um programa que receba três valores (obrigatoriamente maiores que zero),
representando as medidas dos três lados de um triângulo. Elabore funções para: a)
determinar se esses lados formam um triângulo, determinar e mostrar o tipo de triângulo
(equilátero, isósceles ou escaleno), caso as medidas formem um triângulo. Todas as
mensagens deverão ser mostradas na função main.
8. Faça um programa que receba a temperatura média de cada mês do ano e armazene–
as em um vetor. O programa deverá calcular e mostrar a maior e a menor temperatura do
ano, junto com o mês em que elas ocorreram (o mês deverá ser mostrado por extenso: 1
= janeiro; 2 = fevereiro; …). Desconsidere empates. Cada cálculo deve ser realizado e
mostrado em uma função.
9. Crie um programa que receba o número dos M alunos de uma sala, armazenando–os
em um vetor, junto com as notas obtidas ao longo do semestre (foram realizadas quatro
avaliações). Elabore funções para: a) determinar e mostrar a média aritmética de todos os
alunos; b) indicar os números dos alunos que deverão fazer recuperação, ou seja, aqueles
com média inferior a 7. Todas as mensagens deverão ser mostradas na função main.
Teste o programa para M = 15.

10.Elabore e teste uma função recursiva para calcular o resto da divisão inteira usando
subtração.
11.Elabore e teste uma função recursiva para calcular o quociente da divisão inteira
usando subtração.
12.Elabore e teste uma função recursiva para calcular o produto de dois números naturais
usando adição.
13.Elabore e teste uma função que retorna o número de segundos de x horas.
14.Elabore e teste uma função para verificar se um ano é bissexto.
15.Elabore e teste uma função que retorna o número dias um dado mês.
16.Escreva uma função recursiva para calcular a função de Ackermann
{ }
n+1 se m> 0
A (m , n)= A (m−1,1) se m>0 e n=0 , sendo m e n valores inteiros não negativos.
A (m−1 , A ( m, n−1)) se m>0 e n>0
17.Escreva uma função recursiva para calcular o valor de x n.

1 2 3 4 20
18.Para calcular S= + + + +⋯+ escreva: a) uma função não recursiva; b) uma
1 3 5 7 39
função recursiva.
70 69 68 67 70−n
1. Elabore uma função para calcular o valor de S (n)=+ + + +⋯+ para: a) n
7 14 21 28 7n
= 15; b) n = 30; c) n = 45; e d) n = 60. Calcule e explique as razões
S (15) S (30) S (45) S(15)
, , e .
S (30) S(45) S (60) S(60)
2. Escreva uma função para contar o número de primos menores do que 1000.
3. Escreva uma função recursiva para calcular o MDC.
10.6. Biblioteca Padrão C (glibc)
A Biblioteca Padrão C (glibc) é um conjunto de funções que contém operações comuns

em programas C. Estas funções são agrupadas por cabeçalhos. A nomenclatura e o escopo
dos cabeçalhos é comum a diferentes implementações. No Quadro 10.1 estão os cabeçalhos
da Biblioteca Padrão ANSI C.
Quadro 10.1 Cabeçalhos da Biblioteca Padrão ANSI C
Cabeçalho Descrição
Macro para ajudar na detecção de erros lógicos e outros tipos de erros em versões
<assert.h>
de depuração de um programa
<complex.h> Conjunto de funções para manipular números complexos
Funções usadas para classificar caracteres pelo tipo ou para converter entre caixa
<ctype.h>
alta e baixa independentemente da codificação
<errno.h> Teste de códigos de erro reportados pelas funções da biblioteca

<fenv.h> Controle de ponto flutuante
Constantes de propriedades específicas de implementação da biblioteca de ponto
<float.h>
flutuante
<inttypes.h> Conversão precisa entre tipos inteiros
<iso646.h> Programação na codificação de caracteres ISO 646
Constantes de propriedades específicas de implementação da biblioteca de tipos
<limits.h>
inteiros
<locale.h> Constantes para setlocale() e assuntos relacionados
<math.h> Funções matemáticas comuns em computação
<setjmp.h> Macros setjmp e longjmp, para saídas não locais
<signal.h> Tratamento de sinais
<stdarg.h> Acesso dos argumentos passados para funções com parâmetro variável
<stdbool.h> Definição do tipo de dado booleano
<stdint.h> Definição de tipos de dados inteiros
<stddef.h> Diversos tipos e macros úteis
<stdio.h> Manipulação de entrada/saída
<stdlib.h> Diversas operações
<string.h> Tratamento de cadeia de caracteres
<tgmath.h> Funções matemáticas
<time.h> Conversão de tipos de dado de data e horário
<wchar.h> Manipulação de caractere wide, usado para suportar diversas línguas
<wctype.h> Classificação de caracteres wide
10.7. Palavras Reservadas da Linguagem C
As palavras reservadas são componentes da linguagem C e cada uma delas tem sua
própria sintaxe. Uma palavra reservada é essencialmente uma instrução que determina o
que pode ser feito com a linguagem. O conjunto de palavras reservadas especificado pelo pa -
drão ANSI C são listadas no Quadro 10.2.
Quadro 10.2 Palavras reservadas da Linguagem C
Palavra Reservada Uso

Tipos de Dados e afins
auto classe de armazenamento de variável
char tipo de dados utilizado para armazenar caracteres
const cria variável atribuindo um valor que não pode ser modificado
double tipo de dado numérico de ponto flutuante – precisão dupla
enum tipo de dados definido pelo programador
extern indica que a variável foi declarada em outro arquivo
float tipo de dado de ponto flutuante com precisão simples
int tipo de dado numérico para armazenar valores inteiros

long modificador de tipo de dado int e double
register classe de armazenamento de variável
short modificador de tipo de dado int
sizeof função que retorna o tamanho do argumento
signed modificador de tipo de dado int e char
static classe de armazenamento de variável
struct cria estruturas
typedef cria novo nome para tipos de dados
union cria unions
unsigned modificador de tipo de dado int e char
void 19
tipo de dado que indica ausência de parâmetro ou de argumento
volatile classe de armazenamento de variável
Fluxo de Controle e afins
break força a saída das instruções switch, for, while e do-while
case instrução do switch para selecionar uma constante
continue força a interrupção das estruturas de iteração for, while e do-while
default usado no switch
do parte da instrução do-while
else parte opcional da instrução if
for instrução de iteração
goto faz desvio (uso não recomendado)
if instrução de decisão
return instrução para retorno de função
switch instrução de seleção
while instrução de iteração
10.8. Algoritmos Gerais
Há muitos algoritmos, muitos deles documentados como, por exemplo, o livro “Numeri-
cal Recipes in C” (Press, 1992). Entretanto, para os cursos introdutórios, são usados algorit-
mos mais simples, que usam conceitos usuais. Os algoritmos básicos e os derivados, discuti -
dos neste item, são de fácil compreensão e amplamente aplicados.
10.8.1. Algoritmos Básicos
Uma das maiores utilidades do computador é sua capacidade de contar, somar, pesqui -
sar e calcular estatísticas. A Tabela 10.1 contem a descrição dos algoritmos para algumas
19 O uso do void é bem mais sofisticado do que o descrito.

operações destas operações.
Quadro 10.3 Tabela 10.1 Algoritmos básicos e suas descrições, X denota a "variável de
interesse"
Operação Procedimento
Cria-se a variável n inteira, com valor inicial zero (0). Coloque a instrução
Contar n = n + 1 de dentro de uma estrutura de iteração (EI). Ao sair da EI, n é o
número de ocorrências ou a contagem total
Cria-se a variável S, com valor inicial zero (0.0). Coloque a instrução S =

Somar S + X de dentro de uma estrutura de iteração (EI). Ao sai da EI, S é a
soma dos valores de X
Para trocar os valores de duas variáveis, cria-se uma terceira variável

para salvar o valor de uma delas e, em seguida, fazer a troca.
Trocar
Sejam x e y as variáveis e z a terceira variável, a troca é feita pelas
instruções: z = x, x = y e y = z, nesta sequência
A pesquisa de um valor em um conjunto e feita comparando este valor

Pesquisar
com cada elemento do conjunto com uma estrutura de iteração.
Cria-se a variável Xmin, com o valor inicial maior possível.

Cria-se a variável Xmax, com o valor inicial menor possível. Coloque as
Valor Extremo instruções if( X < Xmin ) Xmin = X e if( X > Xmax ) Xmax = X dentro de
uma EI. Ao sair da EI, Xmin é o valor mínimo de X e Xmax é valor máximo
de X
O Comentário 10.7 apresenta outro algoritmo para os valores extremos.
Comentário 10.7 Outro Algoritmo para o Valor Extremo
Cria-se as variáveis Xmin e Xmax, sem valor inicial. Dentro da ER, coloque as instruções
if( contador == 0 ) Xmin = Xmax = X; if( X < Xmin ) Xmin = X; e if( X > Xmax ) Xmax = X.
Ao sair da ER, Xmin o valor mínimo de X e Xmax é o valor máximo de X.
10.8.1.1. Contar
Contar é usado em médias e percentagens, dentre outras estatísticas. Seja o conjunto

numérico X = { x1, x2, x3, x4, x5 }, uma sequência de cinco elementos.
A contagem dos elementos de X, feito matematicamente, é igual a 1 + 1 + 1 + 1 + 1.
Nós, seres humanos, contamos os elementos de X elemento a elemento. E o computador pro-
cessa a contagem dos elementos de X utilizando uma sequência de instruções.
Estas operações são mostrados no Quadro 10.4.
Quadro 10.4 Modos de contar os elementos de X

Matemática Pensamento Computacional Computador

(Equação) (Algoritmo) (Instrução)
Criar variável conta para contar Declarar conta
Iniciar conta com 0, conta = 0 conta = 0
1 Adicionar 1 a conta, conta = 1 conta = conta + 1
1+1 Adicionar 1 a conta, conta = 2 conta = conta + 1
1+1+1 Adicionar 1 a conta, conta = 3 conta = conta + 1
1+1+1+1 Adicionar 1 a conta, conta = 4 conta = conta + 1
1+1+1+1+1 Adicionar 1 a conta, conta = 5 conta = conta + 1
O passo a passo para contar os elementos do conjunto X é sequência apresentada no

Programa 10.16.
Programa 10.16 Conta apenas valores positivos lidos do teclado
1. criar a variável conta (para armazenar a contagem)

2. fazer conta = 0 (elemento neutro da adição)
3. percorrer X, elemento a elemento, do início ao fim, e fazer
a) conta = conta + 1
b) conta = conta + 1
c) conta = conta + 1
d) conta = conta + 1
e) conta = conta + 1
4. Anunciar o valor de conta
Pode-se constatar que o passo 3 é uma estrutura de iteração. Logo, para contar os
elementos de um conjunto X = {xi}, basta criar conta = 0 e, dentro de uma estrutura de
iteração, fazer conta = conta + 1.
#include <stdio.h>
int main( void ){
int conta = 0;
scanf( "%d", &x );
while( x >= 0 ){
conta = conta + 1;
scanf( "%d", &x );
}
printf( "%d", conta );
return 0;
}
10.8.1.2. Somar
Acumuladores são utilizados para a realizar somas. Seja o conjunto numérico X = { x 1,

x2, x3, x4, x5 }, uma sequência de cinco elementos.
A soma dos elementos de X, feito matematicamente, é igual a x 1 + x2 + x3 + x4 + x5 .
Nós, seres humanos, somamos os elementos de X elemento a elemento. E o computador pro-
cessa a soma dos elementos de X utilizando uma sequência de instruções.
Estas operações são mostrados no Quadro 10.5.
Quadro 10.5 Modos de somas elementos de X
Matemática Pensamento Computacional Computador

(Equação) (Algoritmo) (Instrução)
Criar variável para acumular a soma Declarar soma
Iniciar a soma com 0, soma = 0 soma = 0
x1 Adicionar x1 a soma, soma = soma + x1 soma = soma + x1
x1 + x 2 Adicionar x2 a soma, soma = soma + x2 soma = soma + x2
x1 + x 2 + x 3 Adicionar x3 a soma, soma = soma + x3 soma = soma + x3
x1 + x 2 + x 3 + x 4 Adicionar x4 a soma, soma = soma + x4 soma = soma + x4
x1 + x 2 + x 3 + x 4 + x 5 Adicionar x5 a soma, soma = soma + x5 soma = soma + x5
O passo a passo para somar os elementos do conjunto X é a sequência apresentada no

Programa 10.17.
Programa 10.17 Somar 10 valores inteiros lidos do teclado
1. criar a variável soma (para armazenar o somatório)

2. fazer soma = 0 (elemento neutro da adição)
3. percorrer X, do início ao fim, e fazer
a) soma = soma + x1
b) soma = soma + x2
c) soma = soma + x3
d) soma = soma + x4
e) soma = soma + x5
4. Anunciar o valor de soma
Observe que o passo 3 é uma estrutura de iteração. Logo, para somar os elementos de um
conjunto X = {xi}, basta criar soma = 0 e, dentro de uma estrutura de iteração, fazer soma
= soma + xi.
#include <stdio.h>
int main( void ){
int i, soma, x;
soma = i = 0;
while( i < 10 ){
scanf( "%d", &x );
soma = soma + x;
i++;
}
printf( "Soma = %d", soma );
return 0;
}
O Comentário 10.8 discute os conceitos de contagem e soma parciais.
Comentário 10.8 Sobre Contagem e Somas Parciais
Os enunciados dos problemas podem envolver contagens e somas completas. Por

exemplo, o enunciado “Contar os números inteiros de 0 a 100” refere-se a uma contagem
completa, contar todos os números inteiros de 0 a 100, sem exceção. O mesmo pode ser
afirmado do enunciado “Somar os números inteiros de 0 a 100” refere-se a uma soma
completa, somar todos os números inteiros de 0 a 100, sem exceção.
Em muitas situações os enunciados dos problemas requerem contagens e somas parciais.

Por exemplo, o enunciado “Contar os números inteiros ímpares de 0 a 100” refere-se a
uma contagem parcial, contar alguns números, não todos. O mesmo pode ser afirmado
do enunciado “Somar os números inteiros ímpares de 0 a 100” refere-se a uma soma
parcial, somar alguns números, não todos.
As contagens parciais precisam separar o que deve ser contado do não deve ser contado,
para isso deve fazer uso de uma estrutura de decisão, em geral a instrução if/else.
As soma parciais, da mesma forma que as contagens parciais, deve fazer uso de uma
estrutura de decisão para somar apenas as parcelas citadas no problema.
10.8.1.3. Valores extremos
Obter os valores extremos de um conjunto numérico X = { x 1, x2, x3, x4, x5 }, consiste

em criar variáveis, com valores inicial, para armazenar os valores extremos e comparar estes
valores com cada elemento de X e atribuir o valor de X as estas variáveis.
Xmin = min { X1, X2, …, Xn }

Xmax = max{ X1, X2, …, Xn }
Xext = min | max { X1, X2, …, Xn }
O passo a passo para pesquisar os valores extremos do conjunto X é a sequência apre -

sentada no Programa 10.18.
Programa 10.18 Valores extremos de números lidos do teclado
1. criar a variável Xmin (para armazenar o valor mínimo)

2. criar a variável Xmax (para armazenar o valor máximo)
3. fazer Xmin = 1E7 (um valor gigante positivo)
4. fazer Xmax = -1E7 (um valor gigante negativo)
a) se x1 < Xmin então Xmin = x1, se x1 > Xmax então Xmax = x1
b) se x2 < Xmin então Xmin = x2, se x2 > Xmax então Xmax = x2
c) se x3 < Xmin então Xmin = x3, se x3 > Xmax então Xmax = x3
d) se x4 < Xmin então Xmin = x4, se x4 > Xmax então Xmax = x4
e) se x5 < Xmin então Xmin = x5, se x5 > Xmax então Xmax = x5
6. Anunciar os valores de Xmin e Xmax
Observe que:
a) Xmin inicia com um valor gigante positivo, maior do qualquer valor de X;
b) o item 5.a é sempre true e x1 é atribuído a Xmin;
c) Xmax inicia com um valor gigante negativo, menor do qualquer valor de X;
d) o item 5.a é sempre true e x1 é atribuído a Xmax; e
e) o passo 5 é uma estrutura de iteração.
Logo, para obter os valores extremos de X = {xi}, use uma estrutura de iteração para
comparar xi com Xmin e atruibuir xi a Xmin se xi for menor do que Xmin e para comparar xi com
Xmax e atruibuir xi a Xmax se xi for maior do que Xmax.
Programa-fonte
#include <stdio.h>
int main( void ){

int x,
Xmin = 1E7,
Xmax = -1E7;
scanf( "%d", &x );
while( x >= 0 ){
if( x < Xmin ) Xmin =
x;
if( x > Xmax ) Xmax =
x;
scanf( "%d", &x );

}
printf( "\n Xmin = %d",

Xmin );
printf( "\n Xmax = %d",
Xmax );
return 0;
}
10.8.1.4. Trocar
A troca os valores de duas variáveis (x e y) requer criar uma

variável temporária (z) para armazenar o valor de uma delas, por
exemplo, z = x; em seguida faz-se x = y e y = z., como mostrado
na abaixo.
O passo a passo para trocar os valores de duas variáveis é a sequência apresentada no

Programa 10.19.
Programa 10.19 Trocar os valores de duas variáveis inteiras
1. Para trocar os valores das variáveis x e y

2. Cria-se z
3. Fazer z = x
4. Fazer x = y
5. Fazer y = z
6. Anunciar os valores de x e y
Programa-fonte
#include <stdio.h>
int main( void ){
int x, y, z;
scanf( "%d %d", &x, &y );
z = x;
x = y;
y = z;
printf( "x = %d y = %d", x, y );
return 0;
}
10.8.2. Algoritmos Derivados
O Quadro 10.6 apresenta os algoritmos média, percentagem e ordenar, que são deri-
vados dos algoritmos básicos contar, somar e trocar.
Quadro 10.6 Algoritmos derivados e suas descrições
Operação Procedimento
É uma combinação de Contar com Somar. Ao sair da EI, a razão S/n

Média
é a média
Cria-se as variáveis inteiras Nt para contar todas as ocorrências e Ni

para contar as ocorrências de interesse, ambas com valor inicial zero
Percentagem (0). Dentro de uma EI, coloque as instruções Nt++ e uma instrução if
para executar Ni++ das ocorrências de interesse. Ao sair da EI, a
razão 100*Ni/Nt é a percentagem das ocorrências de interesse
A ordenação de um conjunto de valores é feita comparando o valor

de cada elemento do conjunto com os valores dos seus demais
Ordenar elementos e trocando-os quando necessário. Pode-se ordenar um
conjunto em ordem crescente ou decrescente, são necessárias o uso
de duas estrutura de iteração.
10.8.2.1. Média
Calcular a média do conjunto numérico X consiste em somar e contar os elementos de X,

segue o passo a passo do processo.
Soma
Média=
Contagem
O passo a passo para trocar os valores de duas variáveis é a sequência apresentada no

Programa 10.20.
Programa 10.20 Cálculo a média do conjunto numérico X
1. criar a variável conta (para armazenar a contagem)

2. fazer conta = 0 (elemento neutro da adição)
3. criar a variável soma (para armazenar o somatório)
4. fazer soma = 0
a) soma = soma + x1, conta = conta + 1
b) soma = soma + x2, conta = conta + 1
c) soma = soma + x3, conta = conta + 1
d) soma = soma + x4, conta = conta + 1
e) soma = soma + x5, conta = conta + 1
6. Anunciar o valor de soma/conta
Observe que o passo 5 é uma estrutura de iteração. Logo, para calcular a média de X =
{xi}, basta somá-los e contá-los, dentro de uma estrutura de iteração.
#include <stdio.h>
int main( void ){
int conta;
float x, soma;
soma = conta = 0;
scanf( "%f", &x );
while( x >= 0 ){
soma = soma + x;
conta = conta + 1;
scanf( "%f", &x );

}
printf( " média = %f", soma/conta );
return 0;
}
10.8.2.2. Percentagem
Obter o percentual dos elementos do conjunto X = { x 1, x2, x3, x4, x5 } que obedecem a
uma certa regra, consiste em criar duas variáveis, Nt para armazenar a contagem de todos
os elementos de X e Nr para armazenar a contagem apenas dos elementos de X que obede -
cem à regra. Observe que cálculos de percentagens requerem duas contagens, uma comple-
ta (Contagem de Todos) e a outra parcial (Contagem de Alguns), como mostrado abaixo.
Contagem de Alguns
Percentual=100×
Contagem de Todos
O passo a passo para cálculo de percentuais do conjunto X é a sequência apresentada

no Programa 10.21.
Programa 10.21 Percentual de pares lidos do teclado
1. Definir a regra
2. criar a variável Nt (armazenar a contagem total)
3. fazer Nt = 0
4. criar a variável Nr (armazenar a contagem dos elementos que obedecem à regra)
5. fazer Nr = 0
a) Nt = Nt +1, se x1 obedece à regra então Nr = Nr + 1
b) Nt = Nt +1, se x2 obedece à regra então Nr = Nr + 1
c) Nt = Nt +1, se x2 obedece à regra então Nr = Nr + 1

d) Nt = Nt +1, se x2 obedece à regra então Nr = Nr + 1
e) Nt = Nt +1, se x2 obedece à regra então Nr = Nr + 1
7. Anunciar o valor de 100*Nr/Nt
Observe também que o passo 3 é uma estrutura de iteração. Logo, para obter o percentual
dos elementos de X = {xi} que obedecem à regra, basta contar todos xi e também contar
apenas os xi que obedecem à regra, dentro de uma estrutura de iteração.
Uma estrutura de decisão deve ser usada para verificar se x i obedece à regra, neste caso a
instrução é if( xi % 2 == 0).
#include <stdio.h>
int main( void ){
int x,
Nt = 0,
Nr = 0;
scanf( "%d", &x );
while( x >= 0 ){
Nt = Nt + 1;
if( x % 2 == 0 ) Nr = Nr + 1;
scanf( "%d", &x );

}
printf( "%f%% de pares", 100.0*Nr/Nt );
return 0;
}
10.8.2.3. Ordenar
O algoritmo de ordenação se aplica aos tipos de derivados, a saber, vetor, string e ma -

triz. E são tratados nestes itens.
10.8.3. Algoritmos Diversos
10.8.3.1. Número Primo
Os números primos são os números naturais que têm apenas dois divisores, 1 e ele mes-
mo.
Para saber se um número é primo, dividimos esse número pelos números 2, 3, 4, ..., N-1
até que se tenha:
• ao menos uma divisão com resto zero – N não é primo

• todas as divisões com resto diferente de zero – N é primo
O Programa 10.22 é sobre uma função para identificar números primos.
Programa 10.22 Função para identificar número é primo.
A função primo identifica o número inteiro N é primo, consiste em dividir todos os números
entre 1 e N, ambos excluídos, e retornar false se ocorrer divisão exata.
A função retorna true se todas as divisões feita na instrução for tiverem resto diferente de
zero.
Há muitos algoritmos sobre números primos, este é apenas um deles, embora didático é
ineficiente.
Programa-fonte
#include <stdio.h>
bool primo( int n ){
int c;
for( c = 2; c < N; c++ )
if( n % c == 0 ) return false;
return true;
}
int main( void ){
int N = 17;
if( primo(N) ) printf( " N = %d é primo", N );
else printf( " N = %d não e primo", N );
return 0;
}
Execução do Programa
N = 17 N = 15
10.8.3.2. Máximo Divisor Comum

Máximo divisor comum (MDC) de dois ou mais números inteiros positivos é o maior nú-
mero que está na lista de divisores de cada um desses números simultaneamente.
Os divisores (D) de um número inteiro são os números que, quando divididos por esse
número inteiro, deixam resto zero, ou seja, trata-se de uma divisão exata. Por exemplo, os
divisores de 4, D(4), é o conjunto dos números {1, 2, 4}, isto é, D(4) = {1, 2, 4}. O número 3
não faz parte de D(4) porque 4 divido por 3 deixo resto 1, não é exata.
Dados dois números inteiros a e b, b > 0, o Algoritmo de Euclides pode ser usado para
calcular o MDC(a,b) de forma recursiva, usando o resto da divisão como entrada para o próxi-
mo passo, o que é baseado na propriedade MDC(a, b) = MDC(b, r), em que r é o resto da divi-
são de a por b, como mostrado no Programa 10.23.
Programa 10.23 Algoritmo de Euclides, de forma recursiva, calcular MMC
Plano de Teste
Para a = 15 temos D(15) = { 1, 3, 5, 15 } e b = 12 temos D(20) = { 1, 2, 4, 5, 10, 20 },

logo MDC(15,20) = 5.
Programa-fonte
#include <stdio.h>
int mdc( int a, int b ){
if ( b == 0 ) return a;
else return mdc(b, a%b);
}
int main( void ){
int a = 15, b = 20;
printf( "\n mdc(%d,%d) = %d", a, b, mdc(a,b) );
return 0;
}
10.8.3.3. Mínimo Múltiplo Comum
Na Teoria dos Números, o Mínimo Múltiplo Comum (MMC) de dois inteiros a e b é o me -

nor inteiro positivo que é múltiplo simultaneamente de a e de b. Vale ressaltar que a unidade
é múltiplo e qualquer número inteiro positivo.
Exemplos de MMC: mmc(0,0) = 1, mmc(3,5) = 15, mmc(6,9) = 18 e mmc(15,20) = 60.
a×b
O mmc pode ser calculado pela equação mmc(a, b)= , como implementado
mdc⁡(a ,b)
no Programa 10.24.
Programa 10.24 Algoritmo para cálculo do MMC
Plano de Teste
mmc(3,5) = 15
mmc(6,9) = 18
mmc(15,20) = 60
Programa-fonte
#include <stdio.h>
int mdc( int a, int b ){
if ( b == 0 ) return a;
else return mdc(b, a%b);
}
int mmc( int a, int b ){
return (a*b)/mdc(a,b);
}
int main( void ){
printf( "\n mmc( 3, 5) = %d", mmc(3,5) );
printf( "\n mmc( 6, 9) = %d", mmc(6,9) );
printf( "\n mmc(15,20) = %d", mmc(15,20) );
return 0;
}

4. ……………..
5. ……………….
6. ……………….
7. ……………….
8. ……………….
1. Preencha o quadro abaixo. Avalie a precisão dos resultados por tipo de dado
comparado-os com os valores exatos.
3. ……………..
4. ……………….
5. ……………….
6. ……………….
7. ………
10.9. Tabela ASCII
Enquanto a comunicação humana faz uso de alfabetos, com grande diversidade de le-
tras, dígitos, símbolos e formatos, o computador usa apenas bits (0 e 1). Isoladamente, o bits
expressam apenas dois estados mas, agrupando-os, pode-se associar sequências de bits a
cada um dos símbolos dos nossos alfabetos. Sendo necessário, para isso, criar um mapa que
associa palavras de computador aos itens dos alfabetos humano.
O Código ASCII – American Standard Code for Information Interchange – Código Padrão
Americano para o Intercâmbio de Informação, em tradução livre – foi proposto como uma so-
lução para unificar a representação de caracteres alfanuméricos (letras, dígitos, acentos,
símbolos, sinais diversos e códigos de controle) em computadores.
O Código ASCII é binário e codifica um conjunto de 256 símbolos: 95 símbolos gráficos
(letras do alfabeto latino, sinais de pontuação e sinais matemáticos), 33 sinais de controle,
além de outros 128 sinais que compõem a parte estendida deste código.
O Quadro 10.7 contem os símbolos do código ASCII de 0 a 127. Os símbolos de 0 a 31 e
127 são códigos de controle e não são impressos. Já os de 32 a 126 podem ser impressos. O
código 32 corresponde ao caractere espaço.
Quadro 10.7 Caracteres do código ASCII de 0 a 127, com seus valores decimais (D), binários
(B) e seus símbolos (S)
D B S D B S D B S D B S
0 00000000 NUL 32 00100000 64 01000000 @ 96 01100000 `
1 00000001 SOH 33 00100001 ! 65 01000001 A 97 01100001 a
2 00000010 STX 34 00100010 " 66 01000010 B 98 01100010 b
3 00000011 ETX 35 00100011 # 67 01000011 C 99 01100011 c
4 00000100 EOT 36 00100100 $ 68 01000100 D 100 01100100 d
5 00000101 ENQ 37 00100101 % 69 01000101 E 101 01100101 e
6 00000110 ACK 38 00100110 & 70 01000110 F 102 01100110 f
7 00000111 BEL 39 00100111 ' 71 01000111 G 103 01100111 g
8 00001000 BS 40 00101000 ( 72 01001000 H 104 01101000 h
9 00001001 HT 41 00101001 ) 73 01001001 I 105 01101001 i
10 00001010 LF 42 00101010 * 74 01001010 J 106 01101010 j
11 00001011 VT 43 00101011 + 75 01001011 K 107 01101011 k
12 00001100 FF 44 00101100 , 76 01001100 L 108 01101100 l
13 00001101 CR 45 00101101 – 77 01001101 M 109 01101101 m
14 00001110 SO 46 00101110 . 78 01001110 N 110 01101110 n
15 00001111 SI 47 00101111 / 79 01001111 O 111 01101111 o
16 00010000 DLE 48 00110000 0 80 01010000 P 112 01110000 p
17 00010001 DC1 49 00110001 1 81 01010001 Q 113 01110001 q
18 00010010 DC2 50 00110010 2 82 01010010 R 114 01110010 r
19 00010011 DC3 51 00110011 3 83 01010011 S 115 01110011 s
20 00010100 DC4 52 00110100 4 84 01010100 T 116 01110100 t
21 00010101 NAK 53 00110101 5 85 01010101 U 117 01110101 u
D B S D B S D B S D B S
22 00010110 SYN 54 00110110 6 86 01010110 V 118 01110110 v
23 00010111 ETB 55 00110111 7 87 01010111 W 119 01110111 w
24 00011000 CAN 56 00111000 8 88 01011000 X 120 01111000 x
25 00011001 EM 57 00111001 9 89 01011001 Y 121 01111001 y
26 00011010 SUB 58 00111010 : 90 01011010 Z 122 01111010 z
27 00011011 ESC 59 00111011 ; 91 01011011 [ 123 01111011 {
28 00011100 FS 60 00111100 < 92 01011100 \ 124 01111100 |
29 00011101 GS 61 00111101 = 93 01011101 ] 125 01111101 }
30 00011110 RS 62 00111110 > 94 01011110 ^ 126 01111110 ~
31 00011111 US 63 00111111 ? 95 01011111 _ 127 01111111 DEL
No Quadro 10.7 pode-se destacar alguns códigos especiais como código decimal 0, re-
presentado por NUL – é o zero da matemática (0000 0000), dígito 0. O código decimal, repre -
senta o caractere '0' – 0101 0000 em binário. As letras maiúsculas vão de 65 a 90 (decimal) e
as minúsculas vão de 97 a 122 (decimal).
O Comentário 10.9 relaciona caracteres a seus valores numéricos.
Comentário 10.9 Caracteres e seus valores ASCII decimal e fórmulas de conversões
• Caracteres de controle: 0 a 31 e 127

• Espaço: 32
• Símbolos: 33 a 47, 57 a 64, 91 a 96 e 123 a 126
• Números: 48 a 57
• Letra Maiúscula: 65 a 90
• Letra Minúscula: 97 a 122
• Letra Minúscula: a = A + 32, b = B + 32 ...
• Caractere de controle: 0 ≤ caractere ≤ 31 e caractere = 127
• Espaço: caractere = 32
• Números: 48 ≤ caractere ≤ 57
• Letra Minúscula = Letra Maiúscula + 32
• Letra Maiúscula: 65 ≤ caractere ≤ 90
• Letra Minúscula: 97 ≤ caractere ≤ 122
• Vogais Maiúsculas: 65, 69, 73, 79, 85
• Vogais Minúsculas: 97, 101, 105, 111, 117
• Consoantes Maiúsculas: 66-68, 70-72, 74-78, 80-84, 86-90
• Consoantes Minúsculas: 98-100, 102-104, 106-110, 112-116, 118-122
A codificação ASCII é usada para representar textos em computadores, equipamentos de

comunicação, entre outros dispositivos das redes. Os sinais não–imprimíveis, conhecidos co -
mo caracteres de controle, são amplamente utilizados em dispositivos de comunicação e afe -
tam o processamento do texto.
Exemplo 10.1 Escrever a palavra bit em código de máquina utilizando o código ASCII.
Utilizando a O Quadro 10.7 pode–se obter ver o equivalente binário de cada letra:
b → 01100010
i → 01101001
t → 01110100
Logo, a palavra bit em código de máquina é 01100010 01101001 01110100.
bit → 011000100110100101110100
Observe no Quadro 10.7 que as letras maiúsculas precedem as minúsculas no código

ASCII. Os primeiros programas de computador eram escritos utilizando letras maiúsculas.
Com a evolução das linguagens de programação, as letras minúsculas foram incorporadas
aos softwares.
Exemplo 10.2 Escrever a expressão C=A+B em código binário.
Utilizando a Quadro 10.7 pode–se obter o equivalente binário de cada letra:

C → 01000011
= → 01011101
A → 01000001
+ → 00101011
B → 01000010
Logo, C=A+B em código de máquina é 0100001101011101010000010010101101000010.
C=A+B → 0100001101011101010000010010101101000010
Avalie este exemplo.
Exemplo 10.3 Para representar nosso conhecimento usamos símbolos, leia este texto.
50M05 53R35 QU3 49R3ND3 3 R39R353N74M05 N05505 C0NH3C1M3N705 90R M310 D3

51M80L05. 4 M473M471C4 3 UM 6R4ND3 3X3M9L0, 70D05 C0NH3C3M 53U5 51M80L05
QU3 540 4D074D05 90R 70D45 45 CUL7UR45. 0 M35M0 V4L3 94R4 4 MU51C4, 05 51N415
D3 7R4N5170, 05 M4945, 05 1C0N35 D05 9R06R4M45 D3 C0M9U74D0R. 3 MU170 M415.
3NC0N7R3 V0C3 0U7R05 3X3M9L05. 3573 73X70 3574 35CR170 3M 51M80L05, N40 3
F4C1L D3 49R3ND3R 3 3N73D3R? 9R06R4M4R 74M83M U54 51M80L05 C0M0 3573, 3
MU170 F4C1L D3 49R3ND3R 74M83M.
10.9.1.1. Questões

10. ……………..
11. ……………….
12. ……………….
13. ……………….
14. ……………….
10.9.1.2. Exercícios
1. Escrever códigos binários correspondentes aos caracteres:
a) #include <stdio.h>
b) int main( void ){ return 0; }
c) printf( "Alô mundo!" );

d) x = x+1;
e) seu nome e sobrenome
f) a data do seu aniversário no formato “dd/mm/aaaa”
g) sua idade atual
h) sua altura no formato “9.9920 m”
i) sua massa no formato “999.9 kg”
2. Escrever os caracteres correspondentes aos códigos binários:
a) 0100000101010011010000110100100101010011
b) 0111011100111101001100100010101000101000010000010010111100101011010
00010001011110010100100111011
20 Na notação 999.9, o dígito 9 representa todos os dígitos decimais inclusive ele mesmo.
11. Bibliografia
Ascenio, A. F. G.; Campos, E. A. V. Fundamentos da Programação de Computadores. 2ª

ed. Editora Pearson Education, 2003.
Carboni, Irenice de Fátima. Lógica de Programação. Editora Thomson, 2003.
Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford. Algoritmos,
Teoria e Prática. Editora Campus, 2002.
Forbelloni, André; Eberspächer, Henri. Lógica de Programação – A construção de

algoritmos e estruturas de dados. 3ª Edição. Editora Pearson Prentice Hall, 2005.
Medina, Marco; Fertig, Cristina. Algoritmos e Programação – Teoria e Prática. 2ª Edição.

Editora Novatec, 2006.
Oliveira, Alvaro Borges de; Boratti, Isaias Camilo. Introdução à Programação –

Algoritmos. Editora Visualbooks, 1999.
Press, W. H.; Teukolsky, S. A.; Vetterling, W. T.; Flannery, B. P. Numerical Recipes in C:

The Art of Scientific Computing. 2nd edition. Cambridge University Press, 1992. 994p.
Puga, Sandra; Rissetti, Gerson. Lógica de programação e estruturas de dados com

aplicações em Java. Editora Pearson Prentice Hall, 2003.
Schildt, Herbert. C Completo e Total. 3ª ed. Editora Pearson Makron Books, 2006.

Brauliro G Leal: Linguagem C

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Brauliro G Leal: Linguagem C

Enviado por

Direitos autorais:

Formatos disponíveis

Brauliro G Leal

Programação Básica para Engenharias

Copyright© 2018, 2019, 2020, 2021, 2022 Brauliro Gonçalves Leal

Atribuição–CompartilhaIgual – esta licença permite que outros remixem,

Quinta Edição Eletrônica: Outubro de 2022

Brauliro Gonçalves Leal

Professor do Colegiado de Engenharia da Computação

Sobre este documento

Este documento foi escrito em LibreOffice (www.libreoffice.org), suas imagens foram

Software livre é uma boa ideia.

Atualmente, os computadores são onipresentes, estão em todo lugar; eles trabalham

responder, para fins de aprendizagem, as questões:

• a promoção do pensamento rigoroso

É igualmente bom destacar os quatro estágios principais para o pensamento computaci-

• Decomposição – dividir o problema em partes menores

Para auxiliar na aprendizagem da programação de computadores e na solução de pro-

Algumas lições precisam ser vividas antes de ser aprendidas.

Concentre-se menos nos estudos de casos específicos e mais em padrões.

6.6.3. Exercícios Avançados......................................................................................................... 87

8.3.4.1. Questões Básicas....................................................................................................... 219

1. Linguagem de Programação C – LPC

O processo de produção de programas executáveis em computadores usando a Lingua-

Quadro 1.1 Elementos da Linguagem C para produção de programas executáveis

Linguagem C Estabelece as regras para a escrita de programas-fonte

Biblioteca Padrão C Funções padronizadas para uso imediato em programas-fonte

Compilador C Traduz programas-fonte em programas executáveis

Comentário 1.1 As bases da Linguagem C

A Linguagem C costuma ser a linguagem de quem entra no mundo da programação pois

A aprendizagem inicial é feita a partir da solução computacional de pequenos problemas,

A Linguagem C é complementada por uma biblioteca, denominada Biblioteca Padrão da

Em linhas gerais, a linguagem C é uma linguagem de programação compilada, de propósito

A Linguagem C Padrão continua a evoluir. Atualmente é mantida pelo GNU Compiler

Quadro 1.2 Unidades léxicas comumente usadas na Linguagem C

Unidade Léxica Descrição

Palavras Reservadas Palavras de uso exclusivo da linguagem

Comentário Sequência de caracteres iniciadas por // ou entre /* e */

Identificador Nome dado para uma constante, variável ou função

Tipos de dados primitivos da linguagem C: void, bool, char, int, float

Unidade Léxica Descrição

Espaços alocados na memória do computador para armazenar

Meios pelos quais se realizam operações com variáveis, constantes

Combinam variáveis, constantes, funções e operadores para

São as bases da programação estruturada, podem ser estruturas

São as partes (interdependentes) dos programas que trabalham de

Tipos de dados derivados dos tipos de dados primitivos, como

Tipo de dado que permite a interação entre o programa executável

1.2. Biblioteca Padrão C – BPC

A Biblioteca Padrão da Linguagem C (BPC) é projetada para

1 Uma das instruções da Linguagem C

1.3. Compilador C – GCC

Como muitas linguagens de programação são próximas da linguagem natural e as CPUs

O compilador C é um programa que traduz programas-fonte C para

O primeiro passo de um compilador é analisar as instruções do programa-fonte, verifi-

1. Análise Sintática – o compilador analisa o programa-fonte e informa a existência de

A análise sintática inclui o pré-processamento, uma etapa que processa as instruções

• Process terminated with status 0, 0 no GCC indica sem erros

gcc -c /home/leal/AloMundo.c -o /home/leal/AloMundo.o

Process terminated with status 0 (0 minute(s), 0 second(s))

1.4. Estrutura Básica dos Programas

Os programas escritos na linguagem C possuem, principalmente, inclusões, definições,

Programa 1.1 Primeiro programa C (AloMundo.c)

gcc -c /home/leal/AloMundo.c -o /home/leal/AloMundo.o

gcc -o /home/leal/AloMundo /home/leal/AloMundo.o