Vous êtes sur la page 1sur 103

APOSTILA DE ACOMPANHAMENTO EM SALA DE AULA

LÓGICA DE PROGRAMAÇÃO

Prof. Fernando André da Silva 2º Semestre/2016


INDICE

UNIDADE 1 – INTRODUÇÃO À LÓGICA DE PROGRAMAÇÃO .......................................................4


1.1 HISTÓRICO.......................................................................................................... 4
1.2 ORGANIZAÇÃO DE COMPUTADORES ................................................................. 19
1.2.1 Modelo de Von Neumann.......................................................................................... 19
1.2.2 Sistemas de Numeração ............................................................................................ 20
1.2.3 Os sistemas: decimal, binário e hexadecimal ........................................................... 21
1.2.4 Tabelas de Representação de Caracteres: ASCII, ISO, UNICODE. ........................ 23
1.3 LÓGICA DE PROGRAMAÇÃO E LINGUAGEM DE PROGRAMAÇÃO ........................ 25
1.3.1 Software .................................................................................................................... 27
1.3.2 Algumas Linguagens de Programação ..................................................................... 29
1.3.3 Tradutor.................................................................................................................... 31
1.3.4 Compilador ............................................................................................................... 31
1.3.5 Interpretador ............................................................................................................ 31
1.4 ALGORITMOS E AS FORMAS DE REPRESENTAÇÃO ............................................. 33
1.4.1 Algoritmos ................................................................................................................ 33
1.4.2 Fluxograma .............................................................................................................. 35
1.4.3 Português estruturado (Pseudocódigo) .................................................................... 38
1.4.4 Descrição Narrativa ................................................................................................. 39
1.4.5 Diagrama de Chapin ................................................................................................ 39
UNIDADE 2 – ESTRUTURA SEQUENCIAL .......................................................................................... 40
2.1 – RECURSOS PARA COMPOSIÇÃO DOS BLOCOS LÓGICOS .................................... 40
2.1.1 Tipos primitivos de Dados (algoritmos) ................................................................... 40
2.1.2 Tipos primitivos de Dados (C/C++) ......................................................................... 41
2.1.3 Identificadores .......................................................................................................... 41
2.1.4 Variáveis ................................................................................................................... 42
2.1.5 Constantes ................................................................................................................ 42
2.1.6 Operadores ............................................................................................................... 42
2.1.7 Expressões aritméticas ............................................................................................. 47
2.1.8 Atribuição de valores................................................................................................ 47
2.1.9 Entrada e Saída de dados ......................................................................................... 50
2.1.9.1 C .................................................................................................................... 50
2.1.9.2 C++ ................................................................................................................ 51
2.1.10 Comentários ........................................................................................................... 53
2.1.11 Operação com Módulo ........................................................................................... 54
Exercícios .................................................................................................................. 56
UNIDADE 3 – ESTRUTURAS DE TOMADA DE DECISÃO ................................................................ 58
3.1.1 Estrutura de seleção simples (if...) ........................................................................... 58
3.1.2 Estrutura de seleção composta (if...else) .................................................................. 59
3.1.3 Estruturas de seleção aninhadas (if...else if...) ......................................................... 60
Exercícios Estrutura de Seleção ................................................................................ 61
3.1.5 Estrutura de múltipla escolha (switch...case) ........................................................... 65
Exercícios - switch...case ........................................................................................... 70
UNIDADE 4 – ESTRUTURAS DE REPETIÇÃO .................................................................................... 71
4.1 – REPETIÇÃO COM VARIÁVEL DE CONTROLE (FOR) .......................................... 71
4.1.1 Exercícios - for ......................................................................................................... 74
4.2 – REPETIÇÃO COM TESTE NO INÍCIO (WHILE) .................................................... 77
4.2.1 Exercícios - while ..................................................................................................... 79
4.3 – REPETIÇÃO COM TESTE NO FINAL (DO...WHILE)............................................. 82
4.3.1 Exercícios – do while ................................................................................................ 83
UNIDADE 5 – MODULARIZAÇÃO ......................................................................................................... 84
5.1 DEFINIÇÃO DE FUNÇÕES ................................................................................... 84
5.2 LOCALIZAÇÃO DAS FUNÇÕES ........................................................................... 85
5.3 PASSAGEM DE PARÂMETRO .............................................................................. 85
2
5.3.1 Passagem de Parâmetros por Valor ......................................................................... 86
5.3.2 Passagem de Parâmetros por Referência ................................................................. 86
5.3.3 Passagem de Parâmetros por Ponteiro .................................................................... 88
UNIDADE 6 – FUNÇÕES C++ .................................................................................................................. 93
6.1 – POTÊNCIA ...................................................................................................... 93
6.2 – RAIZ QUADRADA ........................................................................................... 94
ANEXO ....................................................................................................................................................... 100

3
Unidade 1 – INTRODUÇÃO À LÓGICA DE PROGRAMAÇÃO

1.1 Histórico

Evolução Histórica do Computador da Antiguidade até ao Século XXI

Ábaco

O ábaco é um antigo instrumento de cálculo, formado por uma moldura com bastões ou
arames paralelos, dispostos no sentido vertical, correspondentes cada um a uma posição digital
(unidades, dezenas,...) e nos quais estão os elementos de contagem (fichas, bolas, contas,...) que podem
fazer-se deslizar livremente.

Teve origem provavelmente na mesopotâmia, há mais de 5.500 anos. O ábaco pode ser considerado
como uma extensão do ato natural de se contar nos dedos. Emprega um processo de cálculo
com sistema decimal, atribuindo a cada haste um múltiplo de dez. Ele é utilizado ainda hoje para
ensinar às crianças as operações de somas e subtrair.

La Pascaline (a pascalina)

Foi a primeira calculadora mecânica do mundo, planejada por Blaise Pascal em 1642.

Originalmente, ele pretendia construir uma máquina que realizasse as quatro operações fundamentais,
4
mas apenas conseguia fazer diretamente operações de adição e subtração.

As operações de multiplicação e divisão podiam ser feitas por repetição. Blaise Pascal se motivou a
criar esta máquina porque seu pai era contador e precisava de ajuda com cálculos mais
avançados..Pascal então, com seu conhecimento em física e em matemática criou uma máquina com
um engenhoso sistema de engrenagens que fazia contas de adição e subtração.

Quando a engrenagem virasse à direita era feita a adição, quando virasse à esquerda era feito a
subtração dos valores armazenados em 2 ou 3 engrenagens anteriores.

5
Calculadora de Leibniz

Construído por Gottfried Leibniz e muitas vezes visto como uma evolução da Calculadora de Pascal,
este mecanismo era uma calculadora mecânica que permitia não só realizar somas e subtrações, mas
também multiplicações e divisões e ainda extrair a raiz quadrada.

O modelo era assim muito parecido com o de Pascal, mas com componentes extras que aceleravam os
cálculos e se moviam dentro da máquina, melhorando o seu funcionamento.

Esta calculadora remonta a 1672, após uma visita de Leibniz a Paris, onde este tomou conhecimento
dos intermináveis cálculos astronômicos através de Christian Huygens.

Leibniz empenhou-se então em melhorar a Calculadora de Pascal, tendo terminado no ano seguinte.

Máquina de Babage

A máquina diferencial foi um invento de Charles Babbage, para cálculos com polinômios.

Em meados do século XIX, em plena segunda fase da Revolução Industrial, estavam em progresso
muitas tentativas de automação de processos, com destaque para aqueles envolvendo cálculos para a
composição de tabelas trigonométricas e de logaritmos quer para o emprego na navegação, na pesquisa
científica ou na engenharia.

Algumas pessoas tentavam conceber máquinas que executassem este tipo de cálculo, tendo sido
construídos vários modelos.

A máquina mais avançada, entretanto, jamais entrou em produção: a chamada máquina diferencial de
Babbage.

Um modelo foi apresentado por Babbage, na Inglaterra, em 1822, capaz de resolver


equações polinômicas através de diferenças entre números, e assim, de efetuar os cálculos necessários
para construir tabelas de logaritmos.
6
A máquina tinha a capacidade de receber dados, processá-los, armazená-los e exibi-los. Graças a ela
Babbage ficou conhecido como o pai do computador e conseguiu apoio governamental para criar um
modelo mais complexo, o "Engenho Analítico".

Devido a problemas de engenharia e a conflitos pessoais e políticos de Babbage, o projeto do Engenho


Analítico jamais foi concluído.

Em 1991, o Science Museum em Londres construiu a máquina diferencial de Babbage n° 2 para


uma exposição sobre a história da computação.

Quais os benefícios que a máquina diferencial trouxe?

 Foi a primeira tentativa de se construir uma máquina de computação que fosse automática e
adaptável;
 Diminuíram-se os erros nas leituras dos resultados, pois ela imprimia-os em cartões perfurados;
 Foi um dos pontos de partida para a indústria de máquinas.

Cilindro de impressão de Cartões

Este cilindro de impressão de três polegadas e meia pertence à primeira máquina que produziu
comercialmente a alta velocidade cartões perfurados - a impressora Carroll desenvolvida pela IBM em
1924.

A impressora rotativa rápida foi a resposta às necessidades da indústria para o fornecimento anual de
bilhões de cartões perfurados.

7
Impressora Carroll desenvolvida pela IBM em 1924.

Cartão perfurado para a entrada de dados

8
Perfuradora IBM 026

Perfuradora IBM 029

9
Perfuradoras

Classificadora de Cartões Perfurados

Impressora de impacto
10
MARK I

O MARK I era um computador, totalmente electromecânico, construído em 1944 pelo


professor Howard Aiken da Universidade de Harvard em Cambridge U.S.A..

O MARK I foi construido na sequência da celebração, em 1939, de um contrato entre a Marinha dos
Estados Unidos da América (US Navy ) e a Universidade de Harvard para construção de um
calculador de tabelas para uso na navegação. A ibm financiava a construção do calculador em 2/3 e o
restante era financiado pela Marinha dos Estados Unidos da América.

O MARK I tinha cerca de 17 metros de comprimento por 2,5 metros de altura e uma massa de cerca de
5 toneladas. Quando em funcionamento, diz-se que reproduzia o ruido de uma grande sala cheia de de
velhinhas todas a tricotar ao mesmo tempo.

A memória e os totalizadores compreendiam 3.000 engrenagens com 10 "dentes", 1.400 comutadores


rotativos e tudo era ligado por cerca de 800 Km de condutores eléctricos. O MARK I trabalhava
números com 23 decimais e realizava as quatro operações aritméticas. Dispunha ainda de subrotinas
integradas que calculavam funções logarítmicas e trigonométricas.

Era um calculador lento demorando 3 a 5 segundos para efectuar uma multiplicação, mas era
totalmente automático e podia realizar cálculos extensos sem intervenção humana.

Após a construção do Mark I, Aiken considerou que o envolvimento da ibm tinha sido nulo o que deu
origem a uma polémica entre Aiken e a ibm.

Quando em Maio de 1944, o MARK I é inaugurado, a polémica entre a Universidade de Harvard, em


sintonia com Aiken, e a ibm era tal que Thomas Watson ("patrão" da ibm) não foi convidado para a
cerimónia. Como resultado desta polémica o computador teve dois nomes de baptismo: MARK I, ou
ibmAutomatic Sequence Controlled Calculator (ASCC).

Ao MARK I seguiu-se uma versão totalmente electrónica denominada MARK II, também construida
pelo professor Aiken, que começou a funcionar em 1947.

Harvard MARK I – 1944

11
Classificação por Geração

 1ª Geração (1945-1956)
 2ª Geração (1956-1960)
 3ª Geração (1960-1971)
 4ª Geração (1971-presente)
 5ª Geração (presente-futuro)

1ª Geração (1945-1956)

Howard Aiken, engenheiro da IBM, cria em 1944 um calculador totalmente eletrônico (Harvard-IBM
Automatic Sequence Controlled Calculator ou MARK I). A finalidade deste era a criação de cartas
balísticas para a US Navy. Tinha metade do comprimento de um campo de futebol e cerca de 800 km
de fios

Grace Hopper em 1945, enquanto trabalhava no MARK II, encontrou o primeiro bug de computador
no sentido literal do termo (uma barata morta num relé). Daí para diante ela e os colegas, sempre que o
computador parava, diziam a Howard Aiken que estavam fazendo debugging ao computador.

Outro computador resultante dos esforços de guerra da 2ª Guerra Mundial surge em 1946, o ENIAC
(Electronic Numerical Integrator and Computer). Este computador resulta de uma parceria entre o
governo dos EUA e a Universidade da Pensilvânia.

O ENIAC construído em 1945.

O ENIAC (Electronic Numerical Integrator Analyzer and Computer), tinha 18000 tubos de vácuo,
17.468 válvulas, 70000 resistências e 5 milhões de juntas soldadas. Consumia 160 kw de energia
eléctrica. Ocupava um galpão imenso. Porém, apesar do tamanho, o poder de processamento do
ENIAC é ridículo para os padrões atuais, suficiente para processar apenas 5.000 adições, 357
multiplicações e 38 divisões por segundo, bem menos até do que uma calculadora de bolso atual, das
mais simples.

John Von Neumann, da Universidade da Pensilvânia, lança em 1945 o conceito de memória de

12
computador para armazenamento de programas e dados bem como a transferência de controlo
condicional. Estes coneitos perdurariam nos próximos 40 anos. Neumann e a sua equipa criam o
EDVAC (Electronic Discrte Variable Automatic Computer).

A 1ª geração de computadores era caracterizada por cada computador ser programado para uma tarefa
específica. Cada computador tinha uma linguagem binária diferente (código máquina).

Outras características destes computadores eram a utilização de tubos de vácuo (responsáveis pelas
enormes dimensões) e os tambores magnéticos para armazenamento de dados.

Válvulas

2ª Geração (1956-1960)

Em 1948, a invenção do transistor contribui para uma significativa mudança nos computadores. Desde
esta data que os computadores vêm decrescendo em dimensão. Em 1956 o transistor começa a ser
montado nos computadores.

A segunda geração de computadores substitui a linguagem máquina com o assembly, que já permitia a
utilização de códigos abreviados em substituição dos longos e difíceis códigos binários.

No início dos anos 60 surgem os primeiros computadores comercializados (Burroughs, Control Data,
IBM,…) com sucesso em áreas como as universidades, negócios e governos.

Estes computadores continham transistores em substituição dos tubos de vácuo. Também possuíam os
componentes que hoje associamos aos computadores modernos: impressoras, fitas e discos magnéticos
para armazenamento, memória e programas armazenados.

Um importante exemplo destes computadores era o IBM 1401 que foi o mais popular no mundo dos
negócios. Este computador, e o IBM 1620 (para escolas e universidades), foram os primeiros com a
fugir á tendência da época para os supercomputadores.

Foi o armazenamento do programa em memória e a linguagem de programação que deu aos


computadores a flexibilidade para serem suficientemente baratos e eficazes para terem aplicação
comercial.

É durante este período que surgem as linguagens de alto nível, muito parecidas com a linguagem
humana, Fortran (Formula Translator), 1957, e Cobol (Common Business-Oriented Language), 1960.
É com estas linguagens que começa toda a indústria de software.

13
O Burroughs B-200, lançado em 1962, um computador de segunda geração

IBM SSEC, lançado em 1959 (primeiro) e o PDP-11 lançado em 1960 (segundo).

3ª Geração (1960-1971)

Mas o transistor aquecia o que provocava muitas avarias. É então que surge o quartzo e o silício. Jack
Kilby da Texas Instruments desenvolve o conceito de circuito integrado em 1958 e a partir daí começa
a miniaturização de componentes em chips.
14
Como resultado, os computadores são cada vez mais pequenos. Também marca esta geração o
desenvolvimento do chamado sistema operativo (programa central que controla as tarefas mais básicas
do computador deixando aos programas o trabalho mais específico).

Em 1963 é criado o ASCII (American Standard Code for Information Interchange) com o objetivo de
normalizar e tornar possível a comunicação entre computadores.

Em 1964 é criada por John Kemeny e Tom Kurtz a linguagem de programação BASIC , que teve uma
extraordinária aceitação pelos jovens, e a IBM anuncia o System/360 como a sua primeira família de
computadores compatíveis .

Em 1968 Edsger Dijkstra lança a primeira pedra na fundação do que viria a ser a Programação
Estruturada ao escrever uma carta ao editor entitulada “GOTO statement considered harmful”. O início
da criação de programas mais fiáveis e de mais fácil manutenção estava lançado.

Em 1969 começa o trabalho na ARPAnet que viria a ser o embrião da Internet.

Em 1971 é criada a Intel Corporation.

15
IBM 360 introduzido em 1966 (primeiro) e um CDC 6600 de 1964 (segundo).

4ª Geração (1971-presente)

Depois dos circuitos integrados só restava diminuir a dimensão do computador.

Primeiro apareceram circuitos integrados com centenas de componentes num chip. Nos anos 80 já se
conseguiam centenas de milhares e agora já vão em milhões de componentes num chip.

É na década de 70 que os fabricantes de computadores (Commodore, Radio Shack e Apple) decidem


levar estes ao consumo doméstico. Para isso desenvolvem-se aplicações especialmente de
processamento de texto e folhas de cálculo.

O Altair 8800, o primeiro microcomputador, 1974. O teclado não tinha teclas, só botões e chaves.

Em 1975 a IBM lança o seu primeiro Personal Computer, o 5100, para uso em casa, escritório e
escola. Aparecem então no mercado os clones do IBM PC cuja garantia de qualidade era anunciada
pela frase “IBM compatível”.

Em competição direta com a IBM aparece em 1976 o Apple II que revoluciona o mercado ao
16
introduzir pela primeira vez um sistema operativo com um interface amigável baseado no conceito do
rato e das janelas (windows). Neste mesmo ano a Microsoft e a Apple são fundadas.

O Sinclair/TK85 Spectrum - primeiro microcomputador popular década de 1980

Em 1981 a IBM lança no mercado o IBM “PC” com um sistema operativo, DOS, completamente
diferente do até então usado por todos, o CP/M.

Lançamento: 8 de dezembro de 1981 (30 anos)

Descontinuado: 2 de abril de 1987 (24 anos)

Sistema operativo: IBM Cassette BASIC / PC-DOS 1.0

Microprocessador: Intel 8088 em 4,77 MHz

Memória: 16 KiB ~ 640 KiB

1 Kibibyte (KiB) = 1 quilobyte (Kb) = 1024 Bytes

17
Em 1982 a Times elege o computador o Homem do Ano. Desde esse ano o computador passa a ser
ferramenta indispensável na indústria do cinema.

A utilização dos computadores pessoais tem um crescimento notável, não mais parando até hoje:

• 1981 - 2 milhões de PC’s em uso;


• 1982 - 5.5 milhões;
• 1992 - 65 milhões.

O tamanho também não parou de diminuir, primeiro os desktop e os tower, depois os laptop e agora os
palmtop.

A utilização dos computadores pessoais generaliza-se começando a substituir os grandes computadores


centrais (Mainframes) e os minicomputadores. Os computadores começam a ser ligados entre si
formando redes, desenvolvem-se protocolos de comunicação entre PC’s e o software sofre um
aumento fantástico.

Os anos 90 marcam o aparecimento da Internet como rede global. A web, o e-mail, o protocolo de
transferência de ficheiros, o acesso remoto por telnet, os newsgroups e a comunicação de
computadores por TCP/IP são alguns dos muitos serviços que passam a ter utilização mundial e que
revolucionam a forma de comunicação, de comércio, de educação e de informação.

