Macromedia Flash MX 2004: Rich Media Design

Сomentários

Transcrição

Macromedia Flash MX 2004: Rich Media Design
Lógica de
Programação
UNIDADE 1 1.1
1.2
1.3
1.4
1.5
1.6
VISÃO GERAL DO PROCESSO DE DESENVOLVIMENTO DE APLICAÇÕES ........................................................................................ 3
LÓGICA DE PROGRAMAÇÃO ............................................................................................................................................ 4
SEQUÊNCIA LÓGICA....................................................................................................................................................... 4
INSTRUÇÕES ................................................................................................................................................................ 5
ALGORITMO ................................................................................................................................................................ 5
EXERCÍCIOS SUGERIDOS ................................................................................................................................................. 9
UNIDADE 2 2.1
2.2
2.3
2.4
CONTEÚDO DINÂMICO........................................................................................................................... 36
CONTEÚDO DINÂMICO - CONCEITO................................................................................................................................ 36
LINGUAGENS: ............................................................................................................................................................ 37
UNIDADE 9 9.1
9.2
9.3
9.4
9.5
9.6
9.7
9.8
SUBROTINAS (PROCEDIMENTOS E FUNÇÕES)......................................................................................... 33
UTILIZAÇÃO DE SUBROTINAS ......................................................................................................................................... 33
PROCEDIMENTOS........................................................................................................................................................ 34
FUNÇÕES .................................................................................................................................................................. 34
UNIDADE 8 8.1
8.2
VETORES E MATRIZES (ARRAYS) ............................................................................................................. 31
VETORES ................................................................................................................................................................... 31
MATRIZES ................................................................................................................................................................. 32
UNIDADE 7 7.1
7.2
7.3
ESTRUTURAS DE SEQUENCIAÇÃO, SELEÇÃO E REPETIÇÃO ..................................................................... 24
SEQUÊNCIA ............................................................................................................................................................... 24
SELEÇÃO ................................................................................................................................................................... 24
REPETIÇÃO ................................................................................................................................................................ 27
UNIDADE 6 6.1
6.1
COMANDOS DE ATRIBUIÇÃO, ENTRADA E SAÍDA DE DADOS ................................................................. 22
COMANDO DE ATRIBUIÇÃO........................................................................................................................................... 22
COMANDO DE ENTRADA DE DADOS ............................................................................................................................... 23
COMANDO DE SAÍDA DE DADOS .................................................................................................................................... 23
UNIDADE 5 5.1
5.2
5.3
ELEMENTOS BÁSICOS DO CÓDIGO ......................................................................................................... 16
VARIÁVEIS E CONSTANTES ............................................................................................................................................ 16
TIPOS PRIMITIVOS DE DADOS ........................................................................................................................................ 16
DECLARAÇÃO DE VARIÁVEIS .......................................................................................................................................... 17
UNIDADE 4 4.1
4.2
4.3
DIAGRAMAS DE FLUXO .......................................................................................................................... 10
DIAGRAMA DE NASSI-SHNEIDERMAN ............................................................................................................................. 10
FLUXOGRAMAS .......................................................................................................................................................... 12
LINGUAGEM NATURAL................................................................................................................................................. 14
PSEUDOCÓDIGO ......................................................................................................................................................... 14
UNIDADE 3 3.1
3.2
3.3
INTRODUÇÃO À LÓGICA DE PROGRAMAÇÃO ........................................................................................... 3
LINGUAGEM PHP.................................................................................................................................... 38
COMO CRIAR UM ARQUIVO PHP ................................................................................................................................... 38
DELIMITANDO O CÓDIGO PHP ...................................................................................................................................... 38
DELIMITADORES ALTERNATIVOS ..................................................................................................................................... 39
SEPARADORES DE INSTRUÇÕES ...................................................................................................................................... 39
COMENTÁRIOS ........................................................................................................................................................... 40
ESTRUTURAS DE DADOS ............................................................................................................................................... 41
VARIÁVEIS ................................................................................................................................................................. 41
CONSTANTES ............................................................................................................................................................. 41
2
9.9
9.10
9.11
ARRAYS .................................................................................................................................................................... 42
TIPOS DE DADOS SUPORTADOS ..................................................................................................................................... 43
ESTRUTURAS DE CONTROLE .......................................................................................................................................... 46
UNIDADE 10 10.1
10.2
10.3
10.4
10.5
ESTRUTURA BÁSICA DE UM PROGRAMA EM C ................................................................................................................... 52
COMANDO IF ............................................................................................................................................................. 53
ESTRUTURAS DE REPETIÇÃO .......................................................................................................................................... 54
ARRAYS (VETORES E MATRIZES) ..................................................................................................................................... 54
FUNÇÕES (SUBROTINAS) .............................................................................................................................................. 55
UNIDADE 11 11.1
11.2
11.3
11.4
LINGUAGEM C .................................................................................................................................... 52
FUNDAMENTOS ORIENTAÇÃO A OBJETOS ......................................................................................... 56
CONCEITOS BÁSICOS .................................................................................................................................................... 56
CLASSE ..................................................................................................................................................................... 59
COLABORAÇÃO .......................................................................................................................................................... 60
BENEFÍCIOS DA ORIENTAÇÃO A OBJETOS ......................................................................................................................... 61
UNIDADE 12 -
EXERCÍCIOS DE FIXAÇÃO .................................................................................................................... 63
3
Unidade 1 - Introdução à Lógica de
Programação
1.1 Visão geral do processo de desenvolvimento de
aplicações
Antes de começarmos a estudar lógica de programação, é importante que tenhamos uma visão
geral do processo de desenvolvimento de aplicações, uma vez que estudaremos lógica de
programação com o objetivo de conseguir um bom embasamento para a prática da programação
de computadores.
Podemos encontrar na literatura em informática várias formas de representação das etapas em
que consiste o processo de desenvolvimento de um programa ou aplicação. Estas formas de
representação podem variar tanto na quantidade de etapas como nas atividades que devem ser
realizadas por cada etapa.
A seguir apresentaremos uma forma de representação do processo de desenvolvimento de
software que é bastante encontrada na literatura:
Planejamento
Análise
Projeto
Implementaçã
o
Testes
Manutenção
Na figura, podemos ver o processo de desenvolvimento de programas dividido em seis etapas. A
seguir daremos uma rápida explicação das atividades realizadas em cada etapa.
Planejamento
Na etapa de planejamento é onde deve ser desenvolvido um plano inicial de desenvolvimento,
levando em considerações questões como definição da abrangência do sistema, missão e
objetivos do sistema, cronogramas de desenvolvimento, análise custo x benefício, levantamento
inicial de informações, etc.
Lógica de Programação
Análise
Também chamada de análise de requisitos, é onde deve se obter um claro entendimento sobre o
sistema. A análise proporciona a base para uma boa implementação do software.
Projeto
Também chamada de especificação do projeto, é onde propomos uma arquitetura de
implementação para o software, que atenda aos requisitos do sistema identificados na análise.
Aqui, passamos a nos preocupar com os diversos aspectos computacionais necessários para uma
boa implementação do software. Os algoritmos dos programas a serem implementados são
construídos nesta fase.
Implementação
A etapa de implementação é onde os programas são efetivamente construídos, a partir da
arquitetura de implementação feita na etapa anterior. Nesta etapa é onde a atividade de
codificação ocorre de forma massiva.
Teste
Nesta etapa os programas construídos serão testados de forma exaustiva. Existe uma grande
variedade de testes que são realizados, indo desde o teste unitário dos módulos de programas até
o teste de integração de todo o sistema de software.
Manutenção
É onde ocorrem ajustes do software implementado, que podem ser ocasionados por vários
motivos: erros de projeto identificados após a implementação e o teste do software, inovações
tecnológicas, evolução do sistema, etc..
1.2 Lógica de Programação
A lógica trata da correção do pensamento. Como filosofia ela procura saber por que pensamos de
uma forma e não de outra. Poderíamos dizer, também, que a Lógica é a arte de pensar
corretamente e, visto que a forma mais complexa de pensamento é o raciocínio, a Lógica estuda
ou tem em vista a "correção do pensamento".
A Lógica de Programação é necessária para pessoas que desejam trabalhar com
desenvolvimento de sistemas e programas, ela permite definir a sequência lógica para o
desenvolvimento.
Então, o que é Lógica?
Lógica de Programação é a técnica de encadear pensamentos para atingir determinado objetivo.
1.3 Sequência Lógica
Os pensamentos podem ser descritos como uma sequência de instruções, que devem ser
seguidas para cumprir uma determinada tarefa.
Podemos dar uma definição concreta:
Sequência Lógica são os passos executados até atingir um objetivo ou solução de um problema.
4
Lógica de Programação
1.4 Instruções
Na linguagem comum, entende-se por instruções "um conjunto de regras ou normas definidas
para a realização ou emprego de algo".
Em informática, porém, instrução é a informação que indica a um computador uma ação elementar
a ser executada.
Convém ressaltar que uma ordem isolada não permite realizar o processo completo, para isso é
necessário um conjunto de instruções colocadas em ordem sequencial lógica.
Por exemplo, se quisermos fazer uma omelete de batatas, precisaremos colocar em prática uma
série de instruções: descascar as batatas, bater os ovos, fritar as batatas, etc...
É evidente que essas instruções têm que ser executadas em uma ordem adequada – não se pode
fritar as batatas para depois descascá-las.
Dessa maneira, uma instrução tomada em separado, não tem muito sentido. Para obtermos o
resultado, precisamos colocar em prática o conjunto de todas as instruções, na ordem correta.
Instruções são um conjunto de regras ou normas definidas para a realização ou emprego de algo.
Em informática, é o que indica a um computador uma ação elementar a executar.
1.5 Algoritmo
A palavra algoritmo, à primeira vista, parece-nos estranha. Embora possua designação
desconhecida, fazemos uso constantemente de algoritmos em nosso cotidiano: a maneira como
uma pessoa toma banho é um algoritmo, por exemplo.
Outros algoritmos frequentemente encontrados são:
instruções para se utilizar um aparelho eletrodoméstico;
uma receita para preparo de algum prato;
guia de preenchimento para declaração do imposto de renda;
a regra para determinação de máximos e mínimos de funções por derivadas sucessivas;
a maneira como as contas de água, luz e telefone são calculadas mensalmente, dentre outros.
São vários os conceitos para algoritmo. Escolhemos alguns para serem apresentados aqui.
"Um conjunto finito de regras que provê uma sequência de operações para resolver um tipo
de problema específico"
Ronald Knuth
5
Lógica de Programação
"Sequência ordenada, e não ambígua, de passos que levam à solução de um dado
problema"
Tremblay
"Processo de cálculo, ou de resolução de um grupo de problemas semelhantes, em que se
estipulam, com generalidade e sem restrições, as regras formais para a obtenção do
resultado ou da solução do problema"
Dicionário Aurélio
Por que precisamos dele?
No desenvolvimento de programas, estaremos tratando constantemente com a complexidade
inerente aos problemas que desejamos que nosso programa de computador resolva. Para
tratarmos da complexidade dos problemas desenvolvemos algoritmos que devem expressar de
forma objetiva e clara a forma de solucionarmos esse problema.
A partir do algoritmo desenvolvido fica fácil construirmos o programa, basta conhecermos a
linguagem de programação que se pretende adotar. Uma vez construído o algoritmo, podemos
transportá-lo para qualquer linguagem de programação, o que nos dá uma flexibilidade para a
efetiva implementação do programa.
Características
Todo algoritmo deve apresentar algumas características básicas:

ter fim;

não dar margem à dupla interpretação (não ambíguo);

capacidade de receber dado(s) de entrada do mundo exterior;

poder gerar informações de saída para o mundo externo ao do ambiente do algoritmo;

ser efetivo (todas as etapas especificadas no algoritmo devem ser alcançáveis em um
tempo finito).
Formas de Representação
Existem várias ferramentas que podem ser utilizadas para a representação de algoritmos, entre
elas: linguagem natural, pseudocódigo (ou português estruturado), diagrama de NassiShneiderman (ou Chapin), fluxogramas, etc.
A seguir, veremos em nível de detalhe algumas delas.
Descrição Narrativa
Faz-se uso da linguagem natural para descrever algoritmos.
Exemplo:
Receita de Bolo
6
Lógica de Programação

Providencie ingredientes.

Misture os ingredientes.

Despeje a mistura na forma de bolo.

Leve a forma ao forno.

Espere 20 minutos.

Retire a forma do forno.

Deixe esfriar.

