You are on page 1of 25

r d r d

de P maçã gica ogra o Ló de P maçã gica o


gica e Progra ação Ló ica de Pr gramaçã Lógica e Progra ação Ló ica de Pr
d m g r o o d m g r
gica e Progra ação Ló ica de P gramaçã Lógica e Progra ação Ló ica de P
d am óg ro ão d am óg
ógica de Progr mação L gica de P ogramaç o Lógica de Progr a ç ão L gica de P
a ó r ã a m Ló
ógica de Progr mação L gica de P ogramaç o Lógica de Progr ação Lógica d
eP
a r a L ó P r ç ã a r a m
Lógic de Prog amação ógica de rograma ão Lógic de Prog mação ógica de
a r L P ç a ra L
Lógic de Prog amação ógica de rograma ão Lógic de Prog mação ógica de
a r L P ç a r a L
Lógic de Prog amação ógica de rograma ão Lógic de Prog mação ógica de
gica ogr o L de P maç gica ogra o L d
o Ló ica de Pr gramaçã Lógica e Progra ação Ló ica de Pr gramaçã Lógica
g r o o d m g r o o d
o Ló ica de P gramaçã Lógica e Progra ação Ló ica de P gramaçã Lógica
óg ro ão d am óg ro ão
ão L gica de P ogramaç o Lógica de Progr a ç ão L gica de P ogramaç o Lógica
ó r ã a m Ló r açã
ão L gica de P ogramaç o Lógica de Progr eP
ação Lógica d Program ção Lóg
ica
L ó P r ç ã a r a m
ção ógica de rograma ão Lógic de Prog mação ógica de rograma ão Lógic
L eP aç ica gra L eP aç ic
ação Lógica d Program ção Lóg a de Pro ramação Lógica d Program ção Lóg
e a ic g e a i
ação Lógica d Program ção Lóg a de Pro ramação Lógica d Program ção Lóg
o d e m a g i c ro g o d e m a g
maçã Lógica e Progra ação Ló ica de P gramaçã Lógica e Progra ação Ló
o d m g r o o d m
maçã Lógica e Progra ação Ló ica de P gramaçã Lógica e Progra ação Ló
ã o a d a m ó g P ro ção ad am ó
maç L ógic de Progr mação L gica de g r ama o Lógic de Progr mação L
çã o a a ó P r o ã a a
ama o Lógic de Progr mação L gica de rogramaç o Lógic de Progr mação L
ç ã a r a L ó P ç ã a ra L
rama ão Lógic de Prog amação ógica de rograma ão Lógic de Prog mação
a ç i c a g r L e P a ç i c a g r a
gram ção Lóg a de Pro ramação Lógica d Program ção Lóg a de Pro ramação
a g i c o g o d e ma gic rog o
gram ção Ló a
r
de P gramaçã Lógica e Progra ação Ló ica de P gramaçã
m a g i c o o d m g o o
ogra ação Ló ica de Pr gramaçã Lógica e Progra ação Ló ica de Pr gramaçã
m g o o d m g o
ogra ação Ló ica de Pr gramaçã Lógica e Progra ação Ló ica de Pr gramaçã
a m ó g P r o ç ã o a d r m
a Lóg Pro çã
rogr a
L
ção ógica de rograma ão Lógic de Prog mação ógica de rograma
ra m L P ç a ra L P ç
Prog mação ógica de rograma ão Lógic de Prog mação ógica de rograma
r a L P ç a r a L P
Prog mação ógica de rograma ão Lógic de Prog mação ógica de rograma
r a L P a ç c a r a L P
Prog mação ógica de rogram ão Lógi d e Prog mação ógica de rograma
gr a L e P aç ic a gr a L eP
e Pro ramação Lógica d Program ção Lóg a de Pro ramação Lógica d Program
ro g o de m a gi c ro g o de m
de P gramaçã Lógica e Progra ação Ló ica de P gramaçã Lógica e Progra
r o o d m g r o o d m
de P gramaçã Lógica e Progra ação Ló ica de P gramaçã Lógica e Progra
r o ã o d a m ó g r o ã o d ra
de P gramaç a r L P
Lógic de Prog amação ógica de rograma ão Lógic de Prog
ç a
P r o ç ã o c a r L P ç a ra
a de rograma ão Lógi d e Prog mação ógica de rograma ão Lógic de Prog
P ç a r a L P ç a r
a de rograma ão Lógic de Prog mação ógica de rograma ão Lógic de Prog
P a ç i c a g r a L P a ç i c a g
ca de Program ção Lóg a de Pro ramação ógica de Program ção Lóg a de Pro
e a i c g L e a i c
ica d Program ção Lóg a de Pro ramação Lógica d Program ção Lóg a de Pro
de ma gic og o de ma gic o
gica e Progra ação Ló ica de Pr gramaçã Lógica e Progra ação Ló ica de Pr
d m g o o d m g
gica e Progra ação Ló ica de Pr gramaçã Lógica e Progra ação Ló ica de Pr
d a m ó g r o ã o d a m ó g
ógica de Progr mação L gica de P ogramaç o Lógica de Progr a ç ã o L ica de P
a ra Ló Pr çã a ram Lóg P
Lógic de Prog amação ógica de rograma ão Lógic de Prog mação ógica de
a r L P ç a ra L
Lógic de Prog amação ógica de rograma ão Lógic de Prog mação ógica de
a r L P ç a r a L
Lógic de Prog amação ógica de rograma ão Lógic de Prog mação ógica de
a r L P ç a r a L
Lógic de Prog amação ógica de rograma ão Lógic de Prog mação ógica de
gi c a og r o L de P ma ç gi c a og r a o L d
o Ló ica de Pr gramaçã Lógica e Progra ação Ló ica de Pr gramaçã Lógica
g o o d m g o o
o Ló ica de Pr gramaçã Lógica e Progra ação Ló ica de Pr gramaçã Lógica
ó g r o ã o d a m ó g r o ã o
ão L gica de P ogramaç o Lógica de Progr a ç ã o L ica de P gramaç Lógic
a
Ló Pr çã a ram Lóg Pro ção a
Daniel Hayashida Simão
Wellington José dos Reis

