Julia Sawaki Tanaka Flávio Andrade Faria

Transcrição

Julia Sawaki Tanaka
Flávio Andrade Faria
Introdução à Ciência da Computação
Sumário
1. CLASSIFICAÇÃO DOS COMPUTADORES.................................................................................................................. 1
2. SISTEMAS DE COMPUTAÇÃO................................................................................................................................ 2
2.1. SOFTWARE - CONCEITOS BÁSICOS.................................................................................................................................. 2
2.2. HARDWARE - CONCEITOS BÁSICOS................................................................................................................................. 5
3. NOÇÕES BÁSICAS DE INTERNET............................................................................................................................. 7
4. NÚMEROS BINÁRIOS............................................................................................................................................ 9
5. ALGORITMOS..................................................................................................................................................... 10
5.1. ALGORITMO NA SOLUÇÃO DE UM PROBLEMA USANDO O COMPUTADOR.............................................................................. 11
5.2. PASSOS PARA A CONSTRUÇÃO DE UM ALGORITMO........................................................................................................... 12
5.3. ALGORITMO, PROGRAMAÇÃO E RACIOCÍNIO LÓGICO......................................................................................................... 12
6. TIPOS DE DADOS................................................................................................................................................ 13
6.1. DADOS NUMÉRICOS.................................................................................................................................................. 13
6.2. DADOS LITERAIS........................................................................................................................................................ 14
6.3. DADOS LÓGICOS....................................................................................................................................................... 14
7. CONSTANTES E VARIÁVEIS.................................................................................................................................. 14
8. EXPRESSÕES....................................................................................................................................................... 14
8.1. EXPRESSÕES ARITMÉTICAS.......................................................................................................................................... 14
8.2. EXPRESSÕES RELACIONAIS........................................................................................................................................... 15
8.3. EXPRESSÕES LÓGICAS................................................................................................................................................. 16
9. FLUXOGRAMAS.................................................................................................................................................. 17
9.1. COMANDO DE ATRIBUIÇÃO......................................................................................................................................... 17
9.2. COMANDO DE ENTRADA............................................................................................................................................. 18
9.3. COMANDO DE SAÍDA................................................................................................................................................. 18
9.4. ESTRUTURA SEQUENCIAL............................................................................................................................................ 18
9.5. ESTRUTURAS CONDICIONAIS........................................................................................................................................ 19
9.5.1. Estrutura Condicional Simples.........................................................................................................................19
9.5.2. Estrutura Condicional Composta.....................................................................................................................20
9.6. ESTRUTURAS DE REPETIÇÃO........................................................................................................................................ 20
9.6.1. Estrutura de Repetição Enquanto-faça...........................................................................................................20
9.6.2. Estrutura de Repetição Faça-enquanto...........................................................................................................21
10. PROGRAMAÇÃO............................................................................................................................................... 22
11. LINGUAGEM C.................................................................................................................................................. 23
11.1. COMPILADOR......................................................................................................................................................... 23
11.2. DEV-C++.............................................................................................................................................................. 24
11.3. ESTRUTURA BÁSICA DE UM PROGRAMA EM C.............................................................................................................. 24
11.4. FUNÇÃO MAIN()..................................................................................................................................................... 24
11.5. MEU PRIMEIRO PROGRAMA EM C.............................................................................................................................. 25
11.6. BIBLIOTECAS........................................................................................................................................................... 25
11.7. DIRETIVA #INCLUDE................................................................................................................................................. 25
11.8. FUNÇÃO PRINTF().................................................................................................................................................... 26
11.9. FUNÇÃO SCANF().................................................................................................................................................... 27
11.10. FUNÇÃO SYSTEM()................................................................................................................................................. 28
11.11. CONSTANTES........................................................................................................................................................ 28
11.12. VARIÁVEIS........................................................................................................................................................... 28
11.12.1. Tipos de Variáveis........................................................................................................................................28
Instituto de Química – UNESP – Araraquara
i
11.12.2. Declaração de Variáveis..............................................................................................................................28
11.12.3. Nomes de Variáveis.....................................................................................................................................29
11.13. PALAVRAS-CHAVE.................................................................................................................................................. 29
11.14. OPERADORES....................................................................................................................................................... 29
11.14.1. Operador de atribuição...............................................................................................................................29
11.14.2. Operadores aritméticos...............................................................................................................................30
11.14.3. Operadores de incremento e decremento...................................................................................................30
11.14.4. Operadores aritméticos de atribuição.........................................................................................................31
11.14.5. Operadores relacionais................................................................................................................................31
11.14.6. Operadores lógicos......................................................................................................................................32
11.14.7. Operador condicional ternário (?:)..............................................................................................................32
11.14.8. Precedência dos Operadores.......................................................................................................................32
11.15. BIBLIOTECA MATH.H.............................................................................................................................................. 33
11.16. BIBLIOTECA LOCALE.H............................................................................................................................................ 33
11.17. COMENTÁRIOS...................................................................................................................................................... 33
11.18. ESTRUTURA SEQUENCIAL........................................................................................................................................ 34
11.19. ESTRUTURAS CONDICIONAIS.................................................................................................................................... 34
11.19.1. Estrutura Condicional Simples.....................................................................................................................34
11.19.2. Estrutura Condicional Composta.................................................................................................................35
11.19.3. Estrutura Condicional com múltiplas ações................................................................................................36
11.20. ESTRUTURAS DE REPETIÇÃO.................................................................................................................................... 38
11.20.1. Estrutura de Repetição do { } while.............................................................................................................38
Observação: O comando system(“cls”) limpa a tela................................................................................................39
11.20.2. Estrutura de Repetição while...................................................................................................................... 39
11.20.3. Estrutura de Repetição for..........................................................................................................................40
11.21. DIRETIVA #DEFINE................................................................................................................................................. 43
11.22. STRINGS.............................................................................................................................................................. 43
11.22.1. Declaração de strings..................................................................................................................................43
11.22.2. Função scanf() para manipulação de strings..............................................................................................44
11.22.3. Outras funções para manipulação de strings.............................................................................................44
11.22.3.1. gets()..................................................................................................................................................................... 44
11.22.3.2. puts()..................................................................................................................................................................... 45
11.22.3.3. strcpy().................................................................................................................................................................. 45
11.22.3.4. strcmp()................................................................................................................................................................. 45
11.22.3.5. strlen()................................................................................................................................................................... 46
11.23. FUNÇÕES............................................................................................................................................................. 46
11.24. CRIANDO BIBLIOTECAS........................................................................................................................................... 48
11.25. VETORES............................................................................................................................................................. 48
11.26. MATRIZES............................................................................................................................................................ 48
11.26.1. Atribuindo valores a uma matriz.................................................................................................................49
11.27. DEBUG................................................................................................................................................................ 51
12. EXERCÍCIOS....................................................................................................................................................... 52
13. BIBLIOGRAFIA................................................................................................................................................... 62
ii
1. Classificação dos Computadores
Os computadores podem ser classificados segundo o porte e a finalidade em algumas categorias
mas estes mudam com o tempo e com a evolução tecnológica.
Computadores de mesa ou desktop: são computadores pessoais (PC - Personal Computer) que não
foram projetados para serem portáteis. Geralmente, essa classe de computadores é constituída por
um monitor, uma Unidade Central de Processamento (CPU) que fica armazenada dentro de um
gabinete do tipo mini-torre ou horizontal, um teclado e um mouse. Como esse tipo de
equipamento precisa de muito espaço para utilização, a sua demanda tem sido cada vez menor.
Para contornar essa dificuldade foi desenvolvido um modelo desktop chamado All-In-One (AIO). Os
AIO possuem a CPU integrada ao monitor, reduzindo o espaço necessário para a acomodação do
equipamento. Apesar da inovação, muitas empresas tem optado por usar modelos portáteis, que
são mais compactos, consomem menos energia, são fáceis de se transportar e possuem sistema
próprio de proteção para o caso de quedas de energia ou surtos elétricos.
Computadores portáteis:
Notebooks (Laptops), Netbooks, Ultrabooks e UltraThins. Os termos notebook e laptop são
utilizados indiferentemente para se referir aos computadores portáteis tradicionais. Netbook é
um notebook projetado para ser mais leve, menor, com "menor poder de processamento",
mais barato e com maior tempo de autonomia. Essas características fazem com que os
Netbooks sejam muito usados durante viagens, expedições ou mesmo em casa para acessos
rápidos a internet. O termo Ultrabook foi criado pela INTEL em 2011 para referenciar
notebooks com determinadas características físicas. A intenção da INTEL era a de criar uma
classe de notebooks que pudesse concorrer com os MacBook Air da Apple. Ou seja, criar
notebooks que fossem leves, finos, com grande autonomia de bateria e poder de
processamento equivalente a um notebook tradicional. Atualmente, esse termo é usado para
referenciar notebooks que possuem no máximo 2 cm de altura. Devido as limitações físicas, os
ultrabooks possuem restrições para a disponibilidade de recursos comuns em notebooks. É
raro encontrar um ultrabook que possua mais de 2 portas USB, entrada ethernet para rede,
entrada VGA para monitor externo e leitor/gravador de DVD/Blu-ray. Como a altura se tornou
um ponto de referência em notebooks, então surgiu no mercado uma nova classe de
computadores portáteis chamada de UltraThin. Esse termo vem sendo usado por alguns
fabricantes para descrever notebooks que possuem no máximo 2,1 cm de altura e dispõe dos
mesmos recursos de um notebook tradicional.
O Tablet não é um computador completo, mas é um dispositivo para acesso à Internet, leitura
de livros, revistas e jornais, visualização de fotos e vídeos, agenda, calendário e jogos.
PDAs (Personal Digital Assistant) ou Handhelds: são os computadores integrados e compactos
(de bolso) que possuem acesso à Internet, recursos de GPS, vários aplicativos e constituem
uma extensão do PC e não um substituto. Os smartphones são telefones celulares que
incorporaram recursos computacionais básicos, acesso à Internet, câmera digital, filmadora,
sendo que alguns modelos incluem também GPS, processador de textos, planilha eletrônica e
outros aplicativos.
Workstations ou Estações de Trabalho: são computadores desktops mais caros e de alto
desempenho, otimizados para aplicações profissionais. As estações de trabalho possuem telas de
alta resolução, circuitos de processamento mais rápido e mais poderoso e grande capacidade de
armazenamento. São geralmente utilizados para manipular e exibir dados complexos, tais como
CAD (Computer Aided Design) 2D e 3D, animação computadorizada, geoprocessamento,
modelagem 3D, desenvolvimento de games, etc.
1
Mainframes ou Servidores Corporativos: são computadores de grande porte, de alto custo, com
elevada velocidade e capacidade de processamento e armazenamento, destinados ao
processamento de grande volume de informações. Os mainframes são caracterizados por um
ambiente multiusuário, no qual várias pessoas utilizam o mesmo computador, ao mesmo tempo,
através dos terminais. No início, os mainframes eram grandes computadores que podiam ocupar
até um andar inteiro, mas com o passar do tempo seu tamanho foi reduzido, sua capacidade
aumentada e o termo mainframe foi sendo substituído pela expressão servidor corporativo. Esses
computadores são utilizados em ambientes comerciais e em grandes organizações como bancos,
companhias aéreas, seguradoras e administradoras de cartões de crédito.
Supercomputadores: são os computadores mais poderosos, com altíssimo custo e capacidade
superior aos mainframes. Geralmente são utilizados em grandes centros de pesquisa para cálculos
sofisticados como previsão do tempo, simulação de testes nucleares, controle de voos espaciais,
etc.
2. Sistemas de Computação
A computação nasceu da ideia de auxiliar o homem nos trabalhos rotineiros e repetitivos, em geral
de cálculo e gerenciamento. Porém, com o crescente desenvolvimento tecnológico, o uso de computadores
tornou-se cada vez mais difundido em todas as áreas e hoje o computador consiste em uma ferramenta de
trabalho indispensável no dia a dia das empresas, das indústrias, das universidades, e até mesmo nas
residências.
A utilização do computador para a resolução de problemas e execução de tarefas de forma
automática traz vantagens como: rapidez de execução e confiabilidade nos resultados obtidos, pois muitos
problemas exigem cálculos sofisticados, assim como a manipulação de grande volume de dados. No
primeiro caso, o risco de erro é grande e no segundo, o trabalho torna-se árduo e entediante. O
computador elimina esses inconvenientes, pois é caracterizado pela rapidez, precisão e grande capacidade
de armazenamento de informações (textos, dados, imagens, voz, etc.).
O computador é capaz de realizar cálculos e tomar decisões lógicas em velocidades bilhões de
vezes mais rápidas que os seres humanos. Porém, o equipamento por si só não é capaz de realizar uma
simples tarefa. Para que ele realize uma determinada tarefa, é preciso que alguém descreva com detalhes
todos os passos que o equipamento deve seguir para a execução desta tarefa. Esta descrição é conhecida
como programa (software) e constitui uma importante parte do sistema de computação. O equipamento
em si, isto é, o computador, faz parte do hardware. Portanto, o hardware e o software, juntamente com o
usuário, faz parte essencial de um Sistema de Computação.
2.1. Software - Conceitos Básicos
Software ou Programa é a parte lógica que dota o equipamento físico (hardware) com a
capacidade de realizar algum trabalho. O programa nada mais é do que uma sequência de instruções
escritas em uma linguagem de programação, informando ao hardware o que fazer, e em que ordem.
Observação: Em sistemas mecânicos que usam inteligência artificial, é muito comum que o “software” seja
uma parte física do equipamento. Isso acontece porque a técnica usada para o controle
automático do aparelho é patenteada e a estrutura lógica só é conhecida pelo fabricante.
Nestes casos, a peça responsável pelo ajuste automático é comumente chamada de software.
Programas Aplicativos constituem uma classe de programas que realizam tarefas específicas. Os 3
programas aplicativos mais populares são: Processadores de Textos, Planilhas Eletrônicas e Sistemas de
Gerenciamento de Banco de Dados. Outros exemplos de programas aplicativos são: folha de pagamento,
controle de estoques, contabilidade, controle de clientes de um consultório médico, controle de rebanhos,
etc.
2
Processador de Texto é um programa aplicativo projetado especialmente para facilitar a criação,
edição, formatação e impressão de textos. Ele permite fazer correção automática, mudar o tamanho e/ou
cor da letra, formatar em várias colunas, inserir um desenho ou gráfico, etc. Exemplos de processadores de
textos: Microsoft Word, LibreOffice Writer, Corel WordPerfect, etc.
Planilha Eletrônica é uma ferramenta para planejamento e análise numérica que permite utilizar a
tela do computador como um papel quadriculado sobre o qual anotamos em linhas e colunas todos os
dados. Este tipo de programa permite definir e embutir fórmulas escondidas que realizam cálculos sobre os
dados visíveis, permite também a correção de valores, e o aplicativo rapidamente recalcula os resultados
afetados por essa correção. São usadas para desenvolver orçamentos de empresas, para organizar e
controlar orçamentos domésticos, para controlar o movimento de uma conta bancária, ou ainda efetuar
previsões de vendas. Exemplos: Microsoft Excel, LibreOffice Calc, Corel WordPerfect Office, etc.
Sistema de Gerenciamento de Banco de Dados (SGBD) é um programa aplicativo capaz de
armazenar e recuperar informações em Banco de Dados.
Banco de Dados, por sua vez, é um conjunto de informações estruturadas e armazenadas de forma
organizada e integrada.
Um SGBD possui recursos para inclusão, eliminação, recuperação e modificação de dados, além de
permitir ordenar os dados, produzir relatórios, etc. Este tipo de programa substitui o antigo fichário.
Exemplos: Microsoft Access, LibreOffice Base, FireBird, MySQL, Sybase, Oracle, etc.
Uma lista de telefones dos moradores de uma determinada cidade constitui um Banco de Dados. O
catálogo telefônico tem uma estrutura pré-definida (nome do assinante, endereço e telefone) e uma
ordem de classificação (por assinante ou por endereço). Para que um Banco de Dados seja eletrônico, basta
que todas as informações sejam processadas por um computador.
Sistema Operacional é o programa mais importante, que gerencia os recursos do computador. O
sistema operacional, no nosso caso o Windows, gerencia o acesso dos programas aplicativos ao teclado, ao
monitor (vídeo), à impressora, assim como aos discos e outros dispositivos de leitura e gravação. O sistema
operacional fica o tempo todo ativo, prestando serviços aos programas aplicativos que estão sendo
executados. Cada linha de computadores tem o seu próprio sistema operacional. Exemplos de sistemas
operacionais: Windows, Linux, Mac OS, Unix, Solaris, etc.
Linguagem de Programação é um conjunto de regras que permitem a construção de sentenças que
descrevem de forma precisa as ações que desejamos que sejam executadas pelo computador.
Linguagem de Máquina é um conjunto de instruções capazes de ativar diretamente os dispositivos
eletrônicos do computador. A linguagem de máquina é constituída somente por 0 e 1 (bits), o que dificulta
a leitura e a compreensão pelas pessoas.
Exemplo de uma instrução em linguagem de máquina: 0 1 1 0 1 0 1 0 1 1 0 1
BIT (BInary DigiT = Dígito Binário) 0 ou 1. Bit é a menor unidade de informação, e apresenta dois
estados identificáveis (sim ou não, verdadeiro ou falso, chave ligada ou desligada, uma corrente passando
ou não por um circuito elétrico, um item magnetizado ou não, etc.) que são associados aos números 1 e 0,
respectivamente.
Byte é um conjunto de bits. A maioria dos fabricantes de computadores utilizam bytes constituídos
por 8 bits. Para o computador armazenar um caractere, que é uma letra, um algarismo, ou símbolo (ex: M,
a, 4, 7, -, ?, *) ocupa um byte, ou seja, uma sequência de 8 bits ligados (1) ou desligados (0).
O byte é a unidade de medida da quantidade de informação digital. Por exemplo: o disco rígido é
de 1 Tera byte (TB), o pen drive é de 8 Giga bytes (GB), etc.
Os prefixos (kilo, mega, giga, tera, etc.) são coloquialmente utilizados na computação para
expressar grandes quantidades de bytes. Como a arquitetura do computador se baseia em números
binários, em computação, esses prefixos geralmente são utilizados para indicar potências de dois, o que
não é correto, pois no Sistema Internacional de Unidades (SI) esses prefixos representam potências de dez.
3
Prefixos em uso na computação coloquial
Nome Símbolo
Potência de dez (SI)
Potência de dois
Diferença
quilo
K
103 = 1.000
210 = 1.024
2,4%
mega
M
106 = 1.000.000
220 = 1.048.576
4,9%
giga
G
109 = 1.000.000.000
230 = 1.073.741.824
7,4%
tera
T
1012 = 1.000.000.000.000
240 = 1.099.511.627.776
peta
P
1015 = 1.000.000.000.000.000 250 = 1.125.899.906.842.624
10,0%
12,5%
A norma publicada em 2008 define os seguintes prefixos binários:
Prefixos binários segundo normas internacionais
Nome Símbolo Potência de dois
kibi
Ki
210 = 1.024
mebi
Mi
220 = 1.048.576
gibi
Gi
230 = 1.073.741.824
tebi
Ti
240 = 1.099.511.627.776
pebi
Pi
250 = 1.125.899.906.842.624
Padrões de Codificação
No computador a representação interna de informações é feita através de um padrão de
codificação onde, por convenção, certos conjuntos de bits representam certos caracteres. No padrão de
codificação ASCII estendido, de 8 bits, a letra A é representada por 1000001. Unicode é outro padrão de
codificação de 16 bits.
Linguagem de Montagem é uma linguagem de baixo nível que situa apenas um nível de abstração
acima da linguagem de máquina e usa mnemônicos (símbolos fáceis de memorizar) para expressar as
instruções. Um programa especial chamado montador deve traduzir as instruções (simbólicas) da
linguagem de montagem para a linguagem de máquina. Exemplo: Assembler é o montador da linguagem
Assembly.
Exemplo de instruções em linguagem de montagem:
ADD C, 1
MOV A, B
CMP A, E
JMP fim
Linguagem de Alto Nível é uma linguagem que utiliza notações matemáticas e grupos de palavras
(em inglês) para representar as instruções de máquina, tornando o processo de programação mais próximo
do entendimento humano.
Exemplos de linguagens: Fortran, Pascal, C++, Visual Basic, Delphi, Java, PHP, Python, etc.
Exemplos de trechos de programa:
4
FORTRAN
10 if (nota .LT. 5) goto 30
write(2, 20)
20 format('Aprovado')
goto 50
30 write(2, 40)
40 format('Reprovado')
50 stop
end
BASIC
30 if nota < 5 then print "Reprovado" else print "Aprovado"
PASCAL
if nota < 5 then write('Reprovado') else write('Aprovado');
C
if (nota < 5) printf(“Reprovado”);
else printf(“Aprovado”);
Compilador: traduz o programa fonte (ou código fonte), escrito na linguagem de alto nível, como
Pascal ou C, para a linguagem de máquina, gerando o programa executável que o computador consegue
entender e processar diretamente.
Interpretador: interpreta cada comando do programa fonte e executa as instruções que a ele
correspondem, sem gerar um programa executável. Em geral os programas interpretados são mais lentos
do que os compilados, pois os compiladores fazem a tradução uma única vez, e a partir daí executam
diretamente o programa traduzido, enquanto que o interpretador traduz o programa fonte todas as vezes
que executa.
2.2. Hardware - Conceitos Básicos
Hardware é a parte física de um Sistema de Computação, ou seja, todos os elementos materiais
que o compõem (a estrutura, os circuitos eletrônicos, os dispositivos mecânicos, elétricos, magnéticos, etc).
Os componentes básicos de um computador são:
 Dispositivo de Entrada e Saída (ou Periféricos)
 Memória
 Unidade Central de Processamento (UCP)