5ª Geração (presente-futuro)

O futuro já se antevê no presente com a evolução espetacular dos microprocessadores (processamento


paralelo, velocidade de processamento) liderados pela Intel, com a evolução do sistema operativo
Windows com liderança incontestável da Microsoft e com a evolução das telecomunicações

18
(supercondutores, fibra óptica).

O computador, provavelmente, deixará de se chamar computador uma vez que cada vez mais integra
funções que antes eram desempenhadas por diferentes equipamentos (fax, televisão, vídeo, telefone)
passando a ser mais uma consola de comunicações, de trabalho e de lazer.

1.2 Organização de Computadores

1.2.1 Modelo de Von Neumann

Von Neumann sugeriu que as instruções fossem armazenadas na memória do computador. Até então
elas eram lidas de cartões perfurados e executadas, uma a uma. Armazená-las na memória, para então
executá-las, tornaria o computador mais rápido, já que, no momento da execução, as instruções seriam
obtidas com rapidez eletrônica.

A maioria dos computadores de hoje em dia segue ainda o modelo proposto por von Neumann.

Esse modelo define um computador sequencial digital em que o processamento das informações é feito
passo a passo, caracterizando um comportamento determinístico (ou seja, os mesmos dados de entrada
produzem sempre a mesma resposta).

Figura - Modelo de Von Neumann

O modelo lógico de computador proposto por von Neumann pode ser descrito resumidamente da
seguinte forma.

 Unidade Central de Processamento - UCP (em inglês, Central Processor Unit - CPU)
constituída por uma Unidade de Controle e uma Unidade de Lógica Aritmética.
 Unidade de controle - A unidade de controle controla o funcionamento da unidade lógica e
aritmética e da memória. Além disso, ela distribui e organiza tarefas, transfere informações da
entrada para a memória e da memória para a saída.
 Unidade de lógica aritmética (em inglês, arithmetic logic unit - ALU) - Realiza todas as
operações lógicas e aritméticas do computador.
 Memória - A memória é o dispositivo de armazenamento de informação do computador. Nela
são armazenados tanto as instruções de um programa quanto os dados necessários para a sua
execução. A memória é dividida em espaços com endereços.
19
 Barramentos (em inglês, Buses) - O barramento é um conjunto de linhas de comunicação que
permitem a interligação entre dispositivos, como o CPU, a memória e outros periféricos.
 Unidade de Entrada - Esta unidade traduz informação (por exemplo, letras, números,
imagens, marcas magnéticas) de uma variedade de dispositivos de entrada em impulsos
elétricos que a CPU entenda.
 Unidade de Saída - Esta unidade converte os dados processados, enviados pela CPU em forma
de impulsos elétricos, em palavras ou números, que são impressos por impressoras ou
mostrados em monitores de vídeo.

1.2.2 Sistemas de Numeração

Sistema de Numeração Decimal

O sistema de numeração que normalmente utilizamos é o sistema de numeração decimal, pois os


agrupamentos são feitos de 10 em 10 unidades.

Os símbolos matemáticos utilizados para representar um número no sistema decimal são chamados de
algarismos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, que são utilizados para contar unidades, dezenas e centenas. Esses
algarismos são chamados de indo-arábico porque tiveram origem nos trabalhos iniciados pelos hindus
e pelos árabes.

Com os algarismos formamos numerais (Numeral é o nome dado a qualquer representação de um


número).

Sistemas de numeração utilizados na Informática

Os sistemas de numeração mais utilizados na informática são:

Base 2: também conhecido como sistema binário. É um sistema posicional composto pelos
numerais 0 e 1 e, além da Informática, é utilizado na Eletrônica Digital na implementação de circuitos
de portas lógicas. Uma de suas primeiras aplicações na informática surgiu quando da utilização de
cartões perfurados para representar informações e programas.

Base 8: o sistema octal também é um sistema posicional e foi utilizado na Informática como
alternativa ao sistema binário. É composto pelos numerais 0, 1, 2,3, 4, 5, 6 e 7.

Base 16: o sistema hexadecimal é, talvez, um dos mais conhecidos da atualidade. É composto de 16
algarismos, representados por 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A,B, C, D, E e F. Trabalha-se com ele como
qualquer outro sistema, mas deve-se prestar atenção ao valor dos caracteres alfabético na hora de fazer
operações e conversões.

É atualmente a maior alternativa ao sistema binário por ser extremamente compacto e é utilizado para
representar portas, interrupções e endereços de memória, além de cores no desenvolvimento web, em
substituição ao sistema RGB.

Para representar as cores, é utilizada uma notação de seis dígitos, onde cada dupla, da esquerda para a
direita, representa o valor da intensidade do vermelho, do verde e do azul, respectivamente, variando
de 00 até FF, que representa o valor decimal 255. Assim, as cores variam de 000000, que representa o
preto, até FFFFFF, que corresponde ao branco. Os tons de cinza são representados por valores iguais
nas três posições, como por exemplo 666666, DEDEDE ou CCCCCC. Quanto mais próximo
de FFFFFF, mais clara é a tonalidade de cinza.
20
Ao todo, essa notação hexadecimal permite a representação de mais de 16 milhões e meio de cores.
Alguns programas de desenho vetorial e de tratamento de imagem incluem, ainda, uma quarta dupla de
valores na notação para representar o nível de transparência da cor selecionada.

Graças à base hexadecimal, as rotinas de tratamento de imagem foram em muito facilitadas, Por
exemplo: para fazer o efeito de negativo em uma foto, isto é, inverter suas cores, basta subtrair
de FF cada valor da tripla que representa a cor de cada pixel.

Base 62: Talvez você nunca tenha ouvido falar deste sistema, mas acredite: você já o utilizou. O
sistema de base 62 está se tornando cada vez mais popular porque seus 62 algarismos são
representados pelos numerais de 0 a 9 e pelas letras de A a Z e de a a z. Uma de suas aplicações mais
recorrentes está nos famosos encurtadores de URL: o código gerado pelo encurtador nada mais é do
que a conversão de um número decimal - geralmente o número de identificação único para cada URL
no banco de dados - nesta base. Assim, quanto mais caracteres um encurtador de URLs utilizar para
gerar sua URL curta, mais URLs ele terá cadastradas.

Base 64: É um sistema numérico utilizado para codificação de dados binários que precisam ser
armazenados e transferidos em meios que foram desenhados originalmente para lidar com dados
textuais. É composto pelos algarismos de 0 a 9, pelas letras de A a Z e de a a z e pelos símbolos / e +.
O caractere = é utilizado como sufixo especial.

1.2.3 Os sistemas: decimal, binário e hexadecimal

Introdução

Os computadores trabalham com um sistema que utiliza apenas dois valores para manipular qualquer
informação. Isso quer dizer que todas as operações que o computador faz, desde permitir-nos a
escrever um simples texto até jogar jogos 3D são realizados utilizando apenas dois valores, que por
convenção são os dígitos “0” (zero) e “1” (um).

Mas como isso é possível? Como o computador consegue dar andamento a todos os seus processos
utilizando apenas os dígitos “0” e “1”?

O que é binário?

De forma geral, binário é um sistema que utiliza apenas dois valores para representar suas quantias. É
um sistema de base dois. Esses dois valores são o “0” e o “1”.

Daí podemos concluir que para 0 temos desligado, sem sinal, e para 1 temos ligado ou com sinal.

Vale ressaltar que o sistema que utilizamos diariamente é o sistema de base dez, chamado também
por base decimal. Esse sistema utiliza os algarismos indo-arábicos, que são: 0, 1, 2, 3, 4, 5, 6, 7, 8, e 9.

Nós seres humanos fomos “treinados” para trabalhar com a base decimal. Ela é a ideal para nós. Mas,
para os computadores a base binária é a ideal.

Nos computadores esses zeros (“0s”) e uns (“1s”) são chamados de dígitos binários ou
somente bit (conjunção de duas palavras da língua inglesa binary digit), que é a menor unidade de
informação dos computadores. Dessa forma, tanto faz dizer dígito “0” e dígito “1”, ou, bit “0” e bit
“1”.
21
Formação de informações / O caractere.

São esses bits que formam qualquer informação, porém, um bit sozinho não faz nada, é apenas um
sinal qualquer. Para que os bits possam realmente formar uma informação, precisam ser agrupados.
Esses grupos podem ser de 8, 16, 32 ou 64 bits.

8 bits - 10100110

Apesar de parecer ser um sistema limitado, agrupando bits é possível fazer uma infinidade de
representações. Vamos pegar como exemplo um grupo de 8 bits (tabela a seguir), onde é possível
fazer as seguintes representações para os números decimais:

Na tabela 01 os números decimais estão representados em grupos de oito bits. Mas, acontece que,
como ocorre no sistema decimal, todo zero que estiver a esquerda de dígitos binários não valem nada.
Por exemplo: o decimal 14 é 1110 em binário, o mesmo que 00001110 ou 000000001110 ou ainda
...0000000000001110.

O computador reune grupos predefinidos de bits (8, 16, 32 ou 64) para formar uma informação, ou
seja, um caracter. Um caracter é qualquer letra, número ou símbolo.

10100110 à 8 bits = um caractere qualquer

Quanto é 1 + 1?

Bem, todos devem responder “2”.

Não foi dito qual é a base (decimal ou binária). Se for decimal dará 2. E se for binária dará 10.

Palavra

Na terminologia dos computadores, palavra é um grupo de algarismos binário (bits) que podem ocupar
uma localização na memória, e, que podem ser processados de uma só vez, podendo ser um número
binário que é para ser manuseado como um dado, ou, uma instrução que diz ao computador que
operação deve ser executada. Pode ser também um caractere ASCII representando uma letra do
alfabeto, ou ainda, um endereço que diz ao processador onde se localiza um dado.

Existem tamanhos de palavras diferentes, onde cada um recebe um nome, veja:

 4 bits = NIBBLE (24 =16 variações);


 8 bits = BYTE (28 = 256 variações);
 16 bits = WORD (216 = 65.536 variações);
 32 bits = DOUBLE WORD (232 = 4.294.967.296 variações);
 64 bits = QUAD WORD (264 = 18.446.744.073.709.551.616 variações).

Para entender melhor, imagine que com palavras de 8 bits, as instruções, os endereços, os números e
dados são representados por números binários de 8 bits. Dessa forma o menor número binário é
00000000 (ou 00 em hexadecimal), e, o maior número é 11111111 (ou FF em hexadecimal), o que
corresponde de 0 a 256 valores diferentes (variações).

Quanto maior a palavra, maior será o número que se pode trabalhar.

22
Por exemplo:

Com palavras de 16 bits pode-se trabalhar com números decimais até 65.536. É preciso frisar aqui que
apesar de um determinado PC usar palavras de 8 bits, por exemplo, não significa que o processador
desse PC ficará restringido a números decimais inferiores a 256. Simplesmente significa que será
necessário usar duas ou mais palavras para representar números maiores.

Dessa forma é certo dizer que um processador de 32 bits é mais rápido que um de 16 bits, pois, este
último será obrigado a dividir números maiores (acima de 65.536) em números menores que sejam
possíveis de se manipular com 16 bits, o que levará mais tempo.

Atualmente os processadores acessam a memória a 64 bits por vez, porém, continuamos a usar o nome
BYTE para referir ao tamanho de uma memória.

O correto seria usar “BYTE” para designar o tamanho de uma memória de 8 bits, e, QUAD WORD
para memórias de 64 bits.

Mas, qual seria o lado prático disso? Nenhum, e pior, acaba confundindo, pois, imagine ter que usar
BYTE para memórias de 8 bits (SIMM/30), WORD para memórias de 16 bits, e assim sucessivamente.
Por isso até hoje o usual é o BYTE para designar o tamanho de uma memória.

Na prática

Agora um ponto importante. Como que isso tudo funciona na prática? Será que dentro de um
processador ou em um CD/DVD veremos, literalmente, uma fileira de “0s” e “1s”? Não é assim que
funciona.

Em nível de eletrônica, os bits 0 e 1 são representados através de valores de tensão.

Por exemplo:

O bit 0 pode ser representado por valores entre 0 e 0,3 volts. Já o bit 1 pode ser representado por
valores entre 2 e 5 volts. Esses números são apenas exemplos, não está se afirmando que são
exatamente esses valores.

De forma geral, qualquer valor pode ser usado para representar os bits, depende do projeto, da
aplicação e da tecnologia empregada. Com o avanço da tecnologia dos computadores, passou a se usar
tensões cada vez menores, pois, os dispositivos eletrônicos passaram a trabalhar com tensões menores.
Nos computadores são usados valores muito baixos, tais como esses que acabamos de mencionar.

1.2.4 Tabelas de Representação de Caracteres: ASCII, ISO, UNICODE.

Representação da escrita em computador

A Tabela ASCII (American Standard Code for Information Interchange, que em português significa
“Código Padrão Americano para o Intercâmbio de Informação”) não é nenhuma novidade para quem
já trabalha com informática, principalmente com desenvolvimento de software.

ASCII é uma codificação de caracteres de oito bits baseada no alfabeto inglês. Os códigos ASCII
representam texto em computadores, equipamentos de comunicação, entre outros dispositivos que
trabalham com texto. Desenvolvida a partir de 1960, grande parte das codificações de caracteres
modernas a herdaram como base.
23
A codificação define 128 caracteres, preenchendo completamente os sete bits disponíveis. Desses, 33
não são imprimíveis, como caracteres de controle atualmente não utilizáveis para edição de texto,
porém amplamente utilizados em dispositivos de comunicação, que afetam o processamento do texto.
Exceto pelo caractere de espaço, o restante é composto por caracteres imprimíveis.

A minha intenção em publicar esta tabela é adicionar várias informações em uma única tabela, já que a
maioria disponível na internet apresenta poucos dados.

Esta tabela é a junção da tabela ASCII Normal (32 a 127), tabela dos Caracteres de Controle (0 a 31) e
a tabela ASCII Estendida (128 a 255).

A primeira tabela ASCII

Basicamente, computadores armazenam números e para armazenar texto na sua memória, é preciso
converter os grafemas em números. Por exemplo: a memória do computador, não armazena a letra A,
mas o número 65. No início do desenvolvimento dos computadores, as soluções para tratar texto
privilegiavam o idioma inglês. A primeira tabela ASCII (American standard code for information
interchange) fazia uma correspondência entre números e os grafemas básicos da ortografia inglesa.
Essa tabela alcançava até o número 127, o que corresponde a um código de 7 bits, pois computadores
operam com o sistema binário de contagem, e convertido em notação binária, 127 equivale a um
número de 7 dígitos.

A primeira tabela ASCII funcionava bem para tratar textos em inglês, mas deixava a desejar na
representação de textos em português, por exemplo, pois não considerava os grafemas com diacríticos
da nossa ortografia como: á, é, ô, ç, u, etc.

Tabelas ASCII estendidas

Com o tempo, a tabela ASCII foi expandida até o número 255. Em notação binária, isso corresponde a
um número com 8 dígitos e, por isso, ela é considerada um código de 8 bits. Uma tabela ASCII
estendida tem todos os caracteres considerados pela tabela anterior de 7 bits, mais uma expansão que
resolveu vários problemas de representação como, por exemplo, os grafemas com diacríticos da língua
portuguesa.

Embora a tabela ASCII de 8 bits seja mais ampla que sua antecessora e atenda às necessidades de
representação em computador de um idioma como o português, ainda assim, alguns problemas
persistem. A tabela ASCII estendida não permite acomodar ao mesmo tempo os grafemas do sistema
latino e de outros sistemas como o cirílico, grego, hebraico, etc. Em função disso, foram criadas várias
tabelas ASCII de 8 bits, cada uma delas adaptada às necessidades de uma ortografia específica.

Números Decimais Código Binário Hexadecimal


0 00000000 00
1 00000001 01
2 00000010 02
3 00000011 03
4 00000100 04
5 00000101 05
6 00000110 06
7 00000111 07
8 00001000 08
9 00001001 09
10 00001010 0A

24
11 00001011 0B
12 00001100 0C
13 00001101 0D
14 00001110 0E
a 01100001 61
b 01100010 62
c 01100011 63
d 01100100 64
e 01100101 65
f 01100110 66
g 01100111 67
h 01101000 68
i 01101001 69
j 01101010 6A
k 01101011 6B
l 01101100 6C
m 01101101 6D
n 01101110 6E
o 01101111 6F
p 01110000 70
q 01110001 71
r 01110010 72
s 01110011 73
t 01110100 74
u 01110101 75
v 01110110 76
w 01110111 77
x 01111000 78
y 01111001 79
z 01111010 7A
Tabela 01: Caracteres alfanuméricos e seus equivalentes em binário

1.3 Lógica de Programação e Linguagem de Programação

Lógica de Programação

Lógica de programação é o modo como se escreve um programa de computador com as regras de


sintaxe específicas de cada linguagem. Uma Linguagem de Programação é a forma de representar na
linguagem escolhida o algoritmo.

Na informática, os programadores escrevem as “receitas de bolo” (algoritmos) de modo que o


computador leia e entenda o que deve ser feito, ao executar o algoritmo. Para isto é necessário
uma linguagem de programação.

A linguagem de programação é como uma língua normal, um grupo de palavras com significados. No
caso da programação, a maioria das linguagens é escrita em Inglês. Estas linguagens fazem o
computador assimilar cada comando e função de um algoritmo, depois executar cada função.

A linguagem de programação é somente como se escreve o algoritmo. O grande problema para muitos
é o que “dizer” para o computador fazer o que é desejado. Para o aprendizado foi desenvolvido o
Software VisualG, que auxilia a programação totalmente em português. Com este software, não é
necessário pensar em linguagem de programação, pois todos os comandos são em Português, ficando
assim o foco na Lógica.

25
Na hora de programar alguns passos são indispensáveis, como declarar variáveis.

Variáveis podem ser escritas por letras ou números, que representam um valor que pode ser mudado a
qualquer momento.

Saber lógica de programação é saber o melhor jeito de escrever um código, para o computador
interpretar corretamente. É saber se comunicar com a máquina a partir de uma linguagem seja lá qual
for.

Um exemplo de algoritmo, que tem como objetivo somar 3 números inteiros.

Algoritmo "soma"
Var Num1, num2, num3, soma:inteiro
Inicio
Escreva (“programa para digitar e somar três números inteiros”)
escreva("digite o primeiro numero:")
leia(num1)
escreva("digite o segundo numero:")
leia (num2)
escreva("digite o terceiro numero:")
leia (num3)
soma <- num1 + num2 + num3
escreva("O resultado é: " soma)
fimalgoritmo

Representação do algoritmo (acima) na Linguagem de Programação C++.

#include <iostream>
using namespace std;
int num1, num2, num3, soma;
int main (){
cout<< "programa para digitar e somar tres números inteiros";
cout<< "\n"; // pular linha antes de imprimir a próxima linha
cout<< "digite o primeiro numero: ";
cin>> num1;
cout<< "digite o segundo numero: ";
cin>> num2;
cout<< "digite o terceiro numero: ";
cin>> num3;
soma = num1 + num2 + num3;
cout<< "O resultado e: " << soma;
cout<< "\n"; // pular linha antes de imprimir a próxima linha
system("pause"); // congelar tela para vermos resultado do processamento
}

No algoritmo acima, alguns elementos são os comandos específicos da linguagem "Portugol":

Var, Inicio, escreva, leia, <-, Fimalgoritmo, :inteiro.

Estes comandos têm funções especificas, e um dos objetivos da lógica de programação é entender
como eles funcionam.