Lógica de Programação
Conhecendo Algoritmos e Criando Programas

1ª Edição
Santa Cruz do Rio Pardo/SP
Editora Viena
2015
Dados Internacionais de Catalogação na Publicação (CIP)
(Câmara Brasileira do Livro, SP, Brasil)

Simão, Daniel Hayashida


Lógica de programação : conhecendo algoritmos
e criando programas / Daniel Hayashida Simão,
Wellington José dos Reis. -- 1. ed. -- Santa
Cruz do Rio Pardo, SP : Editora Viena, 2015. --
(Coleção premium)

Bibliografia.
ISBN 978-85-371-0429-3

1. Lógica 2. Programação (Computadores


eletrônicos) 3. Programação lógica - Problemas e
exercícios I. Reis, Wellington José dos.
II. Título. III. Série.

15-05768 CDD-005.1
Índices para catálogo sistemático:
1. Lógica de programação : Computadores :
Processamento de dados 005.1

Copyright© 2015 – Viena Gráfica e Editora Ltda.

Todos os direitos reservados pela EDITORA VIENA. LEI 9.610 de 19/02/98 e atualizações.
Nenhuma parte desta publicação poderá ser reproduzida ou transmitida, sejam quais forem os meios
empregados: eletrônicos, mecânicos, fotográficos, gravações ou quaisquer outros.
Todas as marcas e imagens de hardware, software e outros, utilizados e/ou mencionados nesta obra, são
propriedades de seus respectivos fabricantes e/ou criadores.

Autores: Daniel Hayashida Simão e Wellington José dos Reis


Revisão Técnica: Wellington José dos Reis
Revisão Ortográfica: Tássia Carvalho
Capa: Luciane Mendonça
Diagramadora: Erika Cristina Bueno
Ilustrações: iStockphoto.com
Revisão de Diagramação: Camila Ceccatto da Silva Perez e Karina de Oliveira
Supervisão Editorial: Karina de Oliveira

ISBN: 978-85-371-0429-3

1ª Edição - 08/2015 - SCRPardo / SP

Impresso no Brasil
Dedico esse trabalho a todos os meus amigos da Viena Gráfica & Editora, em
especial para Karina Oliveira, Denise Andrade, Camila C. Perez, Adriana
Araújo, Luciane Mendonça, Erika Bueno, André Dario, Paulo Araújo,
Wellington dos Reis e Márcia Peregini.

D.H.S.

À minha família, aos amigos de trabalho e a vocês, leitores.

W.J.R
“Lembre-se que as pessoas podem tirar tudo de você, menos o seu
conhecimento.”

Albert Einsten
Prefácio

A lógica de programação está ligada diretamente ao contexto da informática,