Dispositivo
de Entrada
Memória RAM
Unidade Lógica e
Aritmética
Unidade de
Controle
UCP
5
Dispositivo
de Saída
Dispositivo de Entrada serve para receber os dados e programas preparados pelo ser humano e
transformá-los em sinais eletromagnéticos (bits) manipuláveis pelo computador. Exemplo: teclado, mouse,
scanner, drive de DVD, etc.
Dispositivo de Saída serve para transformar os dados processados pelo computador em formas
compreensíveis pelo ser humano e exibi-los. Exemplo: impressora, monitor ou vídeo, plotter, etc.
Memória é o dispositivo que armazena informações. Existem dois tipos de memória: memória
primária e secundária.
Memória Primária é a memória sem a qual o computador não funciona. A sua principal função é
armazenar informações necessárias para o processador, como por exemplo, os programas em execução.
Fazem parte da memória primária, as memórias RAM, ROM e Cache.
 RAM (Random Access Memory) é a memória de trabalho do computador. Ela pode ser lida e
gravada pela Unidade Central de Processamento (UCP) a qualquer instante. É onde ficam
armazenados os dados, os resultados intermediários e os programas que estão sendo executados
pela UCP. Quando um programa que estava sendo usado é fechado, a parte da memória RAM, que
estava sendo utilizada, é liberada para armazenar novos dados e programas. As informações que
são introduzidas no computador através do teclado, da leitura do disco rígido, CD/DVD ou pen drive
são armazenadas na memória RAM. Como a memória RAM é volátil as informações nela
armazenadas desaparecem com o desligamento do computador ou com a queda de energia
elétrica.
 ROM (Ready Only Memory) é a memória exclusivamente de leitura, onde as informações são
gravadas uma única vez, geralmente pelo fabricante e nunca mais alteradas. A memória ROM não
é volátil, e é uma memória permanente, o seu conteúdo não é perdido mesmo com o desligamento
do computador. Nos microcomputadores, existe um programa muito importante chamado BIOS
(Basic Input-Output System - Sistema Básico de Entrada e Saída) que tem várias funções, entre as
quais, a de realizar a "partida" do computador . Quando ligamos o computador, o BIOS realiza a
contagem de memória, faz uma rápida checagem do funcionamento do computador e carrega o
Sistema Operacional do disco rígido (memória secundária) para a memória RAM. O BIOS está
gravado em uma memória ROM, pois esse programa não deve ser alterado e deve ser executado
todas as vezes que o computador é ligado. Existem outros tipos de memória ROM como PROM
(Programmable ROM), EPROM (Erasable Programmable ROM), EEPROM (Electrically Erasable
Programmable ROM), etc.
 Cache é também um tipo de memória primária, volátil, de grande velocidade, mais rápida do que
a memória RAM. A memória cache armazena e recupera os dados usados mais frequentemente
pelo processador de modo que sua recuperação possa ser bem rápida. É uma memória mais cara
do que a memória RAM.
Memória Secundária é um meio de armazenamento a longo prazo no qual o computador armazena
dados que poderão ser posteriormente utilizados. Este tipo de memória não é estritamente necessária para
a operação do computador, o acesso a este tipo de memória é mais lento em comparação com o acesso à
memória primária, e o custo por unidade de memória secundária é muito menor que o custo por unidade
de memória primária.
As memórias secundárias mais comuns, utilizadas pelos computadores são: disco rígido, SSD, pen
drive, cartão de memória micro SD, CD, DVD, Blu-ray, etc.
 Disco Rígido ou HD (Hard Disk) é um meio de armazenamento secundário de informações que
emprega vários discos não flexíveis revestidos com material magnético e alojados juntamente com
6
os cabeçotes de leitura/gravação, em uma caixa hermeticamente fechada. Atualmente a
capacidade de um disco rígido é especificado em termos de centenas de Gbytes ou alguns Tbytes.
 SSD (Solid State Drive) ou Unidade (ou Drive) de Estado Sólido é um meio de armazenamento
secundário de informações, mas não é um disco. É constituído de circuitos eletrônicos do mesmo
tipo da memória flash utilizada nos pen drives, mas com capacidade maior e funcionam
exatamente como se fossem discos rígidos, porém em uma velocidade bem maior. A maioria dos
SSDs comercializados atualmente é de 64 GB a 480 GB, pois o SSD é bem mais caro do que o HD.
 Pen drive é uma memória portátil, constituído por memória flash, que funciona em equipamentos
com porta USB. O pen drive surgiu em 2000 com o objetivo de substituir os disquetes. Existem pen
drives de 1 GB, 2 GB, 256 GB e até 1 TB. O modelo de 1 GB armazena o equivalente a 728 disquetes.
 cartão de memória micro SD (Secure Digital) é um cartão de memória flash removível, utilizado
inicialmente em telefones celulares devido a sua medida reduzida (1,5cm x 1,1cm x 1 mm). Através
de um adaptador o micro SD pode ser utilizado em qualquer dispositivo que suporta o cartão SD.
 CD (Compact-Disk): uma tecnologia de armazenamento ótico que emprega disco a laser e pode
armazenar até 700 Mbytes de informações digitais. Existem os discos CD-R (CD-Recordable) que
podem ser escritos só uma vez e os CD-RW (CD-ReWritable) que podem ser gravados, apagados e
reutilizados.
 DVD (Digital Video Disc e posteriormente Digital Versatile Disc): uma geração de disco ótico que
armazena 4.7 Gbytes de informações em um disco de uma face e uma única camada e 17 Gbytes
em um disco de 2 faces e 2 camadas. Existem também os discos DVD-R (Recordable) que só gravam
uma vez e o DVD-RW (Rewritable) que é a versão regravável.
 Blu-ray (BD): é a nova geração de disco ótico para vídeos de alta definição, que utiliza raio laser
de cor azul com comprimento de onda menor do que o do DVD e CD, mas apresenta o mesmo
tamanho de um DVD e tem a capacidade de armazenar de 25 a 100 Gbytes de informações.
Unidade Central de Processamento (UCP) ou Central Processing Unit (CPU) é a principal unidade
de controle e processamento de um computador, e é constituída de circuitos eletrônicos que interpretam e
executam instruções de programas e comunicam com os dispositivos de armazenamento e de entrada e
saída. A UCP é composta pela Unidade Lógica e Aritmética (ULA) e pela Unidade de Controle (UC).
 Unidade Lógica e Aritmética (ULA): realiza cálculos através de operações aritméticas (adição,
subtração,...) e operações relacionais (comparação de valores).
 Unidade de Controle (UC): gerencia as operações do computador comunicando com a Unidade