Prove.
Vantagens
Desvantagens
O idioma é bastante
conhecido por nós.
Imprecisão.
Pouca
confiabilidade
imprecisão
acarreta
desconfiança).
(a
a
Extensão
(normalmente,
escreve-se muito para dizer
pouca coisa).
Existem três estruturas básicas para a construção de algoritmos: sequenciacão, seleção e
repetição. A combinação destas três estruturas permite-nos a construção de algoritmos para a
resolução de problemas extremamente complexos. A programação estruturada baseia-se nestas
três estruturas básicas.
Imagine a seguinte situação: precisamos elaborar um algoritmo para trocar uma lâmpada.
Início
- pegue uma escada
- coloque-a embaixo da lâmpada
- busque uma lâmpada nova
- suba na escada com a lâmpada nova
- retire a lâmpada velha
- coloque a lâmpada nova
- desça da escada
Fim
7
Lógica de Programação
Observe que este algoritmo resolve o nosso problema da troca de lâmpada. No entanto, trata-se
de um algoritmo bastante simples, que se utiliza apenas da estrutura de sequenciação, ou seja,
nenhuma seleção ou repetição de procedimentos aparece no algoritmo. Uma estrutura de
sequência, caracteriza-se por possuir uma única sequência de ações, que é executada apenas
uma vez.
No entanto, antes de trocarmos a lâmpada devemos nos certificar de que ela realmente esteja
queimada, para então trocá-la. Assim, podemos melhorar nosso algoritmo.
Início
- ligue o interruptor
- se a lampada não acender, então:
- pegue uma escada
- coloque-a embaixo da lâmpada
- busque uma lâmpada nova
- suba na escada com a lâmpada nova
- retire a lâmpada velha
- coloque a lâmpada nova
- desça da escada
Fim
Agora o nosso algoritmo, além da estrutura, de sequência, passa a utilizar uma estrutura de
seleção. Na estrutura de seleção, uma condição deve ser analisada e, a partir do resultado da
análise, um "caminho" do algoritmo será executado. Em outras palavras, uma estrutura de seleção
escolhe ações a serem executadas a partir de uma condição (que pode ser simples ou composta).
Embora nosso algoritmo tenha melhorado, ainda podemos deixá-lo mais completo. Quando
verificamos que a lâmpada está queimada, subimos para trocá-la, mas não consideramos a
hipótese da lâmpada nova também estar queimada. Se isso ocorrer, precisaremos executar
algumas ações novamente, até que possamos efetivamente resolver nosso problema.
Início
- ligue o interruptor
- se a lâmpada não acender, então:
- pegue uma escada
- coloque-a embaixo da lâmpada
- enquanto a lâmpada não acender, faça:
- busque uma lâmpada nova
- suba na escada com a lâmpada nova
- retire a lâmpada velha
- coloque a lâmpada nova
- desça da escada
Fim
8
Lógica de Programação
Neste algoritmo, somente iremos parar de trocar a lâmpada quando colocarmos uma lâmpada que
acenda. Portanto, um conjunto de ações será executado repetidamente enquanto a condição de
repetição for verdadeira. Assim, inserimos uma estrutura de repetição no nosso algoritmo, que
passa a trabalhar com as três estruturas básicas de construção de algoritmos.
É importante salientar que existem várias formas de se construir um algoritmo, pois as pessoas
pensam de formas diferentes. No entanto, devemos sempre buscar a forma mais otimizada
possível (dentro dos limites impostos pela situação).
1.6 Exercícios Sugeridos
1) Crie uma sequência lógica para tomar banho.
a) Solução somente com estrutura sequencial:
b) Solução usando estrutura de seleção:
c) Solução com as três estruturas – sequência, seleção e repetição:
2) Descreva os passos necessários para somar dois números e multiplicar o resultado pelo primeiro número.
2) Descreva com detalhes a sequência lógica para trocar um pneu de um carro.
9
Lógica de Programação
Unidade 2 - Diagramas de Fluxo
2.1 Diagrama de Nassi-Shneiderman
Também conhecido como diagrama de Chapin, esta ferramenta de representação oferece grande
clareza para a representação de sequenciação, seleção e repetição num algoritmo, utilizando-se
de uma simbologia própria.
A idéia básica deste diagrama é representar as ações de um algoritmo dentro de um único
retângulo, subdividindo-o em retângulos menores, que representam os diferentes blocos de
sequência de ações do algoritmo. Seleção e repetição também são representadas de forma
gráfica, dentro dos retângulos
Sequência
Ação - 1
Ação - 2
Ação - 3
Seleção
Condição
V
Ações
F
Ações
10
Lógica de Programação
Repetição
Enquanto (cond) faça
Ações
Ações
Repetir até (condição)
Exemplo
Queremos resolver o seguinte problema: Calcular a média de todos os alunos que cursaram uma
disciplina X, a partir da leitura das notas da 1ª e 2ª prova, passando por um cálculo de média
aritmética. Após a média calculada, devemos anunciar se o aluno foi aprovado ou reprovado por
nota. Somente estão aprovados os alunos com média maior ou igual à 5,0.
Enquanto (não for fim da lista de alunos) faça
Leia nota1
Leia nota2
Leia nota3
Media = (nota1+nota2)/2
Media >= 5.0
V
Aluno Aprovado
F
Aluno Reprovado
11
Lógica de Programação
Embora os diagramas N-S ofereçam uma representação muito clara do algoritmo, à medida que os
algoritmos vão se tornando mais complexos, fica difícil realizar os desenhos necessários numa
única página, prejudicando a sua visualização.
2.2 Fluxogramas
O fluxograma foi utilizado por muito tempo para a representação de algoritmos. No entanto, o seu
grande problema é permitir o desenvolvimento de algoritmos não estruturados. Com o advento das
linguagens de programação estruturada o fluxograma caiu em desuso.
O fluxograma utiliza-se de símbolos específicos para a representação de algoritmos. Existe uma
certa variação na simbologia empregada, mas mesmo assim, apresentaremos a seguir uma
simbologia tradicionalmente usada:
Processo
Decisão
Leitura
Escrita
Conector
Terminal
Setas de Fluxo de Controle
12
Lógica de Programação
Exemplo
Com base no exemplo anterior, feito com N-S, complete o fluxograma abaixo:
Vantagens
Desvantagens
É uma das ferramentas mais
conhecidas.
Pouca atenção aos dados, não
oferecendo recursos para descrevêlos ou representá-los.
Figuras dizem muito mais do
que palavras.
Complica-se à medida que o
algoritmo cresce.
Padrão mundial.
13
Lógica de Programação
2.3 Linguagem Natural
A representação de algoritmos através de linguagem natural é a forma mais espontânea de
representação de algoritmos, pois descrevemos os passos do algoritmo utilizando o nosso
linguajar cotidiano, escrevendo o algoritmo como um texto simples.
Representação
Para todos os alunos da disciplina X, faça: ler as notas da 1ª e 2ª prova, somar as notas e dividir
por dois, chegando assim, ao resultado da média do aluno. Se a média do aluno for maior ou igual
a 5,0, então o aluno está aprovado, senão o aluno está reprovado. Fazer para o próximo aluno.
O problema da representação de algoritmos com linguagem natural é que quanto maior a
complexidade do problema, maior a dificuldade de entendermos o texto que procura descrever os
passos do algoritmo, pois não se emprega nenhum recurso diagramático, e não há uma rigidez na
estruturação das ações.
2.4 Pseudocódigo
O pseudocódigo vem sendo amplamente utilizado por projetistas de softwares e programadores,
pois obriga o uso de estruturas que facilitem o entendimento do algoritmo, e também facilitam a
transformação do mesmo em códigos reais.
O pseudocódigo também recebe outros nomes, como: português estruturado, PDL (Program
Design Language), pascalóide, etc.. Utilizaremos neste curso o pseudocódigo como a forma de
representação padrão para algoritmos. Um dos ambientes que “entende” o pseudocódigo ou
português estruturado é o AMBAP (Ambiente de Aprendizado de Programação desenvolvido pela
UFAL – Universidade Federal de Alagoas).
O exemplo anterior será representado através de pseudocódigo.
//Algoritmo MediaAluno
variaveis
numerico nota1, nota2, media
inicio
faca enquanto (não for fim da lista de alunos)
leia (nota1)
leia (nota2)
media = (nota1+nota2)/2
se (media >= 5.0)entao
escreva ("Aluno aprovado")
senao
escreva ("Aluno reprovado")
14
Lógica de Programação
fim_se
fim_enquanto
fim
Observe que no pseudocódigo, somos obrigados a utilizar algumas estruturas básicas de controle
(sequência, seleção e repetição), de forma a estruturar e organizar melhor os passos do algoritmo.
15
Lógica de Programação
Unidade 3 - Elementos Básicos
do Código
3.1 Variáveis e Constantes
Variáveis e constantes são conceitos fundamentais para a construção de algoritmos e programas
de computadores, pois são através deles que um algoritmo "guarda" os dados do problema.
Todo dado que tem a possibilidade de ser alterado (portanto, sofrer variação) no decorrer do
tempo, deverá ser tratado como uma variável do problema e, portanto, deverá ser definido como
tal no algoritmo a ser desenvolvido.
Quando um dado não tem nenhuma possibilidade de variar com o decorrer do tempo, ele deverá
ser tratado como uma constante, e dessa forma definido e tratado como tal no algoritmo.
Por exemplo, considere o desenvolvimento de um algoritmo para o seguinte problema: calcular as
áreas de cinco triângulos com medidas diferentes. Sabemos que a fórmula para o cálculo da área
de um triângulo é "b*h / 2", onde "b" é o valor da base e "h" é o valor da altura do triângulo. Sendo
assim, "b" e "h" são dados que irão variar no decorrer do "tempo de execução" do algoritmo,
portanto deverão ser tratados como variáveis. O número "2" da fórmula é um dado constante e não
sofrerá variação no decorrer do algoritmo, portanto, deve ser tratado como constante.
Variáveis e constantes são, em um algoritmo ou programa, nomes que identificam os valores
tratados no problema. Estes nomes devem seguir algumas normas e regras para poderem
funcionar corretamente:
Devem começar por um caractere alfabético;
Podem ser seguidos por mais caracteres alfabéticos e/ou numéricos;
Não é permitido o uso de caracteres especiais, como: @, #, &, *, +, ?, etc. (exceto o sublinhado),
nem espaços em branco.
De maneira geral, devem ser legíveis e de fácil compreensão dentro do contexto, a fim de viabilizar
o entendimento para outros programadores.
Exemplos:
X, x3, teste, altura1, nota2, abc213, a1b2c3, etc.
3.2 Tipos Primitivos de Dados
16
Lógica de Programação
Todo dado a ser tratado num algoritmo deve pertencer a algum tipo, que irá determinar o domínio
de seu conteúdo. Os tipos mais comuns de dados são conhecidos como tipos primitivos de dados,
são eles: numérico, texto (ou caracter) e lógico1.
Neste curso, usaremos para a construção de nossos exercícios somente estes três tipos, mas
saiba que existem vários outros e que, em outras bibliografias serão mais detalhistas.
Numérico: todos os valores do tipo numérico seja ele positivo, negativo, zero, ponto flutuante,
decimal, etc.
Texto: todo e qualquer dado composto por um conjunto de caracteres alfanuméricos (números,
letras e caracteres especiais), desde que estejam entre aspas.
Lógico: todo e qualquer dado que só pode assumir duas situações – verdadeiro ou falso
(biestáveis).
3.3 Declaração de Variáveis
Para elaborarmos nossos algoritmos deveremos, antes de tudo, "listar" todas as variáveis que
utilizaremos na construção do programa. Esse método é muito útil principalmente para códigos
muito extensos, uma vez que, na maioria das linguagens de scripts não é necessário declararmos
as variáveis.
Fazemos a declaração de variáveis obedecendo ao seguinte padrão:
//Algoritmo TesteVariaveis
variaveis
tipo: nome_variavel, nome2_variavel, etc
inicio
1
Na Unidade 14 encontram-se maiores explicações sobre a linguagem PHP, e na Unidade 15 sobre a linguagem C.
17
Lógica de Programação
<desenvolvimento>
fim
Onde:
Tipo pode ser numérico, caracter ou lógico.
Nome_variavel é o identificador da variável.
Operadores (aritméticos, relacionais e lógicos)
Quando construímos algoritmos é comum trabalharmos com expressões matemáticas para a
resolução de alguns problemas. As expressões matemáticas podem fazer uso de operadores
aritméticos e relacionais.
Chamamos de operadores aritméticos o conjunto de símbolos que representa as operações
básicas da matemática, conforme tabela a seguir:
Operações
Operadores
Linguagem C
Adição
+
Subtração
–
Multiplicação
*
Divisão
/
Potenciação
^
Módulo (resto da
divisão)
Resto(x,y)
Linguagem
PHP
Não possuem um símbolo,
fazem por função da linguagem
%
%
Há também um operador aritmético especial para obter o resto de uma divisão inteira. Usaremos
para essa operação a função "resto".
Exemplo: resto(20, 3) = 2.
Um outro grupo importante de operadores é formado pelos operadores relacionais. Quando
queremos fazer comparações entre valores, ou entre expressões (tanto matemáticas como
lógicas), precisamos utilizar esta categoria de operadores. Os operadores relacionais são:
Operações Operadores Linguagem Linguagem
C
PHP
Igualdade
=
==
Diferença
<>
!=
Maior
>
Menor
<
Maior
ou >=
18
Lógica de Programação
igual
Menor ou <=
igual
O resultado de uma relação é sempre um valor lógico (verdadeiro ou falso).
Exemplos:
a) 2+5 = 3+2  F (falso)
b) 3*5 <> 2*3  V (verdadeiro)
Uma terceira categoria de operadores que podemos utilizar na construção de algoritmos é
chamada de operadores lógicos. Estes operadores funcionam como conectivos para a formação
de novas proposições.
Os principais operadores lógicos são:
Operações
Operadores
Linguagem C
Conjunção (e)
E
&&
Disjunção (ou)
OU
||
Negação
(não)
NAO
!
Linguagem
PHP
Os resultados das operações lógicas são sempre valores lógicos (verdadeiro ou falso).
Para trabalharmos adequadamente com operadores lógicos, temos que conhecer a tabela verdade
para cada um dos operadores. Uma tabela verdade é o conjunto de todas as possibilidades
combinatórias entre os valores das variáveis lógicas, conforme apresentado a seguir:
A
B
AEB
F
F
F
F
V
F
V
F
F
V
V
V
A
B
F
F
A OU B
F
19
Lógica de Programação
F
V
V
V
F
V
V
V
V
A
NÃO( A)
F
V
V
F
Exemplos:
a) 3 > 6 OU 4 < 5
F OU V
Resultado: V
b) 4 < 7 E 5 > 9
V E F
Resultado: F
Na resolução das expressões aritméticas, lógicas e relacionais, os operadores e as funções
matemáticas possuem uma hierarquia de prioridade.
Parênteses mais internos
Funções matemáticas
^
*
/
resto
+
operadores relacionais
não
e
ou
20
Lógica de Programação
Exemplo:
Não( 2^3 < 4^2) ou abs(int(15/-2)) < 10
Não
8
Não
< 16 ou abs (int(-7,5)) < 10
8 < 16 ou abs (-7)
Não
8 < 16
ou
Não( V )
F
7
ou
ou
<
<
10
10
V
V
V
Exercícios Sugeridos
1) Sabendo que A=3, B=7 e C=4, informe se as expressões abaixo são verdadeiras ou falsas.
(A+C) > B ( )
B >= (A+2) ( )
C = (B-C) ( )
(B+A) <= C ( )
(C+A) > B ( )
2) Sabendo que A=5, B=4, C=3 e D=6, informe se as expressões abaixo são verdadeiras ou
falsas.
(A>C) AND (C<=D)
( )
(A+B) > 10 OR (A+B) = (C+D) ( )
(A>=C) AND (D>=C)
( )
21
Lógica de Programação
Unidade 4 - Comandos de Atribuição,
Entrada e Saída de Dados
4.1 Comando de Atribuição
O comando de atribuição permite-nos atribuir um valor para uma variável, sendo que tipo do dado
atribuído para a variável deve ser compatível com o tipo declarado para a variável. A sintaxe
utilizada será:
Identificador := expressão2
onde identificador é o nome da variável que receberá o valor da expressão.
Exemplo:
X := 0
Y := 10 + 7
A := 0.098
Nome := "teste de atribuição"
Z := verdadeiro
2
Nas linguagens C e PHP o símbolo de atribuição é =, por exemplo, x = 5. Já, nestas linguagens a igualdade é
representada por ==.
22
Lógica de Programação
4.2 Comando de Entrada de Dados
Na prática de construção de programas, será muito comum o uso de comandos que proporcionam
a entrada de dados para o computador. Assim, devemos ter uma representação correspondente
em nível de algoritmo para a entrada de dados. Utilizaremos o comando ler para efetuar a entrada
de dados para o algoritmo, conforme sintaxe abaixo.
Ler variável
Sendo que variável receberá um valor vindo de "fora" do algoritmo para que algum processamento
ocorra.
4.3 Comando de Saída de Dados
Além do comando de entrada de dados será muito comum o uso de comandos que proporcionem
a saída de dados gerados pelo computador. Assim, devemos ter uma representação
correspondente em nível de algoritmo para a saída de dados. Utilizaremos o comando escrever
para efetuar a saída de dados do algoritmo, conforme sintaxe abaixo:
Escrever variável, constante, expressão
Neste exemplo, o algoritmo mostrará os valores de variáveis, constantes e/ou expressões.
//Algoritmo Exemplo
variaveis
numerico x, y, a, res
caracter nome
INICIO
Escrever "Entre com o primeiro valor:"
Ler x
Escrever "Entre com o segundo valor:"
Ler y
Escrever "Entre com o nome da pessoa:"
Ler nome
a:= x * 3 / y
res := (a * 2.4)/3
Escrever "O resultado foi: ", res
FIM
23
Lógica de Programação
Unidade 5 - Estruturas de Sequenciação,
Seleção e Repetição
5.1 Sequência
A estrutura de sequência é a estrutura mais simples que utilizamos na construção de algoritmos
estruturados. Ela é formada por um conjunto de instruções (ou comandos) que serão executadas
numa sequência linear de cima para baixo e da esquerda para a direita, ou seja, da mesma forma
como elas foram escritas. Utilizamos as palavras inicio e fim para delimitar o bloco de sequência,
conforme abaixo:
Exemplo:
INICIO
Ler a
Ler b
c := a + b
Escrever c
FIM
5.2 Seleção
Uma estrutura de seleção permite a escolha de um conjunto de ações e/ou estruturas que serão
executadas a partir do resultado de uma condição (simples ou composta), representada por uma
expressão lógica.
Utilizaremos a seguinte representação para estruturas de seleção:
se (condição) entao
comando 1
comando 2
comando 3
...
fim_se
No caso acima, os comandos somente serão executados se a condição for verdadeira, caso
contrário, o programa continua executando os próximos passos logo após o símbolo de
fechamento de chaves.
Temos ainda a possibilidade de outras representações mais elaboradas, como as que seguem:
24
Lógica de Programação
se (condição) entao
comandos
...
senao
comandos
...
fim_se
ou
se (condição) entao
comandos
...
senao
se (condição) entao
comandos
...
senao
se (condição)entao
comandos
...
senao
comandos
...
fim_se
fim_se
fim_se
Nesses dois casos descritos acima, serão executados os comandos apenas de uma das
condições e somente se ela for verdadeira. Caso não haja condições verdadeiras serão
executados os comandos definidos dentro do bloco senão.
Teste de Mesa
É uma simulação da execução de um programa ou plano, usando para isso simplesmente papel e
lápis para registrar o que teoricamente ocorre em cada passo. Serve para visualizarmos todas as
etapas que o computador realiza durante a execução do algoritmo.
Exemplo de Algoritmo
Receba a nota da prova1
25
Lógica de Programação
Receba a nota de prova2
Receba a nota de prova3
Receba a nota da prova4
Some todas as notas e divida o resultado por 4
Mostre o resultado da divisão
Faça o teste de mesa:
Nota da Prova 1
Nota da Prova 2
Nota da Prova 3
Nota da Prova 4
Utilize a tabela abaixo:
Exercícios
1) Identifique os dados de entrada, processamento e saída no algoritmo abaixo.
Receba código da peça
Receba valor da peça
Receba quantidade de peças
Calcule o valor total da peça
Mostre o código da peça e seu valor total
2) Faça um algoritmo para calcular o estoque médio de uma peça, sendo informado o estoque
mínimo e o estoque máximo.
3) Construa um algoritmo que leia a cotação do dólar, leia valores em dólar, converta esse
valor para real e mostre o resultado.
4) Desenvolva um algoritmo que leia 4 números, calcule o quadrado de cada um, some todos
os resultados e mostre o resultado.
5) Construa um algoritmo para pagamento de comissão de vendedores de peças, levando em
consideração que sua comissão será de 5% do total da venda e que você tem os seguintes
dados: preço unitário da peça e quantidade vendida.
6) João comprou um microcomputador para controlar o rendimento diário de seu trabalho.
Toda vez que ele traz um peso de peixes maior que o estabelecido pelo regulamento de
pesca do Estado (50 quilos) deve pagar uma multa de R$ 4,00 por quilo excedente. João
precisa que você faça um algoritmo que leia a variável P (peso do peixe) e verifique se há
26
Lógica de Programação
excesso. Se houver, gravar na variável E (excesso) e na variável M o valor da multa que
João deverá pagar. Caso contrário, mostrar tais variáveis com o conteúdo zero.
7) Elabore um algoritmo que leia as variáveis C e N, respectivamente código e número de
horas trabalhadas de um operário. Após, calcule o salário sabendo-se que ele ganha R$
10,00 por hora. Quando o número de horas exceder a 50, calcule o excesso de pagamento
armazenando-o na variável E, caso contrário zerar tal variável. A hora excedente de
trabalho vale R$ 20,00. No final do processamento mostrar o salário total e o salário
excedente.
8) Escreva um algoritmo que leia quatro números, calcule o quadrado de cada um e some
todos. Se o quadrado do terceiro for maior que mil (1000), mostre o número original e
finalize o programa. Caso contrário, mostre o resultado de todos.
9) Escreva um algoritmo que leia um número inteiro e mostre uma mensagem dizendo se este
número é par ou ímpar, positivo ou negativo.
10) A Secretaria do Meio Ambiente que controla o índice de poluição mantém três grupos de
indústrias que são altamente poluentes do meio ambiente. O índice de poluição aceitável
varia de 0,05 até 0,25. Se o índice sobe para 0,30 as indústrias do 1° grupo são intimadas
a suspenderem suas atividades. Se o índice crescer para 0,4 as indústrias do 1° e 2° grupo
são intimadas a suspenderem suas atividades. Se o índice atingir 0,50 todos os grupos
devem ser notificados a paralisarem suas atividades. Faça um algoritmo que leia o índice
de poluição medido e emita a notificação adequada aos diferentes grupos de empresas.
11) Elabore um algoritmo que, dada a idade de um nadador, classifique-o em uma das
seguintes categorias:
INFANTIL A: 5 a 7 anos
INFANTIL B: 8 a 11 anos
JUVENIL A: 12 a 13 anos
JUVENIL B: 14 a 17 anos
ADULTOS: Maiores de 18 anos.
5.3 Repetição
Laços Condicionais e Contados
A estrutura de repetição permite que uma sequência de comandos seja executada um certo
número de vezes até que uma determinada condição seja satisfeita. Por exemplo, pode-se citar o
caso em que se deseja realizar o mesmo processamento para um conjunto de dados diferentes,
como a folha de pagamento de uma empresa de 100 funcionários. Neste caso o mesmo cálculo é
efetuado para cada um dos funcionários. Para solucionar este problema precisaríamos escrever o
algoritmo em questão uma vez para cada funcionário, ou seja, sendo 100 funcionários teríamos
que escrevê-lo 100 vezes.
Outro modo de resolver essa questão seria utilizar a mesma sequência de comandos, ou seja,
fazer a repetição de um conjunto de comandos 100 vezes sem ter que reescrevê-lo novamente.
27
Lógica de Programação
A estrutura de repetição é também chamada de laço ou loop e se divide em:
Laços Condicionais
Quando não se conhece o número de vezes que um conjunto de comandos no interior do laço
será repetido. A repetição ou não dos comandos dependerá do resultado de uma condição. As
estruturas de repetição que implementam esse tipo de laço usam testes no início e testes no final
do laço.
Laços Contados
Quando se conhece, previamente, quantas vezes o conjunto de comandos será executado. Esse
tipo de estrutura usa variável de controle.
Repetição com Teste no Início
Caracteriza-se por uma estrutura que efetua um teste lógico no início do laço. Se o resultado do
teste for verdadeiro o laço é executado retornando novamente ao teste lógico e assim o processo
será repetido enquanto a condição testada for verdadeira.
Sintaxe:
faca enquanto (cond)
comando 1
comando 2
...
fim_enquanto
Repetição com Teste no Final
28
Lógica de Programação
Caracteriza-se por uma estrutura que permite que um laço seja executado até que o resultado do
teste lógico seja verdadeiro. Neste caso o laço é executado pelo menos uma vez e então a
condição é testada, se o resultado for falso o laço é executado novamente e este processo é
repetido até que o resultado da condição seja verdadeiro. A diferença que existe dessa estrutura
para a anterior é o fato de ser executada pelo menos uma vez antes de passar pela condição de
teste3.
Sintaxe:
faca
comando 1
comando 2
...
enquanto (cond)
Repetição com Variável de Controle
É utilizada quando se conhece previamente o número de vezes que se deseja executar um
determinado conjunto de comandos. Esse tipo de laço nada mais é que uma estrutura dotada de
mecanismos próprios para contar o número de vezes que o laço vai ser executado obedecendo os
limites fixados.
Sintaxe:
para variavel de valor_inicio ate valor_final passo incremento
comando 1
comando 2
...
3
No AMBAP é implementada somente repetição teste condicional no início, porém, em várias linguagens de
programação existem as duas formas apresentadas, por isso constam na apostila.
29
Lógica de Programação
proximo
onde: variável é inicializada com o valor de valor_inicio e, subsequentemente, incrementada de
incremento, executando comando1, comando2, ... até que variável atinja o valor_final. Caso a
expressão passo seja omitida, o valor padrão 1 é assumido.
Exercícios Sugeridos
1) Escreva um algoritmo que leia as notas finais dos alunos de uma disciplina e calcule a média
da turma.
2) Escreva um algoritmo que leia o nome o sexo a altura e o peso de um grupo de 250 pessoas e
informe: Média das alturas das mulheres e o nome do homem mais pesado.
3) Escreva um algoritmo que leia dois números inteiros (inicial e final) e mostre os números pares
desse intervalo. Além disso, deve mostrar também quantos são e qual é a soma desses
números.
4) Construa um algoritmo que leia 500 valores inteiros positivos e encontre o maior valor, o
menor valor e calcule a média dos números lidos.
30
Lógica de Programação
Unidade 6 - Vetores e Matrizes (Arrays)
6.1 Vetores
Vetores são estruturas de dados que permitem o armazenamento de um conjunto de dados, que
podem ser referenciados por um mesmo nome e acessados por um índice.
Diferentes linguagens implementam vetores de diferentes formas, podendo restringir seu uso
apenas a vetores homogêneos (em que todos os dados da estrutura tem o mesmo tipo) ou aceitar
vetores heterogêneos (em que cada dado pode ser de um tipo diferente). Também pode ser
possível construir vetores multi-dimensionais, indexados por mais de um índice.
No exemplo abaixo observamos um exemplo de um vetor homogêneo unidimensional (o tipo mais
utilizado e que deve ser o primeiro que o aluno deve entender e dominar).
Exemplo:
//Algoritmo Soma_Valores
variaveis
matriz numerico vet[50]
numerico soma, i, val
INICIO
val := 50
escrever "entre com ", val, " valores"
para i de 1 ate val
ler vet[ i ]
proximo
soma:=0
para i de 1 ate val
soma = soma + vet[ i ]
proximo
escrever "a soma foi", soma
FIM
Observando o código anterior, o uso do vetor é razoavelmente claro. Inicialmente ele é utilizado
para armazenar os valores que vão sendo lidos, e em seguida é utilizado no cálculo da variável
Soma.
31
Lógica de Programação
Obviamente o exemplo acima poderia ser reproduzido sem o uso de vetores, com o cálculo da
variável Soma durante a leitura. Porém, isto pode não ser possível em exemplos mais complexos,
como os sugeridos a seguir.
6.1 Matrizes
A matriz mais comum é a de duas dimensões (linha e coluna), por se relacionar diretamente com
a utilização de tabelas. Trabalharemos somente com matrizes de 2 dimensões, por serem mais
comuns, mas podem ser necessárias, em algum momento, matrizes de 3 ou mais dimensões.
Uma matriz de 2 dimensões estará sempre fazendo menção a linhas e colunas e será
representada por seu nome e tamanho. Dessa forma, uma matriz Tabela[8,5] indica que tem 8
linhas e 5 colunas, conforme a figura.
A matriz pode ser declarada da seguinte forma:
variaveis
matriz numerico M[10,10]
Exercícios Sugeridos
1)
Crie uma novo algoritmo, com base no algoritmo sobre vetores, em que após a leitura de
todos os dados, pergunte ao usuário se ele deseja a multiplicação dos dados lidos, sua soma ou o
cálculo de sua média. Conforme a entrada informada pelo usuário, uma resposta diferente é
fornecida pelo sistema.
2)
Faça um algoritmo também baseado no exemplo, que após terminada a entrada de dados,
exiba todos os números do vetor de forma ordenada.
32
Lógica de Programação
Unidade 7 - Subrotinas (procedimentos e
funções)
7.1 Utilização de subrotinas
À medida que a complexidade de um algoritmo aumenta, surge a necessidade de dividir um
grande problema em problemas menores, para que seja compreendido mais facilmente. Dessa
forma, cada parte menor (módulo) tem um algoritmo mais simples, e esse trecho menor é
chamado de subrotina.
Além de facilitar a compreensão do algoritmo, as subrotinas possibilitam que determinados
trechos de programas sejam aproveitados em outros programas. Isso facilita a correção, pois, se
uma rotina para verificar se um número é ou não primo está incorreta, por exemplo, sabe-se
exatamente qual é o trecho do programa que deve ser arrumado.
Rotinas que ficam demasiado complexas podem ainda ser divididas em diversas outras rotinas
mais simples. O processo de dividir uma subrotina em outras é denominado refinamento
sucessivo.
O processo de se programar um computador torna-se bastante simples quando aplicado algum
método para utilização das subrotinas. Um dos métodos mais utilizados na programação
estruturada é o método TOP-DOWN (de cima para baixo) que se caracteriza por:
Antes de iniciar a construção do programa, o programador deverá ter em mente as tarefas
principais que esse programa deverá executar. Não é necessário saber como funcionarão,
somente saber quais são.
Deve-se ter em mente como será o funcionamento do programa principal, que controlará todas as
tarefas distribuídas em subrotinas.
Uma vez definido o programa principal, detalha-se então as subrotinas. São definidos vários
algoritmos, um para cada rotina em separado, para que se tenha uma visão do que será
executado em cada módulo de programa. Isso também facilita a manutenção (alterações
posteriores necessárias).
O método Top-Down pode ser graficamente visualizado conforme a figura:
33
Lógica de Programação
Existem dois tipos de sub-rotinas a serem utilizados na programação, conhecidos como
procedimentos (procedures) e funções (functions). As diferenças entre eles são apresentadas a
seguir.
7.2 Procedimentos
São, na realidade, trechos de programas independentes mas que, para serem processados,
devem ser solicitados pelo programa principal. Exemplo:
procedimento NomeProcedimento ( lista de parâmetros )
inicio
<comandos>
fim
A lista de parâmetros, definida no cabeçalho do procedimento, produz a comunicação de dados
entre o procedimento e quem o chamou. O procedimento pode ter de nenhum a vários parâmetros,
sendo que também pode ter vários parâmetros de entrada, de saída ou ambos. Exemplos:
...
limpa_tela // sem nenhum parâmetro
...
limpa_tela(01,01,24,80) // com parâmetros de entrada somente
...
Fatorial (5; retorno) // 5 é parâmetro de entrada e retorno é parâmetro de
saída
escrever retorno
...
7.3 Funções
É um caso particular de procedimentos. A diferença porém, é que apenas uma informação é
retornada ao programa que a chamou, ou seja, os parâmetros, se existentes, são todos de entrada
e obrigatoriamente há uma e somente uma saída ou retorno para o programa principal.
Algumas linguagens obrigam que a chamada de função nunca seja sozinha, como os
procedimentos, mas sim fazendo parte de um comando de atribuição ou de uma expressão. A sua
declaração segue o seguinte formato:
Funcao NomeFunção ( lista de parâmetros)
inicio
<comandos>
retornar ( parâmetro )
fim
Exemplos do uso de funções:
variaveis
34
Lógica de Programação
numerico A,B
Funcao Soma (A, B)
variaveis
numerico x
inicio
x := A + B
retornar(x)
fim
//Programa principal
Inicio
Ler A
Ler B
escrever "Soma de A e B:", Soma(A,B)
Fim
As rotinas podem ficar no início de um programa, no final ou ainda em um arquivo separado,
dependendo da linguagem utilizada. Uma função pode ainda retornar um valor verdadeiro (v) ou
Falso (f).
Nesse caso, as rotinas 1, 1.1 e 2
"enxergam" as variáveis A e B, porém,
dentro da Rotina 1, a variável A é
definida novamente. Dessa forma, o novo
valor da variável será válido para a rotina
1.1.
As variáveis X e Y não serão
visualizadas pelo programa principal.
A variável X presente na rotina 2 não
interfere na variável X que está na rotina
1 (são independentes).
A estas peculiaridades
Escopo de Variáveis.
denomina-se
35
Lógica de Programação
Unidade 8 - Conteúdo Dinâmico
8.1 Conteúdo Dinâmico - Conceito
A linguagem HTML permite a criação de páginas para a Web contendo texto, imagens, etc, mas
uma limitação desta linguagem é que não é possível produzir conteúdo que sofra mudanças de
acordo com fatores externos.
Para isso criou-se as linguagens conhecidas como Server side, ou seja, linguagens que são
processadas no servidor web e nos permitem uma gama de recursos que até então não existiam,
como por exemplo:
- Utilização de variáveis
- Processamento de dados de formulários
- Acesso a bancos de dados
Quando navegamos por um site chamado estático, ou seja, com conteúdo imutável, a cada clique
disparamos o seguinte processo:

1- O navegador solicita ao servidor uma página HTML.
2- O servidor procura por este arquivo e o retorna para o navegador.
Agora veja a diferença quando navegamos por um site com conteúdo dinâmico:
36
Lógica de Programação

1. O navegador solicita ao servidor um arquivo de linguagem server side.
2. O servidor procura por este arquivo e passa para o interpretador desta linguagem, que processa
os comandos contidos neste arquivo.
3. Após o processamento o interpretador retorna para o servidor Web o resultado deste
processamento, formatado em HTML.
4. O Servidor então, retorna ao navegador este resultado.
8.2 Linguagens:
Entre as linguagens mais populares atualmente no desenvolvimento de sites dinâmicos podemos
citar o ASP (Active Server Pages, mantido pela Microsoft), JSP (Java Server Pages, mantido pela
SUN) e o PHP (PHP Hypertext Preprocessor, mantido pelo PHP Group).
Resumo:
- Websites dinâmicos possuem como principal característica páginas que têm conteúdos que
podem variar de acordo com fatores externos ao código HTML.
- As duas principais linguagens utilizadas no desenvolvimento de websites dinâmicos são o ASP,
da Microsoft e o PHP, do PHP Group.
37
Lógica de Programação
Unidade 9 - Linguagem PHP
PHP é uma linguagem server side que foi criada originalmente pelo programador Rasmus Lerdorf
para utilização em seu site pessoal. Originalmente a sigla queria dizer Personal Home Page,
significado que demonstrava bem que a linguagem ainda dava seus primeiros e despretensiosos
passos.
A linguagem que mais influenciou o PHP foi à linguagem Perl, utilizada no início da web
principalmente para o tratamento de dados de formulários com os famosos “scripts CGI”.
Após a adição de um pacote para tratamento de dados de formulário e outro que dava suporte à
conexão com bancos de dados mSQL (miniSQL), a linguagem foi disponibilizada para o público e
passou a receber contribuições de diversos programadores.
A primeira versão do PHP utilizada em larga escala foi à versão 3, que embora contendo
pequenos bugs, já era utilizada por milhares de websites.
Hoje o PHP se encontra na versão 5 e possui suporte à conexão com os mais diversos bancos de
dados, Orientação a Objetos, geração dinâmica de gráficos, LDAP, XML, etc...
9.1 Como criar um arquivo PHP
Por ser uma linguagem interpretada, um arquivo PHP nada mais é do que um arquivo texto.
Devido a esta característica, um arquivo PHP pode ser criado em praticamente qualquer editor
disponível no mercado, desde os mais avançados até os mais simples, como o Bloco de Notas.
Todo arquivo PHP deve possuir a extensão .php, para possibilitar ao servidor web distingui-lo dos
demais arquivos (HTML, JavaSript, XML, etc...).
É esta extensão que permite ao servidor web “saber” que este arquivo deve ser repassado ao
interpretador PHP antes de retornar o resultado para o navegador.
Mas não basta que informemos ao servidor web que este arquivo deve ser passado para o
interpretador, devemos informar ao interpretador que partes deste arquivo devem ser processadas
como código PHP, o que nos leva ao nosso próximo tópico:
9.2 Delimitando o código PHP
Vejamos a diferença de uma página HTML comum, que cumprimenta o usuário que está entrando
em nosso site, e uma página PHP que fará a mesma coisa, porém chamando o usuário pelo seu
nome. Não se preocupe neste momento com sintaxe e comandos PHP. Este exemplo apenas
ilustra a utilização de delimitadores.
Exemplo 1: index.html
<html>
<head>
<title>Teste 1</title>
38
Lógica de Programação
</head>
<body bgcolor=”#FFFFFF”>
Olá, Usuário!
</body>
</html>
Exemplo 2: index.php
<html>
<head>
<title>Teste 1</title>
</head>
<?php $usuario = „Paulo‟; ?>
<body bgcolor=”#FFFFFF”>
Olá, <?php echo $usuario; ?>!
</body>
</html>
Note que temos dois pares de tags que não são HTML, representados pela tag <?php e a sua tag
de fechamento, ?>. Tudo o que estiver entre estas duas tags é automaticamente processado pelo
interpretador PHP como código, enquanto que o restante é tratado como HTML comum, e por
consequência, ignorado pelo interpretador.
9.3 Delimitadores alternativos
Embora as tags de delimitação de código PHP que são utilizadas como padrão pelos
programadores sejam as tags <?php e ?>, o interpretador reconhece como válidas as seguintes
alternativas:
- <? e ?>
Não recomendável pela possibilidade de confusão com arquivos XML, que possuem uma tag que
inicia exatamente pelos caracteres < e ?.
- <% e %>
Não recomendável pela possibilidade de confusão com arquivos ASP, que utilizam exatamente à
mesma notação.
- <script language=”php”> e </script>
Não recomendável por se tratar da notação padrão para scripts client side (que são executados no
lado cliente), como JavaScript, por exemplo.
A não ser que haja um forte motivo para utilizar um dos delimitadores acima, recomendamos enfaticamente
o uso dos delimitadores padrão: <?php e ?>.
9.4 Separadores de instruções
Existem duas formas de separar instruções em PHP:
39
Lógica de Programação
- Para separar linhas de comandos utilizamos o ponto e vírgula, como no exemplo abaixo:
Exemplo: Delimitando comandos
<?php
$usuario = „Paulo‟;
echo “Olá, $usuario!”;
?>
- Para delimitar blocos de códigos em Estruturas de Controle (que veremos mais adiante)
utilizamos chaves:
Exemplo: Delimitando blocos
if ($usuario == „Paulo‟)
{
echo “Olá, $usuario!”;
}
Note que o comando que define o bloco de código não é terminado por ponto e vírgula.
9.5 Comentários
Comentários servem, principalmente para auxiliar o programador ou à equipe de programadores a
se orientar dentro de um código e para ajudar na tarefa de debug de um arquivo PHP.
Comentários são absolutamente ignorados pelo interpretador.
Existem duas formas de comentários disponíveis em PHP:
- Comentários de uma linha ou linhas comentadas: São comentários curtos que começam e
terminam na mesma linha. Para comentar uma linha utilizamos duas barras:
Exemplo: Comentário de uma linha
<?php
// Este é um comentário de uma linha.
?>
Comentários em mais de uma linha, ou blocos comentados: São comentários mais extensos,
utilizados para grandes descrições ou para anular a execução de uma série de linhas de código.
Para isso utilizamos uma notação semelhante à tags HTML: iniciamos o comentário por uma barra
e um asterisco e o finalizamos com um asterisco e uma barra:
Exemplo: Bloco comentado
<?php
/* Este é um comentário
em mais de uma linha. Todo
este bloco será ignorado pelo
interpretador PHP. */
?>
40
Lógica de Programação
9.6 Estruturas de dados
Estruturas de dados podem ser entendidas como “compartimentos” que nos permitem armazenar
informações. Utilizamos estruturas de dados para que possamos trabalhar mais de uma vez com o
mesmo dado em um programa.
Em PHP existem três estruturas básicas de dados, que veremos com mais detalhes a seguir:
- Variáveis
- Constantes
- Arrays
9.7 Variáveis
Variáveis são a estrutura de dados mais comumente utilizada. Uma variável é uma estrutura de
dado que nos permite guardar apenas um valor por vez. Variáveis, assim como os arrays em PHP
são denominadas pelo sinal de dólar.
Veja o exemplo, ainda utilizando a variável $usuario:
Exemplo: Utilizando variáveis
<?php
$usuario = „Paulo‟; // Inicializamos a variável usuario com o valor
Paulo
$usuario = „João‟; /* A partir deste momento a variável usuario troca
completamente de valor, contendo o valor João.*/
?>
9.8 Constantes
Constantes, ao contrário das variáveis, são estruturas de dados cujo valor é definido apenas uma
vez, não podendo ser modificado. Embora o PHP aceite o nome de constante escrito em
caracteres minúsculos, é uma boa prática de programação definirmos o nome de uma constante
sempre utilizando apenas caracteres maiúsculos.
Constantes são declaradas através do comando define,
define(nome_da_constante, valor [, insensibilidade_à_caixa]);
com
a
seguinte
sintaxe:
Veja o exemplo:
Exemplo: Declarando constantes
<?php
define (USUARIO, „Paulo‟);
define (Pais, „Brasil‟, FALSE);
?>
41
Lógica de Programação
O parâmetro insensibilidade_à_caixa, que tem como parâmetros possíveis TRUE (verdadeiro) ou
FALSE (falso) é opcional. Por default este parâmetro é TRUE, ou seja, a constante deve ser
chamada sempre se respeitando maiúsculas e minúsculas.
Na segunda linha de nosso exemplo, a constante pode ser chamada de qualquer forma – Pais,
PAIS, pais, PaIs, etc... – enquanto que na primeira linha o interpretador PHP só reconhecerá a
constante se ela for chamada exatamente como foi definida, ou seja, toda em caixa alta.
9.9 Arrays
Arrays são vetores ou matrizes, estruturas de dados chamada compostas, pois têm como
característica a possibilidade de armazenar mais de um dado ao mesmo tempo.
Estes dados são acessados através do que chamamos de índice.
Em PHP os arrays são definidos de uma forma mista: ao mesmo tempo em que declaramos o
nome do array com o sinal de dólar, devemos utilizar o comando array para indicar que esta
estrutura é de fato uma matriz.
Veja o exemplo de uma definição de array:
Exemplo: Definindo um array
<?php
$usuarios = array(„Paulo‟, „João‟);
?>
Neste exemplo definimos um array chamado usuarios contendo dois elementos: Paulo e João.
Como não definimos explicitamente os índices deste array, eles são automaticamente definidos
pelo interpretador de acordo com a ordem dos elementos.
É importante notar que, ao contrário do uso coloquial, o primeiro elemento de um array ordenado é
sempre definido pelo índice zero. Caso queiramos chamar um elemento específico deste array,
João, por exemplo, utilizamos a seguinte notação:
$nome_do_array[indice];
Assim sendo nosso exemplo de saudação ao usuário, utilizando um array, poderia ser escrito da
seguinte forma:
Exemplo: Acessando um elemento de um array
42
Lógica de Programação
<html>
<head>
<title>Teste 1</title>
</head>
<?php $usuarios = array(„Paulo‟, „João‟); ?>
<body bgcolor=”#FFFFFF”>
Olá, <?php echo $usuarios[1]; ?>!
</body>
</html>
Podemos também criar o que chamamos de arrays associativos, ou seja, arrays cujo índice é
explicitamente definido por nós:
Exemplo: Declarando um array associativo
<?php
$usuarios = array( „Paulo‟ => „Paulo da Silva‟, „João‟ => „João Paulo
da Costa‟);
?>
E para chamarmos algum dos elementos deste array utilizamos exatamente à mesma forma
mencionada anteriormente:
Exemplo: Acessando um elemento de um array associativo
<?php
echo $usuarios[„Paulo‟];
?>
Resumo:
- Para delimitarmos comandos em PHP utilizamos o ponto e vírgula, enquanto que para blocos de
códigos em estruturas de controle usamos as chaves.
- Comentários em PHP são marcados por duas barras quando forem comentários de apenas uma
linha ou delimitados por barra e asterisco e asetrisco e barra quando forem comentários em mais
de uma linha.
- Em PHP possuímos três estruturas básicas de dados: Variáveis, Constantes e Arrays, sendo
estes últimos chamados de estruturas compostas, pois podem armazenar mais de um dado ao
mesmo tempo. Todas as estruturas de dados em PHP são representadas pelo sinal de dólar.
9.10 Tipos de Dados Suportados
Existem 3 tipos básicos suportados pelo interpretador PHP:
- Strings ou texto.
- Numéricos – inteiros e de ponto flutuante.
- Booleanos
Veremos a seguir cada um destes tipos com maiores detalhes.
Strings
43
Lógica de Programação
Strings podem ser compreendidas como texto. Este texto pode conter qualquer tipo de caractere,
sejam números, letras, acentos, caracteres especiais, etc.
Strings são sempre delimitadas por aspas, que podem ser tanto duplas quanto simples. Os dois
exemplos abaixo são variáveis que contém strings em seu valor:
Exemplo: Declarando strings
<?php
$var1 = „Teste‟;
$var2 = “Teste”;
?>
A diferença no uso das aspas simples ou duplas está na forma como o interpretador PHP tratará o
conteúdo da string. No caso das aspas duplas poderá ocorrer o que chamamos de interpolação,
ou seja, se uma string contiver uma variável, o interpretador PHP automaticamente converterá a
variável para seu valor. As aspas duplas também permitem ao interpretador reconhecer caracteres
especiais, como o caractere de nova linha, por exemplo.
No caso da utilização de aspas simples a interpolação não ocorre, assim como não ocorre o
reconhecimento de caracteres especiais. Veja o seguinte exemplo para uma melhor compreensão
das diferenças:
Exemplo: Utilização de aspas simples e duplas
<?php
$var1 = “teste”;
$var2 = „teste‟;
echo “Isto é um $var2”;
echo „Isto é um $var1‟;
?>
O primeiro comando echo resultará no texto:
Isto é um teste
Enquanto que o segundo produzirá como resultado:
Isto é um $var1
Numéricos
Numéricos são os tipos que representam números. São eles:
- Inteiros
- De ponto flutuante, também conhecidos como float ou double.
Tipos numéricos são representados pela ausência de aspas:
Exemplo: Declarando variáveis numéricas
44
Lógica de Programação
<?php
$var1 = 10;
$var2 = 0.5;
$var3 = -5;
?>
Booleanos
Um tipo booleano é o que representa apenas dois valores possíveis: verdadeiro ou falso.
Normalmente estes valores são representados pelas palavras reservadas TRUE e FALSE:
Exemplo: Declarando uma variável booleana
<?php
$ativo = TRUE;
?>
É importante ressaltar que o interpretador PHP sempre considerará um valor como sendo
verdadeiro, a não ser nos seguintes casos:
- O booleano FALSE
- O inteiro 0 (zero)
- O float 0.0
- A string vazia „‟ ou “”
- A string “0” ou „0‟
- Um array vazio
Conversão de tipos
A exemplo de outras linguagens web, PHP procura fazer a conversão de tipos automaticamente.
Exemplo: conversão automática de tipos
<?php
$var1 = “1”;
$var1 += 5;
$var1 += 2.7;
?>
Neste exemplo nossa variável $var1 começa contendo uma string. Na segunda linha ela passa a
conter um inteiro, enquanto que a partir da terceira linha seu valor passa a ser um float.
Também é possível alterar o tipo de dado de uma variável utilizando-se o comando settype, que
possui a seguinte sintaxe:
settype(variável, tipo);
O parâmetro tipo deve conter um destes possíveis valores:
45
Lógica de Programação
- Boolean
- integer
- float
- string
Sendo assim, nosso exemplo de transformação de tipos poderia ser reescrito de forma à não ser
necessário modificar o valor da variável:
Exemplo: modificando o tipo de uma variável com a função settype
<?php
$var1 = “1”;
settype($var1, „integer‟);
settype($var1, „float‟);
?>
Resumo
- PHP suporta os seguintes tipos básicos: string, numérico e booleano.
- Para realizar a conversão entre tipos efetuamos operações com a variável ou utilizamos o
comando settype.
9.11 Estruturas de Controle
Estruturas de controle são comandos que nos permitem controlar a forma como nosso programa
será executado. Existem dois tipos de estruturas de controle:
- Condicionais
- Loops
Veremos agora cada uma das estruturas com mais detalhes.
Condicionais
Estruturas condicionais, como o próprio nome já diz, são estruturas que impõem uma condição
para que um ou mais comandos sejam executados.
São elas:
If Sintaxe:
if (condição)
{
comandos
}
Descrição:
O if é a estrutura condicional mais simples. Os comandos contidos no bloco delimitado pelas
chaves só serão executados no caso da condição ser verdadeira.
Exemplo: Utilizando uma condicional if
46
Lógica de Programação
if ($usuario == „Paulo‟)
{
echo “Olá, Paulo.”;
}
O if suporta, ainda, múltiplas condições e o que fazer se a condição for falsa. Isto é feito através
das condições else if e else:
if (condição1)
{
comandos
}
else if (condição2)
{
comandos
}
else
{
comandos
}
Switch sintaxe:
switch(variável)
{
case valor1:
comandos
break;
case valor2:
comandos
break;
default:
comandos
}
Descrição:
O condicional switch é comumente utilizado para evitar instruções if-else if muito longas, ou seja,
quando queremos testar uma gama muito grande de condições.
Cada instrução case testa pela igualdade da variável com o valor. Note que a limitação que ocorre
com o condicional switch é que apenas a igualdade é testada. A instrução break é obrigatória entre
cases, pois é ela que separa os blocos de instruções que serão executadas dependendo de cada
condição.
A instrução default é opcional e diz para o interpretador PHP o que fazer se todas as condições
expostas nas instruções case forem falsas.
Exemplo: Utilizando uma condicional switch
47
Lógica de Programação
switch($usuario)
{
case „Paulo‟:
echo “Olá Paulo.”;
break;
case „João‟:
echo “Olá João”;
break;
default:
echo “Usuário desconhecido”;
}
Loops (laços de repetição)
Loops são estruturas que causam a repetição de uma série de instruções dependendo ou não de
uma condição. São elas:
For sintaxe:
for (inicialização_variável; condição_variável; operação)
{
comandos
}
Descrição:
Um loop for é uma estrutura de controle que causará a repetição de comandos com um número
finito de iterações. Para isso criamos uma variável contadora, testamos uma condição e a
incrementamos ou decrementamos para que o loop tenha continuidade.
Exemplo: Utilizando um loop for
for ($c = 0; $c < 10; $c++)
{
echo “Esta é a $c ª iteração de nosso loop de exemplo.”;
}
Em nosso exemplo teremos 10 iterações em nosso loop (de 0 a 9).
While sintaxe:
while(condição)
{
comandos
}
48
Lógica de Programação
Descrição:
Um loop while é executado quantas vezes forem necessárias até que a condição especificada seja
satisfeita (seja verdadeira).
Exemplo: Utilizando um loop while
$c = 0;
while ($c < 10)
{
echo “Esta é a $c ª iteração de nosso loop de teste.”;
$c++;
}
Note que para reproduzir o comportamento de nosso loop for com um loop while precisamos
incluir duas instruções explícitas:
Na primeira linha inicializamos nossa variável com o valor zero. Se esta linha estivesse dentro do
bloco a ser executado pelo loop teríamos o que chamamos de loop infinito, pois a cada iteração a
variável seria reinicializada com o valor zero e, portanto, seria sempre menor do que 10.
Na última linha de nosso bloco de instruções incrementamos a variável (o equivalente à operação
$c = $c + 1;). Se esta linha estivesse fora do bloco a ser executado pelo loop também teríamos um
loop infinito, pois o incremento jamais aconteceria e a variável seria sempre menor do que 10.
do-while sintaxe:
do
{
comandos
}
while (condição)
Descrição:
O loop do-while é extremamente parecido com o loop while, mas possui uma diferença
importantíssima: o bloco de comandos será executado sempre pelo menos uma vez, já que a
condição é testada apenas no final da primeira iteração.
Exemplo: Utilizando um loop do-while
$c = 0;
do
{
echo “Esta é a $c ª iteração de nosso loop de teste.”;
$c++;
}
while ($c < 10)
Note que se tivéssemos inicializado a nossa variável contadora com o valor 1 e testássemos à
condição $c < 1 ainda assim teríamos uma execução do loop, pois a condição só começa a ser
testada após a primeira iteração.
49
Lógica de Programação
Arrays (vetores e matrizes)
Para sabermos quantos elementos existem em um array utilizamos à função count:
count (array [, modo]);
Exemplo: Retornando o número de elementos em um array
$numero_usuarios = count ($usuarios);
O parâmetro modo é opcional e pode conter um dos seguintes valores:
1 ou COUNT_RECURSIVE – Conta recursivamente o número de elementos em um array
multidimensional.
0 (zero) – É o modo default, ou seja, faz a contagem de forma não-recursiva, sendo o array
multidimensional ou não.
Obtendo-se o número de elementos de um array temos condições de percorrer um array com um
loop for:
Exemplo: percorrendo um array com um loop for
for ($c = 0; $c < count($usuarios); $c++)
{
echo “Olá, “.$usuarios[$c].”<BR>”;
}
Note que esta forma de percorrer um array, ao contrário do loop foreach, só funcionará com arrays
de índices numéricos.
Funções (subrotinas)
A sintaxe básica para definir uma função é:
function nome_da_função([arg1, arg2, arg3]) {
Comandos;
... ;
[return <valor de retorno>];
}
50
Lógica de Programação
Qualquer código PHP válido pode estar contido no interior de uma função. Como a checagem de
tipos em PHP é dinâmica, o tipo de retorno não deve ser declarado, sendo necessário que o
programador esteja atento para que a função retorne o tipo desejado. É recomendável que esteja
tudo bem documentado para facilitar a leitura e compreensão do código. Para efeito de
documentação, utiliza-se o seguinte formato de declaração de função:
tipo function nome_da_funcao(tipo arg1, tipo arg2, ...);
Este formato só deve ser utilizado na documentação do script, pois o PHP não aceita a declaração
de tipos. Isso significa que em muitos casos o programador deve estar atento ao tipos dos valores
passados como parâmetros, pois se não for passado o tipo esperado não é emitido nenhum alerta
pelo interpretador PHP, já que este não testa os tipos.
51
Lógica de Programação
Unidade 10 -
Linguagem C
A linguagem C foi primeiramente criada por Dennis M. Ritchie e Ken Thompsom no laboratório
Bell em 1972, baseada na linguagem B de Thompson que era uma evolução da antiga linguagem
BCPL.
A linguagem ficou contida nos laboratórios até o final da década de 70, momento que começou a
popularização do sistema operacional UNIX e consequentemente o C (o UNIX é desenvolvido em
C).
As principais características da linguagem C são:

A união de conceitos de linguagem de montagem e programação de alto nível (o
programador usufrui recursos de hardware sem a necessidade de conhecer o assembly da
máquina);

Linguagem compilada;

Linguagem estruturada;

Possui poucos comandos;

Não possui crítica eficiente para erros de execução;

Uma linguagem em constante evolução. Existem versões orientadas a objeto e visuais
como C++ e C++ Builder, entre outras.
10.1 Estrutura básica de um programa em C
Um programa em C consiste em uma ou várias funções, uma das quais precisa ser denomindada
main. O programa sempre começará executando a função main. Definições de funções adicionais
podem preceder ou suceder a função main.
Para escrever um programa em linguagem C é necessário seguir algumas regras gerais:

Toda função deve ser iniciada por uma chave de abertura { e encerrada por uma chave de
fechamento };

Toda função é sucedida de parêntesis ( );

Todo programa deverá conter a função main;

As linhas de código são sempre encerradas por um “; (ponto-e-vírgula)” ;

A formatação dos programas é completamente livre, mas temos por conveniência manter a
legibilidade;

Os comandos são executados na ordem em que foram escritos;

Os comentários devem ser delimitados por /* no início e */ no final. Podem ser usados
também os caracteres // para comentários de uma linha.
Sintaxe básica:
52
Lógica de Programação
/* Os comentários podem ser colocados em qualquer parte do programa */
Declaração de variáveis globais
void main (void)
{
Declaração de variáveis locais
...
Comandos;
...
}
Tipo função (lista de argumentos)
{
Declaração das variáveis locais à função
...
Comandos;
...
}
Exemplo de um programa em C:
#include <stdio.h>
#include <conio.h>
float processa(float r); //declaração da função processa
void main (void) // função principal main
{
float raio, area; //delcaração de variáveis locais
clrscr (); // comando para limpar a tela
printf(“Raio: “);
scanf(“%f”, &raio);
area = processa(raio);
printf(“Area: %f”, área);
getche();
}
float processa (float r) //implementação da função processa
{
float a; //declaração de variáveis locais
a=3.1415*r*r;
return(a);
}
10.2 Comando if
O comando if instrui o computador a tomar uma decisão simples. Se o valor entre parênteses da
expressão de controle for verdadeiro ele executa as instruções, caso seja falso, as instruções
serão ignoradas, ou executadas as que estão contidas no bloco do else.
O comando if encadeado e o comando switch possuem a mesma sintaxe da linguagem PhP.
Exemplo:
if (x%2)
53
Lógica de Programação
printf (“x é impar”);
else
printf (“x é par “);
10.3 Estruturas de repetição
Comando for:
for (inicialização; teste; incremento)
{
comandos;
}
Exemplo:
for (a=1; a<100; a++)
{
printf(“\n %i”, a);
}
Comando While sintaxe:
while (expressão teste)
{
comandos;
}
Exemplo:
while (conta < 10)
{
total = total + conta;
printf(“conta = %i, total = %i”, conta, total);
conta++
}
Comando do..while:
do
{
comandos;
} while (expressão teste);
Exemplo:
do
{
y--;
x++;
} while (y);
10.4 Arrays (vetores e matrizes)
54
Lógica de Programação
Um vetor ou matriz é um tipo de dado usado para representar uma certa quantidade de valores
homogêneos.
A linguagem C não valida limites dos vetores, cabe ao programador verificar o correto
dimensionamento. O primeiro índice é o zero. Vetores possuem uma ou mais dimensões, como
convenção, os vetores bidimensionais são chamados de matrizes.
Declaração:
tipo variavel [tamanho]; //vetor
tipo variavel [tamanho] [tamanho]; //matriz
10.5 Funções (subrotinas)
Uma função é uma unidade de código de programa autônoma desenhada para cumprir uma tarefa
particular.
A função recebe um certo número de parâmetros e retorna apenas um valor.
Da mesma maneira que são declaradas as variáveis, deve-se declarar a função. A declaração de
uma função é chamada de protótipo e é uma instrução geralmente colocada no início do programa
que estabelece o tipo da função e os argumentos que ela recebe.
Declaração
tipo nome_função (declaração dos parâmetros)
void main(void)
{
a=nome_função(lista dos parâmetros);
}
tipo nome_função(lista dos parâmetros)
{
declaração das variáveis locais
comandos;
return (valor);
}
O tipo de uma função é determinado pelo tipo de valor que ela retorna pelo comando return e não
pelo tipo de seus argumentos.
55
Lógica de Programação
Unidade 11 -
Fundamentos Orientação a
Objetos
Orientação a Objetos é o nome que os pesquisadores da computação, na década de 70, usaram
para batizar este novo paradigma. Esse nome foi dado porque, de acordo com a visão de mundo
desses pesquisadores, tudo é objeto. Ou ao mínimo, se pretende que seja.
Um paradigma é uma maneira diferente de se tentar enxergar uma mesma coisa, um mesmo
mundo. O paradigma da Orientação a Objetos (OO) busca bases filosóficas para tentar traduzir um
mundo mais humano às instruções que o processador realmente entende. E são de viagens deste
tipo, combinadas à estrutura de linguagens imperativas, como o C ou Pascal, que surgem as
linguagens orientadas a objetos. E estas últimas se responsabilizaram pela existência da maioria
dos grandes softwares produzidos nos dias atuais em todo o mundo.
A Crise do Software, ocorrida entre as décadas de 1960 e 1970, caracterizou-se principalmente
por um motivo: complexidade. O modelo de desenvolvimento de sistemas da época já não atendia
à demanda e não conseguia suprir, de forma adequada, todas as necessidades e/ou tarefas que
envolviam a construção de um sistema de informação. Essa forma de trabalho acarretava diversos
problemas, tais como:
 Falta de produtividade das equipes;
 Falta de qualidade e confiabilidade do software;
 Grande dificuldade de manutenção;
 Atraso na entrega do software ao usuário;
 Tempo de vida do software curto;
 Custos elevados de desenvolvimento e, principalmente, de manutenção.