especificamente na programação utilizada no desenvolvimento de softwares, sistemas,
sites e aplicativos.
A expansão da tecnologia e a facilidade de acesso à Internet ampliou as possibilidades
de atuação para programadores. Por isso, esses profissionais devem procurar se
qualificar e atualizar constantemente.
Este material apresenta conceitos que permitem ao leitor o conhecimento
necessário para desenvolver programas eficientes com a linguagem de programação
mais adequada para cada caso.
Dividido em doze capítulos complementares, o livro possibilita uma compreensão
gradativa dos conceitos e a aplicação de vários itens relacionados a lógica de
programação. Entre os tópicos abordados estão: a aplicação da matemática à
linguagem de programação, algoritmos, linguagens de programação, diagrama de
bloco, simbologia, dados, tipos de dados, variáveis e atributos, constantes, operadores
aritméticos, operadores relacionais, operadores lógicos, prioridade dos conectivos,
estruturas condicionais, estrutura de decisão, estrutura de repetição, estruturas de
dados homogêneas, variáveis compostas heterogêneas, sub-rotinas, procedimentos,
parâmetros, funções, estruturas de dados avançadas, listas, filas, pilhas, árvores,
declaração, manipulação de arquivos, localizar registros, linguagem C, principais
comandos da linguagem C, desenvolvendo programas utilizando o codeblocks,
conceitos básicos sobre programação orientada a objetos, abstração, classe, herança,
encapsulamento, polimorfismo, generalização e especialização, introdução à
modelagem de sistemas orientados a objetos, entre outros.
O material possui exemplos que ilustram os textos e um capítulo de exercícios
visando a fixação dos tópicos abordados pelos autores.

Denise de Fatima Andrade


Jornalista - MTB 53277/SP
Sumário
Lista de Siglas e Abreviaturas............................................................................. 15
1. Introdução.............................................................................................. 17
1.1. Aplicação da Matemática à Linguagem de Programação................................................ 19
1.2. Algoritmos......................................................................................................................................... 19
1.3. Programas ......................................................................................................................................... 22
1.3.1. Compilador ...................................................................................................................................... 22
1.3.2. Interpretador ................................................................................................................................... 23
1.3.3. IDE........................................................................................................................................................ 23
1.4. Linguagens de Programação...................................................................................................... 24
1.4.1. Pseudolinguagem........................................................................................................................... 25
1.4.2. Teste de Mesa................................................................................................................................... 26
1.4.3. Boas Práticas para Construção de um Algoritmo................................................................ 26
2. Diagrama de Bloco................................................................................. 29
2.1. Simbologia........................................................................................................................................ 31
2.1.1. Outros Símbolos.............................................................................................................................. 32
3. Dados....................................................................................................... 35
3.1. Tipos de Dados................................................................................................................................ 37
3.2. Variáveis e Atributos...................................................................................................................... 37
3.2.1. Variável Global e Local.................................................................................................................. 39
3.3. Constantes......................................................................................................................................... 39
4. Operadores............................................................................................. 43
4.1. Operadores Aritméticos............................................................................................................... 45
4.2. Operadores Relacionais................................................................................................................ 46
4.3. Operadores Lógicos....................................................................................................................... 47
4.4. Tabela Verdade ................................................................................................................................ 47
4.4.1. Tabela Verdade para Proposição de Negação...................................................................... 48
4.4.2. Tabela Verdade para Proposição de Conjunção.................................................................. 49
4.4.3. Tabela Verdade para Proposição de Disjunção.................................................................... 49
4.4.4. Tabela Verdade para Proposição de Condição .................................................................... 51
4.4.5. Operação Bicondicional................................................................................................................ 51
4.5. Prioridade dos Conectivos........................................................................................................... 52
5. Estruturas Condicionais......................................................................... 55
5.1. Estrutura de Decisão...................................................................................................................... 57
5.1.1. SE ... ENTÃO........................................................................................................................................ 57
5.1.2. SE ... ENTÃO ... SENÃO.................................................................................................................... 58
5.1.3. SELECIONE ... CASO........................................................................................................................ 59
5.2. Estrutura de Repetição.................................................................................................................. 62
5.2.1. PARA..................................................................................................................................................... 62
5.2.2. ENQUANTO ... FAÇA........................................................................................................................ 63
5.2.3. REPITA ... ATÉ QUE........................................................................................................................... 64