Lógica e Aritmética, com a memória e com os dispositivos de entrada e saída. Controla as
instruções dos programas que estão na memória, faz com que o dispositivo de entrada leia os
dados, transfira os valores adequados da memória para a ULA, armazena e recupera dados e
resultados intermediários armazenados na memória e passa os resultados para o dispositivo de
saída.
3. Noções Básicas de Internet
Redes de computadores são grupos de computadores e dispositivos computacionais como
impressoras, scanners, etc., conectados por algum recurso de comunicação. Uma rede pode envolver
conexões permanentes tais como cabos ou conexões temporárias através de linhas telefônicas ou outros
elos de comunicação.
7
Internet é a rede mundial de computadores que é formada por várias redes de computadores
interligadas. A Internet surgiu de um projeto militar nos Estados Unidos na década de 60, evoluiu para uma
rede acadêmica na década de 70 e hoje constitui o maior meio de comunicação do mundo.
A Internet é formada por redes locais (LANs - Local Area Network), redes de abrangência urbana
(MANs - Metropolitan Area Network) e redes remotas (WANs - Wide Area Network) que abrangem estados,
países e continentes, conectando computadores do mundo inteiro. Essas redes são conectadas por
recursos que variam de linhas telefônicas de discagem comum, linhas privadas dedicadas de alta
velocidade, ligações por microondas, ligações por fibras óticas e satélites.
Na década de 80 e no início da década de 90 a rede foi aperfeiçoada e começou a surgir serviços
que caracterizam a Internet atual. O principal desses serviços é World Wide Web (WWW) lançada em 1991,
que viabilizou a transmissão de imagens, sons e vídeos pela Internet. Foi o WWW que popularizou a
Internet.
A Intranet é uma rede interna de informações de uma organização (empresa, universidade, etc.)
baseada na tecnologia da Internet. Serve para compartilhar informações apenas entre os usuários
registrados, sem permitir o acesso de pessoas externas. A Intranet é uma evolução da Internet, em que se
busca, dentro das organizações, formas de acesso às informações, usando os mecanismos de navegação
que são os navegadores. A operação é idêntica, e mesmo as interfaces são as mesmas daquelas vistas na
Internet. Através da Intranet, os usuários internos da organização compartilham informações tais como:
formulários, especificações de produtos, catálogos de produtos, políticas internas de administração e de
recursos humanos, cadastro de clientes, etc.
Alguns dos serviços básicos da Internet são: correio eletrônico (e-mail), WWW (World Wide Web),
acesso remoto ao computador, transferência de arquivos, lista de correio eletrônico, grupos de notícias,
comunicação interativa, etc.
Correio Eletrônico (e-mail) permite um usuário escrever e enviar uma mensagem de texto para
outro usuário ou para um grupo deles, através da internet.
WWW (World Wide Web ou simplesmente Web) é um serviço no formato de hipertextos que
permite ao usuário buscar informações nos diversos computadores da Internet e visualizá-las através de
seções gráficas, formadas por imagens, sons e animações. Hipertexto é um documento que permite acesso
não sequencial, com diferentes níveis de detalhamento e com páginas inter-relacionadas. O leitor pode
percorrer o documento na sequência desejada, saltando de uma página para outra em busca de
informações relacionadas a uma palavra, frase (em destaque) ou ícone.
Acesso Remoto ao Computador é uma ferramenta interativa que permite acessar e executar
programas e aplicações disponíveis em um computador remoto, conectado à internet.
Transferência de Arquivos (ftp, download e upload) permite transferir arquivos entre
computadores interligados pela rede.
Lista de Correio Eletrônico ou Lista de Discussão é uma forma de contatar um grupo de pessoas
através do e-mail. As pessoas que participam da lista podem enviar mensagens para o endereço da lista, o
qual reenvia então a mensgem para cada uma das pessoas (e-mail) inscritas na lista.
Comunicação Interativa é a comunicação instantânea entre duas ou mais pessoas, independente
da localização geográfica dessas pessoas.
Rede Local (LAN - Local Area Network) é uma estrutura que conecta vários computadores e outros
dispositivos (como impressoras) dentro de uma área geográfica limitada. Os usuários de rede local podem
trocar informações, compartilhar periféricos e utilizar recursos de servidor de arquivos. Normalmente a
área geográfica de uma rede local se restringe a uma sala, um departamento, um andar ou um prédio,
dentro de um raio de 100 m.
8
Servidor: nas redes locais o servidor é um computador que fornece algum tipo de serviço para
outros computadores conectados a ele via rede. Um exemplo é o servidor de arquivos que tem um disco
grande e atende pedidos de leitura e gravação naquele disco, outro exemplo é o servidor de impressão que
controla as tarefas de impressão enviadas para a impressora conectada na rede.
4. Números Binários
O sistema binário (ou sistema de base 2), é formado por dois algarismos: 0 e 1, enquanto que o
sistema decimal (ou sistema de base 10), normalmente utilizado, é formado por 10 algarismos: 0, 1, 2, 3, 4,
5, 6, 7, 8 e 9.
Os números binários (0 e 1) foram adotados nos computadores por motivos de precisão e
economia, pois construir um circuito eletrônico capaz de detectar a diferença entre dois estados (presença
ou ausência de corrente elétrica, por exemplo) é muito mais fácil e barato do que construir um circuito que
detecte a diferença entre dez estados diferentes.
Um dígito binário é chamado de BIT, proveniente de BInary digiT, como mencionado
anteriormente.
Transformação de números decimais em números binários
13
2
1
6
2
0
3
2
1
1
=>
46
2
0
23
2
1
11
2
1
5
2
1
2
2
0
1
1 1 0 1
=> 1 0 1 1 1 0
Transformação de números binários em números decimais
1
1
0
1
1
0
1
1
1
X
x
x
x
x
x
x
x
x
23
22
21
5
2
20
2
4
2
3
2
2
0
1
2
x
20
0
1
2
0
4
4
8
8
0
13
32
46
9
Números Decimais Números Binários
00
01
02
03
04
05
06
07
08
09
10
11
12
..
.
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
..
.
5. Algoritmos
Algoritmo é a descrição, de forma lógica, das ações a serem executadas no cumprimento de uma
tarefa, ou seja, é uma sequência de passos que levam à realização de uma tarefa.
Em um algoritmo é importante salientarmos que:
- cada passo deve ser uma instrução simples e sem ambiguidade que possa ser realizada;
- a ordem dos passos deve ser precisamente determinada;
- deve possuir um fim, isto é, um número finito de passos.
Existem várias formas para representar um algoritmo:
 descrição narrativa;
 fluxograma ou diagrama de blocos;
 pseudocódigo (forma genérica de escrever o algoritmo usando uma linguagem
simples, estruturada e nativa a quem o escreve).
A seguir, apresentamos um algoritmo em forma de descrição narrativa, para troca de uma lâmpada
queimada.
1. Remova a lâmpada queimada.
2. Coloque uma nova lâmpada.
Detalhando os passos, temos:
1.1. Coloque uma escada embaixo da lâmpada queimada.
1.2. Suba a escada até alcançar a lâmpada queimada.
1.3. Gire a lâmpada queimada no sentido anti-horário até que ela se solte.
2.1. Escolha uma lâmpada nova de mesma potência da queimada.
2.2. Posicione a nova lâmpada no soquete.
2.3. Gire a lâmpada no sentido horário até que ela se firme.
2.4. Desça a escada.
10
Ordenando e detalhando um pouco mais os passos, temos:
1. Coloque uma escada embaixo da lâmpada queimada.
2. Escolha uma lâmpada nova.
3. Enquanto a potência não for a mesma da queimada,
Descarte a lâmpada escolhida,
Escolha outra lâmpada.
4. Enquanto não possa alcançar a lâmpada queimada,
Suba mais um degrau da escada.
5. Enquanto a lâmpada não estiver livre do soquete,
Gire a lâmpada no sentido anti-horário.
6. Posicione a nova lâmpada no soquete.
7. Enquanto a lâmpada não estiver firme no soquete,
Gire a lâmpada no sentido horário.
8. Desça da escada.
5.1. Algoritmo na solução de um problema usando o computador
Problema do
mundo real
Fase de solução
do problema
Solução na forma de
algoritmo
Solução na forma de
um programa de
computador
Fase de
implementação
No esquema acima, é possível visualizar onde se encaixa o algoritmo, na solução de um problema
utilizando o computador.
Muitas vezes, temos um problema do mundo real que desejamos resolver através do computador,
devido principalmente à rapidez de execução e confiabilidade dos resultados. Neste caso, inicialmente é
necessário compreender muito bem o problema e saber solucionar este problema. A próxima etapa
consiste em transcrever os passos da solução do problema em uma forma de algoritmo (descrição
narrativa, fluxograma ou pseudocódigo). A etapa seguinte é a de implementação, que consiste em passar a
solução, que está em forma de algoritmo, para uma linguagem de programação, gerando assim um
programa de computador. Um programa nada mais é do que a formalização de um algoritmo em uma
determinada linguagem de programação, obedecendo às regras de sintaxe e semântica desta linguagem,
de forma que o computador possa “entender” a sequência de ações que deve ser executada.
Utilizando-se um programa de computador, o problema pode ser resolvido com muita rapidez,
quantas vezes forem necessárias.
11
5.2. Passos para a construção de um algoritmo
Para construir um algoritmo, devemos seguir os passos abaixo:
1) Compreender o problema e a sua solução de uma forma muito clara e destacar os pontos mais
importantes.
2) Definir os dados de entrada, isto é, os dados (valores e informações) que serão fornecidos ao
algoritmo.
3) Definir o processamento, ou seja, os cálculos que deverão ser realizados para a solução do
problema.
4) Definir os dados de saída, ou seja, os resultados do processamento que serão apresentados ao
usuário.
5) Construir o algoritmo usando uma das formas citadas acima (descrição narrativa, fluxograma
ou pseudocódigo).
6) Testar o algoritmo através de simulações.
5.3. Algoritmo, programação e raciocínio lógico
A construção de algoritmos e a programação permitem melhorar o raciocínio lógico e acelerar o
desenvolvimento cognitivo, porque a elaboração de algoritmos e programas faz com que o aluno exercite a
percepção dos pontos chaves, força o aluno a fazer planejamento e pensar organizadamente.
Um dos principais objetivos desta disciplina é estimular o aluno a desenvolver o raciocínio lógico
através da construção de algoritmos e programas, proporcionando um amadurecimento na maneira de
pensar diante dos problemas reais.
Não existem fórmulas prontas na construção de algoritmos e programas. O que se adquire com o
treino é o aperfeiçoamento na forma de pensar e raciocinar sobre o problema em mãos. O raciocínio lógico
é uma habilidade inerente a todas as pessoas e necessária em inúmeras atividades que realizamos.
James Paul Holloway em seu livro “Introdução à Programação para Engenharia” diz: “... a razão
mais importante para estudar e criar algoritmos não é, na verdade, sua utilidade natural, mas em vez disso,
a habilidade de pensamento que a sua criação nos força a desenvolver. Para ser mais exato, o raciocínio
lógico necessário lhe proporcionará boas condições quando você tiver problemas a analisar, mesmo se
esses problemas não puderem ser resolvidos por meio de algoritmos formalmente construídos.”.
Outra passagem a destacar no livro de Holloway é: “Criar algoritmos é exatamente o que fazemos.
Nós os criamos. Começamos com um problema a resolver e uma página em branco, e tentamos preencher
este vazio com um código-fonte que, quando traduzido e executado num computador, resolverá o
problema. Este processo criativo envolve muitos princípios de projeto. Devemos entender o problema;
analisar o problema e encontrar uma solução; analisar a solução para encontrar a melhor maneira de
implementá-la; trabalhar considerando as restrições; procurar simplicidade, elegância e confiabilidade.
Uma introdução aos algoritmos e suas implementações pode, assim, proporcionar uma rica experiência
introdutória no projeto em engenharia.”
Para exercitar um pouco o raciocínio lógico, tente resolver os problemas abaixo:
1) Há três suspeitos de um crime: o cozinheiro, a governanta e o mordomo. Sabe−se que o crime foi
efetivamente cometido por um ou por mais que um deles. Sabe−se, ainda que:
- se o cozinheiro é inocente, então a governanta é culpada;
- ou o mordomo é culpado ou a governanta é culpada, mas não os dois;
- o mordomo não é inocente.
Logo:
(a) a governanta e o mordomo são os culpados
(b) o cozinheiro e o mordomo são os culpados
(c) somente a governanta é culpada
12
(d) somente o cozinheiro é culpado
(e) somente o mordomo é culpado
2) O preço de um produto foi reduzido em 20% numa liquidação. Qual deverá ser a porcentagem
de aumento do preço do mesmo produto para que ele volte a ter o preço original?
(a) 15%
(b) 20%
(c) 25%
(d) 30%
6. Tipos de Dados
Apesar do computador, na maior parte do tempo em nosso meio, ser utilizado como processador
de textos ou para acesso à Internet, o objetivo principal de um computador é a resolução de problemas. Na
resolução de problemas o computador manipula dados de vários tipos. Estes dados podem ser numéricos,
literais ou lógicos. A seguir apresentamos a classificação dos dados e a sua descrição.
Dados
Numéricos
Real
Lógicos
Inteiro
Literais
Caractere
Cadeia de Caracteres
6.1. Dados Numéricos
Os dados numéricos podem ser inteiros ou reais.
Os números inteiros podem ser positivos ou negativos e não possuem a parte decimal.
Os números reais podem ser positivos ou negativos e possuem a parte decimal. Os números reais
podem ser representados em forma decimal ou em forma de ponto flutuante.
Exemplo de números reais em forma decimal: 8.15927, 0.5, 176.48, etc. Obs. O ponto decimal deve
ser representado por ponto (.), seguindo a notação da língua inglesa que é utilizada nas linguagens de
programação.
Geralmente, utiliza-se a representação de números reais em ponto flutuante (notação científica)
quando o número é muito grande ou muito pequeno.
Exemplo: 0.0000000000061725  617 x 10-14 (representação em ponto flutuante)
418639138670259
 419 x 1012 (representação em ponto flutuante)
Para transformar um número real que está na representação decimal para a representação em
ponto flutuante, devemos:
 definir o número de dígitos de precisão (ou significativos) e arredondar o último dígito, se for
necessário.
 ajustar a magnitude do número como potência de 10.