Cada linguagem tem um correspondente a estes comandos, com a mesma função, porém escrito de
modo diferente (sintaxe): cout, cin, =, <<, >>, int.

26
1.3.1 Software

O que é um Programa (Software)?

Um programa ou programa de computador é um conjunto de instruções que são interpretadas pelo


computador afim de se executar uma determinada tarefa. Essas instruções estão armazenadas em um
arquivo que comumente é chamado de executável e, dentro deste arquivo, as instruções aparecem no
formato binário que é extremamente difícil de ser lido por um ser humano.

No mercado existem diversas marcas de computador, cada uma produzindo computadores com
características variadas, desde a capacidade de armazenamento de dados à estética do gabinete.

Dentro de um mercado tão diversificado, nada mais natural que encontrarmos diversos tipos de
processadores que não variam somente o poder de processamento, mas também de arquitetura.

Essa variedade acontece também no mundo dos sistemas operacionais. Hoje temos o Windows, Linux
e o Mac OS X entre os mais populares, mas ao longo dos últimos 20 anos tivemos também o OS/2,
QNX, DOS, BeOS, entre outros.

E o que isso tem a ver com o programa que executamos em nossos computadores?

Tudo. No momento em que um programa é gerado, é dito à ele em qual sistema operacional e em qual
arquitetura de processador ele será executado. Ou seja, nele estará contido instruções específicas para
um determinado tipo de processador, além de instruções específicas para um determinado sistema
operacional.

Desta forma, pode-se caracterizar as linguagens de programação como Linguagem de Alto Nível e
Linguagem de Baixo Nível.

As linguagens de baixo nível que utiliza a linguagem Binária (0’s e 1’s). As linguagens ditas de alto
nível são as linguagens mais utilizadas atualmente, e por motivos óbvios, sendo tais linguagens
consideradas mais próximas às linguagens naturais ou ao domínio de aplicação em questão. Para
operacionalizar os programas, considerando o que foi dito acima, é necessário um processo de
conversão (alto nível para baixo nível), para que o computador “compreenda” o que deverá ser
executado.

As linguagens de programação são classificadas em cinco gerações:

 1ª Geração (Linguagens de Máquina);


 2ª Geração (Linguagens Simbólicas - Assembly);
 3ª Geração (Linguagens Orientadas ao Usuário);
 4ª Geração (Linguagens de alto-nível com objetivos específicos);
 5ª Geração (Linguagens de Conhecimento).

1ª Geração (Linguagens de Máquina)

Tais linguagens permitem a comunicação direta com o computador em termos de bits, registradores e
operações de máquina bastante primitivas. Os seus programas são sequências de 0’s e 1’s, o que os
tornam muito complexos, cansativos e sujeitos a muitos erros.

27
2ª Geração (Linguagens Simbólicas - Assembly)

São as linguagens simbólicas ou de montagem, que foram projetadas para minimizar as dificuldades da
programação binária. Códigos de operação e endereços binários foram substituídos por mnemônicos. O
seu processamento requer uma tradução para a linguagem de máquina, antes de sua execução.

3ª Geração (Linguagens Orientadas ao Usuário)

Algumas são orientadas à solução de problemas científicos, tais como: FORTRA N, PASCAL e
ALGOL; e outras, para aplicações comerciais, tais como:

COBOL. E outras contém as duas finalidades, como PL/I e ADA. São classificadas como linguagens
procedimentais (procedurais ou imperativas), baseadas em procedimentos que apresentam como o
problema deve ser solucionado; e as linguagens declarativas, que podem ser funcionais e lógicas. Tais
linguagens foram projetadas para profissionais de computação e não para usuários finais.

4ª Geração (linguagens de alto-nível com objetivos específicos)

São linguagens capazes de gerar código por si só, são os chamados RAD (Desenvolvimento Rápido de
Aplicativos), com o qual pode-se realizar aplicações sem ser um expert na linguagem. Aqui também se
encontram as linguagens orientadas a objetos, tornando possível a reutilização de partes do código para
outros programas.

Os principais objetivos dessas linguagens são:

 Facilitar a programação de computadores de tal forma que os usuários finais possam resolver
seus problemas;
 Acelerar o processo de desenvolvimento de aplicações;
 Facilitar e reduzir o custo de manutenção de aplicações;
 Minimizar problemas de depuração;
 Gerar código sem erros a partir de requisitos de expressões de alto nível.
o Exemplo:
 Oracle PL/SQL;
 NATURAL;
 Oracle Reports;
 ABAP;
 XML;
 Delphi programming language;
 MATLAB's GUIDE;
 Visual Basic's form editor;
 Windows Forms (part of the .NET Framework).

5ª Geração (Linguagens de Conhecimento)

São usadas principalmente na área de Inteligência Artificial, pois facilitam a representação do


conhecimento que é fundamental para a simulação de comportamentos inteligentes. Por exemplo,
temos o ADA, C++, Java, etc.

A WEB utiliza algumas linguagens de quinta geração e outras adaptadas para esse novo paradigma.

Exemplo:
Java, JavaScript, XML, HTML, etc.
28
1.3.2 Algumas Linguagens de Programação

Assembly

O Assembly foi provavelmente a primeira linguagem de programação da história, surgida na década de


50, época em que os computadores ainda usavam válvulas. A idéia do assembly é usar um comando
em substituição a cada instrução de máquina.

No assembly, cada uma destas instruções, equivale a uma instrução do processador. Ao invés de usar
instruções como 10101011 você pode usar outras bem mais fáceis de entender e de memorizar, como
add, div, mul, and, or, not, etc. Você também pode criar variáveis, que são pequenos espaços na
memória RAM reservados para guardar algum tipo de dado, que o programa precisará mais tarde.
Você pode usar aquelas instruções que citei para lidar com elas.

Por exemplo, a instrução "add" faz com que o processador some duas variáveis; "add x, y" por
exemplo, soma os valores de x e y.

O compilador transforma o código escrito em assembly em linguagem de máquina, que finalmente


poderá ser entendida pelo processador.

Existem também os decompiladores, que fazem o trabalho inverso, de transformar um programa já


compilado, em um código em linguagem assembly. Este recurso é chamado de engenharia reversa. É
assim que conseguem crackear programas, quebrar códigos de proteção (como o do DVD), etc. Claro
que para isso, é preciso alguém que conheça muito de assembly e que tenha disposição para ficar
estudando o código até encontrar o que procura.

Por causa desta característica de permitir trabalhar diretamente com as instruções do processador, o
assembly é chamado de linguagem de baixo nível.

Fortran

Fortran é a contração de "Formula Translator". O Fortran foi uma das primeiras linguagens de alto
nível da história A primeira versão do Fortran foi criada no final da década de 50, mas a linguagem
começou a ser usada em larga escala a partir da metade da década de 60, quando surgiram várias
versões diferentes. Atualmente o Fortran é pouco usado.

Pascal

O Pascal é outra linguagem de alto nível, criada durante a década de 60. O Pascal é uma linguagem
bastante estruturada, com regras bastante rígidas, o que a torna difícil de usar. Hoje em dia o Pascal
original é pouco usado, mas seus descendentes diretos como o Free Pascal evoluíram muito. O Delphi
é uma evolução do Pascal.

Cobol

Cobol significa "Common Business Oriented Language". Esta linguagem foi desenvolvida no final da
década de 50, com o objetivo de ser uma plataforma de desenvolvimento para aplicações bancárias e
financeiras em geral. Comparado com o Pascal e o Assembly, comuns na época, o Cobol é uma
linguagem bastante amigável, o que garantiu uma grande aceitação. Até hoje esta linguagem é usada
em muitos sistemas bancários, o que explica a grande procura por programadores experientes nesta
29
linguagem na época do bug do ano 2000.

O C foi desenvolvido durante a década de 70, mas ainda é largamente utilizado. A grande vantagem do
C é permitir escrever tanto programas extremamente otimizados para a máquina, como seria possível
apenas em assembly, e ao mesmo tempo vir com várias funções prontas, como uma linguagem de alto
nível, que podem ser utilizadas quando não for necessário gerar um código tão otimizado.

A maior parte dos programas Linux e o Kernel quase todo foram escritos em C, o que explica o porque
do sistema ser tão rápido em algumas tarefas.

C++

O C++ mantém os recursos do C original, mas possue muitos recursos novos, como orientados a
objetos e sendo também bem mais fácil de utilizar. O C++ é bastante usado atualmente para
desenvolver muitos programas para várias plataformas.

Java

O Java é uma linguagem de programação multiplataforma, com uma sintaxe até certo ponto parecida
com o C++, porém com bibliotecas diferentes. Os programas em Java podem ser executados em
qualquer sistema operacional, desde que o interpretador esteja instalado.

A JVM é um programa que converte o código Java em comandos que o sistema operacional possa
executar. Existem máquinas virtuais para vários sistemas operacionais, o problema é que devido ao
processamento executado pela máquina virtual, o programa torna-se mais pesado do que seria caso
escrito diretamente para a plataforma.

Explicando de forma mais elaborada, linguagens de programação "tradicionais", como o C e o C++


utilizam um compilador diferente para cada plataforma ou sistema operacional em que o programa irá
rodar. O código fonte em pode ser escrito de forma a ser facilmente portável, ou seja, rodar em
diferentes versões do Unix ou em várias famílias de processadores diferentes sem muitas alterações,
mas ainda assim será necessário recompilar o código fonte, gerando um binário diferente para cada
caso.

Embora o trabalho inicial seja maior, a vantagem desta abordagem é que o desempenho é o melhor
possível, já que sempre teremos um programa binário otimizado para a plataforma.

Mas o Java utiliza um conceito diferente. Ao invés de gerar um binário diferente para cada plataforma,
é gerado um binário que pode ser executado em qualquer plataforma, dentro de uma máquina virtual.
Este binário "universal" é chamado de bytecode.

A idéia é criar aplicativos que possam ser escritos uma vez e executados em qualquer plataforma,
reduzindo os custos de desenvolvimento. Apenas o software da máquina virtual é que precisa ser
reescrita para cada plataforma, mas isso é problema dos desenvolvedores da linguagem, não do
programador.

Existe ainda a opção de abrir mão da flexibilidade do bytecode em troca de um maior desempenho,
passando a compilar os programas com otimizações para uma determinada plataforma. Isso é muito
útil quando o programa será executado apenas dentro de computadores de uma determinada
plataforma, como PCs rodando Linux por exemplo.
30
No caso do Java, a máquina virtual que executa os programas é chamada de Java Virtual Machine.
Muitas páginas Web utilizam applets1 Java, por isso a maioria das pessoas acaba instalando o suporte a
Java. Hoje em dia, além do Java da Sun temos versões alternativas, como o Blackdown e o Kofee, que
possuem conjuntos de recursos variados, mas são a princípio compatíveis com o código gerado para o
Java da Sun.

Embora tenha ganhado relevância com o Java, este conceito não é exatamente novo. Linguagens mais
antigas como o LISP e o Prolog já utilizam bytecode e máquinas virtuais.

1.3.3 Tradutor

No contexto de linguagens de programação, é o sistema que recebe como entrada um programa escrito
em linguagem de programação (linguagem fonte) e produz como resultado um programa equivalente
em outra linguagem (linguagem Objeto).

Tais tradutores podem ser classificados em:

Montadores (Assemblers): mapeiam instruções em linguagem simbólica para instruções de linguagem


de máquina, de forma que uma instrução em linguagem simbólica gera uma instrução em linguagem
de máquina;

1.3.4 Compilador

São tradutores que mapeiam programas escritos em linguagem de alto nível para programas
equivalentes em linguagem simbólica ou de máquina. Tal processo ocorre normalmente em dois
passos:

O intervalo de tempo que ocorre a conversão do programa fonte para um programa objeto é chamado
de Tempo de Compilação, enquanto que o programa objeto é executado no Tempo de Execução. O
programa fonte e os dados são processados em momentos distintos, que são respectivamente, tempo de
compilação e tempo de execução.

Pré-compiladores, Pré-processadores ou Filtros: mapeiam instruções escritas em linguagem de alto


nível estendida para instruções da linguagem de programação original, ou seja, efetuam tradução entre
duas linguagens de alto nível.

1.3.5 Interpretador

São processadores que recebem como entrada o código intermediário de um programa anteriormente
traduzido e produzem o “efeito de execução” do algoritmo original sem mapeá-lo em linguagem de
máquina. Eles processam uma forma intermediária do programa fonte e dados ao mesmo tempo, ou
seja, a interpretação do fonte ocorre em tempo de execução, não gerando assim um programa objeto.

A seguir, temos a exemplificação do processo de interpretação:

Os interpretadores são normalmente menores do que os compiladores e facilitam a implementação de


construções complexas de linguagens de programação. Sua principal desvantagem é que o tempo de

1
As aplets são pequenos programas Java que podem ser inseridos dentro de páginas HTML. Um applet pode ainda executar tarefas
complexas, como realizar cálculos e apresentar gráficos, sons e imagens em movimento.

31
execução de um programa interpretado é maior que o tempo de execução de um programa objeto
(compilado) equivalente, devido ao tempo necessário para realizar a tradução virtual para o código de
máquina cada vez que a instrução em código intermediário deve ser operada. Este código pode ser
visto como o código de máquina de um computador virtual.

Os interpretadores são normalmente mais amigáveis do que os compiladores, pois estão mais próximos
do código fonte do que programas completamente traduzidos. As mensagens de erro e as facilidades de
teste e depuração em relação à interpretação são mais claras e objetivas, e principalmente quando se
refere ao código fonte. Uma grande vantagem dos sistemas interpretados está na implementação de
novas linguagens para diferentes equipamentos, pois a partir do momento em que um código
intermediário é produzido, e este é padrão, ele independe de máquina, onde para cada máquina é
programado um interpretador específico.

Normalmente, os tradutores de linguagens de programação são bastante complexos. Entretanto, existe


um consenso sobre a sua estrutura básica, que independentemente da linguagem a ser traduzida ou do
programa objeto a ser gerado, eles são compostos de funções padrão, tais como: a análise do programa
fonte e a síntese para a geração do código objeto.

32
1.4 Algoritmos e as Formas de Representação

1.4.1 Algoritmos

Conceito de Algoritmo

“Algoritmo é um conjunto finito de regras, bem definidas, para a solução de um problema em


um tempo finito e com um número finito de passos.”

“Conjunto de instruções dispostas sequencialmente (seguindo um critério lógico), com o objetivo


de obter um determinado resultado.”

Informalmente, um algoritmo é qualquer procedimento computacional bem definido que toma algum
valor ou conjunto de valores como entrada e produz algum valor ou conjunto de valores como saída.

Um algoritmo deve sempre possuir pelo menos um resultado, normalmente chamado de saída, e
satisfazer a propriedade da efetividade, isto é, todas as operações especificadas no algoritmo devem ser
suficientemente básicas para que possam ser executadas de maneira exata e num tempo finito.

Para se ter um algoritmo, é necessário:


1. Que se tenha um número finito de passos
2. Que cada passo esteja precisamente definido, sem possíveis ambiguidades
3. Que existam zero ou mais entradas tomadas de conjuntos bem definidos
4. Que existam uma ou mais saídas
5. Que exista uma condição de fim sempre atingida para quaisquer entradas e num tempo
finito.
Para que um computador possa desempenhar uma tarefa é necessário que esta seja detalhada passo a
passo, numa forma compreensível pela máquina, utilizando aquilo que se chama de programa. Neste
sentido, um programa de computador nada mais é que um algoritmo escrito numa forma
compreensível pelo computador.

O aprendizado de algoritmos não se consegue a não ser através de muitos exercícios.

Algoritmos não se aprendem:


– Copiando algoritmos
– Estudando algoritmos

Algoritmos só se aprendem:
– Construindo algoritmos
– Testando algoritmos

33
Função dos Algoritmos na Computação

Um algoritmo tem por objetivo representar mais fielmente o raciocínio envolvido na lógica de
programação e, dessa forma, permite-nos abstrair de uma série de detalhes computacionais, que podem
ser acrescentados mais tarde. Assim, podemos focalizar nossa atenção naquilo que é importante: a
lógica na construção de algoritmos.

Outra importância da construção de algoritmos é que, uma vez concebida uma solução algorítmica
para um problema, esta pode ser traduzida para qualquer linguagem de programação e ser agregada das
funcionalidades disponíveis nos diversos ambientes. Esse processo é chamado de codificação.

Lógica de Programação é a técnica de desenvolver algoritmos (sequências lógicas) para atingir


determinados objetivos e que depois são adaptados para a uma Linguagem de Programação utilizada
por um programador para construir seu software.

Um algoritmo não representa, necessariamente, um programa de computador, e sim os passos


necessários para realizar uma tarefa.

Para sua implementação em um computador torna-se necessário o uso de uma linguagem de


programação.

Linguagem de Programação é um método padronizado para expressar instruções para um


computador, ou seja, é um conjunto de regras sintáticas e semânticas usadas para definir um programa
de computador.

Uma linguagem permite que um programador especifique precisamente sobre quais dados um
computador vai atuar, como estes dados serão armazenados ou transmitidos e quais ações devem ser
tomadas sob várias circunstâncias.

Ou seja, Lógica de Programação (algoritmo) é a ideia, o passo-a-passo de como executar uma tarefa. A
linguagem de programação é a forma que o computador vai entender para executar a lógica
estabelecida pelo programador.

Formas de Representação do Algoritmo

Existem diversas formas de representação de algoritmos, mas não há um consenso com relação à
melhor delas.

Algumas formas de representação de algoritmos tratam dos problemas apenas em nível lógico,
abstraindo-se de detalhes de implementação muitas vezes relacionados com alguma linguagem de
programação específica. Por outro lado, existem formas de representação de algoritmos que possuem
uma maior riqueza de detalhes e muitas vezes acabam por obscurescer a idéia principal, o algoritmo,
dificultando seu entendimento.

Dentre as formas de representação de algoritmos mais conhecidas, sobressaltam:

 Fluxograma Convencional;
 Pseudocódigo, também conhecido como Linguagem Estruturada ou Portugol;
 Descrição Narrativa;
 Diagrama de Chapin.

34
1.4.2 Fluxograma

É uma representação gráfica de algoritmos onde formas geométricas diferentes implicam ações
(instruções, comandos) distintos. Tal propriedade facilita o entendimento das idéias contidas nos
algoritmos.

Fluxogramas têm o mesmo objetivo dos pseudocódigos, a única diferença é que os fluxogramas são
representações gráficas.

A vantagem principal dos fluxogramas é que, diferentemente dos pseudocódigos, eles são
padronizados. Ou seja, cada símbolo representa uma ação específica e sempre representará.

Um fluxograma usa linhas para ligar seus elementos, criando assim, um caminho que deve ser seguido.

Abaixo está uma tabela com as representações do fluxograma e o que são.

Processamento Processo Alternativo Decisão Dados

Processo Pré-definido Armazenamento Interno Documento/relatório Vários Documentos

Início/fim Preparação Entrada Manual Operação Manual

Conector Conector Fora de Página Entrada de dados Fita Perfurada

Somador Ou Agrupar Classificar

Extrair Mesclar Dados Armazenados Atraso

Armazenamento de Acesso Armazenamento de Acesso


Disco Magnético Exibir
Sequencial Direto

Apesar do número de representações assustar a princípio, a maior parte das representações são
utilizadas raramente ou não são utilizadas.

Por exemplo, raramente ou nunca utilizaremos o símbolo fita perfurada, porque não são mais utilizadas
35
aplicações que realmente necessitem de entrada de dados por fita perfurada como ocorria há 20 ou 30
anos atrás. Porém, outros são utilizados com muito mais frequência como o exibir, entrada manual,
processo e assim por diante.