S u m á r i o 11
6. Estruturas de Dados............................................................................... 67
6.1. Estruturas de Dados Homogêneas .......................................................................................... 69
6.1.1. Vetores................................................................................................................................................ 69
6.1.1.1. Declaração......................................................................................................................................... 70
6.1.1.2. Utilização de um Vetor.................................................................................................................. 70
6.1.2. Matrizes.............................................................................................................................................. 71
6.1.2.1. Declaração......................................................................................................................................... 72
6.1.2.2. Leitura e Escrita dos Dados.......................................................................................................... 72
6.2. Variáveis Compostas Heterogêneas......................................................................................... 73
6.2.1. Registros............................................................................................................................................. 73
6.2.1.2. Declaração......................................................................................................................................... 73
6.2.1.3. Leitura e Exibição de Registros.................................................................................................. 74
6.2.1.4. Registro de Conjuntos................................................................................................................... 74
6.2.1.4.1. Declaração de Registros de Conjuntos................................................................................... 74
6.2.1.4.2. Leitura e Escrita de Registro de Conjuntos............................................................................ 75
6.2.1.5. Conjunto de Registros................................................................................................................... 76
6.2.1.5.1. Declaração......................................................................................................................................... 76
6.2.1.5.2. Leitura e Escrita dos Conjuntos de Registros........................................................................ 76
7. Sub-rotinas............................................................................................. 79
7.1. Procedimentos................................................................................................................................. 81
7.2. Parâmetros........................................................................................................................................ 82
7.2.1. Passagem de Parâmetros............................................................................................................. 83
7.3. Funções............................................................................................................................................... 85
8. Estruturas de Dados Avançadas............................................................ 87
8.1. Listas.................................................................................................................................................... 89
8.1.1. Declaração......................................................................................................................................... 89
8.1.2. Inserção.............................................................................................................................................. 90
8.1.3. Remoção............................................................................................................................................ 90
8.1.4. Listas Duplamente Encadeadas................................................................................................. 90
8.1.5. Listas Circulares............................................................................................................................... 91
8.2. Filas....................................................................................................................................................... 91
8.2.1. Declaração......................................................................................................................................... 91
8.2.2. Inserção.............................................................................................................................................. 92
8.3. Pilhas.................................................................................................................................................... 92
8.3.1. Declaração......................................................................................................................................... 92
8.4. Árvores................................................................................................................................................ 93
8.4.1. Declaração......................................................................................................................................... 94
9. Arquivos.................................................................................................. 95
9.1. Declaração......................................................................................................................................... 98
9.2. Manipulação de Arquivos............................................................................................................ 98
9.2.1. Abrir um Arquivo............................................................................................................................. 99
9.2.2. Copiar um Registro......................................................................................................................... 99
9.2.3. Salvar um Registro.......................................................................................................................... 99
9.2.4. Fechar um Arquivo.......................................................................................................................100
9.2.5. Excluir um Arquivo.......................................................................................................................100

12 L ó g i c a de Programação
9.3. Localizar Registros .......................................................................................................................100
9.3.1. Concepção Sequencial................................................................................................................100
9.3.2. Concepção Direta.........................................................................................................................101
10. Praticando a Programação na Linguagem C...................................... 103
10.1. Por que a Linguagem C?.............................................................................................................105
10.2. Principais Comandos da Linguagem C.................................................................................105
10.2.1. Comandos Básicos........................................................................................................................105
10.2.2. Principais Tipos de Variáveis em C..........................................................................................106
10.2.3. Principais Operadores em C......................................................................................................106
10.2.4. Comandos de Entrada e Saída de Dados.............................................................................107
10.2.4.1. Comando printf()...........................................................................................................................107
10.2.4.2. Comando scanf()...........................................................................................................................108
10.2.5. Estruturas Condicionais em C...................................................................................................109
10.2.5.1. Estrutura if.......................................................................................................................................109
10.2.5.2. Estrutura if else .............................................................................................................................110
10.2.5.3. Estrutura switch case...................................................................................................................111
10.2.6. Estruturas de Repetição em C..................................................................................................112
10.2.6.1. Estrutura while...............................................................................................................................112
10.2.6.2. Estrutura for....................................................................................................................................113
10.2.7. Vetor em C.......................................................................................................................................113
10.3. Desenvolvendo Programas Utilizando o CodeBlocks......................................................115
10.4. Baixando e Instalando o CodeBlocks.....................................................................................115
10.4.1. Instalação do Compilador MinGW/GCC ..............................................................................118
10.5. Criar e Salvar um Arquivo no CodeBlocks............................................................................122
10.6. Compilar e Executar o Primeiro Arquivo..............................................................................123
10.7. Compilar e Executar Algoritmos já Criados.........................................................................124
10.7.1. Algoritmo if em C..........................................................................................................................124
10.7.2. Algoritmo if else em C.................................................................................................................125
10.7.3. Algoritmo switch case em C......................................................................................................126
10.7.4. Algoritmo while em C..................................................................................................................127
10.7.5. Algoritmo for em C.......................................................................................................................128
10.7.6. Algoritmo Vetor em C..................................................................................................................129
10.8. Identação.........................................................................................................................................129
11. Conceitos Básicos sobre Programação Orientada a Objetos............ 133
11.1. Abstração.........................................................................................................................................135
11.2. Classe.................................................................................................................................................136
11.2.1. Classe Abstrata...............................................................................................................................136
11.3. Herança.............................................................................................................................................137
11.3.1. Herança Simples............................................................................................................................138
11.3.2. Herança Múltipla...........................................................................................................................140
11.4. Encapsulamento............................................................................................................................141
11.5. Polimorfismo..................................................................................................................................141
11.6. Generalização e Especialização................................................................................................142
11.7. Introdução à Modelagem de Sistemas Orientados a Objetos......................................143
11.7.1. Relacionamentos...........................................................................................................................144