13
6.2. Dados Literais
Os dados literais são caracteres ou cadeia de caracteres.
Caractere é qualquer letra (maiúscula ou minúscula), algarismo (0, 1, 2, …, 9) ou caractere especial
(sinais de pontuação e símbolos: %, +, @, *, ?, &, #, :, etc.). Os caracteres devem ser representados entre
apóstrofos ('). Exemplos: 'y', 'n', '$', etc.
Cadeia de caracteres ou string: é uma sequência de caracteres. As cadeias de caracteres devem ser
representadas entre aspas (“). Exemplos: “Ola”, “Bem vindo!”, “Digite um numero:”, etc.
6.3. Dados Lógicos
Os dados lógicos são também chamados de dados booleanos e podem assumir somente um dos
valores: falso ou verdadeiro. Em linguagens de programação, geralmente usa-se o número 1 para
representar um resultado verdadeiro e o número 0 para representar um resultado falso.
7. Constantes e Variáveis
Constantes são valores fixos que não se modificam durante a execução do programa. As constantes
podem ser numéricas (5, 128, -76), literais ("Paula", "feminino", "fim"), ou lógicas (V ou F).
Variáveis são entidades que possuem um conteúdo (valor) que pode variar no algoritmo ou no
programa. Embora elas possam assumir diferentes valores, só podem armazenar um único valor a cada
instante. Uma variável é conhecida no programa por um nome ou identificador.
O identificador ou o nome de uma variável deve iniciar com uma letra e pode ser seguida de letras,
algarismos ou caractere de sublinhado, mas não pode conter caracteres especiais (-, *, %, ç, e letras com
acentos). Exemplos de identificadores válidos: X, Y1, saldo, nome_do_cliente, RG, Aula26, etc.
Exemplos de nomes de variáveis inválidos: 2x, A[1], M-N, 07/09, nota-do-aluno, salário, etc.
As variáveis podem ser numéricas ou literais e devem ter nomes significativos. Nomes significativos
são nomes que lembram o seu conteúdo. Por exemplo: nota, nome, saldo, ao invés de x, y, z.
8. Expressões
Expressão em termos computacionais está ligado ao conceito de expressão ou fórmula matemática,
onde um conjunto de variáveis e constantes se relacionam por meio de operadores compondo uma
fórmula que, quando avaliada, resulta em um valor.
8.1. Expressões Aritméticas
Expressões Aritméticas: são expressões em que os operadores são aritméticos e os operandos são
constantes e/ou variáveis numéricas.
Operadores Aritméticos e suas Prioridades
prioridade
1
2
operador
ação
*
multiplicação
/
divisão
MOD
resto da divisão inteira
+
adição
-
subtração
14
Funções
função
ação
EXP(x)
exponencial de x (ex, onde e = 2.718282...)
LN(x)
logaritmo neperiano de x (logex)
ABS(x)
valor absoluto de x (x)
TRUNC(x)
parte inteira do número real x
ROUND(x)
arredonda o número real x
SIN(X)
seno de x
COS(x)
Cosseno de x
POW(x,n)
SQRT(x)
potência com base x e expoente n ( x n )
raiz quadrada de x ( x )
Exemplos de expressões aritméticas:
a) A-B*POW(C,2)
b) SQRT(POW(b,2)-4*a*c)
c) TRUNC(3.68) - EXP(3)
d) ROUND(5.8)+ABS(-4)
e) SIN(A)-LN(B)
f) 22 MOD 6 + soma
8.2. Expressões Relacionais
Expressões Relacionais ou Relações: são expressões que realizam comparações entre valores do
mesmo tipo. Estes valores são representados nas relações através de constantes, variáveis ou expressões
aritméticas.
Operadores Relacionais
operador
ação
=
igual
<>
diferente
<
menor
>
maior
<=
menor ou igual
>=
maior ou igual
O resultado obtido de uma expressão relacional é sempre um valor lógico (Verdadeiro ou Falso).
Exemplos de expressões relacionais:
a) X+Y=3*X+5
b) 2*A<8
c) nome <> "Ana Maria"
d) SQRT(POW(b,2)-4*a*c) >= 0
e) A <> B
f) sexo = "masculino"
15
8.3. Expressões Lógicas
Expressões Lógicas: são expressões cujos operadores são lógicos e cujos operandos são expressões
relacionais, constantes e/ou variáveis do tipo lógico. O resultado de uma expressão lógica é sempre um
valor lógico (V ou F).
Operadores Lógicos
operador
ação
e ()
conjunção
ou ()
disjunção
não (~)
negação
Sejam p e q proposições, temos a seguinte Tabela-Verdade:
conjunção
p
V
V
F
F
q
V
F
V
F
disjunção
pq
V
F
F
F
p
V
V
F
F
negação
pq
V
V
V
F
q
V
F
V
F
p
V
F
~p
F
V
Suponha que tenhamos duas proposições:
A : “Eu gosto de dia ensolarado.”
B : “Hoje vai chover”
Podemos criar várias composições de proposições usando os operadores lógicos:
~A : “Eu não gosto de dia ensolarado”
~(A  B) : “Não é verdade que eu gosto de dia ensolarado e hoje vai chover”
A  ~B : “Eu gosto de dia ensolarado ou hoje não vai chover”
Exemplos de expressões lógicas:
a) X > 2*Y  Idade = 18
b) cidade = "Araraquara"  bairro = "Centro"
c) ~Fim  Total < 15
Prioridade entre os Operadores
prioridade
operador
1
aritmético
2
relacional
3
não
4
e
5
ou
Obs: Vários níveis de parênteses podem ser utilizados para fixar uma ordem de execução diferente
da prioridade indicada pela tabela acima.
Exemplo: ~(x = 20  y > 5)
16
9. Fluxogramas
Fluxograma ou diagrama de blocos é a representação simbólica dos passos a serem seguidos em
um algoritmo, ou seja, é a representação esquemática de um processo.
Exemplo de Controle de Estoque:
O funcionário responsável pelo estoque recebe uma solicitação de peça e verifica na listagem de
estoque a disponibilidade da mesma. Caso a peça esteja disponível, ela é entregue ao solicitante e em
seguida é efetuada a baixa no estoque. Caso a peça não esteja disponível, o funcionário verifica o tempo de
entrega junto ao fornecedor da peça e informa o tempo de entrega ao solicitante. Caso o solicitante deseje
a peça, é efetuado o pedido ao fornecedor e aguarda-se a chegada da peça e a sua entrada no estoque. Em
seguida ela é entregue ao solicitante e é efetuada a baixa no estoque.
Início
Recebe a solicitação e
verifica no estoque
S
Entrega ao solicitante
Dá baixa no estoque
Disponível ?
Faz o pedido e
aguarda a entrega no
estoque
N
Verifica o tempo de
entrega e informa ao
solicitante
S
Quer a peça?
N
Fim
Os símbolos básicos utilizados em fluxogramas são:
início ou fim
leitura (entrada)
decisão
cálculo e atribuição
impressão (saída)
sentido do fluxo
9.1. Comando de Atribuição
O Comando de Atribuição permite que se forneça um valor a uma determinada variável. O valor
pode ser resultado de uma expressão.
Identificador  valor ou expressão
17
Exemplos:
a) A  7
b) idade  18
c) NOME  "Marina"
d) media  (a + b)/2
e) X  Y
9.2. Comando de Entrada
O Comando de Entrada permite que o usuário forneça valores ao programa.
lista de identificadores
onde: lista de identificadores são os nomes das variáveis, separados por vírgula, nas quais serão
armazenados os valores provenientes do usuário através dos dispositivos de entrada.
9.3. Comando de Saída
O Comando de Saída permite mostrar ao usuário os valores das variáveis ou das constantes.
lista de identificadores, constantes
ou expressões
onde: lista de identificadores são os nomes das variáveis, cujos conteúdos serão mostrados, as constantes
são os valores e as expressões podem ser expressões aritméticas ou outras, cujos resultados serão
mostrados aos usuários através de um dispositivo de saída.
9.4. Estrutura Sequencial
Estrutura Sequencial é uma coleção de ações a serem executadas sequencialmente.
ação1
ação2
Exemplo 9.1.
Fluxograma para ler três números, calcular a média aritmética entre estes números e imprimir o
resultado.
18
início
A,B,C
media  (A+B+C)/3
“Média = “, media
fim
9.5. Estruturas Condicionais
Estas estruturas permitem escolher um grupo de ações ou estruturas a serem executadas quando
uma determinada condição, representada por uma expressão lógica, é satisfeita ou não.
9.5.1. Estrutura Condicional Simples
condição
F
V
ação / ações
A(s) ação(ões) só será(ão) executada(s) se a condição for Verdadeira. Condição é um teste, cujo
resultado é Verdadeiro ou Falso
Exemplo 9.2.
Fluxograma para ler uma nota e imprimir REPROVADO, caso a nota seja menor do que 5.
início
nota
nota < 5
F
V
“REPROVADO”
fim
19
9.5.2. Estrutura Condicional Composta
V
F
condição
ação1 / ações1
ação2 / ações2
Se a condição for Verdadeira, a ação1 ou a sequência de ações1 serão executadas, se a condição for
Falsa, a ação2 ou a sequência de ações2 serão executadas.
Exemplo 9.3.
Fluxograma para ler a nota da prova e a nota do trabalho, e imprimir REPROVADO, caso a nota da
prova ou do trabalho seja menor do que 5 e caso contrário imprimir APROVADO.
início
prova, trab
V
prova < 5
ou trab < 5
“REPROVADO”
F
“APROVADO”
fim
9.6. Estruturas de Repetição
Uma estrutura de repetição permite repetir um grupo de ações ou estruturas, várias vezes. O fim
da repetição é determinado por um teste de condição.
9.6.1. Estrutura de Repetição Enquanto-faça
Esta estrutura de repetição tem o teste de condição no início da repetição. Portanto, enquanto a
condição é verdadeira, a ação ou as ações serão executadas repetidamente (ENQUANTO-FAÇA). Neste tipo
de estrutura de repetição, caso a condição seja Falsa na primeira vez, a ação ou as ações não serão
executadas nenhuma vez.
condição
F
V
ação / ações
20
Exemplo 9.4
Fluxograma para imprimir o quadrado dos números inteiros entre 1 e 50 (inclusive), usando a
estrutura de repetição Enquanto-faça.
início
N1
N <= 50
F
V
Q  N*N
Q
N  N+1
fim
9.6.2. Estrutura de Repetição Faça-enquanto
Esta estrutura de repetição tem o teste de condição no final da repetição. Portanto, neste tipo de
estrutura de repetição, a ação ou as ações serão executadas pelo menos uma vez.
ação / ações
V
condição
F
21
Exemplo 9.5.
Fluxograma para imprimir o quadrado dos números inteiros entre 1 e 50 (inclusive), usando a
estrutura de repetição Faça-enquanto.
início
N1
Q  N*N
Q
N  N+1
V
N <= 50
F
fim
10. Programação
Linguagem de programação é a linguagem utilizada pelo homem para dar instruções ao
computador. Uma linguagem de programação é formada por um conjunto de regras sintáticas e semânticas
que permite ao homem expressar as instruções que deseja que o computador execute.
Existem vários paradigmas (estilos) de programação:
Programação Imperativa (Fortran, Pascal, C)
Programação Orientada a Objetos (Smalltalk, C++, C#, Delphi, Java, Python, Ruby)
Programação Funcional (Lisp)
Programação Lógica (Prolog)
Na programação imperativa os programas são centrados no conceito de estados (modelados por
variáveis) e ações (comandos) que manipulam o estado. Uma linguagem de programação que utiliza o
paradigma imperativo manipula variáveis a partir de ordens ou comandos. Ex. “faça isso e depois aquilo”.
O paradigma orientado a objetos tenta extrair conceitos do mundo real por meio de estruturas
como objetos, classes, atributos e métodos. Uma classe é um conjunto de objetos e cada classe tem seus
atributos (propriedades) e métodos (ações). Ex. Cachorro é uma classe que possui os atributos: raça, idade,
cor, peso, etc. Totó é um objeto da classe cachorro, assim como Banzé. Os métodos da classe cachorro são:
latir, comer, dormir, etc. A programação orientada a objetos é complexa, envolvendo conceitos de
encapsulamento, herança, polimorfismo, associação, agregação, composição, etc.
No paradigma funcional os programadores abstraem o programa como uma sequência de funções
executadas de modo empilhado. Este paradigma é muito utilizado em Inteligência Artificial.
O paradigma lógico tem estilo declarativo e os programas são relações entre entrada e saída. Há
uso deste paradigma em Sistemas Especialistas e Bancos de Dados.
22
Os paradigmas mais utilizados são os paradigmas imperativo e orientado a objetos.
A relação entre linguagens de programação e paradigmas de programação é complexa porque uma
linguagem pode suportar mais do que um paradigma.
Na programação existem também os conceitos de modularização e programação estruturada que
não são paradigmas, mas técnicas de programação. Na programação estruturada os elementos chaves são
as estruturas básicas de controle (sequencial, condicional e repetitiva). Nesta técnica de programação é
proibido o uso irrestrito de comandos de desvio incondicional GOTO para aumentar a legibilidade e a
compreensão do programa.
A modularização de programas permite dividir o programa em blocos denominados procedimentos,
funções ou subrotinas, de modo a facilitar a compreensão e a correção, melhorando a clareza geral do
programa, além de permitir a reutilização de blocos. Com a modularização pode-se separar e esconder do
resto do programa, as informações necessárias para realizar uma tarefa específica.
11. Linguagem C
A linguagem C foi criada no início da década de 1970 por Dennis Ritchie, no Centro de Pesquisas
“Bell Laboratories” da AT&T. Devido à sua simplicidade e flexibilidade, a linguagem C tornou-se ao longo do
tempo uma das linguagens de programação mais populares e de grande interesse para os mais diversos
segmentos da computação. Ela é usada no desenvolvimento de vários softwares e sistemas operacionais
como: UNIX, Windows, Word, Excel, efeitos especiais do filme Guerra nas Estrelas, etc.
A linguagem C é considerada uma linguagem de médio nível, pois situa-se entre a linguagem de
baixo nível (linguagem próxima à linguagem de máquina) e a linguagem de alto nível (linguagem próxima a
do ser humano). Ela permite a manipulação de bits, bytes e endereços de memória, que são características
das linguagens de baixo nível e ao mesmo tempo suporta o uso de tipos de dados (inteiro, caractere, real,
etc.) que é uma das características da linguagem de alto nível.
C é uma linguagem imperativa que permite programação estruturada e modular.
Uma característica importante da linguagem C é a portabilidade, que permite fácil adaptação do
programa escrito para um sistema operacional (por exemplo, Windows) para ser executado em outro
sistema operacional (como Linux). Outra característica importante da linguagem C é a sua capacidade de
gerar programas extremamente rápidos em tempo de execução.
Nos anos 80, a linguagem C tornou-se muito popular, surgiu vários compiladores comerciais de C e
a linguagem C passou a ser reconhecida como linguagem de propósito geral. Com o desenvolvimento de
vários compiladores, tornou-se necessário padronizar a linguagem para garantir a compatibilidade e a
portabilidade da linguagem. A padronização foi desenvolvida pelo ANSI (American National Standards
Institute) que criou o padrão ANSI C em 1989.
A linguagem C++ é uma extensão da linguagem C e possui características do modelo orientado à
objetos adicionadas à linguagem imperativa, sendo portanto uma linguagem híbrida.
11.1. Compilador
O computador não é capaz de entender um programa escrito na linguagem C, pois ele só entende a
linguagem de máquina. Portanto, um programa escrito em qualquer linguagem que não seja a linguagem
de máquina, precisa ser traduzido para a linguagem de máquina para que o computador possa executá-lo.
Assim, após escrevermos um programa na linguagem C, precisamos de um compilador da linguagem C para
traduzir o programa para a linguagem de máquina.
O compilador lê a instrução do programa fonte (.c) escrito na linguagem C, faz a consistência da
sintaxe e se não houver erro, converte-a para a linguagem de máquina.
O programa com as instruções traduzidas para a linguagem de máquina é o programa objeto (.obj).
A este programa é necessário agregar as funções, em linguagem de máquina, que foram utilizadas no
programa e estão em arquivos de bibliotecas. Este trabalho é feito pelo linkeditor (ou editor de ligações)
que junta as funções necessárias ao programa objeto e gera o programa executável (.exe), que pode ser
executado diretamente pelo computador.
23
11.2. Dev-C++
Para criar um programa executável, é necessário digitar o programa fonte e salvá-lo com extensão
.c. Após isso, é preciso compilar e fazer a linkedição para gerar o programa executável.
Para editar, compilar, corrigir e fazer a linkedição de programas em C, utilizaremos um ambiente de
desenvolvimento integrado (IDE – Integrated Development Environment), denominado Dev-C++ (ou DevCpp), que é um software livre destinado à programação em C ou C++.
O Dev-C++ foi desenvolvido pelo programador Colin Laplace e a última versão lançada por ele é a
Dev-C++ 5.0 beta 9.2 (4.9.9.2). No entanto, esta é uma versão antiga, cuja última atualização foi feita em
2005 e apresenta vários problemas de execução em plataformas 64 bits. Por se tratar de uma ótima
ferramenta para desenvolvimento, Johan Mes Orwell deu continuidade ao desenvolvimento do Dev-C++ e
vem disponibilizando novas versões desde 2011. Portanto, é possível baixar uma versão atualizada do DevC++ no site: http://sourceforge.net/projects/orwelldevcpp/
O Orwell Dev-C++ é um projeto ativo e recebe atualizações constantemente. Na data de edição
desta apostila a última versão disponível no site era: Dev-Cpp 5.11 TDM-GCC 4.9.2 (atualizado em
abril/2015).
O arquivo de instalação (Dev-Cpp 5.11 TDM-GCC 4.9.2 Setup.exe) tem 49,3 Megabytes e vem com
compiladores para plataformas 32 e 64 bits, além do depurador (debugger) GDB.
O pacote TDM-GCC inclui o compilador, o pré-processador, o linkeditor, as bibliotecas padrões do C
e do C++ e os arquivos cabeçalhos correspondentes.
Um outro ambiente de desenvolvimento baseado no Dev-C++ é o wxDev-C++ (última atualização
julho/2012), disponível na página: http://wxdsgn.sourceforge.net/
O wxDev-C++ foi criado a partir do código fonte do Dev-C++ e oferece um ambiente de
programação visual, onde a programação é realizada a partir de elementos gráficos que estão disponíveis
na tela. Como este tipo de programação é mais complexa, não será abordada neste primeiro curso de
programação.
11.3. Estrutura Básica de um Programa em C
Um programa em C consiste em uma ou várias funções, cuja estrutura geral é a seguinte:
tipo nome_da_funcao(declaração dos parâmetros)
{
declaração de variáveis;
instrução_1;
...
instrução_n;
return valor;
}
11.4. Função main()
A função main() é a principal função e inicia a execução de um programa na linguagem C.
Neste exemplo, a função principal retornará o valor inteiro 0.
int main()
{
return 0;
}
24
Podemos escrever a função main() na forma resumida (abaixo), pois a forma resumida é
automaticamente convertida, pelo compilador, para a forma padrão (que retorna um inteiro), apresentada
acima.
main()
{
}
Toda função deve ter parênteses, mesmo que vazio, sem nenhum parâmetro. Além disso, toda
função deve ter chaves que delimitam o corpo da função.
11.5. Meu primeiro programa em C
#include<stdio.h>
#include<stdlib.h>
int main()
{
printf(“Meu primeiro programa!\n”);
system(“pause”);
return 0;
}
11.6. Bibliotecas
Bibliotecas são arquivos em linguagem de máquina que contêm funções desenvolvidas por outros
programadores e que podem ser usadas no seu programa. Além da biblioteca padrão ANSI C, fornecida
com os compiladores C, existem também bibliotecas privadas.
Algumas das bibliotecas básicas que fazem parte da biblioteca padrão ANSI C são apresentadas a
seguir:
A biblioteca stdio.h (standard input/output) é uma biblioteca padrão de entrada e saída que
contém funções, macros e constantes padrões ao compilador. Algumas das funções desta biblioteca são:
printf, scanf, getc, putc, getchar, putchar, gets, puts, fopen, fclose, etc.
A biblioteca stdlib.h, muito utilizada, contém funções de utilidade geral, além de funções para
conversão de número em texto e texto em número, gerar número aleatório: system, free, exit, atoi, atof,
rand, abs, etc.
A biblioteca math.h fornece funções matemáticas básicas como: exp, log, sin, cos, tan, pow, sqrt,
etc.
A biblioteca string.h disponibiliza funções para manipulação de strings como: strcpy, strcmp, strlen,
strcat, etc.
11.7. Diretiva #include
Para utilizar funções de uma biblioteca é necessário incluir a respectiva biblioteca no início do
programa, através da diretiva #include.
A diretiva #include<stdio.h> indica ao linkeditor para juntar o código objeto do programa
(resultado da compilação) com o código objeto das funções da biblioteca stdio.h. O arquivo de cabeçalho
stdio.h contém o nome e as características das funções.
25
11.8. Função printf()
A função printf() é uma função da biblioteca padrão stdio.h e não faz parte da definição da
linguagem C. Dentro do parêntesis deve ser colocado entre aspas o que deseja que seja exibido na tela.
Portanto, o comando printf(“Meu primeiro programa!”) imprime na tela o texto informado como
parâmetro: Meu primeiro programa!
Várias combinações de caracteres especiais podem ser usadas no comando printf(). O \n, por
exemplo, serve para mudar de linha. Ex.: printf(“Meu primeiro programa!\n”).
Códigos especiais
Significado
\n
nova linha
\t
tabulação
\a
alerta audível (campainha)
\'
apóstrofo
\”
aspas
A tabela a seguir apresenta alguns códigos de formatação utilizados no printf():
Código de formatação
para printf()
Significado
Tipo
%c
caractere
char
%s
cadeia de caracteres (string)
char
%d
número inteiro
int
%u
número inteiro sem sinal
unsigned
%f
número real
float ou double
%e
número real em notação científica (e minúsculo)
float ou double
%E
número real em notação científica (E maiúsculo)
float ou double
%g
%f ou %e, o que for menor
float ou double
%x
inteiro hexadecimal sem sinal (letras minúsculas)
int
%X
inteiro hexadecimal sem sinal (letras maiúsculas)
int
%p
ponteiro (endereço)
int
%%
imprime o caractere %
char
vírgula.
A função printf() pode ter um ou vários argumentos. Os argumentos devem ser separados por
Vejamos alguns exemplos de uso do printf.
Exemplo 1.
printf(“Meu primeiro programa!”);
O comando acima possui somente um argumento que está entre aspas e será impresso na tela do
computador.
Exemplo 2.
printf(“Fatorial de %d = %d.”, n, fat);
Este comando possui 3 argumentos (separados por vírgulas). O primeiro argumento contém os
caracteres que serão impressos e os códigos de formatação (%d) que indicam o formato em que os
26
argumentos seguintes (n, fat) devem ser impressos. Os argumentos n e fat são variáveis, cujos valores serão
impressos. Portanto, caso o valor da variável n seja 5 e o valor da variável fat seja 120, o comando acima
imprime:
Fatorial de 5 = 120.
Exemplo 3.
printf(“%s obteve media %f.”, nome, media);
Este comando imprime a string contida na variável nome, a mensagem obteve media e o valor da
variável (media) do tipo float (real). Portanto, caso o valor da variável nome seja “Ana Paula”, e o valor da
variável media seja 8.5, o comando imprime:
Ana Paula obteve media 8.5.
Exemplo 4.
printf(“pi = %.4f”, M_PI);
Este comando imprime a mensagem pi = e o valor da constante M_PI (3.14.159265) do tipo float,
usando 4 casas decimais. Portanto, o comando imprime:
pi = 3.1416
11.9. Função scanf()
A função scanf() também é uma função da biblioteca padrão stdio.h. Ela permite ler dados
fornecidos pelo teclado. A sua sintaxe é semelhante a de printf(), isto é, os códigos de formatação
(ilustrados na tabela anterior), compatíveis com os tipos das variáveis, devem ser colocados entre aspas,
seguida por uma lista de argumentos, separados por vírgulas. Os argumentos de scanf() devem ser os
endereços das variáveis, onde serão armazenados os valores fornecidos pelo teclado. Os endereços das
variáveis são os nomes das variáveis precedidos por &. Exemplo: &x, &salario, &nota.
Código de formatação
para scanf()
Significado
Tipo
%c
caractere
char
%s
string ou cadeia de caracteres
-
%d
número inteiro
int
%u
número inteiro sem sinal
unsigned
%f
número real
float
%lf
número real longo
double
Exemplo 1.
scanf(“%d”, &idade);
O comando acima lê um valor inteiro (código %d) e armazena na variável idade.
Exemplo 2.
scanf(“%f %f”, &prova, &trabalho);
O comando acima lê dois valores reais (código %f) e armazena respectivamente nas variáveis prova
e trabalho.
27
11.10. Função system()
A função system() faz parte da biblioteca stdlib.h e com o parâmetro PAUSE serve para interromper
a execução do programa para que o usuário possa ver os resultados na janela de saída, antes que a janela
seja fechada. Sem essa função, o programa é executado e a janela é fechada automaticamente, não
permitindo a visualização dos resultados.
Exemplo:
system(“pause”);
Com o uso de system(“pause”); será exibida na tela a seguinte mensagem: Press any key to
continue.... Caso deseje que não seja exibida esta mensagem, use: system(“pause>>null”);
11.11. Constantes
Uma constante tem valor fixo e inalterável.
Os números constantes na linguagem C podem ser escritos na base decimal, hexadecimal ou octal.
A base decimal é a base que estamos acostumados. Ex. 318, 19.43, -57. Estes números não podem estar
entre aspas.
Caracteres constantes são escritos entre apóstrofos. Ex. 'X', '8', '\n'.
Cadeias de caracteres constantes são escritas entre aspas. Ex. “Meu primeiro programa”.
11.12. Variáveis
Variável é um espaço de memória reservado para armazenar um certo tipo de dado, tendo um
nome para referenciar o seu conteúdo. O tipo da variável informa a quantidade de memória em bytes, que
ela ocupará e o modo como um valor deverá ser armazenado e interpretado.
11.12.1. Tipos de Variáveis
Os tipos básicos de variáveis em C são: int, float, double, char e void. O tipo int tem o tamanho da
palavra da máquina, isto é, em ambientes de 32 bits o tipo int terá o tamanho de 4 bytes e suportará
números inteiros entre -2147483648 a 2147483647. O float terá o tamanho de 4 bytes e suportará
números reais no intervalo 3.4x10-38 a 3.4x1038. Os dados da tabela abaixo referem-se aos tipos de dados de
um ambiente de 32 bits.
Existem em C, 3 modificadores de tipo (short, long e unsigned) que podem acompanhar qualquer
tipo básico de dados, exceto void.
Tipo
Bytes
Bits
Valores
int
4
32
-2147483648 a 2147483647
float
4
32
3.4x10-38 a 3.4x1038
double
8
64
1.7x10-308 a 1.7x10308
void
0
0
Nenhum valor
short
2
16
-32768 a 32767
unsigned
4
32
0 a 4294967295
long double
10
80
3.4x10-4932 a 3.4x104932
11.12.2. Declaração de Variáveis
As variáveis devem ser declaradas no início de uma função, logo após a abertura da chave e antes
de qualquer instrução.
Na declaração de variáveis, deve-se colocar o tipo da variável seguido pelos nomes das variáveis
separados por vírgula.
28
Exemplo:
int lado1, lado2, lado3;
float nota, media;
char alternativa;
11.12.3. Nomes de Variáveis
Os nomes de variáveis (ou identificadores) devem começar com um caractere alfabético e podem
ser seguidos por caracteres alfabéticos ou dígitos (entre 0 e 9). O caractere de sublinhado é considerado
caractere alfabético. Os nomes de variáveis não devem conter caracteres especiais (!, @, -, #, $, %, ¨, &, *,
etc...) e devem ser diferentes das palavras-chave da linguagem C.
A linguagem C é “case sensitive”, isto é, ela diferencia letra maiúscula de minúscula, por isso: Idade
é diferente de idade e também diferente de IDADE.
11.13. Palavras-chave
A tabela abaixo apresenta as palavras-chave ou palavras reservadas da linguagem C (padrão ANSI).
Observe que todas elas são em letra minúscula.
Categoria
Palavras-chave
Tipos de dados
char, int, float, double, void
Modificadores de tipo
long, short, signed, unsigned
Modificadores de tipo de acesso
const, volatile
Classes de armazenamento
auto, extern, static, register
Tipos definidos pelo usuário
struct, enum, union, typedef
Comandos condicionais
if, else, switch, case, default
Comandos de repetição
while, do, for
Comandos de desvio
break, goto, return, continue
Operador
sizeof
11.14. Operadores
Existem muitos operadores na linguagem C. Os operadores mais utilizados serão apresentados a
seguir.
11.14.1. Operador de atribuição
Em C, o operador de atribuição é o sinal de igual.
Exemplo 1.
x = 10;
atribui o valor 10 para a variável x.
Podemos também executar atribuições múltiplas.
Exemplo 2.
y = x = 0;
As atribuições são executadas da direita para a esquerda. Assim, a variável x receberá o valor 0 e a
variável y também receberá o valor 0.
É possível inicializar uma variável na sua declaração.
Exemplo:
29
int x = 5;
float saldo = 0;
11.14.2. Operadores aritméticos
A linguagem C possui 5 operadores aritméticos binários (que operam entre 2 operandos) e um
operador aritmético unário (que opera sobre um único operando).
Operador binário
Exemplo
Ação
+
x+y
soma x e y
-
x-y
subtrai y de x
*
x*y
multiplica x e y
/
x/y
divide x por y
%
x%y
resto da divisão de x por y
Operador unário
Exemplo
Ação
-
-x
troca o sinal de x
Exemplos:
a) 5 * x
b) 14 / 3
c) 17 % 5
d) - y
O operador módulo (%) só aceita operandos inteiros e retorna o resto da divisão inteira. No
exemplo c) 17 % 5, será retornado 2, que é o resto da divisão de 17 por 5. Todos os demais operadores
aceitam operandos inteiros ou reais.
Na divisão (/), se ambos os operandos forem constantes inteiras ou variáveis declaradas como
inteiras (int), o resultado será inteiro. No exemplo b) 14/3, será retornado 4 e não 4.6667. Porém, se pelo
menos um dos operandos da divisão for um número real, ou uma variável declarada como real (float), o
resultado da divisão será real. Por exemplo, caso a variável x seja declarada como float, a variável y seja
declarada como int, a variável x contenha o valor 14 e a variável y contenha o valor 3, o resultado de x / y
será 4.6667, porque uma das variáveis é real.
O operador menos unário (-) é usado para indicar a troca de sinal. Por exemplo, na expressão y = -x;
a variável y está recebendo o valor da variável x, com o sinal trocado.
Os operadores *, / e % têm precedência maior que os operadores + e -. Isso significa que os
operadores *, / e % serão avaliados antes dos operadores + e -. Para mudar a precedência dos operadores,
pode-se utilizar vários níveis de parênteses como por exemplo: (5*(x+2)-6)/4. As expressões entre
parênteses são as primeiras a serem avaliadas. Quando aparecem vários operadores de mesma
precedência em uma expressão, os cálculos serão realizados seguindo a ordem da esquerda para a direita.
11.14.3. Operadores de incremento e decremento
Os operadores de incremento (++) e decremento (- -) são unários.
Operador
Exemplo
Ação
++
x++ ou ++x
incrementa 1 ao valor de x
--
x- - ou - - x
decrementa 1 ao valor de x
O operador de incremento ++ opera sobre o nome de uma variável e adiciona 1 ao valor desta
variável.
30
Exemplos:
a) x++
b) ++x
No item a) temos um exemplo de uso pós-fixado e no item b) temos um exemplo de uso prefixado.
x++ equivale a ++x que equivale a x = x +1.
O operador de decremento - - opera sobre o nome de uma variável e decrementa 1 ao valor desta
variável. Pode também ser prefixado (- - x) ou pós-fixado (x- -).
x- - equivale a - - x que equivale a x = x – 1.
11.14.4. Operadores aritméticos de atribuição
Os operadores aritméticos de atribuição (ou operadores compostos) combinam as operações
aritméticas com a operação de atribuição, oferecendo uma forma mais compacta para algumas expressões
de atribuição. O operador da esquerda é sempre uma variável e o da direita é uma expressão. A operação
consiste em atribuir um novo valor à variável, que depende do operador e da expressão à direita.
A regra geral para operadores aritméticos de atribuição é
x op = exp;
equivale a
x = x op exp;
onde: x é variável, op é um operador aritmético (+, - *, / ou % ) e exp é uma expressão.
Exemplos:
s += 3;
d –= 2+t;
t *= 4;
x %= 3;
y /= (x-1);
equivale a
equivale a
equivale a
equivale a
equivale a
s = s + 3;
d = d – (2+t);
t = t * 4;
x = x % 3;
y = y / (x-1);
11.14.5. Operadores relacionais
Os operadores relacionais fazem comparações e formam as expressões relacionais que são
condições simples.
Operador relacional
Ação
==
igual
!=
diferente
>
maior
<
menor
>=
maior ou igual
<=
menor ou igual
Em C, o resultado de uma expressão relacional (que usa operador relacional) é 1 para verdadeiro e
0 para falso. Não existem em C, valores booleanos “true” e “false”. Embora C defina o valor verdadeiro
como 1, a linguagem considera qualquer valor não zero como verdadeiro, inclusive valor negativo.
Exemplos:
a) nota >= 5.0
b) opcao == 'S'
O resultado da expressão relacional do item a) será 1, se na variável nota tiver qualquer valor igual
ou superior a 5.0, caso contrário o resultado será 0 (zero). No item b), se a variável opcao tiver valor igual a
S maiúsculo, então o valor da expressão relacional será 1, caso contrário 0.
Observação: A comparação de caracteres é “case sensitive”, isto é, para a linguagem C o caractere
's' minúsculo é diferente do caractere 'S' maiúsculo. De fato, para a linguagem C um caractere é apenas um
número inteiro associado a tabela ASCII. Neste caso, o valor de 'S' maiúsculo na tabela ASCII é 83 e o valor
31
de 's' minúsculo é 115. Logo, se opcao='s' no item b), então a expressão relacional é equivalente à 115==83,
que é falsa e retorna o valor 0. Para mais informações sobre a tabela ASCII consulte o Apêndice C da
referência [7].
11.14.6. Operadores lógicos
Os operadores lógicos são utilizados para formar condições mais complexas ao combinar condições
simples (que usam operadores relacionais).
Operador lógico
Ação
&&
e
||
ou
!
não
O operador ! é unário, enquanto que && e || são operadores binários.
Exemplos:
a) resposta == 'N' && !(idade < 18)
b) x > 10 || -x == 5
11.14.7. Operador condicional ternário (?:)
O operador condicional substitui uma expressão condicional do tipo if-else e tem a seguinte forma
genérica:
exp1 ? exp2 : exp3
Por exemplo:
maior = (x>y) ? x : y;
Esta expressão equivale a
if (x>y)
maior = x;
else
maior = y;
Outro exemplo:
printf(“%s”, idade >= 18 ? “maior de idade” : “menor de idade”);
O comando acima imprime maior de idade caso a idade seja maior ou igual a 18 e menor de idade
caso contrário.
11.14.8. Precedência dos Operadores
A tabela a seguir ilustra a precedência entre os operadores apresentados.
Precedência
Operadores
1
- (unário)
2
*
3
4
<
5
++
--
/
%
+
-
<=
>
==
!=
6
&&
7
||
8
?:
>=
32
!
9
=
*=
/=
%=
+=
-=
Para mudar a precedência dos operadores da tabela acima, pode-se utilizar vários níveis de
parênteses como por exemplo: !(salario < 5000.00 && tempo >= 4).
11.15. Biblioteca math.h
A biblioteca math.h contém várias funções e algumas constantes matemáticas úteis. A tabela
abaixo mostra as principais funções e constantes.
Função
Ação
exp(x)
exponencial de x (ex, onde e = 2.718282...)
log(x)
logaritmo natural ou neperiano de x (log ex)
log10(x)
logaritmo de x na base 10 (log10x)
fabs(x)
valor absoluto de x (x)
sin(x)
seno de x
cos(x)
cosseno de x
pow(x,y)
x elevado à potência y (xy)
sqrtx)
raiz quadrada de x ( x )
ceil(x)
arredonda x para o menor inteiro não menor que x (teto de x)
floor(x)
arredonda x para o maior inteiro não maior que x (piso de x)
fmod(x,y)
resto de x/y (x e y reais ou x ou y real)
M_PI
 (3.14159265358979)