Toda essa situação acabou levando os profissionais da época a buscar uma solução alternativa,
pois a complexidade dos sistemas já havia chegado a tal ponto que nem os programadores
conseguiam dominá-la mais. Sabia-se que as linguagens estruturadas, bem como o próprio
paradigma, não davam mais suporte às necessidades, e esta, possivelmente, tenha sido a
principal causa do surgimento da Orientação a Objetos.
O desenvolvimento orientado a objetos impõe (implicitamente) uma disciplina que diminui, se não
todos, a grande maioria dos esforços inúteis provenientes da programação estruturada e/ou
técnicas baseadas em banco de dados. Problemas, que muitas vezes, são complicados de serem
resolvidos pela programação estruturada, são facilmente solucionados pela orientação a objetos.
Na Orientação a Objetos não existe um conceito de sistema, como na visão estruturada. Isto se
deve ao fato de que aqui a ênfase é em objetos e classes, e não em sistemas e subsistemas. Um
programa será então um grande objeto composto de outros objetos formando assim o que se
chama de mecanismo, o qual define um contexto de negócio e seus respectivos cenários.
11.1 Conceitos básicos
56
Lógica de Programação
Para compreender a essência da Orientação a Objetos é necessário conhecer e entender alguns
conceitos. Alguns deles foram herdados do paradigma estruturado e receberam um enfoque um
pouco diferente de sua aplicação. Para analisar problemas complexos, a metodologia de
orientação a objetos utiliza os seguintes métodos:
 Abstração;
 Hierarquização;
 Encapsulamento;
 Modularização;
 Classificação;
 Relacionamento.