Outra vantagem que os fluxogramas têm em relação aos pseudocódigos é que existem programas que
reproduzem essas representações de forma simples e intuitiva como, por exemplo, o Microsoft Visio,
o BizAgi Modeler e o open source Star UML.

Então, vejamos abaixo a representação do pseudocódigo já utilizado nesta página no formato de


fluxograma.

= Início e final do fluxograma

= Operação de entrada de dados

= Operação de saída de dados

= Operações de atribuição e chamada ou


retorno de subalgoritmo

= Decisão

Figura 2.1 Principais formas geométricas usadas em fluxogramas

36
Início

N1, N2

Média 
(N1+N2)/2

Média “Aprovado”
>=7

“Reprovado” Fim

Figura 2.2 Exemplo de um fluxograma convencional

Figura 2.3 Exemplo de cálculo de média e mensagem situação final

37
A figura 2.2 e 2.3 mostra a representação do algoritmo de cálculo da média de um aluno sob a forma
de um fluxograma.

1.4.3 Português estruturado (Pseudocódigo)

Esta forma de representação de algoritmos, também conhecida como português estruturado ou


portugol, é bastante rica em detalhes e, por assemelhar-se bastante à forma em que os programas são
escritos, encontra muita aceitação.

Na verdade, esta representação é suficientemente geral para permitir que a tradução de um algoritmo
nela representado para uma linguagem de programação específica seja praticamente direta.

A representação de um algoritmo na forma de pseudocódigo é a seguinte:

Algoritmo <nome_do_algoritmo>
<declaração_de_variáveis>
<subalgoritmos>
Início
<corpo_do_algoritmo>
Fim.

onde:
Algoritmo é uma palavra que indica o início da definição de um algoritmo em forma de pseudocódigo.

<nome_do_algoritmo> é um nome simbólico dado ao algoritmo com a finalidade de distinguí-lo dos


demais.

<declaração_de_variáveis> consiste em uma porção opcional onde são declaradas as variáveis globais
usadas no algoritmo principal e, eventualmente, nos subalgoritmos.

<subalgoritmos> consiste de uma porção opcional do pseudocódigo onde são definidos os


subalgoritmos.

Início e Fim são respectivamente as palavras que delimitam o início e o término do conjunto de
instruções do corpo do algoritmo.

Abaixo é mostrado a representação do algoritmo de cálculo da média de um aluno na forma de um


pseudocódigo.

Algoritmo Média
Var N1, N2, Média
Início
Leia N1, N2
Média := (N1+N2)/2
Se Média >= 7 Então
Escreva “Aprovado”
Senão
Escreva “Reprovado”
Fim.

38
1.4.4 Descrição Narrativa

Nesta forma de representação os algoritmos são expressos diretamente em linguagem natural.

Troca de um pneu furado:


1 – Afrouxar ligeiramente as porcas
2 – Suspender o carro
3 – Retirar as porcas e o pneu
4 – Colocar o pneu reserva
5 – Apertar as porcas
6 – Abaixar o carro
7 – Dar o aperto final nas porcas

Cálculo da média de um aluno:


1 – Obter as notas da primeira e da segunda prova
2 – Calcular a média aritmética entre as duas
3 – Se a média for maior ou igual a 7, o aluno foi aprovado, senão ele foi reprovado

Esta representação é pouco usada na prática porque o uso de linguagem natural muitas vezes dá
oportunidade a más interpretações, ambiguidades e imprecisões.

Por exemplo, a instrução “afrouxar ligeiramente as porcas” no algoritmo da troca de pneus está sujeita
a interpretações diferentes por pessoas distintas. Uma instrução mais precisa seria:

“afrouxar a porca, girando-a de 30º no sentido anti-horário”.

1.4.5 Diagrama de Chapin

O diagrama foi criado por Ned Chapin a partir de trabalhos de Nassi-Shneiderman, os quais
resolveram substituir o fluxograma tradicional por um diagrama que apresenta uma visão hierárquica e
estruturada da lógica do programa. A grande vantagem de usar este tipo de diagrama é a representação
das estruturas que tem um ponto de entrada e um ponto de saída e são compostas pelas estruturas
básicas de controle de sequência, seleção e repartição. Enquanto é difícil mostrar o embutimento e a
recursividade com o fluxograma tradicional, torna-se mais simples mostrá-lo com o diagrama de
Chapin, bem como codificá-lo futuramente na conversão de código português estruturado ou
pseudocódigos. A figura 2.3 apresenta um exemplo do tipo de diagrama de Chapin para o algoritmo de
cálculo da média de um aluno.

Início
Leia N1, N2
Média  (N1+N2)/2
Média >= 7
Sim Não
Escreva Escreva
“Aprovado” “Reprovado”

Fim

39
Figura 2.3 Diagrama de Chapin para o algoritmo do cálculo da média de um aluno
Unidade 2 – ESTRUTURA SEQUENCIAL
2.1 – Recursos para composição dos blocos lógicos

2.1.1 Tipos primitivos de Dados (algoritmos)

Todo o trabalho realizado por um computador é baseado na manipulação das informações contidas em
sua memória. Estas informações podem ser classificadas em dois tipos:

 As instruções, que comandam o funcionamento da máquina e determinam a maneira como


devem ser tratados os dados;
 Os dados propriamente ditos, que correspondem à porção das informações a serem processadas
pelo computador.

A classificação apresentada a seguir não se aplica a nenhuma linguagem de programação específica;


pelo contrário, ela sintetiza os padrões utilizados na maioria das linguagens.

Tipos Inteiros

São caracterizados como tipos inteiros, os dados numéricos positivos ou negativos. Excluindo-se
destes qualquer número fracionário.

Como exemplo deste tipo de dado, tem-se os valores: 35, 0, -56, 1024 entre outros.

Tipos Reais

São caracterizados como tipos reais, os dados numéricos positivos e negativos e números fracionários
(com decimal).

Como exemplo deste tipo de dado, tem-se os valores: 35, 0, -56, 1.2, -45.987 entre outros.

Tipos Caracteres

São caracterizados como tipos caracteres, as sequências contendo letras, números e símbolos especiais.
Uma sequência de caracteres deve ser indicada entre aspas (“ ”). Este tipo de dado também é
conhecido como alfanumérico, string, literal ou cadeia.

Como exemplo deste tipo de dado, tem-se os valores: “Programação”, “Rua Alfa, 52 Apto 1”, “Fone
574-9988”, “04387-030”, “ ”, “7” entre outros.

Tipos Lógicos (Booleano)

São caracterizados como tipos lógicos os dados com valor verdadeiro e falso, sendo que este tipo de
dado poderá representar apenas um dos dois valores. Ele é chamado por alguns de tipo booleano,
devido à contribuição do filósofo e matemático inglês George Boole na área da lógica matemática.

Os tipos de dados booleanos são cruciais em qualquer algoritmo. Os dados booleanos baseiam-se no
bit para determinar uma condição, no qual, bit 1 é true ou verdadeiro e bit 0 é false ou falso.

O conceito da aritmética booleana foi de suma importância para o desenvolvimento computacional,


observando do ponto de vista que qualquer computador trabalha com pulsos elétricos, portanto, apenas

40
tem-se dois estados com pulso (1, ligado, verdadeiro) ou sem pulso (0, desligado, falso).

2.1.2 Tipos primitivos de Dados (C/C++)

Variáveis Numéricas

• int - Números inteiros.


• double - Números reais (ponto flutuante). Precisão dupla (mais casas decimais).
• float - Números reais (ponto flutuante). Precisão simples (menos casas decimais).

Variáveis alfanuméricas:

• char/string - Caracteres alfanuméricos entre apóstrofos ("maria", "a", "quadro").

Variáveis lógicas:

• boolean - Assume apenas valores booleanos, que são: true (verdadeiro) ou false (falso).

2.1.3 Identificadores

São os nomes que podem ser dados para variáveis e funções. Para representarmos um valor que pode
variar como por exemplo os índices que medem a inflação, precisamos criar parâmetros para
representar esses valores. Os identificadores são os nomes das informações de caráter variável.
Seguem as seguintes regras de formação:

Para a escolha destes nomes é necessário seguir alguams regras:

1. Um identificador deve iniciar por uma letra ou por um "_" (underscore);


2. A partir do segundo caracter pode conter letras, números e underscore;
3. Deve-se usar nomes significativos dentro do contexto do programa;
4. C é uma linguagem case-sensitive, ou seja, faz diferença entre nomes com letras maiúsculas e
nomes com letras minúsculas. Peso e peso são diferentes;
5. Costuma-se usar maiúsculas e minúsculas para separar palavras: "PesoDoCarro";
6. Deve ser diferente dos comandos da linguagem (palavras reservadas);
7. Deve ter no máximo 31 caracteres (no caso do TurboC);
8. Pode conter números a partir do segundo caracter;

Tabela 1: Palavras Reservadas da Linguagem C++

auto break case char const continue


default do double else enum extern
float for goto if int long
main register return short signed sizeof
static struct switch typedef union unsigned
void volatile while

41
Exemplo:

Variáveis e funções.

loat salario; int numero; string nome;

float calculaMMC(){
........
}

2.1.4 Variáveis

Um dado é classificado como variável quando tem a possibilidade de ser alterado em algum instante
no decorrer do tempo, ou seja, durante a execução do algoritmo em que é utilizado, o valor do dado
sofre alteração ou o dado é dependente da execução em um certo momento ou circunstância.

Uma variável corresponde a uma posição na memória principal, isto é, um endereço que armazena um
conteúdo. Recebe valor de uma constante ou de uma outra variável ou o resultado de uma expressão. O
conteúdo de uma variável pode ser de vários tipos: inteiro, real, caracter, lógico entre outros.

Declaração de Variáveis
 Todas as variáveis tem que ser declaradas antes de serem usadas;
 Não há uma inicialização implícita na declaração

Exemplo:

Declaração

float salario;
int numero;
string nome;

Uso da variável

numero = numero + 1;

2.1.5 Constantes

Um dado é considerado como constante quando não sofre nenhuma variação no decorrer do tempo, ou
seja, seu valor é constante desde o início até o fim da execução do algoritmo.

Exemplo:

const float pi = 3,1415927

2.1.6 Operadores

Operadores são símbolos que executam várias operações sobre seus argumentos. Os operadores podem
ser aritméticos, relacionais, lógicos e de atribuição conforme demonstrado abaixo:

42
Operadores Aritméticos

• Adição ( + )
• Subtração ( - )
• Multiplicação ( * )
• Divisão ( / )
• Resto da divisão ( % )

Hierarquia dos Operadores

Nível Operador Sentido


1o Parêntese Direita/Esquerda
2o Potência Esquerda/Direita
3o Multiplicação e Divisão Esquerda/Direita
4o Adição e Subtração Esquerda/Direita
5o Operadores Relacionais
6o Operadores Lógicos

Operadores Relacionais

• Maior ( > )
• Maior ou igual ( >= )
• Menor ( < )
• Menor ou igual ( <= )
• Igual ( = ) - Algoritmo
• Igual ( == ) – C++
• Diferente ( <> ) - Algoritmo
• Diferente ( != ) – C++

Operadores de Atribuição

• Atribuição ( = ) – Algoritmo/C++
• Atribuição ( := ) – Algoritmo
• Atribuição ( <- ) - Algoritmo

Operadores de incremento

• Incremento ( ++ )
• Decremento ( -- )

Os operadores de incremento e decremento são similares à atribuição, realizando operações de adição


e subtração, respectivamente. Dessa forma, uma variável é incrementada ou decrementada em uma
unidade. Portanto essas variáveis devem ser do tipo integer e terão uso específico.

43
Operadores lógicos

• not ( ! )
• and ( && )
• or ( ll )

Expressões lógicas

Denominamos expressão lógica aquela cujos operadores são lógicos ou relacionais e cujos operandos
são relações ou variáveis ou constantes do tipo lógico. O resultado obtido de uma relação é sempre um
valor lógico.
Os operadores lógicos são de suma importância para muitas estruturas algorítmicas, principalmente, as
estruturas base de programação como são as estruturas seletivas e as estruturas de repetição.

Basicamente, os operadores lógicos se baseiam em tabelas chamadas de tabelas verdade que mostram
o resultado booleano (verdadeiro ou falso) de acordo com as comparações ou combinações.

Os símbolos de comparações variam um pouco de linguagem para linguagem, mas podemos destacar
dois grandes grupos - as linguagens baseadas em C e as linguagens baseadas em Visual Basic - embora
suas funções são sempre as mesmas.

Tabelas
Maior (>) - C/C++: >; VB: >;
20 > 10 verdadeiro
20 > 20 falso
10 > 20 falso

Menor (<) - C/C++: <; VB: <;


20 < 10 falso
20 < 20 Falso
10 < 20 Verdadeiro

Maior ou igual (≥) – C/C++: >=; VB: >=;


20 ≥ 10 Verdadeiro
20 ≥ 20 Verdadeiro
10 ≥ 20 Falso

Menor ou igual (≤) – C/C++: <=; VB: <=;


20 ≤ 10 Falso
20 ≤ 20 Verdadeiro
10 ≤ 20 Verdadeiro

Igual a (=) – C/C++: ==; VB: =;


20 = 10 Falso
20 = 20 Verdadeiro
10 = 20 Falso

44
Diferente de (≠) – C/C++: !=; VB: <>;
20 ≠ 10 Verdadeiro
20 ≠ 20 Falso
10 ≠ 20 Verdadeiro

Exemplo em C++:

if (num >= 10){


//a condição lógica será executada se a variável num for >= 10
}
else
//a condição lógica será executada se a variável num for < 10

Operadores Lógicos de Sentença

Os operadores lógicos de sentença servem para comparar uma combinação de outras comparações.
Isso é muito rotineiro em scripts SQL no qual temos que validar muitos critérios na cláusula WHERE
do comando SELECT.

Aqui, novamente podemos destacar os dois grupos de linguagens baseadas em C e Visual Basic.

E – C/C++: &&; VB: AND.


verdadeiro (E) verdadeiro verdadeiro
verdadeiro (E) falso falso
falso (E) verdadeiro falso
falso (E) falso falso

OU – C/(++: ||; VB: OR.


verdadeiro (OU) verdadeiro verdadeiro
verdadeiro (OU) falso verdadeiro
falso (OU) verdadeiro verdadeiro
falso (OU) falso falso

OU EXCLUSIVO – C/C++: ^; VB: XOR;


verdadeiro (EX_OR) verdadeiro falso
verdadeiro (EX_OR) falso verdadeiro
falso (EX_OR) verdadeiro verdadeiro
falso (EX_OR) falso falso

45
Tabelas-Verdade

Exemplo:

Para a contratação de um programador é necessário que ele conheça a Linguagem de programação C e


Pascal. ( and )

Candidato Conhece a Conhece a


Linguagem C? Linguagem Pascal? Candidato aprovado

Moisés Não Não Não


Rudimar Não Sim Não
Rogério Sim Não Não
Zilon Sim Sim Sim
Para a contratação de um programador é necessário que ele conheça a Linguagem de programação C
ou Pascal. ( or )

Candidato Conhece a Conhece a


Linguagem C? Linguagem Pascal? Candidato aprovado

Moisés Não Não Não


Rudimar Não Sim Sim
Rogério Sim Não Sim
Zilon Sim Sim Sim
Exemplo em C++:

if ((num == 10) || (num > 10)){


//a condição lógica será executada se a variável num for >= 10
}
else
//a condição lógica será executada se a variável num for < 10

if ((num > 10) && (num < 20)){


//a condição lógica será executada se a variável num for > 10 e < 20
}
else
//a condição lógica será executada se a variável num for <= 10 e >= 20

46
Endentação

A endentação está diretamente ligada a formatação de programas e tem como finalidades principais:

 Melhorar a legibilidade dos programas;


 Facilitar a manutenção posterior;
 Facilitar a identificação do erro lógico durante a execução.

A endentação deve ser utilizada para indicar que as instruções endentadas estão sob controle da
instrução anterior não-endentada. O uso consistente de endentação é essencial para legibilidade do
programa.

Exemplo:

#include <stdio.h>
#include <conio.h>
int main(){
int a;
printf (“Digite um numero: “);
scanf (“%i”,&a);
}

2.1.7 Expressões aritméticas

a) X + A / B
b) (X + A) / B
c) D – B * A + C
d) D – B * (A + C)
e)(D – B) * (A + C)
f) X + D / B + A * C * B – A
g)((X + D) / B) + (A * (C * B – A))

2.1.8 Atribuição de valores

Algoritmo
num := 5
salario = 880.00
a  100

C++
valor = 10.5
b = 300
nome = “Maria”

Include e as Bibliotecas

A linguagem C tem a capacidade de importar bibliotecas. A importância da biblioteca em C é imensa,


pois ela nos poupa de muita programação.

Uma vez que a função já está pronta dentro da biblioteca, basta importar tal biblioteca e utilizar a
função que queremos.

47
Por exemplo, se você quiser mostrar uma mensagem na tela, você não tem que produzir uma função
inteira ou criar um comando novo, basta importar uma biblioteca de I/O (entrada e saída) e utilizar
uma função dela. Quando for compilar, o compilador vai buscar nas bibliotecas tais funções para saber
como utilizá-las.

O papel do pré-processamento é indicar, antes mesmo de compilar, os parâmetros necessários para ser
criado o arquivo executável.

O pré-processamento é indicado pelo caracter sharp no início da linha e deve ser usado no início da
programação.

Importando uma biblioteca

A importação de uma biblioteca é dada pelo comando include (incluir) seguido da biblioteca entre os
sinais de menor (<) e maior (>).

Porém, devemos notar que existem diferenças entre a importação de bibliotecas de C e de C++.

Importando uma biblioteca em C

Em C, a importação de bibliotecas são mais simples, bastando acrescentar para cada biblioteca um
include em uma linha diferente e o nome da biblioteca seguido de ponto H (.h) - .h é a extensão do
arquivo da biblioteca que vem da palavra inglesa HEADER (cabeçalho) - se você esquecer de colocá-
lo o programa não será compilado.

No exemplo abaixo, vamos incluir duas bibliotecas padrões de C.

#include <stdio.h>
#include <stdlib.h>

Como podem ver, cada biblioteca foi incluída em uma linha.

Importando uma biblioteca em C++

Em C++, a importação de bibliotecas é um pouco diferente. O comando de importação continua sendo


o include, mas nesse caso, não usaremos o ponto H (.h) no final das bibliotecas legitimamente de C++.

Muitos compiladores aceitam formas híbridas de inclusão de bibliotecas, podendo misturar bibliotecas
de C e de C++.

Após importarmos uma biblioteca por linha, no final dessa lista devemos demonstrar que tipo de
funções usaremos. Na grande maioria dos casos usaremos as funções padrões de cada biblioteca.
Podemos fazer isso facilmente digitando a palavra reservada USING indicando o espaço de nome
(namespace) standard (std), que quer dizer padrão em inglês.

Não se esqueça que a palavra reservada USING necessita terminar a linha com ponto e vírgula(;).

Abaixo importaremos uma biblioteca padrão de entrada e saída de C/C++.

#include <stdlib.h> //biblioteca de C


#include <iostream> //biblioteca de C++
using namespace std;
48
As bibliotecas de C são diferentes das bibliotecas de C++. Apesar de muitos compiladores de C++
suportarem as bibliotecas de C, nenhum compilador exclusivamente de C suporta bibliotecas de C++.