S u m á r i o 13
11.7.1.1. Relação Dependência..................................................................................................................144
11.7.1.2. Relação Generalização................................................................................................................145
11.7.1.3. Relação Associação......................................................................................................................145
Exercícios............................................................................................................ 149
Referências......................................................................................................... 171
Glossário............................................................................................................ 173

14 L ó g i c a de Programação
Lista de Siglas e Abreviaturas
FIFO ������������� First In, First Out.
IDE �������������� Integrated Development Environment.
LIFO ������������� Last In, First Out.
PEPS ������������� Primeiro que Entra, Primeiro que Sai.
POO ������������� Programação Orientada a Objetos.
RAD ������������� Rapid Application Development.
UML ������������� Unified Modeling Language.

L i s ta de Siglas e A b r e v i at u r a s 15
16 L ó g i c a de Programação
1
Introdução
1.1. Aplicação da Matemática à Linguagem de Programação
1.2. Algoritmos
1.3. Programas
1.3.1. Compilador
1.3.2. Interpretador
1.3.3. IDE
1.4. Linguagens de Programação
1.4.1. Pseudolinguagem
1.4.2. Teste de Mesa
1.4.3. Boas Práticas para Construção de um Algoritmo
Lógica de Programação
1. Introdução
A lógica de programação está ligada diretamente ao contexto da informática,
mais precisamente no segmento da programação, que é utilizada para desenvolver
softwares, sistemas, sites e aplicativos. No entanto, a lógica está muito mais presente
no nosso cotidiano do que imaginamos. Para qualquer coisa que fazemos é necessário
realizar tomadas de decisões, e estas seguem um fluxo lógico, que são os passos
que executamos para atingir um determinado objetivo. Na lógica de programação,
também é necessário analisar o problema e a partir daí ordenar instruções em uma
sequência lógica. Isso é feito utilizando uma linguagem de programação que possui
suas particularidades.
É importante informar que não existe somente uma maneira correta para se atingir
determinado objetivo, pois, cada pessoa possui sua lógica, sua maneira de pensar e de
executar determinados passos.
Nesta etapa de aprendizado, o maior desafio é desenvolver uma mentalidade
lógica e adequá-la às rotinas básicas da programação, com o intuito de analisar e
resolver problemas da melhor maneira possível, pois, possuindo uma boa lógica de
programação é possível adequá-la a qualquer linguagem de programação.
O presente livro é o ponto de partida para iniciar os estudos da programação,
desde o seu início e evoluir até o ponto de adequar os conhecimentos em lógica para
linguagens de programação, para que, assim, possam se aprofundar em linguagens de
programação específicas e obter resultados mais relevantes. Este livro é destinado a
pessoas que desejam iniciar os estudos em programação e que não possuam nenhuma
noção do assunto.

1.1. Aplicação da Matemática à Linguagem de


Programação
A matemática está presente em todas as tarefas realizadas diante do computador e
liga-se diretamente à lógica de programação. As atividades relacionadas à programação
exigem que o programador possua conhecimentos das principais funções e
propriedades da matemática, como cálculo de vetores, matrizes e diversos princípios
de álgebra, os quais são transmitidos ao indivíduo durante seu período acadêmico.
O desenvolvimento de algoritmos que servirão de base para a criação de programas
é estritamente dependente do uso de técnicas matemáticas, como testes de mesa,
uso de estruturas condicionais, de decisão, utilização de operadores lógicos, além de
outros fundamentos matemáticos. Portanto, se o interesse é se aprofundar no mundo
da lógica de programação, é necessário dedicação e empenho na área de exatas.

1.2. Algoritmos
O estudo da lógica de programação tem como objetivo principal construir algoritmos
válidos e eficazes. Mas o que são algoritmos? Podemos defini-los como uma sequência
de procedimentos que visam atingir um determinado objetivo. Portanto, na medida
em que é necessária a criação de novos algoritmos para resolver novos problemas, é de
extrema importância a utilização da lógica.