Abstração
Abstração é a habilidade de ignorar os aspectos não relevantes de um assunto para o propósito
em questão, tornando possível uma concentração maior nos assuntos principais. Quando se quer
diminuir a complexidade, seleciona-se parte do que está sendo analisado, em vez de tentar
compreender o todo.
Selecionados os objetos, é necessário definir os procedimentos desses objetos, ou seja, definir o
comportamento de cada objeto selecionado. Isto vem de acordo com o escopo do sistema. Só
serão definidos os procedimentos que ajudarão a resolver o problema pelo qual o sistema está
sendo criado. Definir procedimentos errados pode significar que o escopo do sistema e seus
objetivos não foram bem entendidos e atendidos.
Abstrações permitem gerenciar a complexidade e concentrar a atenção nas características
essenciais de um objeto. Uma abstração é dependente da perspectiva: o que é importante em um
contexto pode não ser importante em outro. Levando em consideração essa definição, pode-se
afirmar que o Princípio da Abstração é aplicado em todos os demais Princípios da Orientação a
Objetos.
Hierarquização
Após dividir uma forma complexa em várias partes, é comum a hierarquização destas partes, ou
seja, ordenação e organização delas. Essa organização, normalmente, parte do mais geral para o
mais específico. É o que se chama de hierarquização. Por exemplo, a figura projeta uma
hierarquia com a percepção do tipo de objeto Pessoa no nível mais alto, o que significa que
Pessoa é um tipo mais geral de objeto que Empregado e que Estudante. Empregado e Estudante
são subtipos de Pessoa, ou, da forma reversa, Pessoa é um supertipo de Empregado e de
Estudante. Todavia, hierarquizar um todo não significa priorizar determinada parte.
57
Lógica de Programação
O nível de detalhe do exercício da hierarquização depende única e exclusivamente do observador.
A hierarquização de um sistema dá origem, normalmente, a poucos subsistemas, porque estes
utilizam elementos comuns. Por exemplo, no microcomputador, o elemento memória é utilizado
por todos os componentes: CPU, teclado e vídeo. Outro fato a se considerar para o nível de
detalhamento da hierarquização é o objetivo e contexto do negócio, ou seja, para um bom
entendimento do problema e, consequentemente, a criação de uma solução adequada a ele, é
importante não perder o foco do objetivo que se deseja e o contexto do negócio ao qual se está
trabalhando. Isso ajuda a delimitar o nível de detalhe do trabalho de hierarquização.
Encapsulamento
Encapsulamento é um mecanismo que utilizamos para esconder detalhes de estruturas
complexas, que de outra forma iriam interferir na análise. O objetivo do encapsulamento é
restringir ou definir o escopo da informação, para obter legibilidade, manutenibilidade e
principalmente reutilizabilidade no desenvolvimento de sistemas.
O encapsulamento protege os dados de um objeto contra corrupção. Se todos os programas
pudessem acessar os dados de qualquer maneira que os usuários desejassem, os dados
poderiam se facilmente adulterados ou usados para fins indevidos. O encapsulamento protege os
dados contra utilização arbitrária e que fujam aos objetivos.
O encapsulamento esconde, dos usuários de um objeto, os detalhes da implementação interna.
Os usuários compreendem quais operações podem ser solicitadas de um objeto, mas não
conhecem os detalhes de como a operação é executada. Todas as características específicas dos
dados de um objeto e a codificação de suas operações ficam escondidas.
Classificação
Classificar é associar o objeto analisado a uma determinada categoria. Cada categoria possui
características próprias. Ao se comparar as características do objeto analisado com as
características daquela categoria, é que se pode dizer se um objeto pode ser ou não classificado
como pertencente àquela categoria, definindo-se assim um tipo de objeto.
Um tipo de objeto é uma categoria de objeto.
58
Lógica de Programação
Os tipos de objeto são importantes porque eles criam os elementos conceituais básicos para se
projetar os sistemas. Na programação baseada em objetos, esses elementos básicos orientam o
projetista na definição de classes e suas estruturas. Além disso, os tipos de objeto fornecem os
índices para a operação do sistema. Por exemplo, operações tais como Contratar, Promover e
Demitir estão intimamente ligadas ao tipo de objeto Empregado, porque elas alteram o estado de
um empregado. Em outras palavras, um objeto só deve ser manipulado via operações associadas
ao seu tipo. Sem tipos de objeto, portanto, as operações não podem ser definidas
adequadamente.
Modularização
Modularizar é juntar partes com algumas semelhanças. Para melhor entendermos um sistema
complexo, juntamos categorias com algumas características comuns em módulos.
Este conceito é bem empregado na fase de projeto do software. É através da aplicação dele que
conseguimos organizar melhor os componentes de sistema, auxiliando no entendimento da
construção, da manutenção e, muitas vezes, na implantação do software.
Relacionamento
Para o funcionamento do todo, é necessário que as partes funcionem separadamente, mas em
conjunto. Este funcionamento em conjunto (cooperação) é possível porque as partes se
relacionam entre si. O relacionamento entre os objetos é feito através de mensagens, passadas de
uma parte para outra. Uma empresa, por exemplo, é composta de diversos departamentos,
funcionando autonomamente. Mas, para que a empresa como um todo atinja seu objetivo (ou seja,
lucre), é necessário um relacionamento entre estes departamentos, para que funcionem em
conjunto. Este relacionamento é possível através da troca de mensagens entre os integrantes dos
departamentos.
No paradigma da Orientação a Objetos, as mensagens trocadas entre os objetos podem ser
entendidas como solicitações. Essa solicitação faz com que uma determinada operação seja
ativada. A operação executa o método adequado e, opcionalmente, devolve uma resposta. A
mensagem que constitui a solicitação contém o nome do objeto, o nome da operação e, às vezes,
um grupo de parâmetros. Dessa forma, é possível realizar uma modelagem que espelha, o mais
fiel possível, a realidade. Afinal, empresas, departamentos, setores e pessoas relacionam-se
através de mensagens enviadas uns aos outros, ou seja, através de solicitações.
Objetos podem ser muito complexos, porque objetos podem ser feitos de outros objetos, que, por
sua vez, podem ser feitos de outros objetos, e assim por diante. O usuário de um objeto não
precisa tomar conhecimento de sua complexidade interna, apenas precisa saber como se
comunicar com ele e como ele reage.
11.2 Classe
O termo classe se refere à implementação, no software, do tipo de objeto. Tipo de objeto é uma
noção conceitual. Ele especifica uma família de objetos, sem estipular como eles são
implementados. Os tipos de objeto são identificados durante as fases de Levantamento de
Requisito e Análise. Os detalhes das classes são determinados na Análise e no Projeto.
Uma classe é uma implementação de um tipo de objeto. Ela tem uma estrutura de dados e
métodos que especificam as operações que podem ser feitas com aquela estrutura de dados.
59
Lógica de Programação
11.3 Colaboração
Os objetos colaboram entre si, a fim de disponibilizar as funcionalidades requeridas pelo sistema.
Esta disponibilização de funcionalidades se dá através de troca de mensagens entre os objetos.
Se um objeto precisa de uma informação que não é sua, ou seja, que está em outro objeto, este
deve pedir para ele enviando uma mensagem. Um objeto Aluno, por exemplo, não pode cancelar
sua própria matrícula. Ele deve enviar uma mensagem ao objeto Setor de Matrículas, solicitando o
cancelamento de sua matrícula.
A seguir, veremos os tipos de colaboração que podem existir entre objetos.
Agregação
Agregar significa juntar, colar, grudar. Neste contexto, dizemos que agregação é o ato de agregar
duas ou mais classes para formar uma nova classe, onde podemos identificar um relacionamento
do tipo Todo-Parte. Esse relacionamento (todo-parte) pode ser visto de duas formas:
Composição: quando o todo não existe sem as partes. Por exemplo: um objeto da classe Aluno, para uma
universidade, não existe sem seu Currículo. O Currículo de um Aluno é algo pessoal e intransferível. Se um
Aluno for excluído, seu Currículo deve ser excluído junto.
Referência: quando o todo somente faz referência às partes. Por exemplo: um objeto da classe Nota Fiscal
faz referência a objetos do tipo Produto. A Nota Fiscal é composta, entre outras coisas, de uma lista de
produtos, mas se ela for excluída os produtos não precisam ser excluídos de seu cadastro original.
Generalização/Especialização
Especialização é quando, dada uma determinada classe ou categoria, criamos uma outra, com
novos atributos ou serviços que a tornam mais restrita. Generalização é a operação inversa, ou
seja, é a remoção de uma ou mais características de determinada classe, de modo a formar uma
classe mais abrangente.
É importante entender que generalização é o mecanismo para expressar a similaridade entre
classes. Esse princípio permite representar membros comuns, serviços e atributos uma só vez.
Permite a reutilização de especificações comuns. Por exemplo: uma empresa possui o seu
cadastro de Clientes. Podemos especializar a classe Cliente em Pessoa Física e Pessoa Jurídica.
Em programação, o conceito de generalização é visto como herança. Podemos, então, identificar
basicamente dois tipos de herança: herança de INTERFACE e de IMPLEMENTAÇÃO. Herdar uma
interface significa assumir o compromisso de oferecer as operações definidas pela interface, ou
seja, todos os métodos declarados. Dessa forma, diz-se que se herda a interface da classe.
Herdar a implementação significa que instâncias da classe especializada terão parte de seus
estados definidos e também controlados pela classe mais geral, mas em compensação, as
operações definidas na classe mais geral também se aplicam à classe especializada, o que
permite reaproveitamento de código.
Polimorfismo
60
Lógica de Programação
Muito provavelmente em alguns dos primeiros programas estruturados que criamos nos
deparamos com uma pequena dúvida: “...será que eu poderia criar um procedimento em que o
número de parâmetros modificasse em tempo de execução?”. A questão anterior na verdade que
saber se é possível criar uma operação que mude seu código em tempo de execução. Esse tipo
de questionamento é o princípio do polimorfismo. Ou seja, fazer a mesma coisa de várias formas
ou de forma diferente (poli = muito; morfismo = formas).
A grande vantagem de serem permitidas implementações de polimorfismo é a flexibilidade. Por
exemplo: Levando em consideração o desenho abaixo – Um Aluno comunica-se com o Setor de
Matrículas – podemos entender que um Aluno pode solicitar a realização de sua matrícula, em um
determinado curso ou disciplinas, para o Setor de Matrículas. Contudo, a forma com que sua
matrícula vai se realizar vai depender do nível de ensino do curso em que ele quer se matricular:
extensão, especialização, graduação, etc.
Para a matrícula em um curso de extensão necessita-se somente do nome e do RG da pessoa. Já
para a matrícula de um curso de especialização é necessário o RG e a identificação do curso que
a pessoa deseja seguir. E para a matrícula em um curso de graduação precisa-se somente do RG
da pessoa e do código da disciplina que ela deseja cursar. Somente com o polimorfismo é que se
pode realizar a mesma ação – no caso aqui se trata da ação de Matricular – de várias formas
distintas, dando maior flexibilidade ao sistema.
11.4 Benefícios da Orientação a Objetos
A programação orientada encapsula dados (atributos) e métodos (comportamentos) em objetos;
os dados e os métodos de um objeto estão intimamente associados entre si.
Estão listados a seguir os principais ganhos para o desenvolvedor, caso este troque a Metodologia
Tradicional pela Orientada ao Objeto:
Exatidão – Devido à característica do desenvolvimento estruturado, onde se elabora um projeto e
DEPOIS se faz os programas, podemos ter no final um sistema que não atenda perfeitamente
seus objetivos depois de implementado. No desenvolvimento OOP, o desenvolvimento pode ser
feito de maneira quase que interativa com o usuário, o que faz com que este risco caia
significativamente. A pouca quantidade de código programável também reduz os problemas
inerentes às mudanças das especificações durante o desenvolvimento do projeto.
Potencialidade – Definimos como potencialidade, a forma como o programa reage aos erros
imprevistos tais como uma falha na impressora, ou um disco cheio. Quanto maior for a
potencialidade, maior a capacidade do programa em causar o menor dano possível aos dados e
evitar uma saída drástica do sistema.
61
Lógica de Programação
Extensibilidade – Dizemos que quanto maior for a extensibilidade do software, maior será sua
capacidade em adequar-se as especificações definidas pelos analistas.
Reutilização – A capacidade de se otimizar a produtividade do programador depende diretamente
da maneira como o software disponibiliza a reutilização do código gerado. De fato, a maioria dos
programadores profissionais já reutiliza códigos criados, porém a perfeita reutilização consiste na
utilização COMPLETA de um código gerado para algum sistema SEM qualquer outra adaptação
prévia.
Exercícios
Descrever os atributos de uma classe Pessoa.
Descrever os atributos de uma classe Carro.
Descrever os atributos de uma classe ContaCorrente.
Descrever os métodos de uma classe Pessoa.
Descrever os métodos de uma classe Carro.
Descrever os métodos de uma classe ContaCorrente.
62
Lógica de Programação
Unidade 12 -
Exercícios de Fixação
1.
Escreva um algoritmo para calcular a média entre dois números quaisquer.
2.
final.
Escreva um algoritmo para calcular a área de um triângulo, exibindo o resultado
3.
Escreva um algoritmo para calcular o valor de y como função de x, segundo a
função y(x)=3x+2, num domínio real.
4.
Escreva um algoritmo para efetuar a leitura de um número inteiro e apresentar o
resultado do quadrado deste número.
5.
Escreva um algoritmo para ler dois números quaisquer, calcular a soma deles e
após mostrar os números lidos e o resultado da soma precedido da palavra "Resultado:".
6.
Escreva um algoritmo para ler dois números quaisquer, dividir o primeiro pelo
segundo. Mostrar os números lidos e o resultado calculado.
7.
Escreva um algoritmo para ler três números quaisquer e calcular a média aritmética
entre eles. Escrever os números lidos e a média calculada.
8.
Escreva um algoritmo para ler dois inteiros (variáveis OP1 e OP2) e efetuar as
operações de adição, subtração, multiplicação e divisão de OP1 por OP2 apresentando ao
final os quatro resultados obtidos.
9.
Escreva um algoritmo para ler dois inteiros (variáveis OP1 e OP2) e imprimir o
resultado do quadrado da diferença do primeiro valor pelo segundo.
10.
Escreva um algoritmo para ler dois números. Multiplicar o primeiro por 4 e o
segundo por 6. Calcule a média aritmética dos resultados obtidos. Escrever os valores lidos,
os calculados e a média aritmética.
11.
Escreva um algoritmo para ler os seguintes números: OP1, OP2 e OP3. Após,
calcular o valor de RESULTADO segundo a expressão:
12.
RESULTADO = OP1^2 - 4OP2*OP3 e mostrar os valores lidos e o resultado.
13.
Escreva um algoritmo para calcular e escrever o consumo médio de um automóvel
(medido em Km/l), fornecida a distância total percorrida e o volume do combustível
consumido para percorrê-la (medido em litros).
14.
Escreva um algoritmo para calcular a média de quatro números inteiros e exibir o
resultado final.
15.
Faça um algoritmo que leia três notas de um aluno e calcule e escreva a média final
deste aluno. Considerar que a média é ponderada e que os pesos das notas são 2, 3 e 5,
respectivamente.
16.
Escreva um algoritmo para calcular a função f(x,y)=2x+3y2, num domínio real.
63
Lógica de Programação
17.
Escreva um algoritmo que efetue e cálculo do salário líquido de um professor. Para
fazer este programa você deverá possuir alguns dados, tais como: valor da hora aula,
número de aulas dadas no mês e percentual de desconto do INSS. Em primeiro lugar, devese estabelecer qual será o seu salário bruto para efetuar o desconto e ter o valor do salário
líquido. Ao final do algoritmo deve ser mostrado o salário bruto e o salário líquido do
professor.
18.
Faça um algoritmo que calcule a média ponderada de um aluno, a partir de suas 3
notas obtidas no curso, sabendo-se que a primeira avaliação tem peso 2, a segunda tem
peso 4 e a terceira tem peso 4. Mostre, ao final, a mensagem : “A MEDIA FINAL DE ... FOI
...” . Informar também se o aluno foi aprovado, mostrando a mensagem “APROVADO” caso
a nota final seja maior ou superior a 7,0.
19.
Modifique o algoritmo da média do aluno para informar:
APROVADO ............ caso a nota final esteja no intervalo [10, 7]
RECUPERAÇÃO...... caso a nota final esteja no intervalo [5, 7)
REPROVADO .......... caso a nota final esteja no intervalo [0, 5)
20.
Faça um algoritmo que leia 2 valores numéricos e um símbolo. Caso o símbolo seja
um dos relacionados abaixo efetue a operação correspondente com os valores. Atenção
para a divisão por 0!
“+”
operação de soma
“-”
operação de subtração
“*”
operação de multiplicação
“/”
operação de divisão
21.
Dados 3 valores A, B, C, verifique se podem ser valores de lados um triângulo e, se
for, determine se o triângulo é equilátero, isósceles ou escaleno.
22.
Sejam 3 números distintos A, B, C. Coloque-os em ordem crescente, utilizando
seleção encadeada (ou aninhada).
23.
Faça um programa que lê dois valores, o primeiro servindo de indicador de
operação e o segundo correspondendo ao raio de uma circunferência. Caso o primeiro valor
lido seja igual a 1, calcular e imprimir a área desta circunferência. Se o valor lido for 2,
calcular e imprimir o perímetro da circunferência. E se o valor lido for diferente destes dois
valores, imprimir uma mensagem dizendo que o indicador de operação foi mal fornecido.
24.
Uma loja fornece 5% de desconto para funcionários e 10% de desconto para
clientes especiais. Faça um programa que calcule o valor total a ser pago por uma pessoa. O
programa deverá ler o valor total da compra efetuada e um código que identifique se o
comprador é um cliente comum ou um dos dois tipos de clientes que recebem desconto.
25.
Construa um programa que receba os nomes de 5 clientes de uma loja e o valor
(em reais) que cada um destes clientes pagou por sua compra. O programa deverá informar:
a)
o
valor
total
pago
pelos
5
b)
o
valor
da
compra
média
c) nome dos clientes que efetuaram compras superiores a
d) o número de clientes que efetuaram compras inferiores a 50 reais.
clientes;
efetuada;
20 reais;
64
Lógica de Programação
26.
A partir do preço à vista de um determinado produto, calcular o preço total a pagar e
o valor da prestação mensal, referentes ao pagamento parcelado. Se o pagamento for
parcelado em três vezes deverá ser dado um acréscimo de 10% no total a ser pago. Se for
parcelado em 5 vezes, o acréscimo é de 20%.
27.
O departamento que controla o índice de poluição do meio ambiente fiscaliza 3
grupos de indústrias que são altamente poluidoras do meio ambiente. O índice de poluição
aceitável varia de 0.05 até 0.25. Se o índice sobe para 0.3 as indústrias do 1º grupo são
intimadas a suspenderem suas atividades; se o índice sobe para 0.4, as do 1º e do 2º grupos
são intimadas a suspenderem suas atividades; e se o índice sobe para 0.5, todos os três
grupos devem ser notificados a paralisarem suas atividades. Escreva um programa que lê o
índice de poluição medido e emite a notificação adequada aos diferentes grupos de
empresas.
28.
Faça um programa que lê 4 valores I, A, B e C onde I é um número inteiro e positivo
e A, B, e C são quaisquer valores reais. O programa deve escrever os valores lidos e:
a) se I = 1, escrever os três valores A, B e C em ordem crescente;
b) se I = 2, escrever os três valores A, B e C em ordem decrescente;
c) se I = 3, escrever os três valores A, B, e C de forma que o maior valor fique entre os
outros dois;
d) se I não for um dos três valores acima, dar uma mensagem indicando isto.
29.
Fazer um programa para imprimir o conceito de um aluno, dada a sua nota. Supor
notas inteiras somente. O critério para conceitos é o seguinte:
nota
inferiores
nota de 3 a 5 - conceito D
notas
6
notas
8
nota 10 - conceito A
a
e
e
3
7
9
-
conceito
conceito
conceito
E
C
B
30.
Elabore um algoritmo que verifique se um dado número inteiro positivo é PAR ou
ÍMPAR.
31.
Escreva um algoritmo que leia um número n (número de termos de uma progressão
aritmética), a1 (o primeiro termo da progressão) e r (a razão da progressão) e escreva os n
termos desta progressão, bem como a soma dos elementos.
32.
soma:
Escreva um algoritmo que lê um valor n inteiro e positivo e que calcula a seguinte
S := 1 + 1/2 + 1/3 + 1/4 + ... + 1/n
O algoritmo deve escrever cada termo gerado e o valor final de S.
33.
Escreva um algoritmo que leia um número n que indica quantos valores devem ser
lidos a seguir. Para cada número lido, mostre uma tabela contendo o valor lido e o fatorial
deste valor.
34.
Escreva um algoritmo que leia um valor N inteiro e positivo e que calcule e escreva
o valor de EX.
EX = 1 + 1 / 1! + 1 / 2! + 1 / 3! + 1 / N!
65
Lógica de Programação
35.
Faça um algoritmo que mostre os conceitos finais dos alunos de uma classe de 75
alunos, considerando:
i.
os dados de cada aluno (número de matrícula e nota numérica final) serão
fornecidos pelo usuário
ii.
a tabela de conceitos segue abaixo:
Nota Conceito
de 0,0 a 4,9
D
de 5,0 a 6,9
C
de 7,0 a 8,9
B
de 9,0 a 10,0
A
36.
Foi feita uma estatística nas 20 principais cidades brasileiras para coletar dados
sobre acidentes de trânsito. Foram obtidos os seguintes dados:
b.
código da cidade
c.
estado (RS, SC, PR, SP, RJ, ...)
d.
número de veículos de passeio (em 2007)
e.
número de acidentes de trânsito com vítimas (em 2007)
Deseja-se saber:
i.
qual o maior e o menor índice de acidentes de trânsito e a que cidades
pertencem
ii.
qual a média de veículos nas cidades brasileiras
iii.
qual a média de acidentes com vítimas entre as cidades do Rio Grande do
Sul.
37.
Faça um algoritmo que leia um indeterminado número de linhas contendo cada uma
a idade de um indivíduo. A última linha, que não entrará nos cálculos, contém o valor da
idade igual a zero. Calcule e escreva a média das idades deste grupo de indivíduos.
38.
Imagine uma brincadeira entre dois colegas, na qual um pensa um número e o outro
deve fazer chutes até acertar o número imaginado. Como dica, a cada tentativa é dito se o
chute foi alto ou baixo. Elabore um algoritmo dentro desse contexto, que leia o número
imaginado e os chutes, ao final mostre quantas tentativas foram necessárias para descobrir
o número.
39.
Construa um algoritmo que permita fazer um levantamento do estoque de vinhos de
uma adega, tendo como dados de entrada tipos de vinho, sendo: „T‟para tinto, „B‟ para
branco e „R‟ para rose. Especifique a porcentagem de cada tipo sobre o total geral de vinhos;
a quantidade de vinhos é desconhecida, utilize como finalizador „F‟ de fim.
40.
Uma certa firma fez uma pesquisa de mercado para saber se as pessoas gostaram
ou não de um novo produto. Para isso, forneceu o sexo do entrevistado e sua resposta (sim
ou não). Este programa deverá ser executado até que o sexo X seja informado pelo usuário,
encerrando, assim sua execução. Calcule e escreva os itens que seguem:
 o número de pessoas que responderam sim;