Programação Básica em C++

Essencialmente, um programa C++ consiste de uma ou mais partes chamadas funções.

Além disso, um programa em C++ deve definir pelo menos uma função chamada main.

Esta função marca o ponto de início de execução do programa.

Programas C++ tem a seguinte estrutura geral:

#include <iostream>
using namespace std;

declaração de constantes
declaração de varáveis globais
definição de funções

int main(){
declaração de variáveis locais
sentenças (instruções)
}

Sentenças: simples e compostas

Cada instrução em C++ é chamada de sentença. Sentenças simples são terminadas com um ponto e
vírgula. Usando chaves, podemos agrupar sentenças em blocos, chamados de sentenças compostas.

Exemplos de sentenças incluem:

Simples:

x = 3;

Composta:

{
i = 3;
cout<< i << endl;
i = i + 1;
}

A linguagem C e C++ não possui nenhum comando de entrada e saída predefinido na linguagem.

Todas as operações de E/S são realizadas por funções que se encontram nas mais diversas bibliotecas.

As principais funções são: printf, scanf, cout e cin.

49
2.1.9 Entrada e Saída de dados

2.1.9.1 C

Comando de Entrada (scanf)

A função "scanf()" é a função de entrada formatada de dados pelo teclado.

scanf("<expressao de controle>", <lista de argumentos>);

A expressão de controle pode conter tanto códigos de formatação precedidos pelo sinal "%", que
indicam o tipo dos dados a serem lidos, como caracteres de espaçamento.

a) Códigos de formato:

 %c lê um caracter
 %d lê um inteiro decimal
 %e lê um número em notação científica
 %f lê um número de ponto flutuante
 %s lê uma string
 %u lê um decimal sem sinal
 %l lê um inteiro longo
 %lf lê um double

Exemplo:
scanf("%f",&anos);

Toda entrada correspondente um comando "scanf" deve sempre ser finalizado por <ENTER>.

Comando de Saída (printf)

A função "printf()" é a função para saída formatada de dados e funciona da seguinte forma:

Sintaxe

printf("<string de controle>",<lista de argumentos>);

O primeiro argumento é uma string entre aspas (chamada de string de controle) que pode conter tanto
caracteres normais como códigos de formato que começam pelo caracter de porcentagem.

Caracteres normais são apresentados na tela na ordem em que são encontrados. Um código de formato
informa a função "printf" que um item não caracter deve ser mostrado. Os valores correspondentes
encontram-se no segundo argumento (lista de argumentos).

Além de códigos de formato e caracteres normais a string de controle pode conter ainda caracteres
especiais iniciados pelo símbolo "\".

Exemplos:

printf("O preço é R$ %d,00",preco);

50
printf("São %d horas e %d minutos.", hora, minuto);
printf("O nome é %s.",nome);
printf("%d dividido por %d é igual a %f", n1, n2, (float)n1/n2);
printf("O código de %c é %d", letra, letra);

Códigos de formato:

Normalmente os códigos de formato são utilizados na sua forma mais simples:

 %c - caracter simples
 %d - decimal
 %ld - inteiro "longo"
 %f - ponto flutuante
 %o - octal
 %s - cadeia de caracteres
 %x - hexadecima
 %f - double

Obs.:
Deve haver uma variável ou constante para cada código de formato! O tipo das variáveis ou
constantes também deve coincidir com os códigos de formato.

int a;
float b;
char c;
double d;
printf("%d %f %c %lf",a,b,c,d);

Obs.:

Por enquanto vamos assumir que todas as variáveis da lista de argumentos, com exceção das variáveis
string, deverão ser antecedidas do operador "&". Mais adiante vamos entender a razão do operador
"&" e quando o mesmo deve ser utilizado.

Como a linguagem C não possui nenhum comando de entrada e saída incorporado à linguagem, todas
essas operações são realizadas através de funções que encontram-se nas bibliotecas da linguagem.

Para utilizar essas funções dentro do programa é necessário incluir o cabeçalho das funções no início
do programa através da diretiva de compilação #include:

2.1.9.2 C++

iostream
A linguagem C++ não possui nenhum comando de entrada e saída predefinido na linguagem. Todas as
operações de E/S são realizadas por funções que se encontram nas mais diversas bibliotecas.

A <iostream> é uma biblioteca usada para entrada e saída de dados.

A <iostream> fornece o objeto std::cout, que é usado para enviar uma mensagem para a tela.

A <iostream> fornece o objeto std::cin, que é usado para entrada de dados.

51
Sintaxe:

#include <iostream>

Objeto “cout<<”

O objeto cout representa o stream de saída no C++. Este stream é uma espécie de sequência (fluxo)
de dados a serem impressos na tela.

Para realizar a impressão, usa-se o Operador de Inserção (<<). Esse operador executa a saída (imprime
na tela) com streams em C++. O objeto cout é usado em conjunto com ele para a impressão de dados
(cout<<).

Objeto “cin>>”

O objeto cin representa o stream de entrada no C++. Ele realiza a leitura de um sequência de dados
vindas do teclado. Para coletar estes dados armazenados, usa-se o Operador de Extração (>>) que
"extrai" dados do stream (cin>>).

O que é uma stream?

Uma stream é um dispositivo lógico que representa um arquivo ou dispositivo.

system("pause")

A função system funciona como se tivéssemos digitado o que está entre aspas duplas na janela de
console. Nesse caso, pause.

system é uma função da linguagem C. Isso vai gerar uma mensagem: "pressione uma tecla
para continuar..." na tela do console.

Incluímos esta função para que o programa não encerre imediatamente após ser executado (se não
tivéssemos a incluído, o programa apareceria na tela e em segundos encerraria, logo não
conseguiriamos ler a tempo "A mensagem" gerado na janela do console.

Exemplo:

cout<< "Digite o nome do funcionario: "; //mensagem da tela


cin>> nomefuncionario; //entrada de dados

Estrutura de um Programa em C++

#include <iostream>
using namespace std;
int main(){
int n;
cout << "Digite um numero: "; //escreve na tela " Digite um numero: "
//espera o usuário digite o valor de n
//e um enter.
cin >> n; //armazena o valor digitado no objeto n
cout << "Numero digitado: " << n; //escreve na tela o numero digitado
system("pause"); // aguarda pressionar alguma tecla para
// encerrar o programa }

52
Caracteres de Espaçamento:

São considerados caracteres de espaçamento o espaço em branco, o caracter "\t" e o "\n". Sempre que
um destes surgir na string de controle de um comando "scanf" ele indicará que o mesmo deve ser
considerado como separador dos valores a serem digitados. Esses caracteres serão então lidos pelo
"scanf", porém, não armazenados.

Normalmente quando o usuário está entrando com valores atendendo a um "scanf", quando o mesmo
digita um destes caracteres de espaçamento, o mesmo é lido e não armazenado.

A diferença é que se o caracter de espaçamento aparece na string de controle, então o scanf não é
encerrado enquanto o mesmo não for digitado.

2.1.10 Comentários

Comentários são linhas ou trechos de um programa que não é analisado pelo compilador. São
utilizados para escrever observações sobre trechos do programa ou documentar alterações feitas pelos
programadores.

Em C++, quando queremos comentar uma linha usamos duas barras ( // ). Quando queremos comentar
um bloco maior usamos uma barra e um asterisco no início do bloco e asterisco barra no final do
bloco.

Exemplo:
// Para uma linha por exemplo:
/*
Para varias linhas por exemplo
usamos barras e asteriscos
*/

Exemplos de Programas em C e C++

1) Escrever um algoritmo que imprima a seguinte mensagem: ALGORITMO SÓ SE APRENDE


PRATICANDO.

Resolução em C++
#include <iostream> // Para o uso de cout e cin - c++
using namespace std;
int main(){
cout<< ("ALGORITMO SO SE APRENDE PRATICANDO");
system("pause");
}

Resolução em C
#include <conio.h> // Ativa getch
#include <stdio.h> // Controla monitor e teclado
int main(){
printf ("ALGORITMO SO SE APRENDE PRATICANDO");
getch();
}

53
Alguns de Compiladores de C e C++

Nome Gratuito Descrição


Criado pela Bloodshed, o melhor para quem é iniciante tanto na linguagem quanto
na programação. Tem suporte a projeto e boa interface com o usuário. A
Dev-C++ sim desvantagem é a impossibilidade de se criar projetos muito extensos. Apesar de
compilar a linguagem C, seu código é escrito em um código totalmente diferente - o
Delphi!
Compilador utilizado pelo projeto GNU. É padrão ANSI C e nativo do sistema Linux,
facilitando muito a vida de usuários Linux, pois não é preciso instalar compiladores
GCC sim
de terceiros. Seu único problema é a falta de uma interface, que prejudica quem é
principiante na linguagem.
O C++ Builder é um dos melhores compiladores que tem, com possibilidade de
criação de projetos extensos. A Borland mantém no site da Code Gear duas versões:
uma demo e outra paga. Ele segue o padrão ISO ou ANSI C, mas também tem muitas
C++ Builder não
bibliotecas não padrão, fazendo muitas vezes com que o programa perca a
portabilidade e o código escrito no C++ Builder não rode em outros compiladores,
mesmo que a linguagem C seja a mesma.
O visual C++ é um compilador profissional da Microsoft que compõe o pacote Visual
Studio, com vários recursos, como incremento de código, depurador de erros
avançado e outras ferramentas que aumentam a produtividade do programador. O
Visual C++ não
problema é que por ser da Microsoft tem o preço elevado e só compensará se você
for usar esta linguagem para desenvolvimento profissional em aplicações Windows.
Tem uma versão trial no site oficial.

2.1.11 Operação com Módulo

Módulo é uma operação matemática que utilizamos para obter o resto de uma divisão.
Mas, a questão é: Para que necessitamos saber o resto de uma divisão?

Por mais que seja estranho ter que obter o resto de uma divisão, no mundo algorítmico da computação,
isso faz muito sentido.

Existem muitos números que podem ser descobertos por meio do resto de divisão como números
primos, pares, ímpares, etc.

Só para dar um exemplo, um número sempre será par se ele for divisível por 2. Ou seja, se dividirmos
um número por 2 e o resto for 0, este número com certeza será par.

Veja em fluxograma:

O fluxograma acima demonstra o seguinte:

1. O usuário digita um número que será gravado na variável nr.


2. Depois, verificamos: se nr módulo de 2 (o resto de nr dividido por 2) é igual a 0.
54
3. Se for, então mostrar na tela: nr é par.
4. Caso contrário: nr é ímpar.

55
Exercícios

1) Escrever um algoritmo que imprima seu nome.

#include <iostream> // Para o uso de cout e cin - c++


using namespace std;
int main(){
cout<< ("Meu Nome e: .................");
cout<< "\n";//pular uma linha antes de imprimir a proxima
system("pause");
}

2) Ler um nome e um número do teclado e imprimi-los.

#include <iostream>
#include <string>
using namespace std;
int numero;
string nome;
int main(){
cout<< "Digite um numero: " ;
cin>> numero;
cout<< "Digite o nome ..: " ;
cin>> nome;
cout<< "\nNumero digitado: " << numero;
cout<< "\nNome digitado .: " << nome;
cout<<("\n");
system("pause");
}

3) Ler três números inteiros do teclado e imprimi-los.

4) Ler um número inteiro do teclado e imprimir seu sucessor e seu antecessor.

5) Ler do teclado matricula, nome, endereço, telefone valor da mesada e imprimi-los.

6) Ler três números inteiros do teclado e imprimir a soma. Antes do resultado, imprimir a mensagem
: SOMA.

7) Ler dois números inteiros do teclado e imprimir o produto. Mudar o tipo para decimal e fazer o
cálculo.

8) Ler um número inteiro do teclado e imprimir a terça parte deste número.

9) Entrar com dois números inteiros e imprimir o resto da divisão.

10) Entrar com dois números inteiros e imprimir a média aritmética com a mensagem : MÉDIA: antes
do resultado.

11) Ler dois valores para as variáveis A e B, efetuar a troca dos valores de forma que a variável A passe
a possuir o valor da variável B e que a variável B passe a possuir o valor da variável A. Apresentar os
valores trocados.

12) Entrar com quatro números e imprimir a média ponderada, sabendo-se que os pesos são
respectivamente: 1,2,3 e 4.
56
13) Se a poupança rende 20% ao mês e você deposita mensalmente a quantia de R$ 100,00 , após 12
meses, quanto terá acumulado ? Imprimir o valor acumulado.

Fórmula: Valor Acumulado = P * (1 + i ) n - 1

Onde :

P - aplicação mensal
i – taxa
n - número de meses.

14) Construir um algoritmo que efetue o cálculo do salário líquido de um professor. Sabendo os
dados: valor da hora aula, n° de aulas dadas no mês e percentual de desconto do INSS.

ht = horas trabalhadas no mês


vh = valor hora aula
pd = percentual de desconto
sb = salário bruto
td = total de desconto
sl = salário líquido

15) Ler uma temperatura em graus Centígrados e apresentá-la convertida em graus Fahrenheit. A
fórmula de conversão é: F ¨ (9 * C + 160) / 5. Onde F é a temperatura em Fahrenheit e C é a
temperatura em Centígrados.

16) Faça um algoritmo que leia um valor de conta de restaurante, representando o gasto realizado pelo
cliente e imprima o valor total a ser pago, considerando que o restaurante cobra 10% para o garçom.

17) Faça um algortimo que leia o valor do salário mínimo e o valor do salário de um funcionário.
Calcule e imprima quantos salários mínimos ganha o funcionário.

18) Sabendo-se que o Kilowatt de energia custa um quinto do salário mínimo, faça um algoritmo que
receba o valor do salário mínimo e a quantidade de kilowatts gasta por uma residência e calcule e
imprima:

- o valor em reais de cada kilowatt;


- o valor em reais a ser pago;
- o novo valor a ser pago por essa residência a partir de um desconto de 15%.

19) Escrever um algoritmo que receba um número inteiro do teclado. Esse número deve ser multiplicado por 5,
diminuído de 10, adicionado 30 e no final dividi-lo por 2.

57
Unidade 3 – ESTRUTURAS DE TOMADA DE DECISÃO
A estrutura if...else é a mais simples estrutura de controle do C. Esta estrutura permite executar um
entre vários blocos de instruções. O controle de qual bloco será executado será dado por uma condição
(expressão lógica ou numérica). Esta estrutura pode se apresentar de modos ligeiramente diferentes.

3.1.1 Estrutura de seleção simples (if...)

A estrutura de decisão de um bloco permite que se execute (ou não) um bloco de instruções conforme
o valor de uma condição seja verdadeiro ou falso. O fluxograma desta estrutura é mostrada na figura
5.3.

condição V

F bloco

Figura 5.3: Fluxograma da estrutura de decisão if...

Sintaxe: Decisão com um bloco:

if (condição){
bloco
}

onde:

condição é uma expressão lógica ou numérica.


bloco é um conjunto de instruções.

Se a condição verdadeira, o bloco é executado. Caso contrário, o bloco não é executado.

Exemplo:

Selecionar o aluno aprovado com média maior ou igual a 7

#include <iostream>
using namespace std;
int main(){
float media = 7;
if(media >= 7){
cout<< "O aluno esta aprovado. Sua media e: " << media << endl;
}
}

58
3.1.2 Estrutura de seleção composta (if...else)

Também é possível escrever uma estrutura que execute um entre dois blocos de instruções. A figura
5.4 mostra o fluxograma correspondente a esta estrutura de decisão.

condição?

bloco 1 bloco 2

Figura 5.4: Fluxograma da estrutura de decisão if...else

Sintaxe: Decisão de dois blocos:

if (condição){
bloco 1;
}
else{
bloco 2;
}

onde:

condição é uma expressão lógica ou numérica.

bloco 1 e bloco 2 são conjuntos de instruções.

Se a condição for verdadeira o bloco 1 é executado. Caso contrário, o bloco 2 é executado.

Exemplo:

Selecionar o aluno aprovado com média maior ou igual a 7 ou reprovado se a media for menor que 7

#include <iostream>
using namespace std;
int main(){
float media = 7;
if(media >= 7){
cout<< "O aluno esta aprovado. Sua media e: " << media << endl;
else
if(media < 7){
cout<< "O aluno esta reprovado. Sua media e: " << media << endl;
}
}

59
3.1.3 Estruturas de seleção aninhadas (if...else if...)

Também é possível escrever uma estrutura que execute um entre múltiplos blocos de instruções.

Sintaxe: Decisão de múltiplos blocos:

if(condição 1){
bloco 1;
}
else
if(condição N){
bloco N;
}
else{
bloco P
}

onde:

condição 1, condição 2, ... são expressões lógicas ou numéricas.

bloco 1 , bloco 2,... são conjuntos de instruções.

Se a condição 1 for verdadeira o bloco 1 é executado. Caso contrario, a condição 2 é avaliada.

Se a condição 2 for verdadeira o bloco 2 é executado. Caso contrario, a condição 3 é avaliada e assim
sucessivamente. Se nenhuma condição é verdadeira bloco P é executado.

Observe que apenas um dos blocos é executado.

Exemplo:

Selecionar o aluno aprovado com média maior ou igual a 7, selecionar o aluno que está em
recuperação se a média estiver entre 4 (inclusive) e menor que 7 ou se o aluno aluno está reprovado
se a média é menor que 4.

#include <iostream>
using namespace std;
int main(){
float media = 7;
if(media >= 7){
cout<< "O aluno esta aprovado. Sua media e: " << media << endl;
else
if(media < 4){
cout<< "O aluno esta reprovado. Sua media e: " << media << endl;
else
if(media >= 4) && (media < 7 ){
cout<< "O aluno esta em recuperacao. Sua media e: " << media
<< endl;
}
}

60
Exercícios Estrutura de Seleção

1) Faça um programa em C++ que leia duas notas, calcule a média e imprima a seguinte mensagem:

Aprovado: nota maior ou igual a 7;


Reprovado: nota menor que 5;
Prova final: nota menor que 7 e maior ou igual a 5;

#include "iostream"
#include "string"
using namespace std;
int main(){
float nota1,nota2,media;
string nome;
cout<< ("Digite o nome do aluno: ");
cin>> nome; fflush (stdin);
cout<< ("Digite a primeira nota: ");
fflush (stdin);
cin>> nota1;
cout<< ("Digite a segunda nota : ");
cin>> nota2;
media = (nota1 + nota2) / 2;
cout<< "Media: " << media << endl;
if (media < 5)
cout<< ("Reprovado");
else
if (media >= 7)
cout<< "Aprovado" << endl;
else
cout<< "Recuperacao" << endl;
system("pause");
}

2) Considerando que prefeitura multou carros estacionados irregularmente, faça um programa em


C++ para calcular o valor da multa. Carros com data de fabricação até 2000 o percentual da multa será
de 1,5% de seu valor, acima deste ano o percentual será de 3,5%. Calcular e imprimir o valor da multa.

#include "iostream"
#include "string"
using namespace std;
void main(){
int i,anof; float vlrveic,vlrmulta;
cout<< ("Digite o ano de fabricacao do veiculo: ");
cin>> anof; fflush (stdin);
cout<< ("Digite o valor do veiculo ...........: ");
cin>> vlrveic;
if (anof < 2000)
vlrmulta = vlrveic * 0.015;
else
vlrmulta = vlrveic * 0.035;
cout<< "\n";
cout<< "========= Multa Calculada ==========" << endl;
cout<< "Ano fabricacao do veiculo: " << anof << endl;
cout<< "Valor do veiculo ........: " << vlrveic << endl;
cout<< "Valor da multa ..........: " << vlrmulta << endl;
system("pause");
}
61
1) Com base nos dados informados: vlrsal e tabela do inss faça um algoritmo para calcular o salário
líquido de um trabalhador:
Tabela do INSS