M_E
e (2.71828182845904)
11.16. Biblioteca locale.h
A biblioteca locale.h especifica constantes de acordo com a localização específica (regionalização),
como acentuação, ponto decimal, moeda, data, etc.
Portanto, para usar palavras acentuadas no printf, inclua a biblioteca locale.h e no início do
programa inclua o comando setlocale(LC_ALL,”portuguese”) para definir o idioma como português ou
setlocale(LC_ALL,””) para usar a localidade padrão do sistema operacional.
11.17. Comentários
Os comentários são utilizados para documentar o programa e são ignorados pelo compilador. Os
comentários devem ser escritos entre /* e */ e podem ocupar várias linhas. Pode ser usado também o
comentário de linha única //, no qual, tudo a partir de // até o final da linha será considerado comentário.
Exemplos:
a) /* Este programa lê um número fornecido pelo usuário, calcula o fatorial deste número
e mostra para o usuário o valor (fatorial) encontrado. */
b) printf("Digite um numero: "); // mostra na tela a mensagem entre aspas
scanf("%d", &n);
// lê um valor inteiro e armazena na variável n
33
11.18. Estrutura Sequencial
Estrutura sequencial é uma sequência de comandos de atribuição, comandos de entrada ou de
saída.
Exemplo:
Programa para ler o consumo mensal de energia elétrica em kWh e imprimir o valor da conta de
energia, supondo que 1 kWh custe R$ 3,00 e que não há imposto nenhum envolvido no cálculo da conta.
#include<stdio.h>
#include<stdlib.h>
int main()
{
int consumo;
float conta;
printf("Digite o valor do consumo: ");
scanf("%d", &consumo);
conta = consumo*3.00;
printf("Valor da conta = R$ %.2f \n\n", conta);
system("pause");
return 0;
}
11.19. Estruturas Condicionais
11.19.1. Estrutura Condicional Simples
A estrutura condicional simples permite executar um comando (ou bloco de comandos) quando
uma condição for verdadeira. Uma condição é uma comparação que pode ser verdadeira ou falsa.
No trecho abaixo, se a condição1 for verdadeira, o comando1 será executado.
if (condição1)
comando1;
Exemplo:
anos.
Programa para ler a idade e imprimir a mensagem Menor de idade, caso a idade seja inferior a 18
#include<stdio.h>
#include<stdlib.h>
int main()
{
int idade;
printf("Digite a idade: ");
scanf("%d", &idade);
if (idade < 18)
printf("Menor de idade.\n\n");
system("pause");
return 0;
}
34
Quando você deseja que mais que um comando sejam executados caso uma condição seja
verdadeira, você deve utilizar chaves { } para delimitar os comandos que serão executados.
No trecho a seguir, se a condição1 for verdadeira, então o comando1 e o comando2 serão
executados. O comando3 será sempre executado, independentemente da condição1, porque ela está fora
das chaves.
if (condição1)
{
comando1;
comando2;
}
comando3;
Abaixo, se a condição1 for verdadeira, o comando1 será executado. O comando2 e o comando3
sempre serão executados, independentemente da condição1. Isso porque, os comandos (comando1,
comando2 e comando3) não estão entre chaves, assim, o compilador interpretará que somente o
comando1 faz parte da estrutura condicional e os demais comandos estão fora da estrutura condicional e,
portanto serão executados independentemente da condição1, ou seja, serão sempre executados.
if (condição1)
comando1;
comando2;
comando3;
Exemplo:
Programa para ler o raio e caso o raio lido seja positivo, calcular e imprimir a área do círculo.
#include<stdio.h>
#include<math.h>
int main()
{
float raio, area;
printf("Digite o raio do circulo: ");
scanf("%f", &raio);
if (raio >0)
{
area = M_PI*pow(raio,2);
printf("Area do circulo = %f.\n\n", area);
}
system("pause");
return 0;
}
11.19.2. Estrutura Condicional Composta
A estrutura condicional composta permite executar um comando (ou bloco de comandos) quando
uma condição for verdadeira e outro comando (ou bloco de comandos) quando a condição for falsa.
No trecho abaixo, caso a condição1 seja verdadeira, o comando1 será executado e caso contrário,
isto é, se a condição1 for falsa, o comando2 será executado.
if (condição1)
comando1;
else
comando2;
No trecho abaixo, caso a condição1 seja verdadeira, o comando1 será executado e caso contrário, o
35
comando2 e o comando3 serão executados.
if (condição1)
comando1;
else
{
comando2;
comando3;
}
Exemplo:
Programa para ler a nota da prova e do trabalho, e imprimir Reprovado, caso a nota da prova ou do
trabalho seja menor do que 5 e caso contrário, imprimir Aprovado e a média dada pela fórmula:
4 P+ T
M=
.
5
#include<stdio.h>
#include<stdlib.h>
int main()
{
float prova, trab, media;
printf("Digite a nota da prova: ");
scanf("%f", &prova);
printf("Digite a nota do trabalho: ");
scanf("%f", &trab);
if (prova < 5 || trab < 5)
printf("Reprovado \n\n");
else
{
printf("Aprovado \n");
media = (4*prova + trab)/5;
printf("Media = %f. \n\n", media);
}
system("pause");
return 0;
}
11.19.3. Estrutura Condicional com múltiplas ações
Existem situações onde um programa deve executar uma determinada ação baseado num conjunto
finito de opções. Como podem existir várias opções, cada uma delas com uma sequência específica de
comandos, então é necessário usar uma estrutura de decisão que seja capaz de definir qual a ação será
executada dentre as várias opções disponíveis. Para executar essa tarefa podemos usar a estrutura switch
… case. A forma geral da estrutura é:
switch(controle)
{
case opcao_1 :
Sequência de comandos 1;
case opcao_2 :
...
case opcao_n :
36
Sequência de comandos n;
default :
Sequência de comando padrão;
}
A variável controle é usada como indexador no switch, é ela que define qual sequência de
comandos será executada. Por padrão, a variável indexadora (neste caso controle) tem que ser do tipo int
ou char. O comando switch passa o valor da variável controle para o comando case que compara o valor da
variável controle com o valor das constantes opcao_1, opcao_2, …, opcao_n. Então, quando é encontrada
uma constante igual ao valor da variável controle, todas as sequências de comandos a partir daquela opção
são executadas. Por exemplo, se controle == opcao_3, então todas as sequências de comandos a partir da
sequência 3 são executadas. Para executar apenas a sequência de comandos referente a uma determinada
opção, devemos incluir o comando break no final de cada comando case.
switch(controle)
{
case opcao_1 :
break;
...
case opcao_n :
Sequência de comandos n;
break;
default :
Sequência de comando padrão;
}
O comando default é opcional e é executado quando o valor da variável controle é diferente de
todas as constantes opcao_1, opcao_2, …, opcao_n, ou, quando não for incluído break no final dos
comandos case. O break é um comando de desvio. Na linguagem C ele só pode ser usado dentro do
conjunto de comandos de uma estrutura de decisão ou repetição. O comando break é usado para forçar o
encerramento de uma estrutura. No caso de estruturas aninhadas (uma dentro da outra), o comando
encerra apenas a estrutura a qual ele pertence.
Exemplo:
Programa para imprimir um valor de acordo com um número lido pelo teclado. Se o valor lido for
incompatível com as opções, então o programa imprime uma mensagem de erro.
#include<stdio.h>
#include<stdlib.h>
int main()
{
int x;
printf("Digite um numero inteiro entre 1 e 4: ");
scanf("%d",&x);
switch (x)
{
case 1:
printf("O valor = %d\n", x);
break;
case 2:
printf("O dobro de %d = %d\n", x, 2*x);
break;
case 3:
37
printf("O triplo de %d = %d\n", x, 3*x);
break;
case 4:
printf("O quadruplo de %d = %d\n", x, 4*x);
break;
default:
}
printf("Opcao invalida! Voce digitou %d\n", x);
}
system("pause");
return 0;
11.20. Estruturas de Repetição
Uma estrutura de repetição é usada para repetir uma ação ou um conjunto de ações enquanto uma
determinada condição é satisfeita. Estruturas de repetição são essenciais para a manipulação de vetores,
matrizes, criação de menus e outras estruturas de dados em linguagens de programação.
O padrão ANSI C define 3 comandos de repetição para a linguagem C:
do { } while
while
for
A única diferença entre eles está na localização da condição de parada.
No comando do { } while a condição de parada está localizada após o conjunto de comandos do
laço (loop) de repetição. Dessa forma, a condição é testada somente após a primeira execução do laço. Já
nos comandos while e for a condição de parada está localizada antes do conjunto de comandos do laço de
repetição. Então, primeiro testa-se a condição e se ela for falsa, os comandos do laço não são executados. A
sintaxe dos comandos de repetição é discutida em detalhes a seguir.
11.20.1. Estrutura de Repetição do { } while
A estrutura de repetição do { } while (faça-enquanto) é usada quando o laço de repetição tem que
ser executado pelo menos uma vez.
No trecho abaixo, os 3 comandos (comando1, comando2 e comando3) serão repetidos enquanto a
condição for verdadeira e o comando4 só será executado após a condição tornar-se falsa.
do
{
comando1;
comando2;
comando3;
}
while (condição);
comando4;
Exemplo:
Programa para imprimir a soma dos números pares positivos menores que 50.
38
#include<stdio.h>
#include<stdlib.h>
int main()
{
int x, soma;
soma = 0;
x = 2;
do
{
soma = soma+x;
x = x + 2;
} while (x < 50);
printf("Soma = %d \n\n", soma);
system("pause");
return 0;
}
Observação: O comando system(“cls”) limpa a tela.
11.20.2. Estrutura de Repetição while
Na estrutura de repetição while (enquanto) o teste de parada fica antes do conjunto de comandos
do laço e, portanto, existe a possibilidade da repetição não ser executada nenhuma vez, caso a condição
assuma valor falso na primeira verificação.
O comando while foi adicionado à linguagem C por uma questão de compatibilidade com outras
linguagens de programação. Na linguagem C, o comando while pode ser facilmente substituído pelo
comando for e seu uso é recomendado somente para os casos em que não se conhece o número de vezes
que o trecho do programa deve ser repetido. Os comandos no laço serão repetidos enquanto a condição do
teste de parada for verdadeira.
No trecho abaixo, somente o comando1 será repetido enquanto a condição for verdadeira. O
comando2 e o comando3 só serão executados uma vez, após terminar a repetição, isto é, após a condição
assumir valor falso.
while (condição)
comando1;
comando2;
comando3;
Caso você queira que os 3 comandos (comando1, comando2 e comando3) sejam repetidos, você
deve delimitá-los com chaves { }.
No trecho a seguir, os comandos 1, 2 e 3 serão repetidos enquanto a condição for verdadeira e o
comando4 só será executado após a condição tornar-se falsa.
while (condição)
{
comando1;
comando2;
comando3;
}
comando4;
Exemplo:
39
Programa para imprimir a soma dos números pares positivos menores que 50.
#include<stdio.h>
#include<stdlib.h>
int main()
{
int x, soma;
soma = 0;
x = 2;
while (x < 50)
{
soma = soma+x;
x = x + 2;
}
system("pause");
return 0;
}
11.20.3. Estrutura de Repetição for
O comando for (para) é a estrutura de repetição mais comum, sendo definida em qualquer
linguagem de programação. No entanto, na linguagem C esse comando foi melhorado, sendo possível usálo para qualquer operação de repetição cujo teste de parada é realizado antes dos comandos do laço.
Em linguagem C a sintaxe do comando for é da forma:
for (inicialização da variável de controle; condição para repetir; incremento ou decremento da
variável de controle)
comando1;
Ou seja, o comando for é dividido em três partes, sendo cada parte separada por um ponto e
vírgula (;). As partes são opcionais e a linguagem C permite que uma delas seja omitida (ou todas elas sejam
omitidas). A separação em partes faz com que o comando for seja muito mais versátil na linguagem C do
que em outras linguagens de programação.
As partes do comando for são explicadas a seguir:
inicialização da variável de controle: é aqui que se define qual é a variável de controle da repetição
e então atribui-se um valor inicial a ela. Esta parte é executada apenas uma vez, no início da primeira
iteração (execução dos comandos do bloco de repetição).
condição para repetir: esta parte é executada após a inicialização da variável de controle e após o
incremento ou decremento da variável de controle. É ela que diz quando a repetição deve parar. Os
comandos do bloco de repetição serão executados enquanto o valor lógico da condição para repetir for
verdadeiro.
incremento ou decremento da variável de controle: esta parte é executada cada vez que termina
uma iteração. É aqui que a variável de controle é incrementada ou decrementada.
Exemplo:
for (i=1,i<=5; i++)
comando1;
A linguagem C permite utilizar várias variáveis de controle e realizar múltiplas operações de
incremento (ou decremento), sendo que cada operação deve ser separada por vírgula. Por exemplo,
podemos implementar um comando for da seguinte maneira:
for (i=0,j=10; i<=5; i++,j--)
comando1;
40
Neste caso, o comando for possui duas variáveis de controle (i e j) que são inicializadas com valores
i=0 e j=10. Em seguida, definimos qual a condição para repetição (i<=5) e finalmente as operações de
incremento ou decremento das variáveis de controle (i++ e j--).
Também podemos definir condição para repetir envolvendo apenas as variáveis de controle.
Exemplo:
for ( i=0,j=10; i<=j; i++,j-- )
comando1;
Após cada iteração, o comando atualiza os valores de i e j e então faz o teste da condição de
repetição. Isso quer dizer que o comando for é capaz de prever mudanças tanto no lado esquerdo quanto
no lado direito do teste de parada. Para finalizar, na linguagem C as variáveis de controle do comando for
podem receber incrementos ou decrementos de qualquer valor. Exemplo:
for (i=0,j=3; j<=300; i+=3,j*=i+1)
comando1;
No trecho acima a variável de controle i recebe incrementos de 3 em 3 e a variável j é
incrementada pela multiplicação de j com i+1. Como i é incrementado antes de j, então o valor usado em j
é sempre o obtido após a atualização da variável i.
Quando há vários comandos que devem ser repetidos, estes comandos devem ser escritos entre
chaves { }.
for (variável = valor inicial; condição para repetição; incremento ou decremento da variável)
{
comando1;
comando2;
}
Exemplo 1 (Incrementando a variável de controle em duas unidades por vez).
Programa para imprimir a soma dos números pares entre 20 e 40 (inclusive os extremos).
#include<stdio.h>
#include<stdlib.h>
int main()
{
int i, soma;
soma = 0;
for (i=20; i<=40; i=i+2)
soma = soma + i;
system("pause");
return 0;
}
Exemplo 2 (Usando 2 variáveis de controle).
Programa para imprimir a soma dos números entre 20 e 40 que possuem posição simétrica quanto
ao centro do intervalo. Ou seja, S1=20+40, S2=21+39, S3=22+38, ...
#include<stdio.h>
#include<stdlib.h>
int main()
{
int i, j, soma;
41
for (i=20,j=40; i<=j; i++,j--)
{
soma=i+j;
printf("%d + %d = %d \n\n",i,j,soma);
}
system("pause");
return 0;
}
Como mencionado, as três partes do comando for são opcionais e existem casos onde essa
característica é muito útil. Por exemplo, quando desejamos criar um menu com várias opções.
Neste caso, é muito comum criarmos uma repetição infinita para assegurar que o programa será
encerrado somente quando a opção Fechar o programa for acionada.
Exemplo 3 (Criando uma repetição sem critério de parada).
Programa que cria um menu para executar várias operações distintas em um número fornecido
pelo usuário.
#include <stdio.h>
#include<stdlib.h>
#include <math.h>
int main()
{
float N;
int opt;
printf("Digite um numero positivo 'N': ");
scanf("%f", &N);
printf("\n Este programa efetua as seguintes operacoes:\n\n");
printf("1 - Imprime o numero lido\n");
printf("2 - Imprime o dobro do numero lido\n");
printf("3 - Imprime o quadrado do numero lido\n");
printf("4 - Imprime a raiz quadrada do numero lido\n");
printf("5 - Fecha o programa\n");
printf("\n Que operacao deseja executar [1~5]? ");
scanf("%d", &opt);
for( ; ; ) // Laço sem critério de parada
{
switch (opt)
{
case 1 :
printf("\n Valor de N: %.2f\n", N);
break;
case 2 :
printf("\n Valor do dobro de %.2f: %.2f \n", N, 2*N);
break;
case 3 :
42
printf("\n Valor do quadrado de %.2f: %.2f \n", N, N*N);
break;
case 4 :
printf("\n Valor da raiz quadrada de %.2f: %.2f \n", N, sqrt(N));
break;
case 5 :
return 0;
default : printf("\n Opcao invalida! \n O Valor digitado foi: %d \n", opt);
}
printf("\n Que operacao deseja executar [1~5]? ");
scanf("%d", &opt);
}
system("PAUSE");
}
Observação: O comando for( ; ; ) é uma repetição sem critério de parada, equivalente ao comando
while (1).
11.21. Diretiva #define
O uso mais frequente da diretiva #define é para dar nome simbólico a uma constante. Por exemplo,
quando estamos escrevendo um programa sobre uma empresa que tem 200 funcionários, podemos definir
n_func como 200, e utilizar n_func no lugar do número de funcionários. Assim, quando houver alteração no
número de funcionários, basta alterar o valor do n_func na diretiva #define, ao invés de modificar todo o
programa onde o número de funcionários é utilizado.
Exemplo:
#define n_func 200
#define mensagem “Bem vindo!”
11.22. Strings
Uma string consiste em uma série de caracteres tratados como uma única entidade. Uma string
pode incluir letras, dígitos e caracteres especiais, inclusive espaço. As constantes strings são escritas entre
aspas: “Ana Cristina Mattos”, “Av. Dom Pedro II, 2183”, “(16) 3301-9500”.
Na linguagem C, string é um vetor (array) do tipo char, que armazena um texto formado por
caracteres, e termina com caractere nulo (\0). Uma string é acessada através de um ponteiro para o
primeiro caractere da string. O valor de uma string é o endereço de seu primeiro caractere. Portanto, em C,
string é um ponteiro para o primeiro caractere do vetor.
Quando o compilador C encontra qualquer coisa entre aspas, ele reconhece que se trata de uma
string constante. Por exemplo:
printf("Digite um numero: ");
11.22.1. Declaração de strings
Uma string deve ser declarada da seguinte forma:
char nome_da_string[tamanho_da_string];
Exemplo:
char curso[30];
char nome[40], sexo[20];
43
No exemplo acima, curso é uma string de 29 caracteres, nome é uma string de 39 caracteres e sexo
é uma string de 19 caracteres.
Cuidado!
a) Ao entrar com os caracteres da string pelo teclado, se o número de caracteres digitados exceder
o tamanho da string (overflow), os últimos caracteres da string substituirão outros dados da memória, o
que pode afetar o funcionamento correto do programa.
b) É muito comum programadores iniciantes errarem o tamanho da string na declaração da
variável. Como toda string termina com o caractere \0, então o tamanho da string tem que ser fornecido de
maneira a caber o caractere de encerramento. Por exemplo, para criar uma string que vai armazenar uma
frase com 40 caracteres, devemos usar o comando:
char nome[41];
11.22.2. Função scanf() para manipulação de strings
A função scanf() lê caracteres de uma string até encontrar um caractere de espaço em branco,
tabulação, nova linha ou indicador de fim de arquivo. Assim, a função scanf() não é apropriada para ler um
texto de múltiplas palavras, pois somente a primeira palavra será armazenada. Exemplo:
#include<stdio.h>
#include<stdlib.h>
int main()
{
char nome[50];
printf(“Digite um nome: “);
scanf("%s", nome);
printf("Ola %s, tudo bem?\n\n", nome);
system("pause");
return 0;
}
No exemplo acima, caso seja fornecido o nome: Maria Cristina de Oliveira, será impresso: Ola
Maria, tudo bem? ao invés de: Ola Maria Cristina de Oliveira, tudo bem? Isso significa que na variável nome
foi armazenada somente a string “Maria”.
Repare também que no comando scanf("%s", nome) não foi utilizado o operador & antes do
segundo argumento (nome). Isto se deve ao fato de que nome é o endereço inicial do vetor de caracteres.
Portanto, a expressão nome é equivalente a &nome[0].
Para ler uma cadeia de caracteres com espaço deve usar gets(nome).
11.22.3. Outras funções para manipulação de strings
Seguem algumas funções próprias para manipulação de strings.
11.22.3.1. gets()
A função gets(), que também faz parte da biblioteca padrão stdio.h, é mais conveniente para a
leitura de textos. Ela permite ler dados fornecidos pelo teclado, até que a tecla <Enter> seja pressionada.
Veja o programa acima, alterado para o uso da função gets().
44
#include<stdio.h>
#include<stdlib.h>
int main()
{
char nome[50];
printf(“Digite um nome: “);
gets(nome);
printf("Ola %s, tudo bem?\n\n", nome);
system("pause");
return 0;
}
No exemplo acima, caso seja fornecido o nome: Maria Cristina de Oliveira, será impresso: Ola Maria
Cristina de Oliveira, tudo bem? Isso significa que na variável nome foi armazenada a string “Maria Cristina
de Oliveira”.
Repare que no gets() não é necessário colocar o código de formatação (“%s”) como no scanf().
Cuidado! Quando é usado scanf() antes do gets(), o gets() não funcionará como esperado, devido o
seguinte problema: quando digitamos um número e teclamos <enter>, o que é enviado é o número e o '\n'
(<enter>), mas o scanf() só lê o número e deixa o '\n' no buffer de entrada padrão (stdin). Daí, se o próximo
comando for gets(), o '\n' será lido automaticamente pelo gets(), e com isso o programa não vai ler
(esperar) nenhuma entrada quando passar por esse gets(). Para resolver esse problema, coloque o
comando fflush(stdin); antes do comando gets(). Outra forma de resolver esse problema é colocando %*c
no scanf() anterior ao gets(), para que o \n seja descartado. Exemplo: scanf(“%d%*c”, &num);.
11.22.3.2. puts()
A função puts(), que também faz parte da biblioteca padrão stdio.h, imprime uma única string por
vez. A função puts() imprime a cadeia de caracteres e muda de linha, por isso não é necessário o \n.
Exemplo:
puts(“Hello!”);
puts(nome);
11.22.3.3. strcpy()
A função strcpy() faz parte da biblioteca padrão string.h. Esta função recebe dois endereços de
strings e copia o conteúdo da segunda na primeira.
Exemplo:
strcpy(mensagem, “Seja bem vindo!”);
Este comando copia a string “Seja bem vindo!” para a variável mensagem. Portanto, após esse
comando, a variável mensagem passará a conter a string “Seja bem vindo!”.
Exemplo:
strcpy(rico, nome);
Este comando copia o conteúdo da variável nome para a variável rico. Portanto, caso a variável
nome tenha o conteúdo “Ana Helena”, após esse comando, a variável rico passará a conter “Ana Helena”.
11.22.3.4. strcmp()
A função strcmp() faz parte da biblioteca padrão string.h. Esta função serve para comparar os
caracteres contidos em duas cadeias. Caso você tenha uma variável string denominada nome, e queira
verificar se o seu conteúdo é “fim”. Neste caso, como você quer comparar strings, deve fazer o seguinte
teste: strcmp(nome,"fim")==0 ao invés de nome == "fim". Isto porque, o último comando comparará o
endereço da string nome e não o seu conteúdo.
45
A função strcmp() retorna 0 quando o conteúdo das duas strings forem iguais e qualquer outro
número positivo ou negativo, caso os conteúdos das strings sejam diferentes.
Exemplo:
strcmp(rico, nome);
Este comando compara o conteúdo da variável rico com o conteúdo da variável nome (ambas
variáveis do tipo string) e retorna 0 caso os conteúdos sejam iguais e qualquer outro número caso os
conteúdos sejam diferentes.
11.22.3.5. strlen()
A função strlen() faz parte da biblioteca padrão string.h. Esta função recebe uma string e retorna o
comprimento (número de caracteres) da string.
Exemplo:
tamanho = strlen(nome);
No exemplo acima, o comprimento da string nome será atribuído à variável tamanho.
11.23. Funções
Funções são blocos de instruções que realizam tarefas específicas, possuem suas próprias variáveis
e são agrupadas em uma unidade com um nome para referenciá-las .
As funções são utilizadas para a obtenção de programas modulares. É aconselhável a elaboração de
programas modulares, pois dividindo o programa em pequenas partes, é mais fácil de criar, atualizar e
podem ser testados separadamente e integrados somente após termos certeza de que funcionam
corretamente.
As funções evitam que o programador tenha que escrever o mesmo código repetidas vezes.
Qualquer bloco de instruções que aparece mais de uma vez no programa é candidato a ser uma função. As
funções permitem que o mesmo bloco de instruções seja executado com diferentes conjuntos de dados, ou
em diferentes lugares do programa.
Para uma função ser executada ela deve ser chamada ou ativada por uma função. A única exceção
é a função main() que é a principal função e é chamada ao iniciar a execução de um programa na
linguagem C. As funções printf(), scanf(), gets(), strcpy() fazem parte da biblioteca do C e são adicionadas
aos programas pela diretiva #include, no momento da linkedição e são utilizadas por nós sem sabermos
detalhes de suas programações.
A estrutura geral de uma função é:
tipo nome_da_funcao(declaração dos parâmetros)
{
declaração de variáveis;
instrução_1;
...
instrução_n;
return valor;
}
Veja no programa abaixo, um exemplo de função que calcula a área do círculo.
// Programa para calcular a área do círculo usando função.
#include<stdio.h>
#include<stdlib.h>
46
float area_do_circulo(float);
// protótipo ou declaração da função
int main()
// programa principal
{
float r, a;
printf("Digite o raio de um circulo: ");
scanf("%f", &r);
a = area_do_circulo(r);
// chamada da função
printf("A area deste circulo = %.2f\n\n", a);
system("pause");
return 0;
}
float area_do_circulo(float raio)
{
float area;
area = 3.1415*raio*raio;
return area;
}
// definição da função
Uma função só pode ser chamada depois de ter sido declarada. A declaração da função (ou
protótipo da função) deve ser colocada no início do programa. O protótipo serve para definir o tipo da
função e os seus parâmetros. O tipo da função é o tipo do valor retornado pela função. O protótipo da
função deve preceder a chamada e a definição da função, mas caso a função seja definida (escrita) antes da
função chamadora, o protótipo pode ser omitido.
No exemplo acima, o protótipo: float area_do_circulo(float); informa que a função area_do_circulo
é do tipo float, isto é, retorna um valor do tipo float, e recebe um argumento float.
O comando return termina a execução da função, retorna o valor para a função que chamou e
retorna o controle para a instrução seguinte à instrução que chamou a função.
Quando uma função não retorna nenhum valor, ela é do tipo void. Vários valores podem ser
passados para uma função como argumentos, mas somente um valor pode ser retornado pela função. Uma
função pode também não receber nenhum argumento. Quando vários valores são passados para uma
função, estes devem ser separados por vírgula e cada um deve ter o seu tipo declarado. Ex. soma(int n1, int
n2).
Na função area_do_circulo() podemos eliminar a variável area e colocar a expressão
3.1415*raio*raio diretamente no comando return, como segue:
float area_do_circulo(float raio)
{
return 3.1415*raio*raio;
}
O termo parâmetro muitas vezes é utilizado como sinônimo de argumento, mas geralmente utilizase "parâmetros" quando se faz referência às variáveis encontradas (entre parênteses) na definição de uma
função e "argumentos" aos valores atribuídos a esses parâmetros. Os parâmetros servem para enviar dados
para uma função e podem ser utilizados livremente no corpo da função.
47
11.24. Criando Bibliotecas
Quando escrevemos programas em C, inicialmente colocamos as diretivas #include para incluir ou
importar as bibliotecas (stdio.h, stdlib.h, math.h) que serão utilizadas no programa.
Quando uma função ou estrutura é utilizada em vários programas, nós podemos criar uma
biblioteca que contenha essa função ou estrutura e importar ou incluir essa biblioteca nos nossos
programas.
Para criar uma biblioteca, siga os passos:
Comece um novo arquivo e digite a sua função ou estrutura normalmente, como se
estivesse escrevendo um programa.
Salve esse arquivo com extensão .h (h significa header = cabeçalho), na própria pasta onde
armazena os seus programas. Por exembo: minha_bib.h
No seu programa, para usar uma função ou estrutura contida em uma biblioteca que foi criada:
Acrescente a diretiva #include e o nome da biblioteca (que contém a função ou a estrutura
desejada) entre aspas (“).
Para incluir a biblioteca citada acima, seria #include”minha_bib.h”
As aspas são utilizadas no lugar do < >, para indicar ao compilador para procurar esta biblioteca na
pasta onde está o programa, antes de procurar na pasta include.
11.25. Vetores
Vetor (ou matriz unidimensional) é uma coleção de dados do mesmo tipo que compartilham o
mesmo nome. É necessário 1 índice para individualizar um elemento da coleção. O índice utilizado na
linguagem C para identificar a posição de um elemento do vetor começa sempre em 0 (zero) e vai até o
tamanho do vetor menos uma unidade.
Na declaração de um vetor, é colocado o nome do vetor seguido do tamanho do vetor entre
colchetes [ ].
Observação: Lembre que uma string é um vetor de char.
Exemplos de declaração:
char nome[50];
// nome é um vetor de 50 caracteres
int temperatura[10];
// temperatura é um vetor de 10 números inteiros
float nota[40];
// nota é um vetor de 40 números reais
nota
nota[0]