I n t r o d u ç ã o 19
Antes de entrar na parte mais técnica dos algoritmos, vamos criar algoritmos para
resolver problemas cotidianos, como o bom e velho exemplo da troca de lâmpadas.
Problema: Troca de lâmpadas.
Exemplo de algoritmo:
1. Localize a escada.
2. Pegue-a.
3. Posicione-a abaixo da lâmpada.
4. Pegue a lâmpada nova.
5. Suba na escada.
6. Retire a lâmpada velha.
7. Coloque a lâmpada nova.
8. Desça da escada.

Desta forma, involuntariamente, analisamos um problema, criamos procedimentos


e os executamos, ou seja, foi utilizada uma lógica para criar um algoritmo.
O algoritmo descrito anteriormente é apenas uma possível resolução para o problema
proposto. Existem diversas outras soluções, pois, como mencionado anteriormente,
cada pessoa possui sua lógica, ou seja, sua maneira de elaborar procedimentos para
atingir o objetivo.
Analisando o algoritmo anterior, é possível observar que ele tem um objetivo claro,
que é trocar a lâmpada, o que foi executado com êxito. Mas será que a lâmpada está
funcionando? Quais os procedimentos que devem ser tomados caso a lâmpada esteja
funcionando e quais os procedimentos que devem ser tomados caso a lâmpada não
esteja funcionando? Essas são situações que não foram pensadas na criação do primeiro
algoritmo. Portanto, é possível criar um algoritmo mais completo, envolvendo teste e
situações condicionais.
Problema: Trocar a lâmpada com teste.
Exemplo de algoritmo:
1. Localize a escada.
2. Pegue-a.
3. Posicione-a abaixo da lâmpada.
4. Pegue a lâmpada nova.
5. Suba na escada.
6. Retire a lâmpada velha.
7. Coloque a lâmpada nova.
8. Desça da escada.
9. Aperte o interruptor. A luz acendeu?
9.1. Sim.
9.1.1. Guarde a escada.
9.2. Não.
9.2.1. Pegue uma lâmpada nova.
9.2.2. Suba na escada.
9.2.3. Retire a lâmpada velha.
9.2.4. Coloque a lâmpada nova.
9.2.5. Desça da escada.
9.2.6. Aperte o interruptor. A luz acendeu?

20 L ó g i c a de Programação
9.2.6.1. Sim.
9.2.6.1.1. Guarde a escada.
9.2.6.2. Não.
9.2.6.2.1. Pegue outra lâmpada nova.
...
...
...

O algoritmo acima se aproxima um pouco mais de uma solução completa, pois o


fluxo só será finalizado quando a lâmpada for trocada e a luz acender, ou seja, só assim
a troca será realizada com êxito, do contrário, o fluxo será realizado infinitas vezes.
Esse algoritmo está mais completo, no entanto possui dois pontos negativos: não saber
o número necessário de lâmpadas para atingir o objetivo e ter de ficar repetindo o
texto várias vezes. Para não precisar ficar repetindo o texto várias vezes, é necessário
expressar uma situação condicional de repetição, a qual será realizada sempre que a
lâmpada não acender.
Problema: Trocar a lâmpada com teste e condição.
Exemplo de algoritmo:
1. Localize a escada.
2. Pegue-a.
3. Posicione-a abaixo da lâmpada.
4. Pegue a lâmpada nova.
5. Suba na escada.
6. Retire a lâmpada velha.
7. Coloque a lâmpada nova.
8. Desça da escada.
9. Aperte o interruptor. A luz acendeu?
9.1. Sim.
9.1.1. Guarde a escada.
9.2. Enquanto a lâmpada não acender, faça:
9.2.1. Pegue uma lâmpada nova.
9.2.2. Suba na escada.
9.2.3. Retire a lâmpada velha.
9.2.4. Coloque a lâmpada nova.

Por meio desse algoritmo poderemos atingir o que foi proposto, que é trocar a
lâmpada até que ela acenda, além de criar um “código” mais curto utilizando uma
condição de parada. Mas é claro que, mediante um simples problema como “trocar uma
lâmpada”, poderíamos definir diversos outros problemas e condições para aprimorar
nosso algoritmo, por exemplo, trocar no máximo 10 lâmpadas e parar mesmo que ela
não acenda, testar a mesma lâmpada em vários soquetes, e assim por diante.
Mas o que trocar a lâmpada tem a ver com programação e com desenvolver um
software? Assim, como nos procedimentos para trocar uma lâmpada, um programa
é desenvolvido por meio de linhas de códigos, que são nada mais do que instruções
escritas de acordo com uma linguagem de programação específica. Nos exemplos
anteriores, escrevemos nossos códigos utilizando a língua portuguesa, mas poderia
ser em C, Java, Python, entre outras linguagens.