Faixa Salarial Percentual


De 0,00 a 500,00 8%
De 500,01 a 1000,00 9%
De 1000.01 a 2400,00 11%
Acima de 2400,00 valor fixo 264.00

Obs.
Salário líquido = valor do salário – inss

Ao final imprimir na tela o vlr-salário, inss e salário liquido.

2) Com base no exercício anterior (4) incluir cálculo do imposto de renda (irrf).

Obs.
Percentual do imposto de renda: 10%
Valor do desconto padrão: 100.00
Irrf = (valor do salário – valor do inss) * percentual – desconto padrão
Salário líquido = valor do salário – inss - irrf

3) Faça um algoritmo para verificar se um número inteiro lido é par ou ímpar.

4) Ler dois números distintos e imprimir o maior.

5) Ler três números, somá-los e imprimir o resultado caso seja maior que 10.

6) Faça um algoritmo que calcule a subtração de dois números inteiros positivos. Se o resultado for
positivo, imprima-o.

7) Desenvolver um algoritmo para ler dois números inteiros e verificar se o resto da divisão entre eles
é maior que 12. Se isto ocorrer imprimir o resto.

8) Faça um algoritmo que leia dois números inteiros e identifique se os mesmos são iguais ou
diferentes. Caso eles sejam iguais imprima uma mensagem dizendo que eles são iguais. Caso
contrário, diga qual dos dois números é o maior.

9) Fazer um algoritmo para ler três números e imprimir o maior deles.

10) Fazer um algoritmo para imprimir em ordem decrescente 3 números lidos.

11) Desenvolver um algoritmo para ler um número, verificar e imprimir se o mesmo é nulo, positivo
ou negativo.
12) Se considerarmos que o numero 1 representa DOMINGO e que 7 representa SÁBADO,
desenvolva um algoritmo para ler um determinado número e imprimir qual o dia correspondente da
semana.
13) Desenvolva um algoritmo para ler o nome e as quatro notas bimestrais de um aluno e imprimir se o
mesmo foi aprovado, considerando-se que a media para aprovação deve ser no mínimo igual a 6.

62
14) O preço de uma transportadora é composto por duas parcelas: Distância e peso. Baseado nas
tabelas abaixo, faça um algoritmo que leia uma relação de distância e peso e forneça o valor do frete
para cada caso. Encerre a leitura quando a distância for igual a zero.
15) Com base nos dados informados: vlrsal, percentual do imposto de renda e o desconto padrão e
tabela do inss.
De 0,00 a 500,00 – 8%
De 500,01 a 1000,00 – 9%
De 1000.01 a 2400,00 - 11%
Acima de 2400,00 – valor fixo 264.00

16) faça um algoritmo para calcular o salário de um trabalhador: Ao final imprimir na tela o vlr-
salário, inss, irrf e salário líquido.
17) Um determinado material radioativo perde metade da sua massa a cada 50 segundos. Dada a massa
inicial em gramas, faça um algoritmo que determine o tempo necessário para que essa massa se torne
menor do que 0,5 grama. Escreva a massa inicial, a massa final e o tempo calculado em horas, minutos
e segundos.

18) Fazer um algoritmo que leia três notas de um aluno e mostre:


- a média aritmética das notas
- a situação final do aluno considerando-se que:

aprovado: media > = 7 prova final: media > = 4 e media < 7 reprovado: media < 4

19) Fazer um algoritmo para ajudar no cálculo do salário de um funcionário.

Deverá ser informado: nome do funcionário, salário bruto, número de dependentes


Deverá ser impresso: nome do funcionário e salário líquido
Considere a seguinte regra para o cálculo:

Salário Líquido = Salário Bruto - Desconto INSS + (15,00 * Número de Dependentes) +


Auxílio Passagem (40,00) + Auxílio Refeição (100,00)

Salário Bruto Desconto INSS


(Percentual sobre o Salário
Bruto)
Até 300 8%
Acima 300 até 700 9%
Acima de 700 10%

20) Considere que uma empresa queira dar um aumento salarial a um funcionário. Deste funcionário, a
empresa possui as seguintes informações: seu nome, idade e salário base. O procedimento adotado
para o cálculo de aumento do salário é o seguinte:

1) Reajustar o salário base do funcionário em 30% se ele tem mais de 30 anos ou 20% caso
contrário;
2) Conceder uma gratificação de 20% sobre o salário já reajustado;

21) Efetuar descontos de 15% sobre o salário já reajustado e sem a concessão da gratificação. Deverão
ser impressos o nome e o novo salário do funcionário na sua forma bruta (aumento + gratificação) e
líquida (aumento + gratificação - descontos).
63
22) Fazer um algoritmo que leia o valor máximo em dólares que um turista pode comprar no exterior e
o valor das compras apurado pela receita federal quando de sua chegada ao Brasil. Informar se o turista
está liberado ou se o valor comprado excedeu o valor permitido.

23) Suponha que a Universidade possua a seguinte tabela de valores de créditos por curso;

Curso Valor do Crédito


PD 12,00
ADM 10,00
CONTAB 15,00
CIÊNCIAS 18,00

24) Faça um algoritmo que leia o nome de um aluno, curso que o mesmo está matriculado e o número
de créditos que ele está cursando e calcule a mensalidade a ser paga pelo aluno. Deverão ser impressos
o nome do aluno, seu curso e o valor da mensalidade a pagar.

25) Faça um algoritmo que leia o código do departamento em que um funcionário trabalha (1-
secretaria, 2-tesouraria, 3-depto pessoal, 4-almoxarifado), seu nome, salário base e o tempo de serviço.
O algoritmo deverá então calcular e imprimir o novo salário base do funcionário conforme as
condições abaixo:

Departamento Tempo de Serviço % de


Aumento
Secretaria < 4 anos 50%
Ou >= 4 anos 60%
Tesouraria
Depto Pessoal Ate 3 anos 30%
>= 3 anos 35%
Almoxarifado >= 2 anos e < = 4 40%
anos 50%
> 4 anos

Deverão ser impressos o nome do funcionário, seu salário antigo e o novo salário.

26) Fazer um algoritmo que leia duas notas do teclado. Calcular a média e imprimir a situação do aluno.

Nota >= 7 aprovado


Nota < 4 reprovado
Nota >= 4 e < 7 Prova final

27) Faça um algoritmo que imprima o nome do aluno, seu conceito e o resultado final.. O programa
deve ler o nome do aluno, suas 3 notas, juntamente com seus 3 pesos e calcular a média ponderada do
aluno de acordo com a fórmula abaixo:

(p1 * nota1) + ( p2 * nota2) + (p3 * nota3) / ( p1+ p2 + p3)

Após o cálculo da média, o algoritmo deverá verificar o conceito final do aluno e indicar sua
aprovação ou não, conforme a tabela abaixo:

Média Conceito Resultado


9.00 - 10.00 A Aprovado

64
7.50 - 8.99 B Aprovado
6.00 - 7.49 C Aprovado
5.00 - 5.99 D Reprovado
0.00 - 4.99 E Reprovado

3.1.5 Estrutura de múltipla escolha (switch...case)

Switch e Case

Uma outra forma de estrutura seletiva é o SWITCH. Dentro dos switch há o case (que significa caso).
Ou seja, é quase que um if com várias possibilidades, mas com algumas diferenças importantes.

1a diferença: Os cases não aceitam operadores lógicos. Portanto, não é possível fazer uma
comparação. Isso limita o case a apenas valores definidos.

2a diferença: O switch executa seu bloco em cascata. Ou seja, se a variável indicar para o primeiro
case e dentro do switch tiver 5 cases, o switch executará todos os outros 4 cases a não ser que
utilizemos o comando para sair do switch. (Nos referimos ao BREAK).

Agora, que conhecemos diferenças importantes, vamos ver como proceder com o switch / case.

Primeiro o comando SWITCH e entre parênteses a váriavel na qual está guardado o valor que será
avaliado pelo case. Então, abre-se o bloco de dados. Dentro do bloco de dados colocamos o comando
CASE e logo após um valor terminando a linha com dois pontos (:). Preste atenção no tipo de dado que
será colocado, pois há diferenças entre um dado e outro. Por exemplo: 1 não é a mesma coisa que '1' e
'a' não é a mesma coisa que 'A'...

Então, é estruturado os comando que serão executados pelo case.

Estruturadamente, seria isso:

switch (variável){
case valor1: dados a serem executados
break;
case valor2: dados a serem executados
break;
default: cout<< "Opçao invalida!" << endl;
break;
}

O valor de expressão é avaliado e o fluxo lógico será desviado para o conjunto cujo rótulo é igual ao
resultado da expressão e todas as instruções abaixo deste rótulo serão executadas. Caso o resultado da
expressão for diferente de todos os valores dos rótulos então conjunto d é executado. Os rótulos devem
ser expressões constantes inteiras diferentes entre si. O rótulo default é opcional.

Esta estrutura é particularmente útil quando se tem um conjunto de instruções que se deve executar em
ordem, porém se pode começar em pontos diferentes.

65
Em fluxograma:

expr essão

r otulo 1

c onjunt o 1

r ot ulo 2

c onjunto 2

.. .

r otulo N

c onjunt o N

r otulo D

c onjunt o D

Figura 5.6: Fluxograma da estrutura switch...case.

A expressão ou variável no comando case deve ser do tipo simples, normalmente char ou int.

Após a avaliação da expressão, seu valor ou o valor da variável é comparado com os diversos valores
discriminados. Se houver algum que satisfaça, o comando subsequente será executado.

Exemplo1:

#include "iostream"
using namespace std;
int main(){
int opcao;
cout<< "************* Menu de Opcoes **************" << endl << endl;
cout<< "1 - Inclusao " << endl;
cout<< "2 - Alteracao" << endl;
cout<< "3 - Consulta " << endl;
cout<< "4 - Exclusao " << endl;
cout<< "Digite a Opcao: ";
cin>> opcao;
switch (opcao){
case 1:
cout<< "Inclusao" << endl;
break;
case 2:
cout<< "Alteracao" << endl;
break;
default: cout<< "Opçao invalida!" << endl;
break;
}
system("pause");
}

66
Exemplo2:

Calcular a soma, ou a subtração, ou a multiplicação, ou a divisão entre dois números lidos do teclado.

#include "iostream"
#include "string"
using namespace std;
int main(){
char operador;
int num1,num2;

cout<< "Valor de num1 = ";


cin>> num1;

cout<< "Valor de num2 = ";


cin>> num2;

cout<< ("Digite o Operador (+, -, * ou /): ");


cin>> operador;

switch(operador){
case '+': cout<< "num1 + num2 = " << (num1 + num2) << endl;
break;
case '-': cout<< "num1 - num2 = " << (num1 - num2) << endl;
break;
case '*': cout<< "num1 * num2 = " << (num1 * num2) << endl;
break;
case '/': cout<< "num1 / num2 = " << (num1 / num2) << endl;
break;
default: cout<< "Nao e operador!" << endl;
}
system("pause");
}

Interrupção e Desvio: break, continue, goto, exit()

As instruções vistas anteriormente podem sofrer desvios e interrupções em sua sequência lógica
normal através do uso certas instruções. As instruções que veremos a seguir devem ser usadas com
muita parcimônia, pois fogem da lógica estruturada tem a tendência de tornar um programa
incompreensível.

A Instrução break

Esta instrução serve para terminar a execução das instruções de um laço de repetição (for, do...while,
while) ou para terminar um conjunto switch...case.

Quando em um laço de repetição, esta instrução força a interrupção do laço independentemente da


condição de controle.

Exemplo:

No trecho abaixo um laço de repetição lê valores para o cálculo de uma média. O laço possui uma
condição de controle sempre verdadeira o que, a princípio, é um erro: laço infinito.

Porém, a saída do laço se dá pela instrução break que é executada quando um valor negativo é lido.
67
cout<< "digite valores: ";
do{
cout<< "valor:";
cin>> val;
if(val < 0.0){
break; // saída do laço
}
num++;
soma += val;
}while(1); // sempre verdadeiro

cout<< "média: " << (soma/num);

Exemplo: No exemplo acima, o uso da instrução break poderia ter sido evitado, como segue:

cout<< "digite valores: ";


do{
cout<< "valor: ";
cin>> val;
if(val >= 0.0){
num++;
soma += val;
}
}while(val >= 0.0);

cout<< "média: " << (soma/num);

A Instrução continue

Esta instrução opera de modo semelhante a instrução break dentro de um laço de repetição.

Quando executada, ela pula as instruções de um laço de repetição sem sair do laço. Isto é, a instrução
força a avaliação da condição de controle do laço.

Exemplo:

No trecho abaixo revemos um laço de repetição lê valores para o cálculo de uma média. Se (val < 0.0)
então o programa salta diretamente para a condição de controle, sem executar o resto das instruções.

cout<< "digite valores: ";


do{
cout<< "valor: ";
cin>> val;
if(val < 0.0){
continue;
}
num++;
soma += val;
}while(val >= 0.0);

cout<< "média: " << (soma/num);

68
A Instrução goto

Esta instrução é chamada de desvio de fluxo. A instrução desvia o programa para um rótulo (posição
identificada) no programa. São raros os casos onde a instrução goto é necessária, no entanto, há certas
circunstâncias, onde usada com prudência, ela pode ser útil.

Sintaxe: A sintaxe da instrução goto é a seguinte:

goto rótulo;
...
rótulo:
onde rótulo é um identificador válido.

Exemplo:

No trecho abaixo revemos um laço de repetição lê valores para o cálculo de uma média. Foram usadas
duas instruções goto.

cout "digite valores: ";


inicio: // rótulo
cout<< "valor: ";
cin>> val;
if(val < 0.0){ // se val é negativo...
goto fim; // ...salta para fim
}
num++; // se (val < 0.0) estas instruções
soma += val; // não são executadas!
goto inicio; // salta para inicio
fim: // rótulo
cout<< "média: " << (soma/num);

A Função exit()

Esta função (não instrução) exit() , da biblioteca stdlib.h, é uma função que termina a execução de um
programa. Normalmente um programa é terminado quando se executa a última sua instrução, porém
pode-se terminar a execução do programa a qualquer momento com o uso desta função.

A função exit() tem a seguinte declaração: void exit(int status). Onde o argumento da função é um
valor inteiro que será passado para o Sistema Operacional: (variável de sistema errorlevel no DOS).

Exemplo: No trecho abaixo revemos um laço de repetição lê valores para o cálculo de uma média. Foi
usado a função exit para terminar a execução do programa.

cout<< "digite valores: ";


do{
cout<< "valor: ";
cin>> val;
if(val < 0.0){ // se val é negativo...
cout<< "média: " << (soma/num); // imprime resultado
exit(0); // termina programa
}
num++;
soma += val;
}while(1);

69
Exercícios - switch...case

1) Se considerarmos que o numero 1 representa DOMINGO e que 7 representa SÁBADO, desenvolva


um algoritmo para ler um determinado número e imprimir qual o dia correspondente da semana.

2) Faça um algoritmo para verificar se um número inteiro lido é par ou ímpar.

3) Fazer um algoritmo que crie um menu com as seguintes opcões:

1 – Cadastramento de Aluno;
2 – Lancamento de Notas;
3 – Inclusao de Plano de Estudos;
4 – Alteracao de Plano de Estudos;
5 – Alteracao de Dados Cadastrais
6 – Encerra;
Escolha a Opcao:

4) Fazer um algoritmo que tenha um menu com as seguintes opções:

1 – Cálculo da Média dos Alunos


2 – Somatório de Salários
3 – Encerra
Escolha a Opção:

Pede-se:
1 – Usar a instrução case para testar e executar as opções;
2 – Criar rotina para calcular a média de duas notas;
3 – Criar rotina para somar o salário de 2 funcionários.

5) Calcular a soma, ou a subtração, ou a multiplicação, ou a divisão entre dois números lidos do


teclado.

70
Unidade 4 – ESTRUTURAS DE REPETIÇÃO
As estruturas de repetição permitem executar mais de uma vez um mesmo trecho de código.

Trata-se de uma forma de executar blocos de comandos somente sob determinadas condições, mas
com a opção de repetir o mesmo bloco quantas vezes for necessário.

As estruturas de repetição são úteis, por exemplo, para repetir uma série de operações semelhantes que
são executadas para todos os elementos de uma lista ou de uma tabela de dados, ou simplesmente para
repetir um mesmo processamento até que uma certa condição seja satisfeita.

4.1 – Repetição com Variável de Controle (for)

Este comando permite que um grupo de operações ou comandos sejam repetidos um certo número de
vezes.

Sintaxe geral:

for (inicialização; condição; incremento){


bloco de instruções;
}

onde:

inicialização é uma expressão de inicialização do contador.


condição é uma expressão lógica de controle de repetição.
incremento é uma expressão de incremento do contador.
bloco é um conjunto de instruções a ser executado.

A variável de controle deverá ser, obrigatoriamente, do tipo int. A variação, o valor inicial e valor final
será crescente e de um em um, quando utilizamos o operador de incremento ++, e decrescente de um
em um, quando utilizamos o operado de decremento --.

Esta estrutura executa um número determinado de repetições usando um contador de iterações. O


contador é inicializado na expressão de inicialização antes da primeira iteração.

Por exemplo: i = 0; ou cont = 20;

Então o bloco é executado e depois de cada iteração, o contador é incrementado de acordo com a
expressão de incremento.

Por exemplo: i++ ou cont -= 2.

Então a expressão de condição é avaliada: se a condição for verdadeira, o bloco é executado


novamente e o ciclo recomeça, se a condição é falsa termina-se o laço. Esta condição é, em geral, uma
expressão lógica que determina o ultimo valor do contador.

Por exemplo: i <= 100 ou cont > 0.

Exemplo: No trecho abaixo, o contador i é inicializado com o valor 1. O bloco é repetido enquanto a
condição i <= 10 for verdadeira. O contador é incrementado com a instrução i++.
71
Esta estrutura, deste modo, imprime os números 1, 2, ..., 9, 10.

for(i=1; i<=10; i++){


printf(" %d",i);
}

Em fluxograma:

Exemplos:

Programa que calcula e imprime números pares e impares. Ele exemplifica o uso da estrutura for.

#include <iostream>
using namespace std;
int main(){
int i; // contador de iteracao
int num; // numero de valores lidos
cout<< "Digitacao de numeros reais..." << endl;
cout<< "Repetir quantas vezes? ";
cin>> num;
for(i = 1; i <= num; i++){
if(i % 2 == 0)
cout<< "Numero par .: " << i << endl;
else
cout<< "Numero impar: " << i << endl;
}
system("pause");
}

72
2) Leia 20 valores reais e escreva o seu somatório.

#include <iostream>
using namespace std;
int main(){
int i, num; int somatorio = 0;
for(i=0; i < 20; i++){
cout<< "Digite um numero: ";
cin>> num;
somatorio = somatorio + num;
}
cout<< "Somatorio dos numeros: " << somatorio << endl;
system("pause");
}

3) Faça um algoritmo para somar os restos da divisão por 3 de 5 números.

#include <iostream>
using namespace std;
int main(){
int i, num, resto; int totresto = 0;
for(i=0; i < 3; i++){
cout<< "Digite um numero: ";
cin>> num;
resto = num % 3;
totresto = totresto + resto;
}
cout<< "Somatorio do resto: " << totresto << endl;
system("pause");
}