8.2
nota[1]

3.6
nota[2]

9.5
...
nota[39]

7.1
Cada elemento do vetor é referenciado pelo nome do vetor seguido pela posição do elemento
entre colchetes [ ]. Exemplo: nota[0], nota[3], etc.
11.26. Matrizes
Matriz é uma variável capaz de armazenar vários elementos do mesmo tipo em uma estrutura com
um único nome. As matrizes podem ser unidimensionais (vetores), bidimensionais ou multidimensionais.
Estudaremos aqui as matrizes bidimensionais que necessitam de 2 índices para individualização de um
elemento (o primeiro índice identifica a linha e o segundo índice identifica a coluna).
Exemplos de declaração:
float tabela[5][3];
int quadro[3][3];
// tabela é uma matriz de 5 linhas e 3 colunas, cujo conteúdo é número real.
// quadro é uma matriz de 3 linhas e 3 colunas, cujo conteúdo é inteiro.
48
quadro[0,0] quadro[0,1]


6
-1
0
 quadro[0,2]
quadro
2
8
14  quadro[1,2]
-5
9
7
 quadro[2,2]


quadro[2,0] quadro[2,1]
Obs. Lembre-se que uma string (ou cadeia de caracteres) é um vetor de caracteres na linguagem C.
Portanto, uma matriz de strings é um vetor contendo vetores de caracteres. No exemplo abaixo, nome é
uma matriz de 20 linhas e 40 colunas, cujo conteúdo é caractere (ou seja, nome é um vetor de 20 cadeias
de caracteres, de tamanho 39).
char nome[20][40];
nome
Ana Carolina de Oliveira
 nome[0]