I n t r o d u ç ã o 21
A elaboração de um algoritmo para a criação de um programa de computador
requer algumas etapas:
• Definir o problema (o que o programa tem que fazer).
• Estudar a situação atual e analisar a forma de resolver o problema.
• Desenvolver o programa utilizando uma linguagem de programação.
• Testar o programa com o intuito de encontrar possíveis erros.
• Após a implementação, analisar junto aos usuários se o programa satisfaz
todas as necessidades (se o problema foi solucionado).

É necessário salientar que o algoritmo deve possuir procedimentos claros e precisos,


que precisam ser seguidos fielmente a fim de que se crie um padrão para garantir que
sempre ele seja executado sob as mesmas condições, funcione e produza o resultado
esperado.

1.3. Programas
Como já mencionado anteriormente, os programas são desenvolvidos por meio
de linguagens de programação específicas. Mas, para que esses programas sejam
executados e disponham de todas as suas funcionalidades, é necessário outros
programas que traduzam o código do programa desenvolvido para uma linguagem
que o computador entenda e execute. Existem diversos programas que auxiliam no
desenvolvimento de programas, como o compilador, interpretador e a IDE.

1.3.1. Compilador
O compilador é um programa que traduz o código escrito em uma linguagem
de programação para um código capaz de ser interpretado pelo computador. Esse
código compilado é chamado de código objeto, que pode ser executado e reproduzir
as funcionalidades descritas no programa. Esse tipo de programa é um dos mais
utilizados.
Os compiladores analisam o código em três partes: de forma sintática ou hierárquica,
análise léxica ou linear e análise semântica.
Veja abaixo o fluxo seguido pelo compilador:

-
-

Vantagens:
• O código compilado é mais rápido de ser acessado.
• Dificulta o acesso ao código-fonte original.
• Permite otimização do código por parte do compilador.
• Compila o código somente se ele não possuir erros.

Desvantagens:
• Para ser utilizado, o código precisa passar por muitos níveis de compilação.
• A dificuldade em acessar o código-fonte, que foi citada acima como uma
vantagem, também pode ser uma desvantagem.

22 L ó g i c a de Programação
• A
o realizar uma alteração no código, será necessário recompilar tudo
novamente.

1.3.2. Interpretador
Os interpretadores leem um código-fonte de uma linguagem de programação
interpretada e o convertem em um código capaz de ser executado pelo computador.
Em alguns casos, o interpretador lê linha por linha e converte em código-objeto à
medida que vai executando o programa e, em outros casos, converte o código-fonte
por inteiro e depois o executa, o que pode variar de acordo com a implementação.
Ao contrário do compilador, o interpretador executa o código-fonte escrito como
sendo o código-objeto, traduzindo-o linha por linha. Dessa forma, o programa vai
sendo utilizado à medida que vai sendo traduzido. Cada execução do programa exige
que ele seja novamente traduzido e interpretado.
Veja abaixo o fluxo seguido pelo interpretador:

-
-

Os interpretadores analisam os códigos de duas formas: sintática e semanticamente.


Se o código for aprovado mediante essas duas análises, ele poderá ser executado.
Vantagens:
• Rapidez na realização de correções e alterações.
• Eliminação da necessidade de compilar o código para que seja executado.
• Consumo de menos memória em relação ao compilador.

Desvantagens:
• Execução mais lenta do programa.
• Necessidade de ler o código original sempre que for executado.

1.3.3. IDE
A IDE (Integrated Development Environment - Ambiente Integrado de
Desenvolvimento) é um programa de computador com características e ferramentas
que agilizam o processo de desenvolvimento de programas.
Esse tipo de programa favorece a aplicação de uma técnica chamada RAD (Rapid
Application Development), em português Desenvolvimento Rápido de Aplicativos,
que visa maior produtividade por parte dos desenvolvedores.
A IDE é a alternativa mais completa para o desenvolvimento de programas. Veja
abaixo algumas das funções e ferramentas mais comuns encontradas em uma IDE:
• Editor de código: Local para desenvolvimento e edição do código do
programa.
• Compilador: Transforma o código digitado em uma linguagem de
programação para a linguagem da máquina.
• Linker: Reuni as partes do código-fonte compilados em linguagem de
máquina em um programa executável, para que, assim, possa ser executado
em um computador.