73
4.1.1 Exercícios - for

1) Fazer um algoritmo para ler 5 números inteiros do teclado.

2) Imprimir os 50 primeiros números inteiros maiores que 0.

3) Imprima os números pares de 2 a 100.

4) Ler nome e duas notas de 5 alunos. Calcular a média ponderada e imprimir o nome, a média e a
seguinte mensagem:

Se nota < 4
“Reprovado”
se nota >= 7
“Aprovado”
se >= 4 e < 7
“Prova Final”
Obs.
Os pesos são: Pr1 = 2 e Pr2 = 3

5) Em uma turma com 15 alunos deseja-se saber o valor total de bolsas concedidas. Faça um algoritmo
que leia a matricula, o nome e o valor da mensalidade. O percentual da bolsa corresponde a 16% do
valor da mensalidade.

6) Considerando que 10 carros foram rebocados pela prefeitura e que todos foram multados, calcular o
valor das multas. Carros com data de fabricação anterior a 2000 o percentual da multa será de 1,5% de
seu valor, os outros 3,5%. Calcular e imprimir o valor das multas.

Obs.
Ao final informar o valor total das multas aplicadas.

7) Com base no exercício anterior, imprimir a chapa, o ano e a multa do veículo com multa superior a
3000.00.

8) Para cada nota de compra, tem-se o Nome do produto comprado, o valor e o imposto. Faça um
algoritmo que escreva o valor total do produto, o valor total do imposto e o valor total cobrado de
todas as notas. Considere 10 notas fiscais.

9) Um comerciante deseja fazer um levantamento do estoque de 100 das suas mercadorias. Para isto
fez uma lista onde cada linha possui o nome e o preço de venda das mercadorias. Faça um algoritmo
que leia estas informações e escreva quantas mercadorias apresentam:

preço de até 10.00


preço entre 10.01 e 20.00
preço acima 20.00

10) Considerando uma turma de 60 alunos, faça um algoritmo que, dados o nome e a nota de cada
aluno, informe o nome dos alunos que tiraram respectivamente a maior e a menor nota.

11) Ler uma sequência de 10 números inteiros e imprimir o maior.

12) Faça um algoritmo ler 12 números e verificar se o número inteiro lido é par ou ímpar.

74
13) Fazer um algoritmo para ajudar no cálculo do salário de 5 funcionários. Deve ser informado: nome
do funcionário, salário bruto, número de dependentes. Deve ser impresso: nome do funcionário e
salário líquido

Considere a seguinte regra para o cálculo:

Salário Líquido = Salário Bruto - Desconto INSS + (15,00 * Número de Dependentes) +


Auxílio Passagem (40,00) + Auxílio Refeição (100,00)

Salário Bruto Desconto INSS (Percentual


sobre o Salário Bruto)
Até 300 8%
Acima de 300 até 700 9%
Acima de 700 10%

14) Faça um algoritmo que leia dois números inteiros e identifique se os mesmos são iguais ou
diferentes. Caso eles sejam iguais imprima uma mensagem dizendo que eles são iguais. Caso
contrário, diga qual dos dois números é o maior. Processar essa rotina 10 vezes.

15) Fazer um algoritmo que leia o valor máximo em dólares que 30 turistas podem comprar no exterior
e o valor das compras apurado pela receita federal quando de sua chegada ao Brasil. Informar se o
turista está liberado ou se o valor comprado excedeu o valor permitido.

16) Faça um algoritmo que leia um valor de conta de restaurante, representando o gasto realizado pelos
90 clientes e imprima o valor total a ser pago considerando que o restaurante cobra 10% para o
garçom.

17) Faça um algoritmo que leia o valor de um depósito e o valor da taxa de juros de 30 correntistas de
um banco. Calcule e imprima o valor do rendimento e o valor total depois do rendimento.

18) Faça um algoritmo que leia uma série de 5 números e imprima a média aritmética dos ímpares e a
soma dos pares.

19) Uma loja recebeu pagamentos de 15 clientes e deseja organizar estes dados. Faça um algoritmo que leia o
código do cliente, o sexo do cliente, produto comprado, qtde vendida e preço por cada um destes clientes. O
algoritmo deve apresentar as seguintes informações:
1 – Valor total do faturamento da loja;
2 – Valor do faturamento pago por homens;
3 – Valor do faturamento pago por mulheres;

20) Considerando uma turma de 60 alunos, faça um algoritmo que, dados o nome e a nota de cada
aluno, informe o nome dos alunos que tiraram respectivamente a maior e a menor nota.

21) Um comerciante deseja fazer um levantamento do lucro de 100 das suas mercadorias. Para isto fez
uma lista onde cada linha possui o nome, o preço de compra e o preço de venda das mercadorias. Faça
um algoritmo que leia estas informações e escreva quantas mercadorias apresentam:

lucro de até 10%


lucro entre 10% e 20%
lucro maior que 20%

75
Informar também o valor total de compra e de venda das mercadorias.

22) Em uma turma com 55 alunos deseja-se saber o valor total de bolsas concedidas. Faça um
algoritmo que leia a matricula, o nome e o valor da mensalidade. O percentual da bolsa corresponde a
16% do valor da mensalidade.

23) Considerando que 50 carros foram rebocados pela prefeitura e que todos foram multados, calcular
o valor das multas. Carros com data de fabricação anterior a 2000 o percentual da multa será de 1,5%
de seu valor, os outros 3,5%. Calcular e imprimir o valor das multas.

Obs.
O valor da multa é diário.

24) Com base no exercício anterior, imprimir a chapa, o ano e a multa do veículo com multa superior a
3000.00.

76
4.2 – Repetição com Teste no Início (while)

A estrutura while permite controlar o número de vezes que uma instrução ou bloco de instruções será
executado. A expressão lógica é avaliada antes da primeira interação, isto significa que,
eventualmente, pode não ocorrer sequer a primeira interação.

A sintaxe de while é:

while(expressão_lógica){
instruçoes;
}

Os loops servem para executar um comando ou script repetidamente.

O loop "enquanto" (while) executa um comando (ou vários) enquanto uma condição for verdadeira.

Em fluxograma:

Exemplos:

1) Fazer um algoritmo para ler N números inteiros do teclado, diferentes de 999. A leitura termina com
a leitura do número 999.

#include <iostream>
using namespace std;
int main(){
int num;
cout<< "Digite um numero (999-Encerra): ";
cin>> num;
while ( num != 999) {
cout<< "Digite um numero (999-Encerra): ";
cin>> num;
}
system("pause");
}

77
2) Fazer um algoritmo para ler números inteiros positivos do teclado e informar se o número é par ou
impar, a quantidade de números pares, a quantidade de números impares e a quantidade total de
números digitados. A digitação se encerra quanto for digitado o número -1.

#include <iostream>
using namespace std;
int main(){
int num, resto;
int qtdepar = 0; int qtdeimpar = 0; int qtdetotal = 0;
cout<< "Digite um numero (-1-Encerra): ";
cin>> num;
while ( num != -1){
resto = num % 2;
if (resto == 0){
cout<< "O numero digitado e par" << endl;
qtdepar++;
}
else{
cout<< "O numero digitado e impar" << endl;
qtdeimpar++;
}
qtdetotal++;
cout<< "Digite um numero (-1-Encerra): ";
cin>> num;
}
cout<< endl;
cout<< "Qtde numeros pares .: " << qtdepar << endl;
cout<< "Qtde numeros impares: " << qtdeimpar << endl;
cout<< "Qtde total .........: " << qtdetotal << endl;
cout<< endl;
system("pause");
}

3) Faça um algoritmo para ler e escrever o Nome, idade e sexo de um número indeterminado de
alunos. Ao final escreva o total de alunos lidos.

#include <iostream>
#include <string>
using namespace std;
int main(){
int qtdelidos = 0; string nome, sexo; int idade;
cout<< "Digite o nome do aluno (fim-Encerra): ";
getline (cin,nome);
while (nome != "fim"){
cout<< "Digite o sexo do aluno .............: ";
getline (cin,sexo);
cout<< "Digite a idade do aluno ............: ";
cin>> idade;
fflush (stdin);
qtdelidos++;
cout<< "Digite o nome do aluno (fim-Encerra): ";
getline (cin,nome);
}
cout<< endl;
cout<< "qtde de alunos lidos: " << qtdelidos << endl;
system("pause");
}
78
4.2.1 Exercícios - while

1) Fazer um algoritmo para ler nome e duas notas do teclado. Calcular a media a e imprimir a
mensagem abaixo. A leitura termina com a leitura do nome igual a “fim” ou “FIM”.

Nota < 4
“Reprovado”
Nota >= 7
“Aprovado”
Nota > 4 e <= 7
“Prova final”

2) Ler a média dos alunos de uma turma. Imprimir a maior média. A leitura termina com a leitura da
média = –1.0.

3) Ler a média dos alunos de uma turma. Imprimir a menor média. A leitura termina com a leitura da
média = –1.0.

4) Fazer um algoritmo que leia o valor máximo em dólares que um número indefinido de turistas
podem comprar no exterior e o valor das compras apurado pela receita federal quando de sua chegada
ao Brasil. Informar se o turista está liberado ou se o valor comprado excedeu o valor permitido, total
das compras e a quantidade de turistas.

5) Dado um número indeterminado de funcionários, onde é fornecido o nome, número de dependentes


e o número de horas trabalhadas. Pede-se que seja impresso, para cada funcionário, o seu Nome,
salário bruto, salário líquido e o valor descontado. A empresa, paga R$ 25,00 por hora de trabalho, e
R$ 5,55 por dependente, e ainda faz um desconto de 12% sobre o salário bruto. Pede-se ainda que seja
impresso o total de funcionários da empresa, o total gasto com salários, e o total descontado.

6) Dado um conjunto de n registros cada registro contendo um valor real, faça um algoritmo que
calcule a média dos valores maiores que 4.

7) Dado Nome e salário de um número indeterminado de funcionários, imprima o Nome e o salário de


funcionário que tem o maior salário, bem como o Nome e o salário que possui o menor salário.

8) Faça um algoritmo que calcule o salário e o imposto de renda de um grupo de pessoas,


considerando:

a) Para cada pessoa tem-se: Nome, Número de Dependentes, Renda Bruta Anual;
b) O imposto é calculado segundo a tabela abaixo:

Renda Liquida % até R$ 10.000,00 isento


> R$ 10.000,00 até R$ 30.000,00 5%
> R$ 30.000,00 até R$ 60.000,00 10%
> R$ 60.000,00 15%

c) Há um desconto de R$ 600,00 para cada dependente.


d) Sendo que a renda liquida é igual a renda bruta menos o abatimento de cada dependente.

9) O Departamento de trânsito do estado anotou dados de acidentes de trânsito no ultimo ano. Para
cada motorista envolvido no acidente, têm-se as seguintes informações:

79
- Ano de nascimento;
- Sexo (M - Masculino, F - Feminino);
- Procedência (0 - Capital, 1 - Interior, 2 - Outro estado);

Faça um algoritmo que:

a) Calcule a porcentagem de motoristas com menos de 21 anos;

b) Calcule quantas mulheres são da capital;

c) Calcule quantos motoristas do interior do estado tem idade maior que 60 anos;

d) Verifique se existe alguma mulher com idade maior que 60 anos;

10) Um comerciante deseja fazer um levantamento do estoque de suas mercadorias. Para isto fez uma
lista onde cada linha possui o nome e o preço de venda das mercadorias. Faça um algoritmo que leia
estas informações e escreva quantas mercadorias apresentam:
preço de até 10.00
preço entre 10.01 e 20.00
preço acima 20.00

Obs
A leitura termina com nome da mercadoria igual a “fim”.

11) Ler uma sequência de n números inteiros e imprimir o maior.

12) Faça um algoritmo ler n números e verificar se o número inteiro lido é par ou ímpar.

13) Fazer um algoritmo para ajudar no cálculo do salário de vários funcionários. Deve ser informado:
nome do funcionário, salário bruto, número de dependentes. Deve ser impresso: nome do funcionário e
salário líquido

Considere a seguinte regra para o cálculo:

Salário Líquido = Salário Bruto - Desconto INSS + (15,00 * Número de Dependentes) +


Auxílio Passagem (40,00) + Auxílio Refeição (100,00)

Salário Bruto Desconto INSS (Percentual


sobre o Salário Bruto)
Até 300 8%
Acima de 300 até 700 9%
Acima de 700 10%

14) Faça um algoritmo que leia dois números inteiros positivos e identifique se os mesmos são iguais
ou diferentes. Caso eles sejam iguais imprima uma mensagem dizendo que eles são iguais. Caso
contrário, diga qual dos dois números é o maior. O Algoritmo pára quando for digitado –1.

15) Fazer um algoritmo que leia o valor máximo em dólares que vários turistas podem comprar no
exterior e o valor das compras apurado pela receita federal quando de sua chegada ao Brasil. Informar
se o turista está liberado ou se o valor comprado excedeu o valor permitido.
80
16) Faça um algoritmo que leia um valor de conta de restaurante, representando o gasto realizado pelos
clientes e imprima o valor total a ser pago considerando que o restaurante cobra 10% para o garçom.

17) Faça um algoritmo que leia o valor de um depósito e o valor da taxa de juros dos correntistas de
um banco. Calcule e imprima o valor do rendimento e o valor total depois do rendimento.

18) Faça um algoritmo que leia uma série de números e imprima a média aritmética dos ímpares e a
soma dos pares.

19) Uma loja recebeu pagamentos dos clientes e deseja organizar estes dados. Faça um algoritmo que leia o
código do cliente, o sexo do cliente, produto comprado, qtde vendida e preço por cada um destes clientes. O
algoritmo deve apresentar as seguintes informações:
1 – Valor total do faturamento da loja;
2 – Valor do faturamento pago por homens;
3 – Valor do faturamento pago por mulheres;

20) Um comerciante deseja fazer um levantamento do lucro de suas mercadorias. Para isto fez uma
lista onde cada linha possui o nome, o preço de compra e o preço de venda das mercadorias.
Faça um algoritmo que leia estas informações e escreva quantas mercadorias apresentam:

lucro de até 10%


lucro entre 10% e 20%
lucro maior que 20%

Informar também o valor total de compra e de venda das mercadorias.

21) Considerando que vários carros foram rebocados pela prefeitura e que todos foram multados,
calcular o valor das multas. Carros com data de fabricação anterior a 2000 o percentual da multa será
de 1,5% de seu valor, os outros 3,5%. Calcular e imprimir o valor das multas.

Obs.
O valor da multa é diário.

22) Com base no exercício anterior, imprimir a chapa, o ano e a multa do veículo com multa superior a
3000.00.

81
4.3 – Repetição com Teste no Final (do...while)

Repete um bloco de instruções até que uma certa condição seja satisfeita.

Sua sintaxe é:

do{
instruções;
}
while (expressão_lógica);

Neste caso, todos os comandos entre as palavras reservadas do e while serão executadas, até que a
expressão lógica seja verdadeira.

Exemplo:

#include <iostream>
using namespace std;
int main(){
int opcao;
do {
system("cls");
cout<< "1 - Executar" << endl;
cout<< "2 - Sair" << endl;
cout<< endl;
cout<< "Escolha a opcao: ";
cin>> opcao;
if (opcao == 1){
cout<< "Executar uma determinada rotina" << endl;
cout<< endl;
system("pause");
}
else
if (opcao == 2){
cout<< "Sair..." << endl;
cout<< endl;
system("pause");
}
else{
cout<< "Opcao invalida. Digite 1 ou 2." << endl;
system("pause");
}
}
while (opcao != 2);
}

82
4.3.1 Exercícios – do while

1) Fazer um algoritmo que crie um menu com as seguintes opções:

1 – Cadastramento de Aluno;
2 – Lancamento de Notas;
3 – Inclusao de Plano de Estudos;
4 – Alteracao de Plano de Estudos;
5 – Alteracao de Dados Cadastrais
6 – Encerra;
Escolha a Opcao:

83
Unidade 5 – MODULARIZAÇÃO
A estrutura de uma função de usuário é muito semelhante a estrutura dos programas que escrevemos
até agora. Uma função de usuário constitui-se de um bloco de instruções que definem os
procedimentos efetuados pela função, um nome pelo qual a chamamos e uma lista de argumentos
passados a função. Chamamos este conjunto de elementos de definição da função.

Exemplo: o código mostrado abaixo é uma função definida pelo usuário para calcular a média
aritmética de dois números reais:

float media2(float a, float b){


float med;
med = (a + b) / 2.0;
return(med);
}

No exemplo acima definimos uma função chamada media2 que recebe dois argumentos tipo float: a e
b. A média destes dois valores é calculada e armazenada na variável med declarada internamente. A
função retorna, para o programa que a chamou, um valor também do tipo float: o valor da variável
med. Este retorno de valor é feito pela função return() que termina a execução da função e retorna o
valor de med para o programa que a chamou.

Depois de definimos uma função, podemos usá-la dentro de um programa qualquer. Dizemos que
estamos fazendo uma chamada a função.

Exemplo: No exemplo abaixo chamamos a função media2() dentro de um programa principal:

void main(){
float num_1, num_2, med;
cout<< ”Digite dois números: ”;
cin>> num_1, num_2;
med = media2(num_1, num_2); // chamada a função
cout<< ”\nA media destes números e: ” << med;
}

5.1 Definição de funções

De modo formal, a sintaxe de uma função é a seguinte:

tipo_de_retorno nome_da_função(tipo_1 arg_1, tipo_2 arg_2, ...){


[bloco de instruções da função]
}

A primeira linha da função contém a declaração da função. Na declaração de uma função se define o
nome da função, seu tipo de retorno e a lista de argumentos que recebe. Em seguida, dentro de
chaves {}, definimos o bloco de instruções da função.

O tipo de retorno da função especifica qual o tipo de dado retornado pela função, podendo ser
qualquer tipo de dado mostrado na seção 2.3: int, float, etc. Se a função não retorna nenhum valor para
o programa que a chamou devemos definir o retorno como void, ou seja um retorno ausente. Se
nenhum tipo de retorno for especificado o compilador entenderá que o retorno será tipo int.

84
Vale notar que existe apenas um valor de retorno para funções em C. Não podemos fazer o retorno de
dois ou mais valores como em algumas linguagens (no MatLab: [media,desvio] = estat(a, b, c, d, e)).
Porém isto não é um limitação séria pois o uso de ponteiros (cap. ?) contorna o problema.

Por ser um identificador, o nome da função segue as mesmas regras de definição de identificadores.

A lista de argumentos da função especifica quais são os valores que a função recebe. As variáveis da
lista de argumentos são manipuladas normalmente no corpo da função.

A chamada de uma função termina com a instrução return() que transfere o controle para o programa
chamador da função. Esta instrução tem duas finalidades: determina o fim lógico da rotina e o valor
de retorno da função. O argumento de return() será retornado como valor da função.

5.2 Localização das Funções

Existem basicamente duas posições possíveis para escrevermos o corpo de uma função: ou antes ou
depois do programa principal. Podemos ainda escrever uma função no mesmo arquivo do programa
principal ou em arquivo separado.

Corpo da função antes do programa principal (no mesmo arquivo)

Quando escrevemos a definição de uma função antes do programa principal e no mesmo arquivo
deste, nenhuma outra instrução é necessária. A sintaxe geral para isto é a seguinte:

Sintaxe: Uma função escrita antes do programa principal:

tipo nomef(...){ // definição da função


[corpo de função]
}
void main(){ // programa principal
...
var = nomef(...) // chamada da função
...
}