Carlos Alberto de Souza
 nome[1]
Denise de Mattos
 nome[2]
...
...
Luis Vitor Vicentini
 nome[19]
11.26.1. Atribuindo valores a uma matriz
Existem duas formas de atribuir valores em matrizes. A primeira consiste em atribuir valores a
matriz durante o seu processo de criação. Esse caso também é conhecido na literatura como inicialização
de variáveis. Tal como foi visto na Seção Operador de atribuição, podemos criar uma variável com valor
inicial da seguinte maneira:
int mat[2][2]={{-1 2},{5 -4}};
O comando acima cria uma matriz 2x2 com valores:
[
mat= −1 2
5 −4
]
Quando o número de valores fornecidos na inicialização é menor que o número de elementos da
matriz ou vetor, o compilador automaticamente preenche os termos restantes com zero. Esse
procedimento é muito útil para a construção de certas matrizes.
Exemplo 4 (Criando uma matriz identidade).
Programa que cria e imprime uma matriz identidade de dimensão NxN, sendo N um valor definido dentro
do programa.
#include <stdio.h>
#include<stdlib.h>
#define N 2
main(){
int MA[N][N]={0},i,j;
for(i=0;i<N;i++)
MA[i][i]=1;
printf("\n\n MA = \n [");
49
for(i=0;i<N;i++){
for(j=0;j<N;j++)
printf("%3d",MA[i][j]);
if(i<N-1) printf("\n ");
else printf(" ]\n\n");
}
system("PAUSE");
return 0;
}
Uma outra forma de atribuirmos valores em uma matriz consiste em fornecer os valores dos
termos da matriz manualmente. Para isso usamos o comando for. Abaixo, apresentamos um exemplo de
um trecho de programa para preenchimento de uma matriz 3x2 com valores inteiros provenientes do
teclado.
#define m 3
#define n 2
int mat[m][n], i, j;
for ( i=0; i<m; i++ )
for ( j=0; j<n; j++ )
scanf("%d", &mat[i][j]);
Exemplo 5 (Exibindo a transposta de uma matriz).
Programa cria uma matriz retangular de dimensão 3x2 com dados fornecidos pelo usuário e então imprime
na tela a matriz de entrada e sua transposta.
#include <stdio.h>
#include<stdlib.h>
#define m 3
#define n 2
main(){
int i,j;
float A[m][n],TA[n][m];
printf(" Este programa exibe a transposta de uma matriz A 3x2\n\n");
printf("\t Digite os elementos da matriz.\n\n");
for ( i=0; i<m; i++ )
for ( j=0; j<n; j++ ){
printf("\t Elemento A(%d,%d) = ",i+1,j+1);
scanf("%f", &A[i][j]);
TA[j][i]=A[i][j];
printf("\n");
}
printf("\n A = \n [");
for(i=0;i<m;i++){
50
for(j=0;j<n;j++)
printf(" %7.2f",A[i][j]);
if(i<m-1) printf("\n ");
}
printf(" ]\n\n\n A^T = \n [");
for(i=0;i<n;i++){
for(j=0;j<m;j++)
printf(" %7.2f",TA[i][j]);
if(i<n-1) printf("\n ");
}
printf(" ]\n\n");
system("PAUSE");
return 0;
}
11.27. Debug
Em informática, depurar um programa significa detectar e eliminar erros do programa. O Dev-C++
possui uma ferramenta para depuração (debug) que auxilia nestas tarefas.
Para utilizar o depurador do Dev-C++:
abra o programa que deseja depurar
crie pelo menos um ponto de parada de execução no programa, clicando na coluna
numerada à esquerda do código (a linha ficará com a cor de fundo vermelha)
na parte inferior da janela do Dev-C++, clique em Depurador
para começar a depurar o programa, clique em Depurar, na parte inferior da janela
para acompanhar o programa linha à linha, clique em Próxima linha
para pular para o próximo ponto de parada, clique em Continuar
para saber o valor atual da variável, posicione a seta do mouse sobre a variável no programa
para visualizar e acompanhar o valor de uma variável no Depurador, clique em Adicionar
marcador e digite o nome da variável
para remover um marcador (variável) do Depurador, clique o botão direito do mouse sobre o
marcador e selecione Remover marcador
na chamada de uma função, para rastrear os passos da função, clique em Passar por dentro
para parar o programa no meio da execução, clique em Parar Execução
51
12. Exercícios
1. Considere os valores das variáveis a seguir e determine o resultado das expressões lógicas
abaixo:
A 2
B  -3
C  1.5
ano  1996
objeto  ”relógio”
fim  verdadeiro
a) objeto = ”computador” ou A+B/A = C/B
b) 3*A+B >= 2*C e ano = 2005
c) TRUNC(C) <= ABS(A+B) ou 8*C MOD 5 = A e POW(B,2) > -A*B*C
d) não(fim) ou ROUND(C) <= 2*A
e) objeto = ”relógio” e ABS(B+C) <> C
f) SQRT(2*A-A*B*C+2*C) = 2-B e ano <> 2000
2. Determine os valores das variáveis numéricas X, Y e Z após a execução dos comandos abaixo:
X  31 MOD 4
Y  ROUND(4.5)
Z  TRUNC(2.6) -2*X
X  SQRT(X*Y-2*Z+2) + Z
Y  ROUND(ABS(Z) + Y/2)
Z  X + 3*Z MOD 8
3. Em quais dos seguintes pares é importante a ordem dos comandos? Isto é, em quais pares
quando se muda a ordem dos comandos os resultados finais se alteram?
a) A  C
BD
b) B  A
CB
c) B  A
BC
d) A  B
BA
4. Baseado nos valores de entrada L1 e L2, que constituem a base e a altura de um triângulo, o que
significa o valor de saída X?
início
L1, L2
X  L1*L2/2
X
fim
5. Elabore um fluxograma para ler uma temperatura dada na escala Celsius (C) e imprimir a
equivalente temperatura em Fahrenheit (F).
9
F= C+32
5
52
= R2.
6. Elabore um fluxograma para ler o raio (R) de um círculo e imprimir a sua área. Sabe-se que: Área
7. Elabore um fluxograma para ler a idade de um aluno e imprimir uma mensagem dizendo se ele é
menor de idade ou maior de idade.
8. Elabore um fluxograma para ler um número e imprimir uma mensagem dizendo se o número lido
é par ou ímpar.
9. Elabore um fluxograma para ler um número e imprimir uma mensagem dizendo se o número é
positivo, negativo ou nulo.
10. Dado o seguinte fluxograma:
início
V
V
V
F
condição2
comando1
F
condição1
comando2
condição3
F
comando4
comando5
comando3
fim
Responda :
a) Se condição1 = V, condição2 = V e condição3 = F, quais os comandos executados?
b) Se condição1 = F, condição2 = V e condição3 = V, quais os comandos executados?
c) Se condição1 = V, condição2 = F e condição3 = F, quais os comandos executados?
d) Quais os valores de condição1, condição2 e condição3 para que nenhum comando seja
executado?
11. Elabore um fluxograma para ler um número e imprimir uma mensagem dizendo se o número
lido é inteiro ou se o número tem a parte decimal.
12. Elabore um fluxograma para ler um ano e imprimir uma mensagem dizendo se o ano lido é
bissexto ou não.
Utilize a seguinte regra: Um ano é bissexto se:
- é divisível por 4 e não é divisível por 100, ou
- é divisível por 400.
Exemplos:
2008 é bissexto porque 2008 é divisível por 4 e não é divisível por 100.
2000 é bissexto porque é divisível por 400.
1900 não é bissexto porque apesar de ser divisível por 4, é também divisível por 100, e por outro
lado, não é divisível por 400.
53
13. Elabore um fluxograma para ler os valores dos coeficientes a, b, e c de uma equação do
segundo grau, e imprimir a única raiz real, ou as duas raízes reais, ou uma mensagem dizendo que as raízes
são complexas.
14. Elabore um fluxograma para ler 3 números e imprimir o maior deles.
15. Uma empresa está dando um reajuste aos seus funcionários de acordo com o seguinte critério:
25% para os funcionários que recebem até R$ 500,00 (inclusive);
20% para os funcionários que recebem entre R$ 500,01 e R$ 1.000,00 (inclusive);
15% para os funcionários que recebem acima de R$ 1.000,00.
Elabore um fluxograma para ler o salário de um funcionário e imprimir o seu salário reajustado.
16. O que faz o seguinte fluxograma ?
início
N1
N <= 15
F
V
N
N  N+2
fim
17. Elabore um fluxograma para imprimir os números pares positivos menores que 100.
18. O que será impresso ao final de cada um dos seguintes fluxogramas ?
54
a)
b)
início
início
X0
Y0
X0
Y0
X<2
F
X >= 0
V
X  X+1
Y  Y+2
V
X  X+1
Y  Y+2
Y
Y
fim
fim
c)
F
F
d)
início
início
X0
Y0
X0
Y0
X  X+1
Y  Y+2
X  X+1
Y  Y+2
F
X<2
X=3
V
V
Y
Y
fim
fim
19. Elabore um fluxograma para imprimir os 10 primeiros números positivos múltiplos de 6.
20. Elabore um fluxograma para imprimir N termos de uma Progressão Aritmética (PA) de elemento
inicial a e razão r. Os valores de N, a e r devem ser lidos inicialmente.
21. Elabore um fluxograma para ler a idade de 500 vestibulandos e imprimir quantos desses
vestibulandos são menores de idade.
55
22. Elabore um fluxograma para calcular e imprimir a soma dos números entre 1 e 10 inclusive.
23. Elabore um fluxograma para calcular e imprimir a soma dos números inteiros positivos ímpares
inferiores ou iguais a um número N (positivo) lido inicialmente.
24. Elabore um fluxograma para calcular e imprimir o produto dos números inteiros entre 1 e 15
(inclusive).
25. Elabore um fluxograma para ler um número e calcular e imprimir o fatorial deste número.
26. Elabore um fluxograma para ler o saldo de 1500 clientes de uma agência bancária, e imprimir:
a) o saldo médio desses clientes;
b) a porcentagem de clientes com saldo devedor.
27. Elabore um fluxograma para ler 2 números e imprimir o Máximo Divisor Comum (MDC) entre
esses números.
Exemplo: MDC entre 15 e 54 é 3 pois:
Quociente =
3
54 15
Resto = 9
1
9
6
1
6
3
2
3
0
MDC
28. Elabore um fluxograma para ler o nome e a nota de 70 alunos e imprimir:
a) quantos alunos foram reprovados (nota inferior a 5,0).
b) a maior nota e o nome do(a) aluno(a) que obteve essa nota.
29. Elabore um fluxograma para ler o nome, a idade e o sexo de 50 funcionários de uma empresa, e
imprimir:
a) a idade média dos funcionários do sexo masculino;
b) a porcentagem de funcionários do sexo feminino, com idade superior a 30 anos;
c) a menor idade e o nome do(a) funcionário(a) que possui essa idade.
30. Elabore um fluxograma para ler o saldo de 800 clientes de uma agência bancária e imprimir:
a) a porcentagem de clientes com saldo devedor;
b) o maior e o menor saldo.
31. Elabore um programa, em linguagem C, para ler 2 números e calcular e imprimir a média
aritmética destes números.
32. Elabore um programa, em linguagem C, para ler a medida da base e da altura de um triângulo e
imprimir a área deste triângulo.
33. Um marceneiro precisa cortar vários pedaços de madeira de comprimento = 45 cm cada um.
Elabore um programa, em linguagem C, para ler o comprimento da tábua (em metros) e imprimir a
quantidade de pedaços e a sobra (em centímetros). Exemplo: Caso o comprimento da tábua seja 5 m, a
quantidade de pedaços será 11 e a sobra será de 5 cm.
34. Uma entidade filantrópica faz sorteios cujos bilhetes contém números de 3 dígitos. O sorteio é
baseado no primeiro prêmio da loteria federal, sendo o número sorteado formado pelos três últimos
dígitos do primeiro prêmio na ordem inversa. Por exemplo, se o primeiro prêmio for 51782, o número
sorteado será 287. Elabore um programa, em linguagem C, para ler o número do primeiro prêmio da loteria
federal (de 5 dígitos), em uma variável do tipo int, e imprimir o número sorteado.
56
35. Elabore um programa, em linguagem C, para ler a nota de um aluno e imprimir uma mensagem
dizendo se ele foi aprovado (nota  5,0) ou reprovado.
36. Elabore um programa, em linguagem C, para ler 2 números, e escrever se o primeiro número é
maior, menor ou igual ao segundo.
37. Elabore um programa, em linguagem C, para ler o salário de um funcionário e imprimir o
percentual de reajuste e o salário reajustado de acordo com a seguinte tabela:
Salário
até R$ 1.000,00
Reajuste
15%
acima de R$ 1.000,00 até R$ 2.000,00
12,5%
acima de R$ 2.000,00
10%
38. Um casal divide as despesas domésticas mensalmente. Durante o mês, cada um anota as
despesas que paga e no final eles dividem a despesa total ao meio. Elabore um programa, em linguagem C,
para ler as despesas pagas por cada um e imprimir quem deve a quem e o valor da dívida. Lembre que
pode acontecer de nenhum precisar pagar para o outro, caso já tenham pago exatamente a metade das
despesas. Exemplo:
ITEM
Despesas Pagas
Valor Devido
Diferença
MARIDO
2000,00
1700,00
300,00
ESPOSA
1400,00
1700,00
-300,00
TOTAL
3400,00
No exemplo acima, o programa deve imprimir a seguinte mensagem: A esposa deve pagar R$
300,00 ao marido.
39. Elabore um programa, em linguagem C, para ler os lados de um triângulo e testar inicialmente
se é possível formar um triângulo. Caso seja possível formar um triângulo, o programa deve imprimir uma
mensagem informando o tipo de triângulo formado: equilátero, isósceles ou escaleno. Caso contrário, o
programa deve imprimir uma mensagem informando que não é possível formar um triângulo.
40. Elabore um programa, em linguagem C, para ler um número inteiro N  [1 7] e imprimir o dia
da semana equivalente ao número. Por exemplo: Se N = 2, então o programa deve imprimir “segundafeira”.
41. Elabore um programa, em linguagem C, que deve ler um número real X e executar uma das
operações abaixo:
a) Imprimir o dobro de X;
b) Imprimir o valor da expressão X2-X;
c) Imprimir a raiz cúbica de X;
d) Imprimir o valor da expressão X3-X2+X-1.
O programa deverá executar somente uma das opções.
42. Um supermercado está dando descontos no valor das compras, segundo a tabela abaixo:
Valor da compra
Desconto
até R$ 50,00
0%
de R$ 50,01 a R$ 100,00
10%
acima de R$ 100,00
15%
57
Elabore um programa, em linguagem C, para ler o valor da compra de 80 clientes e imprimir para
cada cliente o percentual de desconto e o valor a pagar após o desconto.
43. O que vai ser impresso no final de cada trecho do programa, em linguagem C, abaixo:
a) a=0;
b=0;
do
{
b=b+2;
a=a+1;
} while (a<=2)
printf("%d",b);
b) a=0;
b=0;
do
{
b=b+2;
a=a+1;
} while (a>=3);
printf("%d",b);
c) a=0;
b=0;
while (a<3)
b=b+2;
a=a+1;
printf("%d",b);
d) a=0;
b=0;
while (a<3)
{
b=b+2;
a=a+1;
}
printf("%d",b);
e) b=0;
for (a=1;a<=3;a++)
b=b+2;
printf("%d",b);
f) b=0;
for (a=4;a>=1;a- -)
b=b+2;
printf("%d",b);
44. Um atleta faz flexões em série, com quantidades crescentes: na primeira série faz 1 flexão, na
segunda série faz 2 flexões, na terceira série faz 3 flexões e assim por diante. Ao final de algumas séries, ele
quer saber a quantidade total de flexões que fez. Por exemplo, se ele fez 5 séries, fez ao todo 15 flexões
(1+2+3+4+5). Elabore um programa, em linguagem C, para ler o número de séries e imprimir o total de
flexões.
45. Elabore um programa, em linguagem C, para ler um número e imprimir o fatorial deste número.
46. Elabore um programa, em linguagem C, para ler o nome e a idade de 20 crianças e imprimir:
a) a idade média;
b) a maior idade e o nome da criança que tem essa idade.
47. Elabore um programa, em linguagem C, para ler o nome, a nota da primeira prova ( P1) e a nota
da segunda prova (P2) de 50 alunos. O programa deve imprimir:
a) a média (M) de cada aluno, onde M =
3P1 + 5P 2
;
8
b) a porcentagem de alunos aprovados (M  5,0);
c) a maior média e o nome do(a) aluno(a) que obteve essa média.
48. O que faz o seguinte programa em linguagem C?
#include<stdio.h>
#include<stdlib.h>
int main()
{
58
}
int n,s;
s=0;
printf("Digite um numero inteiro: ");
scanf("%d",&n);
while (n!=0)
{
if ((n>0) && (n % 2==0))
{ s=s+n; }
printf("Digite outro numero inteiro, ou digite 0 para terminar: ");
scanf("%d",&n);
}
printf("%d\n",s);
system("pause");
return 0;
49. Elabore um programa, em linguagem C, para ler o nome e o preço de um número
indeterminado de mercadorias, sendo o fim de dados identificado pelo nome = FIM. O programa deve
imprimir:
a) o preço médio dessas mercadorias;
b) o maior preço e o nome da mercadoria de maior preço.
50. Elabore um programa, em linguagem C, para ler o nome, o sexo e o salário de um número
indeterminado de funcionários de uma loja, sendo o fim de dados identificado pelo nome = FIM. O
programa deve imprimir:
a) o salário médio dos homens e o salário médio das mulheres;
b) a porcentagem de funcionários do sexo masculino;
c) o nome do(a) funcionário(a) que recebeu o maior salário, e o respectivo salário.
51. Elabore um programa, em linguagem C, para ler o nome e saldo de um número indeterminado
de clientes de um banco, sendo o fim de dados identificado pelo nome = FIM. O programa deve imprimir:
a) o saldo médio dos clientes;
b) a porcentagem de clientes com saldo devedor;
c) o nome do cliente que possui o menor saldo e o respectivo saldo.
abaixo:
52. Elabore um programa, em linguagem C, que deve ler um número real X e executar as operações
a) Imprimir o valor de X5;
b) Imprimir o valor de X!;
c) Imprimir o valor de XX;
d) Imprimir o valor de
X
√ ∣X∣ ;
e) Sair do programa.
O programa deverá executar apenas uma ação por vez e enquanto a opção escolhida for diferente
de e o programa deverá solicitar uma nova opção para execução.
53. Elabore um programa, em linguagem C, para ler 3 números (x, y, N) e imprimir os N primeiros
números naturais que são múltiplos de x ou de y.
Exemplo: caso x=3, y=7 e N=8, o programa deve imprimir: 3 6 7 9 12 14 15 18
59
54. Elabore um programa, em linguagem C, para ler um número e imprimir uma mensagem
dizendo se o número lido é primo ou não. Pode-se supor que o número lido seja maior do que 1. Obs. Um
número é primo se ele é divisível somente por 1 e por ele mesmo.
55. Elabore um programa, em linguagem C, para imprimir os N primeiros números da Sequência de
Fibonacci. O número N (N  2) deve ser lido inicialmente. A Sequência de Fibonacci é definida como tendo o
primeiro termo igual a 0, o segundo termo igual a 1 e cada termo seguinte igual a soma dos dois termos
imediatamente anteriores.
Sequência de Fibonacci: 0
1
1
2
3
5
8
13
21
34 ...
56. Elabore um programa, em linguagem C, para ler um número e imprimir uma mensagem dizendo
se o número lido é par ou impar, usando para isso uma função que retorne 1 para número par e 0 para
número ímpar.
57. Elabore um programa, em linguagem C, para ler um número real e imprimir este número
arredondado. O programa deve criar uma função para arredondar o número. Coloque repetição no
programa de forma que ao final de cada execução, o usuário possa decidir se deseja repetir o programa ou
não.
58. Elabore um programa, em linguagem C, para ler n e k e imprimir o número de combinações de
n elementos tomados k a k
(
Cn,k=
)
n!
. Crie uma função fatorial para o cálculo do fatorial.
(n−k )! k !
59. Elabore um programa, em linguagem C, para ler 10 números e armazená-los em uma variável
composta unidimensional (vetor) e determinar o menor número.
60 Elabore um programa, em linguagem C, para ler as temperaturas máximas registradas nos
últimos 30 dias e imprimir:
a) a menor temperatura registrada;
b) a maior temperatura registrada;
c) a temperatura média destes 30 dias;
d) o número de dias em que a temperatura foi superior à temperatura média.
61. Elabore um programa, em linguagem C, para ler os nomes e os pesos de 20 judocas e armazenálos em vetores denominados NOME e PESO. O programa deve imprimir:
a) o maior peso;
b) os nomes dos judocas que têm o maior peso;
62. Um armazém trabalha com 250 mercadorias diferentes identificadas pelos números inteiros de
1 a 250. O dono do armazém possui 3 tabelas, uma com o nome de cada mercadoria, outra com o preço de
cada mercadoria, e uma outra tabela com a quantidade de cada mercadoria vendida no mês.
Elabore um programa, em linguagem C, para ler o nome, o preço e a quantidade de mercadorias
vendidas e armazená-los em variáveis compostas unidimensionais (vetores) denominadas MERCADORIA,
PRECO e QUANTIDADE e imprimir:
a) os nomes das mercadorias que possuem o maior preço;
b) os nomes das mercadorias que não foram vendidas nenhuma unidade;
c) o faturamento mensal do armazém.
63. Elabore um programa, em linguagem C, para ler o nome e a nota de 60 alunos e armazenar os
nomes dos alunos aprovados (nota  5,0) no vetor denominado APROVADO e os nomes dos alunos
reprovados no vetor denominado REPROVADO. No final o programa deve imprimir:
a) o número de alunos aprovados;
60
b) a lista dos nomes dos alunos aprovados;
c) o número de alunos reprovados;
d) a lista dos nomes dos alunos reprovados.
64. Elabore um programa, em linguagem C, para ler o nome e a idade de um número
indeterminado de candidatos de um concurso, sendo o fim de dados identificado pelo nome = FIM. O
programa deve imprimir:
a) a idade média dos candidatos;
b) a porcentagem de candidatos com idade superior a 40 anos;
c) a maior idade e os nomes dos candidatos com essa idade (usar vetor).
65. Elabore um programa, em linguagem C, para imprimir o signo do zodíaco correspondente a uma
data (dia e mês) lida. Coloque repetição no programa para que ao final de uma execução, o usuário possa
decidir se deseja repetir o programa ou não.
A tabela abaixo mostra o último dia de cada mês e o signo correspondente.
mês
1
2
3
4
5
6
7
8
9
10
11
12
último dia
20
19
20
20
20
20
21
22
22
22
21
21
signo
Capricórnio
Aquário
Peixes
Áries
Touro
Gêmeos
Câncer
Leão
Virgem
Libra
Escorpião
Sagitário
Obs: De 22/12 a 31/12 – Capricórnio
66. Elabore um programa, em linguagem C, para ler 10 números inteiros e armazená-los em um
vetor e determinar e mostrar os números primos e as suas respectivas posições. Usar uma função (primo)
que retorna 1 quando o número é primo e 0 quando não é primo.
67. Elabore um programa, em linguagem C, no qual o programa principal lê 8 números e imprime o
maior e o menor deles. Os números maior e menor devem ser determinados através de funções
denominadas maior e menor, respectivamente.
68. Elabore um programa, em linguagem C, para ler o número do voo e a quantidade disponível de
vagas de 30 voos diários de uma companhia aérea e armazenar em vetores denominados VOO e VAGAS.
Em seguida o programa deve ler o número do voo e o número de vagas a reservar neste voo, de um
número indeterminado de voos, sendo o fim dos dados identificado pelo número do voo = 0. Para cada
número de voo, o programa deve atualizar o vetor VAGAS.
No final, o programa deve imprimir todos os números de voos e as respectivas vagas.
69. Elabore um programa, em linguagem C, para ler os elementos de uma matriz mxn e um
número. O programa deve imprimir:
a) a matriz original;
b) a matriz resultante do produto entre o número lido e a matriz original.
61
70. Matriz diagonal é uma matriz quadrada cujos elementos que não pertencem à diagonal princi pal são iguais a zero. Elabore um programa, em linguagem C, para ler os elementos de uma matriz nxn e
imprimir:
a) a matriz;
b) uma mensagem dizendo se a matriz é diagonal ou não.
71. Elabore um programa, em linguagem C, para ler os elementos de uma matriz mxn e imprimir:
a) a matriz;
b) a soma dos elementos de cada linha;
c) a soma de todos os elementos da matriz.
72. Elabore um programa, em linguagem C, para ler os elementos de uma matriz nxn, verificar se a
matriz é simétrica (isto é, M[i][j]=M[j][i]) e imprimir:
a) a matriz;
b) uma mensagem dizendo se a matriz é simétrica ou não.
73. Elabore um programa, em linguagem C, para ler os elementos de uma matriz A (mxn) e os
elementos de uma matriz B (nxm) e imprimir:
a) a matriz A;
b) a matriz B;
c) a matriz produto A*B (mxm).
74. Uma matriz quadrada é dita matriz de permutação caso seus elementos sejam 0's ou 1's de
forma que em cada linha e em cada coluna exista somente um elemento igual a 1. Exemplo:
[ ]
1 0 0
0 0 1
0 1 0
Elabore um programa, em linguagem C, para ler os elementos de uma matriz nxn e verificar se é
uma matriz de permutação. O programa deve imprimir:
a) a matriz;
b) uma mensagem dizendo se a matriz é de permutação ou não.
75. Elabore um programa, em linguagem C, para gerar a seguinte saída, perguntando ao usuário o
número máximo, que deve ser ímpar e no máximo 9.
123456789
2345678
34567
456
5
13. Bibliografia
[1] ASCENCIO, A.F.G.; CAMPOS, E.A.V. Fundamentos da Programação de Computadores. 3a ed.
Longman do Brasil, 2012. 680 p.
[2] DEITEL, P.; DEITEL, H. C Como Programar. 6ª ed. Pearson Education - Br, 2011. 848 p.
[3] FARRER, H. et al. Algoritmos Estruturados. 3ª ed. LTC, 1999. 260 p.
62
[4] FEOFILOFF, P. Algoritmos em linguagem C. 1ª ed. Campus, 2008. 232 p.
[5] HOLLOWAY, J.P. Introdução à Programação para Engenharia. 1ª ed. LTC, 2006. 360 p.
[6] MIZRAHI, V.V. Treinamento em Linguagem C. 2ª ed. Pearson Education - Br, 2008. 423 p.
[7] PINHEIRO, F.A.C. Elementos de programação em C. 1ª ed. Booklman – Grupo A, 2012. 528 p.
http://www.facp.pro.br/livroc/
[8] SCHILDT, H. C - Completo e Total. 3ª ed. Makron Books , 1997. 856 p.
63

Julia Sawaki Tanaka Flávio Andrade Faria

Transcrição

Documentos relacionados

Gostou desse modelo? Veja como imprimir nas próximas páginas

Mariana Paravani Palaçon

2016-05-02 16:15:13

Como retirar o trabalho na impressora

Alejandra Van Schaik

Exercícios com Métodos

Tópicos Especiais em Periodontia

Exercícios de Linguagem C resolvidos EXERCÍCIOS DO CAPÍTULO

Para utilizar o SAT você precisa configurar a quantidade de colunas

Guia - Ricoh MP 171