66
Lógica de Programação
 o número de pessoas que responderam não;
 a porcentagem de pessoas do sexo feminino que responderam sim; a porcentagem de
pessoas do sexo masculino que responderam não.
41.
Leia dez elementos de um vetor.
42.
Leia oito elementos de um vetor A. Construa um vetor B de mesma dimensão com
os elementos do vetor A multiplicados por três. Apresente o vetor B.
43.
Leia dois vetores A e B com quinze elementos cada. Construa um vetor C, sendo
este a junção dos dois vetores. Desta forma, C deverá ter o dobro de elementos de A e B.
44.
Leia vinte elementos de um vetor A e construa um vetor B de mesma dimensão com
os mesmos elementos de A, sendo que estes deverão estar invertidos, ou seja, o primeiro
elemento de A passa a ser o último de B. O segundo elemento de A passa a ser o penúltimo
de B e assim por diante. Apresente os dois vetores.
45.
Leia doze elementos de um vetor colocá-los em ordem decrescente e apresente os
elementos ordenados.
46.
Leia um vetor A com doze elementos. Após sua leitura, coloque os seus elementos
em ordem crescente. Depois leia um vetor B também com doze elementos. Coloque os
elementos de B em ordem crescente. Construa um vetor C, onde cada elemento de C é a
soma do elemento correspondente de A com B. Apresente os valores de C.
47.
Escreva uma matriz que leia uma matriz M(6,6) e calcule as somas das partes
indicadas:
a.
Acima da diagonal secundária.
b.
Abaixo da diagonal principal.
c.
A esquerda abaixo da diagonal principal e acima da diagonal secundária.
d.
Acima das diagonais principal e secundária.
Escreva M e as somas calculadas.
48.
Considerando uma matriz M(5,5), efetue as seguintes somas:
a.
soma dos elementos da linha 3;
b.
soma dos elementos da coluna 5;
c.
soma dos elementos da diagonal principal (i=j);
d.
soma dos elementos da diagonal secundária (i+j=n+1);
e.
soma dos elementos da matriz toda.
Escreva as somas calculadas.
49.
Escreva uma matriz M(5,3) e a escreva. Verifique, a seguir, quais elementos de M
que estão repetidos e quantas vezes cada um deles é repetido com uma mensagem dizendo
que aparece X vezes em M.
67
Lógica de Programação
68

Documentos relacionados