Exemplo: Função media2() escrita antes do programa principal.

float media2(float a, float b){ // função


float med;
med = (a + b) / 2.0;
return(med);
}
void main(){ // programa principal
float num_1, num_2, med;
cout ”Digite dois números: ”;
cin>> num_1, &num_2;
med = media2(num_1, num_2); // chamada da função
cout<< ”\nA media destes números e :” << med);
}

5.3 Passagem de Parâmetro

As variáveis que aparecem na lista de parâmetros da função são chamadas de parâmetros formais da
função. Eles são criados no início da execução da função e destruídos no final.
85
Parâmetros são valores que as funções recebem da função que a chamou. Portanto, os parâmetros
permitem que uma função passe valores para outra. Normalmente os parâmetros são inicializados
durante a chamada da função, pois para isto que foram criadas. No entanto, as variáveis que atuam
como parâmetros são iguais a todas as outras e podem ser modificadas, operadas, etc, sem nenhuma
restrição.

Parâmetros podem ser passados para funções de três maneiras: passagem por valor, por referência e
por ponteiro.

5.3.1 Passagem de Parâmetros por Valor

Forma mais comum de passagem de parâmetro. É passado um valor ou o nome do objeto. Uma cópia
do objeto é criada e os valores iniciais permanecem inalterados.

Sentença da passagem de parâmetro por valor

 É passada uma cópia do objeto é a condição default em funções.


 É mais lento porque precisa criar uma cópia de cada objeto passado como parâmetro. Como é
criada uma cópia, o objeto original não sofre nenhuma alteração.

Exemplo 1: Soma de dois números.

#include <iostream>
using namespace std;
int calcula(int fnum1, int fnum2){ // Recebe por valor/copia
int resultado;
cout<< "Numero de fnum1 : " << fnum1 << endl;
cout<< "Numero de fnum2 : " << fnum2 << endl<<endl;
resultado=fnum1+fnum2;
return resultado;
}
int main(){
int num1, num2;
cout<< "======== Main ========" << endl << endl;
cout<< "Digite o primeiro numero: ";
cin>> num1;
cout<< "Digite o segundo numero : ";
cin>> num2;
cout<< endl;
cout<< "======== Funcao ========" << endl << endl;
cout<< "Soma dos numeros: " <<(calcula(num1,num2)) << endl;
cout<< endl;
system("pause");
return 0;
}

5.3.2 Passagem de Parâmetros por Referência

O operador de referência cria outro nome para uma variável já existente. Toda operação em qualquer
dos nomes tem o mesmo resultado. A referência não é uma cópia da variável à que se refere. É a
mesma variável sob diferentes nomes.

86
Quando argumentos são passados por valor, a função não tem acesso às variáveis originais da função
chamadora, portanto não poderá modificar seus conteúdos.

Quando argumentos são passados por referência, a função recebe um outro nome para as variáveis
originais e poderá modificar os seus conteúdos. Esse mecanismo possibilita que uma função retorne
mais de um valor para a função chamadora. Os valores a serem retornados são colocados em
referências de variáveis da função chamadora.

O operador de referência cria outro nome para uma variável já existente. Toda operação em qualquer
dos nomes tem o mesmo resultado. A referência não é uma cópia da variável à que se refere. É a
mesma variável sob diferentes nomes.

Sentença da passagem de parâmetro por referência

 É passada uma referência do objeto.


 É mais rápido, visto que tem acesso direto aos parâmetros (sem criar uma cópia dos mesmos).
 Observe que o objeto passado pode sofrer alterações dentro da função.

Exemplo 1: Soma de dois números.

#include <iostream>
using namespace std;
int calcula(int &fnum1, int &fnum2){ // Recebe por referencia
int resultado;

cout<< "Numero de fnum1 : " << fnum1 << endl;


cout<< "Numero de fnum2 : " << fnum2 << endl<<endl;
cout<< "Endereco de fnum1: " << &fnum1 << endl;
cout<< "Endereco de fnum2: " << &fnum2 << endl << endl;

resultado=fnum1+fnum2;
return resultado;
}
int main(){
int num1, num2;

cout<< "======== Main ========" << endl << endl;


cout<< "Digite o primeiro numero: ";
cin>> num1;

cout<< "Digite o segundo numero : ";


cin>> num2;

cout<< endl;
cout<< "Endereco de num1 : " << &num1 << endl;
cout<< "Endereco de num2 : " << &num2 << endl;
cout<< endl;
cout<< "======== Funcao ========" << endl << endl;
cout<< "Soma dos numeros: " <<(calcula(num1,num2)) << endl;
cout<< endl;
system("pause");
}

87
Exemplo 2:

O programa solicita ao usuário que insira o preço atual de uma certa mercadoria. Em seguida, modifica
o preço para um valor reajustado em 20% e calcula o valor do aumento.

#include<iostream>
using namespace std;
void reajusta(float &fpreco, float &freajuste){ // Recebe por referencia
cout<< "Valor de fpreco .....: " << fpreco << endl;
cout<< "Valor de freajuste ..: " << freajuste << endl<<endl;
cout<< "Endereco de fpreco ..: " << &fpreco << endl;
cout<< "Endereco de freajuste: " << &freajuste << endl << endl;
freajuste = fpreco * 0.2;
fpreco = fpreco * 1.2;
}
int main(){
float valpreco=0, valreaj=0;
cout<< "======== Main ========" << endl << endl;
cout << "Insira o preco atual: ";
cin >> valpreco;
cout << "Endereco do preco ..: " << &valpreco << endl;
cout << "Endereco do reajuste: " << &valreaj << endl;
cout<< endl;
cout<< "======== Funcao ========" << endl << endl;
reajusta(valpreco, valreaj);
cout << "O preco novo e ......: " << valpreco << endl;
cout << "O aumento foi de ....: " << valreaj << endl;
system("pause");
}

Funções que recebem argumentos por referência utilizam o operador & somente na declaração do tipo
do argumento.

Observe que a chamada a uma função que recebe uma referência é idêntica à chamada às funções em
que os argumentos são passados por valor.

A declaração

float& fpreco, float& freajuste;

Indica que preco e reajuste são outros nomes para as variáveis passadas como argumentos pela função
main(). Em outra palavras, quando usamos fpreco e freajuste, estamos realmente usando valpreco e
valreaj de main().

5.3.3 Passagem de Parâmetros por Ponteiro

Se uma função deseja alterar variáveis da função chamadora, as variáveis não podem ser passadas por
valor.

Em situações como essa, podemos usar referências ou ponteiros. Para usarmos ponteiros como
argumentos, devemos seguir dois passos. Primeiro, a função chamadora, em vez de passar valores para
a função chamada, passa endereços, usando o operador de endereços. Os endereços são de variáveis
que poderão ser alteradas, onde queremos colocar novos valores.
88
Segundo, a função chamada deverá criar variáveis para armazenar os endereços que estiver recebendo,
enviados pela função chamadora. Essas variáveis são ponteiros.

Sentença da passagem de parâmetro por ponteiro

 É passado um ponteiro para o objeto. Declara-se como parâmetro um ponteiro, que é utilizado
dentro da função para acessar o objeto. O objeto passado através do ponteiro pode sofrer
alterações.

Exemplo 1: Soma de dois números.

#include <iostream>
using namespace std;
int calcula(int *fnum1, int *fnum2){ // Recebe por ponteiro
int resultado;
cout<< "Numero de fnum1 : " << fnum1 << endl;
cout<< "Numero de fnum2 : " << fnum2 << endl<<endl;
cout<< "Endereco de fnum1: " << &fnum1 << endl;
cout<< "Endereco de fnum2: " << &fnum2 << endl << endl;
resultado = *fnum1 + *fnum2;
return resultado;
};
int main(){
int num1, num2;
cout<< "======== Main ========" << endl << endl;
cout<< "Digite o primeiro numero: ";
cin>> num1;
cout<< "Digite o segundo numero : ";
cin>> num2;
cout<< endl;
cout<< "Endereco de num1 : " << &num1 << endl;
cout<< "Endereco de num2 : " << &num2 << endl;
cout<< endl;
cout<< "======== Funcao ========" << endl << endl;
cout<< "Soma dos numeros: " << (calcula(&num1,&num2)) << endl;
cout<< endl;
system("pause");
}

Exemplo 2:

O programa solicita ao usuário que insira o preço atual de uma certa mercadoria. Em seguida, modifica
o preço para um valor reajustado em 20% e calcula o valor do aumento.

#include<iostream>
using namespace std;
void reajusta(float *fpreco, float *freajuste){ // Recebe por ponteiro
cout<< "Valor de fpreco .....: " << fpreco << endl;
cout<< "Valor de freajuste ..: " << freajuste << endl<<endl;
cout<< "Endereco de fpreco ..: " << &fpreco << endl;
cout<< "Endereco de freajuste: " << &freajuste << endl << endl;
*freajuste = *fpreco * 0.2;
*fpreco = *fpreco * 1.2;
}

89
int main(){
float valpreco=0, valreaj=0;
cout<< "======== Main ========" << endl << endl;
cout << "Insira o preco atual: ";
cin >> valpreco;
cout << "Endereco do preco ..: " << &valpreco << endl;
cout << "Endereco do reajuste: " << &valreaj << endl;
cout<< endl;
cout<< "======== Funcao ========" << endl << endl;
reajusta(&valpreco, &valreaj);
cout << "O preco novo e ......: " << valpreco << endl;
cout << "O aumento foi de ....: " << valreaj << endl;
system("pause");
}

Exemplo3:

Construir um algoritmo que leia dois números do teclado. Criar funções que façam a soma, subtração,
multiplicação e a divisão desses números.

#include "iostream"
using namespace std;

int divide(int fnum1,int fnum2){


int fresult;
fresult = fnum1 / fnum2;
cout<< "A divisao e .....: " << fresult << endl;
return fresult;
}
int soma(int fnum1,int fnum2){
int fresult;
fresult = fnum1 + fnum2;
cout<< "A soma e ........: " << fresult << endl;
return 0;
}
int subtrai(int fnum1,int fnum2){
int fresult;
fresult = fnum1 - fnum2;
cout<< "A subtracao e ...: " << fresult << endl;
return fresult;
}
int multiplica(int fnum1,int fnum2){
int fresult;
fresult = fnum1 * fnum2;
cout<< "A multiplicacao e: " << fresult << endl;
return fresult;
}

int main(){
int num1,num2,res,i;
for (i=1; i <=2; i++){
cout<< "Digite o primeiro numero: ";
cin>> num1;
cout<< "Digite o segundo numero: ";
cin>> num2;

soma(num1,num2);

90
subtrai(num1,num2);
multiplica(num1,num2);
divide(num1,num2);
}
system("pause");
}

Sem modularização:

#include "iostream"
using namespace std;

int main(){
int num1,num2,res,i;
for (i=1; i <=2; i++){
cout<< "Digite o primeiro numero: ";
cin>> num1;
cout<< "Digite o segundo numero: ";
cin>> num2;

res = num1 / num2;


cout<< "A divisao e .....: " << res << endl;

res = num1 + num2;


cout<< "A soma e ........: " << res << endl;

res = num1 - num2;


cout<< "A subtracao e ...: " << res << endl;

res = num1 * num2;


cout<< "A multiplicacao e: " << res << endl;
}
system("pause");
}

Exemplo4:

Construir um algoritmo para receber o valor do salário do teclado. Calcular o inss e o salário líquido e
ao final imprimir o inss e o salário líquido.

Obs. Percentual do INSS = 8%


Usar função para o cálculo do inss

#include "iostream"
#include "string"
using namespace std;

float calcinss(float vlrsal){


float inss;
inss = (vlrsal * 8) / 100;
return inss;
}

int main(){
float vlrsal,salliqdo, vlrinss;
cout<< "Digite o salario: ";

91
cin>> vlrsal;

vlrinss = calcinss(vlrsal);
salliqdo = vlrsal - vlrinss;

cout<< endl;
cout<< "========== Salario Calculado ==========" << endl << endl;

cout<< "Valor do salario ....: " << vlrsal << endl;


cout<< "Valor Inss ..........: " << vlrinss << endl;
cout<< "Valor salario Liquido: " << salliqdo << endl;
system("pause");
}

92
Unidade 6 – FUNÇÕES C++

6.1 – Potência

Potências

A função pow() retorna o valor da base elevada ao expoente. Recebe dois argumentos do tipo double,
o primeiro é a base e o segundo o expoente.

Incluir a biblioteca math.h:

#include <math.h;
pow(x, y);

X = numero base;
Y = numero expoente, 2 por exemplo(quadrado);

Sintaxe:

#include <math.h;
float base, expoente, resultado;
resultado = pow(base, expoente);

Exemplo1:

Se quisermos saber o resultado da operação 23, faríamos pow (2, 3).

#include <iostream>
#include <math.h>
using namespace std;

int main(){
float resultado;

resultado = pow(2, 3); // base x expoente


cout << "\nO Numero " << 2 << " " << "elevado ao Expoente " << 3 << " e
igual a " << resultado;

cout<< "\n\n";
system("pause");
}

93
Exemplo2:

#include <iostream>
#include <math.h>
using namespace std;

int main(){
float base, expoente, resultado;

cout << "Digite a base: ";


cin >> base;
cout << "Digite o expoente: ";
cin >> expoente;

resultado = pow(base, expoente);


cout << "\nO Numero " << base << " " << "elevado ao Expoente " <<
expoente << " e igual a " << resultado;

cout<< "\n\n";
system("pause");
}

6.2 – Raiz Quadrada

http://www.tiexpert.net/programacao/c/math.php

pow(x, y);

incluir a biblioteca math.h:

X = numero base;
Y = numero expoente, 2 por exemplo(quadrado);

#include <math.h;

float base, expoente, resultado;

resultado = pow(base, expoente);

Exemplo1:

94
#include <iostream>
#include <math.h>
using namespace std;

int main(){
float num, resultado;

cout<< "*** Esta Aplicacao Extrai a Raiz Quadrada de Numero ***\n\n";

cout<< "Digite um numero: ";


cin>> num;

resultado = sqrt(num);
cout<< "\nA Raiz Quadrada do Numero " << num << " e igual a " <<
resultado;

cout<< "\n\n";
system("pause");
}

95
Exemplos scanf/printf

ENTRADA E SAÍDA DE DADOS EM C (scanf/printf)

Ler e imprimir número inteiro

#include <stdio.h> // Controlar monitor e teclado


#include <stdlib.h> // Pausar e limpar a tela
int main(){
int num1,num2,num3,soma; // Declaração de variáveis
printf ("Digite tres numeros"); // Imprime mensagem na tela
printf ("\n Primeiro numero: ");
scanf ("%I",&num1); // Leitura de variável
printf (" Segundo numero : ");
scanf ("%i",&num2);
printf (" Terceiro numero: ");
scanf ("%i",&num3);
printf ("\nSoma ............: %i",(num1 + num2 + num3));

printf ("\n");
system("pause");
}

Ler e imprimir número com ponto flutuante (float)

#include <stdio.h> // Controla monitor e teclado


#include <stdlib.h> // Pausar e limpar a tela
int main(){
float num1,num2,num3,soma; // Declaração de variáveis
printf ("Digite tres numeros com casa decimal");
printf ("\n Primeiro numero: ");
scanf ("%f",&num1); // Leitura de variável
printf (" Segundo numero : ");
scanf ("%f",&num2);
printf (" Terceiro numero: ");
scanf ("%f",&num3);
printf ("\nSoma ............: %1.2f",(num1 + num2 + num3));

printf ("\n");
system("pause");
}

Ler e imprimir número com ponto flutuante (double)

#include <stdio.h> // Controla monitor e teclado


#include <stdlib.h> // Pausar e limpar a tela

int main(){
double num1,num2,num3,soma; // Declaração de variáveis
printf ("Digite tres numeros com ponto flutuante");
printf ("\n Primeiro numero: ");
scanf ("%lf",&num1); // Leitura de variável
96
printf (" Segundo numero : ");
scanf ("%lf",&num2);
printf (" Terceiro numero: ");
scanf ("%lf",&num3);
printf ("\nSoma ............: %.2f",(num1 + num2 + num3));

printf ("\n");
system("pause");
}

Ler e imprimir caracter (char)

#include <stdio.h> // Controla monitor e teclado


#include <stdlib.h> // Pausar e limpar a tela

int main(){
char letra1,letra2,letra3; // Declaração de variáveis
printf ("Digite tres letras"); // Imprime mensagem na tela
printf ("\n Primeira letra: ");
scanf ("%c",&letra1); // Leitura de variável
fflush(stdin);
printf (" Segunda letra : ");
scanf ("%c",&letra2);
fflush(stdin);
printf (" Terceira letra: ");
scanf ("%c",&letra3);
printf ("\nLetras ............: %c %c %c", letra1, letra2,
letra3);

printf ("\n");
system("pause");
}

Ler e imprimir caracteres (string)

#include <stdio.h> // Controla monitor e teclado


#include <stdlib.h> // Pausar e limpar a tela

int main(){
char nome1[20];
char nome2[30];
printf ("Digite dois nomes"); // Imprime mensagem na tela
printf ("\n Primeira nome: ");
scanf ("%s",&nome1); // Leitura de variável
fflush(stdin);
printf (" Segunda nome : ");
gets(nome2);
printf ("\nNomes ............: %s", nome1);
printf ("\nNomes ............: %s", nome2);
printf ("\n");
system("pause");
}

97
Outros Exemplos

#include <stdio.h> // Controla monitor e teclado


#include <conio.h> // Getch

int main(){
char nome[40] = "Maria da Silva";
char sexo = 'M';
int idade = 25;
float peso = 6.5;
double mensalidade = 1000.65;

printf("Nome: %s",nome);
printf("\nSexo: %c", sexo);
printf("\nIdade: %i",idade);
printf("\nPeso: %.1f",peso);
printf("\nMensalidade: R$ %.2f",mensalidade);

getch();
}

#include <stdio.h> // Controla entrada e saida


#include <conio.h> // necessário para as funções clrscr e getch
char nome[40];
char sexo;
int idade;
float peso;
double mensalidade;

int main(){
printf("Digite um nome .....: ");
gets(nome);
printf("Digite o sexo ......: ");
scanf("%s",&sexo);
printf("Digite a idade .....: ");
scanf("%i",&idade);
printf("Digite o peso ......: ");
scanf("%f",&peso);
printf("Digite a mensalidade: ");
scanf("%lf",&mensalidade);

printf("Nome: %s",nome);
printf("\nSexo: %c", sexo);
printf("\nIdade: %i",idade);
printf("\nPeso: %.1f",peso);
printf("\nMensalidade: R$ %.2f",mensalidade);
getch();
}

#include <stdio.h> // Controla entrada e saida


#include <conio.h> // necessário para as funções clrscr e getch
98
#include <stdlib.h>

char nome[40];
char sexo;
int idade;
float peso;
double mensalidade;

int main(){
printf("Digite um nome .....: ");
gets(nome);
printf("Digite o sexo ......: ");
scanf("%s",&sexo);
printf("Digite a idade .....: ");
scanf("%i",&idade);
printf("Digite o peso ......: ");
scanf("%f",&peso);
printf("Digite a mensalidade: ");
scanf("%lf",&mensalidade);

printf("Nome: %s",nome);
printf("\nSexo: %c", sexo);
printf("\nIdade: %i",idade);
printf("\nPeso: %.1f",peso);
printf("\nMensalidade: R$ %.2f",mensalidade);
printf("\n");
system("pause");
}

99
Anexo

100
101
102
103