I n t r o d u ç ã o 23
• D epurador ou Debugger: Auxilia no processo de encontrar possíveis erros
no código do programa.
• Modelagem: Criação do modelo de classes, objetos, interfaces, associações e
interações de todo o programa que está sendo desenvolvido.
• Geração de código: Gera códigos baseados em códigos comumente
utilizados para solucionar problemas rotineiros, uma espécie de templates.
Esse recurso torna muito mais rápido o desenvolvimento e a distribuição do
programa.
• Distribuição: Auxilia na criação do instalador do software.
• Testes automatizados: São testes automáticos no programa, baseados em
scripts ou programas de testes, gerando um relatório, com o intuito de
analisar o impacto das alterações no código.
• Refatoração: Esse recurso consiste na melhoria constante do código do
programa. A refatoração, juntamente com os testes automatizados, é uma
ótima alternativa para tentar eliminar os famosos “bugs”.

1.4. Linguagens de Programação


Podemos considerar uma linguagem de programação como um idioma qualquer,
o alemão ou japonês, por exemplo, pois uma linguagem de programação, assim como
os idiomas, é padronizada e possui regras de sintaxe para comunicar instruções,
sendo a linguagem de programação utilizada para se comunicar com o computador,
permitindo a um programador que especifique precisamente como o computador
deverá agir. Linguagens de programação são utilizadas para expressar algoritmos com
precisão.
A linguagem de programação tem como objetivo facilitar a comunicação do
programador com o computador, permitindo ao programador que expresse melhor
suas intenções por meio de uma linguagem de programação, em vez de programar na
linguagem do computador, que só entende números binários (0 e 1). Dessa forma, é
mais fácil o programador aprender uma linguagem de programação, como o Java ou
o C, que possuem uma sintaxe mais fácil de ser compreendida por nós, humanos, em
vez de aprender a linguagem da máquina, os números binários (0110001001010010).
As linguagens de programação tornam os programas mais portáteis, ou seja,
menos dependentes de computadores ou ambientes computacionais específicos, pois
programas escritos em linguagens de programação são traduzidos para o código de
máquina do computador no qual será executado, em vez de ser executado diretamente.
Podemos catalogar as linguagens de programação em dois tipos: de alto nível e
baixo nível. Lembramos que isso não significa superioridade de um tipo sobre o outro.
• Linguagem de programação de alto nível: Esse tipo de linguagem possui
um nível de abstração relativamente elevado, ou seja, é mais compreensível ao
ponto de vista humano, longe do código de máquina, que só é compreendida
pelos computadores. Portanto, o programador de uma linguagem de alto
nível não precisa conhecer características do processador, como instruções e
registradores, pois elas são abstraídas na linguagem de alto nível. Esse tipo de
linguagem é a mais utilizada atualmente.

24 L ó g i c a de Programação
• Linguagem de programação de baixo nível: Esse tipo de linguagem está
diretamente relacionado com a arquitetura do computador, pois esta
utiliza somente instruções do processador, sendo necessário conhecer os
registradores da máquina. Um programa desenvolvido em linguagem de
baixo nível permite máximo controle das instruções, tendendo a ser um
programa que exige velocidade de processamento.

1.4.1. Pseudolinguagem
Pseudolinguagem ou pseudocódigo são maneiras genéricas de se escrever um
algoritmo utilizando uma linguagem simples, que pode ser entendida por todos,
sem necessariamente conhecer uma linguagem de programação. Pelo fato de não
ser uma linguagem de programação padronizada, os algoritmos desenvolvidos com
pseudolinguagens não podem ser executados em sistemas reais. No entanto, foi criada
uma pseudolinguagem denominada Portugol, que nada mais é que um português
estruturado para escrever algoritmos.
Veja um simples esboço da pseudolinguagem Portugol, cujo objetivo é apenas
exibir a mensagem Olá Mundo:
ALGORITMO OláMundo

INÍCIO

ESCREVA (“Olá Mundo”)

FIM

Os livros e os cursos superiores da área de programação utilizam frequentemente


o pseudocódigo para ilustrar os seus exemplos e introduzir os conceitos iniciais sobre
programação e novas técnicas.
Observe a seguir um exemplo utilizando o Portugol para resolver outro problema,
que envolve a necessidade de ler dois números reais, calcular a multiplicação entre eles
e exibir o resultado na tela:
ALGORITMO multiplicacao
VARIÁVEIS
m: REAL
n: REAL
x: REAL
INÍCIO
LEIA m
LEIA n
x ← m × n
ESCREVA x
FIM

A declaração das variáveis deve ser feita antes da execução das instruções do
programa, ou seja, antes do INÍCIO do programa. Após a declaração das variáveis,
começa-se a montar a lógica para atingir o objetivo: a entrada dos dois números, o
processamento da multiplicação e a exibição do resultado.
Após esse processamento, o resultado armazenado na variável x é exibido na tela
do computador.

I n t r o d u ç ã o 25