Apostila - Introdução a Computação

Prévia do material em texto

INTRODUÇÃO À COMPUTAÇÃO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Maceió, 2009 
 
 
 
 
 
 
 SUMÁRIO 
 
 
LISTA DE FIGURAS ................................................................................................. v 
LISTA DE TABELAS ................................................................................................ vi 
1 Introdução...........................................................................................................7 
1.1 Motivação .........................................................................................................7 
1.2 Histórico e Desenvolvimento dos Computadores...................................................8 
1.3 Sistemas de Computação ................................................................................. 12 
1.3.1 Arquitetura................................................................................................... 13 
1.3.1.1 Unidade de Entrada ................................................................................... 13 
1.3.1.2 Memória.................................................................................................... 13 
1.3.1.3 Unidade Central de Processamento (CPU) .................................................... 14 
1.3.1.3.1 Unidade Lógica e Aritmética..................................................................... 15 
1.3.1.3.2 Unidade de Controle................................................................................ 15 
1.3.1.4 Unidade de Saída....................................................................................... 15 
2 Noções de Lógica e Algoritmos ............................................................................ 15 
2.1 Noções de Lógica ............................................................................................ 15 
2.2 Algoritmos ...................................................................................................... 16 
2.2.1 Conceituação................................................................................................ 16 
2.2.2 Refinamentos Sucessivos............................................................................... 18 
2.2.3 Programa Computacional .............................................................................. 19 
2.3 Linguagens de Programação............................................................................. 19 
2.4 Introdução ao MATLAB .................................................................................... 22 
2.4.1 Execução do MATLAB.................................................................................... 23 
2.4.2 Alguns Comandos Básicos ............................................................................. 23 
3 Tópicos Preliminares........................................................................................... 27 
3.1 Tipos Primitivos............................................................................................... 28 
 
3.2 Constantes...................................................................................................... 28 
3.2.1 Constante Numérica...................................................................................... 28 
3.2.2 Constante Lógica .......................................................................................... 28 
3.2.3 Constante Literal .......................................................................................... 28 
3.3 Variáveis......................................................................................................... 29 
3.4 Expressões Aritméticas .................................................................................... 30 
3.4.1 Operadores Aritméticos ................................................................................. 31 
3.4.2 Prioridades................................................................................................... 32 
3.5 Expressões Lógicas.......................................................................................... 33 
3.5.1 Operadores Relacionais ................................................................................. 33 
3.5.2 Operadores Lógicos ...................................................................................... 34 
3.5.2 Prioridades................................................................................................... 36 
3.6 Expressões Literais .......................................................................................... 37 
3.7 Comando de Atribuição.................................................................................... 40 
3.8 Comandos de Entrada e Saída .......................................................................... 40 
3.9 Blocos ............................................................................................................ 44 
4 Estruturas de Controle ........................................................................................ 44 
4.1 Estruturas Seqüenciais ..................................................................................... 44 
4.2 Estruturas de Controle de Fluxo........................................................................ 46 
4.2.1 Estruturas de Seleção (Condicional) ............................................................... 46 
4.2.1.1 Seleção Simples......................................................................................... 46 
4.2.1.2 Seleção Composta...................................................................................... 47 
4.2.1.2 Seleção Encadeada .................................................................................... 48 
4.2.1.4 Seleção de Múltipla Escolha ........................................................................ 49 
4.2.1.5 Exercícios.................................................................................................. 49 
4.3 Estruturas de Repetição ................................................................................... 51 
4.3.1 Estruturas de Repetição Definidas .................................................................. 51 
4.3.2 Estruturas de Repetição Indefinidas ............................................................... 54 
4.3.2.1 Exercícios.................................................................................................. 55 
5 Estruturas de Dados ........................................................................................... 57 
5.1 Introdução...................................................................................................... 57 
5.2 Variáveis Compostas Homogêneas .................................................................... 57 
5.2.1 Variáveis Compostas Homogêneas Unidimensionais......................................... 58 
 
5.2.2 Variáveis Compostas Homogêneas Multidimensionais...................................... 62 
5.3 Variáveis Compostas Heterogêneas................................................................... 65 
6 Modularização.................................................................................................... 68 
6.1 Introdução...................................................................................................... 68 
6.2 Módulos (Funções) .......................................................................................... 69 
6.3 Argumentos (Parâmetros) de Funções............................................................... 72 
6.4 Valores de Retorno de Funções ........................................................................ 74 
Referências Bibliográficas ...................................................................................... 80 
 
 
 
 
 vLISTA DE FIGURAS 
 
 
Figura 1 – Stonehenge ............................................................................ 8 
Figura 2 – Exemplos de ábacos ................................................................ 9 
Figura 3 – Régua de cálculo ....................................................................10 
Figura 4 – Arquitetura básica de um computador......................................13 
Figura 5 – Compilador ............................................................................20 
 
 
 vi
 
 
 
 
 LISTA DE TABELAS 
 
 
Tabela 1 – Linguagens de programação...................................................20 
Tabela 2 – Prioridades das operações ......................................................37 
 
 
 7
INTRODUÇÃO À COMPUTAÇÃO 
 
 
1 Introdução 
 
 Este primeiro capítulo tem por objetivo motivar o leitor para o estudo do tema 
“Introdução à Ciência da Computação”, apresentar um breve histórico a respeito do 
desenvolvimento dos computadores, a forma como esses são organizados e a 
explicação de alguns termos técnicos. 
 
1.1 Motivação 
 Pode-se dizer que o estudo da introdução à computação é o primeiro passo em 
direção ao conhecimento do mundo da tecnologia e funcionamento dos computadores. 
 O uso de computadores no dia-a-dia tem sido cada vez mais freqüente. Em todas 
as áreas de estudo, pesquisa e trabalho eles são essenciais. Veja um exemplo simples 
que serve para ilustrar esta afirmação. 
 Considere que se deseja fazer um levantamento para avaliar qual o melhor aluno 
do ano de 2005 em uma determinada universidade. Naturalmente, poderíamos pegar 
as cadernetas escolares de todos os alunos, calcular a média de suas notas e verificar 
qual aluno obteve a maior média. Isso representa um trabalho muito laborioso, pois a 
quantidade de informações (dados) a serem levantados é extremamente grande. 
 Mas e se tivermos um computador? Como ele pode ser útil para resolver o nosso 
problema? Simples. É necessário apenas garantir que todos os dados dos alunos 
estejam armazenados em um computador e que se possa usar um programa 
computacional para fazer os cálculos desejados. Em questão de segundos poderíamos 
ter a resposta desejada. 
 Mas qual programa usar? Existem duas alternativas: uma é comprar um 
programa comercial (e existem vários) que possa ser utilizado para resolver o 
problema. A outra é desenvolvermos o nosso próprio programa. 
 O presente curso tem com objetivo fornecer uma base teórica e prática para 
permitir o aprendizado, capacitando o leitor a desenvolver programas computacionais 
para resolver os mais diversos problemas do nosso cotidiano, principalmente aqueles 
relacionados à Engenharia. 
 8
1.2 Histórico e Desenvolvimento dos Computadores 
 O objetivo deste item é dissertar a respeito da descoberta do computador e a 
sua evolução ao longo do tempo. 
 Antes de apresentar o que é e como surgiu o computador, define-se aqui o 
termo “informática”, criado na França por volta de 1962. 
 
information automatique = informação automática 
 
 Ou seja, informática é a ciência que estuda o tratamento automático e racional 
da informação com uso de equipamentos e procedimentos da área de processamento 
de dados. Trata do estudo e desenvolvimento de máquinas e métodos para processar 
informações. 
 As principais funções da informática são: 
• Desenvolvimento de novas máquinas; 
• Desenvolvimento de novos métodos de trabalho; 
• Construção de aplicações automáticas; 
• Melhoria dos métodos e aplicações existentes. 
 Desde que o homem começou a processar dados, ele tentou construir máquinas 
que pudessem ajudá-lo em seu trabalho. O computador eletrônico é o resultado dessas 
tentativas que vêm sendo realizadas através dos tempos. Certamente, o computador é 
um dos principais produtos da ciência do século XX. 
 Para alguns pesquisadores, Stonehenge é o primeiro computador feito pelo 
homem. Trata-se de um monumento paleolítico constituído de blocos de pedra de 3 a 6 
metros de altura, construído entre 2.600 a.C. a 1.700 a.C., na planície de Salisbury, na 
Grã-Bretanha. Em 1960 um astrônomo americano (utilizando computador!) mostrou 
que se tratava de um meio capaz de prever eclipses lunares. 
 
Figura 1 – Stonehenge 
 9
 Porém, a maioria dos estudiosos considera o ábaco o primeiro hardware da 
história da computação. Registros históricos de cerca de 2.000 a.C. comprovam que o 
ábaco era utilizado no oriente. Consiste de uma tábua com hastes que trespassam 
contas com formato lenticular com seção transversal hexagonal. 
 
Ábaco chinês 
 
Ábaco japonês 
Ábaco russo 
Figura 2 – Exemplos de ábacos 
 
 O ábaco japonês é chamado de Soroban e foi trazido da china em 1622. O 
Soroban começou como um instrumento simples destinado a registrar valores e realizar 
operações de soma e subtração. Posteriormente, foram desenvolvidas técnicas de 
multiplicação e divisão; atualmente, já são conhecidas técnicas para extração de raízes 
(quadrada e cúbica), operação com horas, minutos e segundos e conversão de pesos e 
medidas. É possível trabalhar com números inteiros, decimais e negativos. 
 O ábaco chegou ao Brasil em 1908 trazido por imigrantes. Sua versão moderna, 
introduzida em 1953, teve sua técnica de utilização difundida pelo Prof. Fukutaro Kato, 
em 1956. 
 Em 1621, o matemático inglês William Outgred inventou a régua de cálculo, 
considerada um dos primeiros dispositivos analógicos de computação. 
 
 10
 
Figura 3 – Régua de cálculo 
 
 Em 1642/1647, o francês Blaise Pascal conseguiu somar e subtrair utilizando sua 
máquina, conhecida como Pascalina, por meio de engrenagens mecânicas. 
 Em 1801, o matemático francês Joseph Marie Jacquard consegue armazenar 
informações em placas perfuradas, para controle de máquinas de tecelagem. A 
invenção gerou grande temor de desemprego. 
 Em 1820, uma máquina de calcular criada pelo francês Charles Thomas de 
Colmar vende mais de 1.500 unidades. As Arithmometers, como eram chamadas, são 
consideradas o primeiro sucesso de vendas no setor. 
 Em 1822, Ada Lovelace, filha do famoso poeta Lord Byron, é contratada pelo 
inglês Charles Babbage para programar sua então criada máquina diferencial. Ada é 
considerada a primeira programadora do mundo. 
 Em 1854, George Boole estabelece os princípios binários que seriam utilizados 
posteriormente como base para o estudo de lógica matemática. 
 Em 1880, Hermann Hollerith, constrói uma máquina de tabulação, utilizada no 
senso norte-americano. 
 Em 1896, Hermann Hollerith funda a Tabulating Machine Company. 
 Em 1911, Hollerith associa-se a outras empresas e a Tabulating Machine 
Company passa a ser dirigida por Tomas Watson. 
 Em 1924 nasce a IBM (International Business Machine Corporation), resultado da 
associação de Hollerith com Watson. 
 Em 1931 o primeiro computador analógico é construído pelo MIT (Massachusetts 
Institute of Technology). 
 Em 1937, Howard Haiken, professor de matemática de Harvard, convence Tomas 
Watson da IBM a fabricar o primeiro computador eletromecânico, o MARK I. 
 11
 Em 1939 surgiu o primeiro computador eletrônico digital, o ABC (Atanasoff Berry 
Computer), que foi apresentado pelo professor de matemática John Atanasoff. 
 Em 1943, a Inglaterra constrói, com o auxílio de Alan Turing, dez computadores 
Colossus I. Esse equipamento eletrônico digital, a válvulas, foi utilizado para decifrar 
códigos militares dos alemães. 
 Em 1946 é apresentado o primeiro grande computador eletrônico da época, o 
ENIAC (Electronic Numeric Integrator Analyser and Calculator). O ENIAC ocupava quase 
200m2, pesava 30 toneladas e conseguia resolver5.000 adições por segundo. 
 Em 1950, John von Neumann, Arthur Burks e Hermann Goldstine desenvolvem 
conceitos de programação e operações por números binários utilizados até hoje. 
 Em 1951, o UNIVAC I, primeiro computador a utilizar os conceitos de von 
Neumann, é produzido em escala comercial. Tinha 20 m2 e pesava 5 toneladas. 
 Em 1953 é lançado o computador IBM 701. 
 Em 1954 é lançado o IBM 650, maior sucesso de vendas da década. 
 O ano de 1959 marca o fim dos computadores de primeira geração, baseados 
em válvulas. Assim, a evolução dos computadores pode ser dividida nas seguintes 
etapas: 
¾ Computadores da 1a Geração: 
y Utilização de circuitos eletromecânicos e válvulas. 
¾ Computadores da 2a Geração: 
y Utilização de transistores (controlam a passagem de corrente) 
à Redução do tamanho e da potência consumida; 
à Dispositivos mais robustos e confiáveis. 
¾ Computadores da 3a Geração: 
y Circuitos integrados 
à Integração de vários transistores em uma única embalagem com a dimensão 
aproximada de um transistor; 
à Maior potência de cálculo; 
à Mais rápidos; 
à Mais confiáveis; 
à Menores fisicamente. 
¾ Computadores da 4a Geração: 
y Circuitos integrados em altíssima escala 
à Integração de milhares de transistores em uma única pastilha. 
 
 Além da evolução acima, pode-se destacar a evolução das telecomunicações 
usando a mesma tecnologia. Isso viabilizou o uso de recursos de telecomunicações 
 12
(internet, por exemplo) aplicados à computação, possibilitando o uso à distância de um 
computador por um ou vários usuários. 
 
1.3 Sistemas de Computação 
 Um sistema de computação é formado por usuários, software e hardware; cada 
um desses componentes será definido posteriormente. 
 O objetivo de um sistema de computação é realizar o processamento dos dados, 
que é a execução de processos sobre o dado original para transformá-lo em uma 
informação. 
 Software ou programa é a parte lógica que dota o equipamento físico com a 
capacidade de realizar algum trabalho. O programa nada mais é que uma seqüência de 
instruções escritas em uma linguagem de programação, informando ao hardware o que 
fazer em que ordem. 
 Hardware é a parte física de um sistema de computação, ou seja, todos os 
elementos materiais que o constitui (circuitos eletrônicos, dispositivos mecânicos, 
elétricos e magnéticos). 
 Existem dois tipos de computadores: os analógicos e os digitais. Um termômetro 
é um exemplo de funcionamento por analogia, pois a dilatação de mercúrio é análoga à 
mudança de temperatura. 
 O princípio da analogia também é utilizado em uma régua de cálculo (figura 3), 
que pode ser considerada como um computador analógico, onde as operações de 
multiplicação e divisão são executadas simplesmente somando-se ou subtraindo-se a 
distância medida na régua externa àquela marcada na régua interna deslizante. 
 Um dos primeiros computadores analógicos de grande porte foi construído para 
prever a altura das marés nos portos ingleses. 
 Os computadores analógicos de hoje são capazes, por exemplo, de simular as 
forças que atuam numa represa ou as forças que atuam nas asas de um avião a partir 
da voltagem elétrica. 
 Resumindo, os computadores analógicos são caracterizados por lidarem com 
grandezas contínuas. Neles, as variáveis do problema são representadas por tensões, 
que são quantidades físicas contínuas. 
 Ao contrário dos computadores analógicos, que trabalham com grandezas físicas, 
os computadores digitais são capazes de somar, subtrair, multiplicar, dividir e comparar 
 13
através de pulsações elétricas que, em última análise, representam os dígitos 0 
(ausência de corrente) e 1 (presença de corrente). 
 Os computadores digitais serão o foco deste nosso curso. 
 
1.3.1 Arquitetura 
 Esta seção trata da estrutura de um computador digital. 
 O esquema de um computador digital pode ser representado pela figura 4. 
 
 
Figura 4 – Arquitetura básica de um computador 
 
 A seguir, são descritos cada componente do computador digital. 
 
1.3.1.1 Unidade de Entrada 
 Esta unidade traduz informação de uma grande variedade de dispositivos em um 
código que a unidade central de processamento (CPU) é capaz de entender. Em outras 
palavras, ela é capaz de traduzir números, letras e imagens em pulsos elétricos que são 
compreensíveis ao computador. Alguns exemplos de unidades de entrada são: teclado, 
unidades de discos (disquetes e cds, por exemplo), scanners, mouse, leitores ópticos, 
etc. As unidades de entrada também são conhecidas como periféricos. 
 
1.3.1.2 Memória 
 É o local físico capaz de armazenar os dados e também os programas que irão 
manipulá-los. Também conhecida como memória RAM (Randon Access Memory). 
 Memória
Unidade de
Controle
Unidade Lógica
e Aritmética
Unidade de 
Entrada
Unidade de
Saída 
CPU
Memória
Unidade de
Controle
Unidade de 
Entrada
Unidade de
Saída 
CPU
 14
 Geralmente, a memória de alta velocidade é utilizada para armazenar 
temporariamente dados e programas que estão sendo processados, já que qualquer 
programa, para ser executado, tem que estar nessa memória. Além disso, as unidades 
de controle e lógica e aritmética se comunicam com cada um de seus bytes. Essa 
memória costuma ser chamada de memória principal. 
 Ao menor item de informação binária dá-se o nome de bit. A palavra bit é uma 
contração de binary digit (dígito binário) significando um dígito que pode assumir um 
dos dois valores de estados diferentes 0 ou 1, tal qual um dígito decimal pode assumir 
um dos dez valores 0, 1, 2, ..., 9. 
 Os bits são agrupados de modo a possibilitar ao usuário representar os dados e 
programas que deseje. Denomina-se byte a um conjunto de bits. Cada byte armazena o 
equivalente a um caractere. O número de bits que formam um byte não é fixo e 
dependem exclusivamente da máquina considerada. O mais usual é encontrar os bytes 
constituídos de 8 bits. 
 A memória do computador é constituída por um conjunto de bits, sendo que o 
byte recebe um endereço a fim de que os programas possam fazer referência aos seus 
dados. 
 A capacidade de um computador normalmente é medida pelo tamanho da sua 
memória. 
 Cada 1024 bytes representam 1 kbyte (quilobyte). Cada 1024 kbytes 
representam 1 Mbyte (megabyte). 1024 Mbytes representam 1 Gbyte (gigabyte). 
 
1.3.1.3 Unidade Central de Processamento (CPU) 
 A Unidade Central de Processamento de um computador, devido a sua 
complexidade, é normalmente dividida em duas partes: unidade lógica e aritmética, e 
unidade de controle. 
 Devido ao desenvolvimento da microeletrônica é possível construir toda uma CPU 
em uma única pastilha de Silício. Essa pastilha, ou chip, denomina-se microprocessador. 
Como exemplo, podemos citar INTEL PENTIUM IV, MOTOROLA 6800, INTEL CELERON, 
etc. 
 Os microprocessadores são classificados pelo comprimento, em bits, da unidade 
de informação que são capazes de processar de uma só vez. Atualmente, os 
microprocessadores mais usuais são os de 32 bits. 
 15
 Resumindo, o microprocessador é a unidade central de processamento (CPU) de 
um microcomputador. 
 A seguir, são descritas as unidades que constituem a CPU. 
 
1.3.1.3.1 Unidade Lógica e Aritmética 
 Nesta unidade são realizados todos os cálculos aritméticos (adição, subtração, 
multiplicação e divisão) e qualquer manipulação de dados (sejam eles numéricos ou 
não). 
 
1.3.1.3.2 Unidade de Controle 
 É a unidade responsável pelo “tráfego” de dados. Ela obtém dados armazenados 
na memória e interpreta-os. Controla a transferência de dados da memória para a 
unidade lógica e aritmética, da unidade de entrada para a memória e da memória paraa unidade de saída. 
 
1.3.1.4 Unidade de Saída 
 Os dados processados são convertidos, por esta unidade, de impulsos elétricos 
em palavras ou números que podem ser disponibilizados ao usuário final. Exemplos 
dessas unidades são o vídeo (monitor), impressoras, unidades de disco (disquetes e 
cds, por exemplo), etc. Assim como as unidades de entrada, as unidades de saída 
também são conhecidas como periféricos. 
 
2 Noções de Lógica e Algoritmos 
 
 Para compreender melhor o processo de criação de programas computacionais, é 
necessário entender os conceitos de lógica de programação e algoritmos, que serão 
descritos nas seções seguintes. 
 
2.1 Noções de Lógica 
 Lógica de programação significa o uso correto das leis do pensamento e de 
processos de raciocínio para a produção de soluções logicamente válidas e coerentes, 
que resolvam com qualidade os problemas que se deseja programar. Ou seja, é a 
técnica de encadear pensamentos para atingir determinado objetivo. 
 16
 A Lógica de programação pode ser representada em qualquer uma das inúmeras 
linguagens de programação, com a utilização dos algoritmos. 
 O aprendizado dessa técnica é necessário para quem deseja trabalhar com o 
desenvolvimento de sistemas e programas computacionais. 
 
2.2 Algoritmos 
2.2.1 Conceituação 
 Algoritmo é uma seqüência ordenada e sem ambigüidades de passos finitos que 
visam atingir um objetivo bem definido e, conseqüentemente, levam à solução de um 
problema. 
 Algoritmo não é a solução do problema. Algoritmo é o conjunto de passos ou 
ações (caminhos) que levam à solução de um dado problema. 
 Em um algoritmo é importante salientar que: 
9 Deve descrever exatamente as instruções que devem ser executadas e em que 
seqüência. 
9 A ordem dos passos deve ser precisamente determinada. 
9 Eficiente: resolve o problema com um mínimo de recursos. 
9 Eficaz: consegue resolver o problema em qualquer situação. Todas as situações 
de exceção que possam alterar o comportamento do algoritmo devem ser 
especificadas e tratadas. 
 
 Existem várias formas de representar os algoritmos, como, por exemplo: 
descrição narrativa, fluxograma ou diagrama de blocos, pseudocódigos etc. 
 O exemplo abaixo ilustra o uso de um algoritmo do tipo descrição narrativa para 
resolver um dado problema. 
 
Exemplo 1: 
 
Problema: Deseja-se falar com alguém através de um telefone público. Como 
proceder? 
 
Solução: Seguir os passos descritos no telefone (algoritmo) 
 17
 
1 – Retirar o telefone do gancho; 
2 – Esperar o sinal; 
3 – Colocar o cartão; 
4 – Discar o número; 
5 – Falar ao telefone; 
6 – Colocar o telefone no gancho; 
7 – Retirar o cartão. 
 
 O algoritmo é exatamente esta seqüência de passos que foi utilizado para 
resolver o problema proposto. É como se fosse ensinar uma máquina a fazer alguma 
tarefa específica. 
 Normalmente, existem vários caminhos que levam à solução de um problema. 
Podemos concluir, então, que existem diversos algoritmos que podem ser utilizados 
para encontrar uma solução. 
 O aprendizado de algoritmos não é uma tarefa muito fácil. Só conseguimos 
utilizá-lo racionalmente através de muitos exercícios práticos. 
 
Exercício 1: Algoritmo para o final de semana 
 
1 – Ver a previsão do tempo; 
2 – Se fizer sol 
 ir à praia; 
 Senão 
 Estudar; 
3 – Almoçar; 
4 – Ver televisão; 
5 – Dormir. 
 
Exercício 2: Algoritmo para fazer uma prova 
 
1 – Ler a prova; 
 18
2 – Pegar a caneta; 
3 – Enquanto houver questão em branco e enquanto o tempo não terminou 
faça 
 
 Se souber fazer a questão 
 Resolvê-la; 
 Senão 
 Pular para a próxima; 
 
4 – Entregar a prova. 
 
2.2.2 Refinamentos Sucessivos 
 Um algoritmo é considerado completo se os seus comandos forem do 
entendimento do seu destinatário. 
 Num algoritmo, um comando que não for do entendimento do destinatário terá 
de ser desdobrado em novos comandos, que constituirão um refinamento do comando 
inicial. Por exemplo, o algoritmo para trocar uma lâmpada queimada poderia ser: 
 
1 – Remova a lâmpada queimada. 
2 – Coloque uma lâmpada nova. 
 
 Detalhando ou refinando os passos: 
 
1.1 – Coloque uma escada embaixo da lâmpada queimada. 
1.2 – Suba na escada até alcançar a lâmpada queimada. 
1.3 – Gire a lâmpada queimada no sentido anti-horário até que ela se solte. 
2.1 – Escolha uma lâmpada nova de mesma potência da queimada. 
2.2 – Posicione a lâmpada nova no soquete. 
2.3 – Gire a lâmpada no sentido horário até que ela se firme. 
2.4 – Desça da escada. 
2.5 – Guarde a escada. 
 
 19
 Se um comando de um refinamento for um tanto vago, ele poderá, por sua vez, 
ser desdobrado em novos comandos, produzindo-se o refinamento de um refinamento, 
e assim sucessivamente. 
 
2.2.3 Programa Computacional 
 É um algoritmo escrito em uma linguagem computacional (C, Fortran, Pascal, 
MATLAB etc). É a tradução do algoritmo para uma linguagem que será interpretada 
pelo computador. O mais importante de um programa computacional é a sua lógica, o 
raciocínio utilizado para resolver o problema (ou seja, o algoritmo). 
 
2.3 Linguagens de Programação 
 Para armazenar um algoritmo na memória do computador e para que ele possa, 
em seguida, comandar as operações a serem executadas, é necessário que ele seja 
programado, ou seja, transcrito para uma linguagem que o computador possa 
“entender” direta ou indiretamente. 
 Os computadores só podem executar diretamente os algoritmos expressos em 
linguagem de máquina, que é um conjunto de instruções capazes de ativar diretamente 
os dispositivos eletrônicos do computador. 
 Essa linguagem tem vários inconvenientes para os humanos: 
• Diferente para cada tipo de computador, pois depende da sua arquitetura; 
• Extremamente rudimentar; 
• Expressa em forma numérica, tornando-se pouco expressiva; 
• Manipulação dos dados na memória. 
 
 Para suprir esses problemas, foram desenvolvidas linguagens em que a 
programação é feita através de uma notação matemática e de algumas palavras 
reservadas. As linguagens de programação são bem mais simples e podem ser 
facilmente entendidas e utilizadas pelos usuários do computador. 
 Os programas escritos nessas linguagens são traduzidos para a linguagem de 
máquina através de um programa especial chamado Compilador. 
 
 20
Linguagem de 
Programação
Linguagem de 
Máquina
Compilador
Linguagem de 
Programação
Linguagem de 
Máquina
Compilador
 
Figura 5 – Compilador 
 
 Como exemplo de linguagens de programação, podemos citar o Fortran, C, C++, 
Pascal, Cobol, MATLAB etc. 
 O MATLAB, cujos detalhes serão descritos nas seções seguintes, tem uma 
característica bem particular. Ele não só incorpora as características de uma linguagem 
de programação, mas também do compilador. Isso será visto com mais detalhes na 
seqüência deste curso. 
 A tabela 1 apresenta uma genealogia de várias linguagens de programação. 
Observa-se que o ano associado a cada linguagem pode significar os anos do projeto 
da linguagem, da sua implementação ou da sua primeira descrição publicada. 
 
Tabela 1 – Linguagens de programação 
 
Linguagem Ano Criador Linguagemoriginária Objetivo 
FORTRAN 1954-57 J. Backus Computação numérica 
ALGOL 60 1958-60 Comitê FORTRAN Computação numérica 
COBOL 1959-60 Comitê Processamento de dados de negócios 
LISP 1956-62 J. McCarthy Computação simbólica 
BASIC 1964 J. Kemeny and T. Kurtz FORTRAN Educacional 
SIMULA 67 1967 O. -J. Dahl ALGOL 60 Simulação 
Algol 68 1963-68 Comitê ALGOL 60 Objetivos gerais 
Pascal 1971N. Wirth ALGOL 60 Educacional 
PROLOG 1972 A. Colmerauer Inteligência artificial 
C 1972 D. Ritchie Algol 68 Programação de sistemas
Pascal atual 1975 P. Brinch Hansen Pascal Programação concorrente
Ada 1979 J. Ichbiah Pascal SIMULA 67
Objetivos gerais 
Sistemas embutidos 
Smalltalk 1971-80 A. Kay SIMULA 67LISP Computação pessoal 
C++ 1984 B. Stroutrup C SIMULA 67 Objetivos gerais 
 21
Tabela 1 – Linguagens de programação 
 
Linguagem Ano Criador Linguagemoriginária Objetivo 
Eiffel 1988 B. Meyer SIMULA 67 Objetivos gerais 
Java 1995 SUN Microsystems C++ Computação em rede
 
 Algumas observações podem ser feitas a respeito das linguagens apresentadas 
na tabela 1. 
 As linguagens FORTRAN e ALGOL 60 foram desenvolvidas como ferramentas 
para resolver problemas científicos numéricos (sistemas de equações, por exemplo), ou 
seja, problemas envolvendo computação complexa e dados relativamente simples. 
COBOL foi desenvolvido como uma ferramenta para resolver problemas de 
processamento de dados de negócios, ou seja, problemas envolvendo computação 
simples e grandes quantidades de dados estruturados, como por exemplo, uma 
aplicação de folha de pagamento. A exceção do ALGOL 60 – que originou outras 
linguagens, como Pascal, mas não sobreviveu aos dias atuais –, FORTRAN ainda está 
entre as linguagens de programação mais utilizadas. As razões para este sucesso tão 
longo podem ser: a relutância dos usuários em mudar para linguagens mais novas, por 
causa de necessidade de compatibilidade com aplicações existentes ou simplesmente 
por medo da mudança; e o fato de que essa linguagem tem evoluído: FORTRAN 66, 
FORTRAN 77 e FORTRAN 90. 
 SIMULA 67, um sucessor da linguagem ALGOL 60, introduziu o conceito de 
classe, um esquema de modularização que pode agrupar um conjunto de rotinas 
relacionadas e estruturas de dados. Classes podem ser organizadas como hierarquias 
de especialização crescente. O conceito de classe influenciou a maioria das linguagens 
desenvolvidas após o SIMULA 67, tais como: C++, Smalltalk, Java e Eiffel. 
 A linguagem de programação Pascal também obteve muito sucesso. Apesar de 
ter sido concebida inicialmente como uma ferramenta para o ensino de programação 
estruturada, houve uma rápida expansão de interesse em Pascal com o advento de 
computadores pessoais de baixo custo. A principal vantagem da linguagem é sua 
simplicidade. 
 Também por razões de simplicidade, Basic é outra linguagem que foi 
desenvolvida no meio dos anos 60 e que foi muito popular. Melhorias recentes, como 
 22
Visual Basic, promoveram facilidades de alto nível para o rápido desenvolvimento de 
aplicações interativas baseadas no ambiente windows. 
 A linguagem de programação C, desenvolvida no início dos anos 70, é hoje uma 
das linguagens mais utilizadas por causa de sua potencialidade e eficiência para 
programação de sistemas. 
 A versão atual de Ada apresentada em 1995, Ada 95, incorpora várias melhorias 
sobre a versão original, em particular, suporte para programação orientada a objetos. 
 As origens da programação orientada a objetos remontam à linguagem de 
programação Simula 67. Porém, este paradigma só ficou popular por causa do sucesso 
do Smalltalk, no final dos anos 70, e do C++. A linguagem de programação C++ teve 
êxito na implantação de características de orientação a objetos em uma linguagem de 
sucesso e amplamente acessível como C. Isto permitiu que muitos programadores 
migrassem de um paradigma de programação convencional para outro considerado 
melhor. Eiffel é outra linguagem orientada a objetos. 
 C++ parece estar ganhando aceitabilidade crescente como uma linguagem de 
programação para fins diversos, primeiro porque suporta programação orientada a 
objetos e segundo porque não requer o abandono de métodos convencionais. 
 Uma direção importante para novos desenvolvimentos está na área de 
computação em rede. Java, derivado de C++ suportando mobilidade de código na 
Internet, pode ser visto como o ponto inicial de uma nova geração de linguagens de 
programação. 
 Por fim, é importante dizer que a escolha da melhor linguagem depende da 
aplicação. É preciso aprender a lidar com uma variedade de linguagens e ser capaz de 
migrar de linguagem a linguagem quando necessário, ou seja, quando a aplicação 
mudar. As linguagens evoluem e novas aparecem quando novas necessidades de 
aplicação emergem. 
 
2.4 Introdução ao MATLAB 
 O MATLAB é um programa que incorpora duas características básicas essenciais. 
A primeira refere-se ao fato dele possuir uma “linguagem de programação” que pode 
ser usada para desenvolver programas computacionais. A segunda está relacionada 
com o fato de ser um programa de computação numérica, podendo ser usado para 
 23
resolver não só operações matemáticas complexas, mas também auxiliar na solução de 
problemas das mais diversas áreas, incluindo a Engenharia. 
 Este curso dá ênfase ao uso do MATLAB como “linguagem de programação”, 
permitindo a construção de programas computacionais para a solução dos mais 
diversos tipos de problemas. 
 Na realidade, será visto uma noção geral e superficial do MATLAB como um todo. 
Àqueles que têm um interesse maior no seu aprendizado, recomenda-se um estudo 
mais aprofundado das referências indicadas. 
 
2.4.1 Execução do MATLAB 
 O MATLAB possui basicamente duas áreas de trabalho: a janela principal, onde é 
realizado o gerenciamento do MATLAB (e de suas tarefas); e a janela de comandos que 
é o principal local de interação com o programa. 
 
2.4.2 Alguns Comandos Básicos 
Comando de Espera 
 
• >> 
 
Finalização dos comandos 
 
• <Enter> 
 
Exemplo 01: 
 
>> 5 * 3 + 4 
 ans = 19 
 
 Nota-se que o MATLAB funciona como calculadora (executa matemática 
elementar). 
 
 
 
 24
Exemplo 02: 
 
>> a = 5 
>> b = 3 
>> c = 4 
>> a * b + c 
 ans = 19 
 
 Neste exemplo, = é o comando de atribuição, e a, b, e c são variáveis. Esses 
detalhes serão vistos na próxima seção. 
 
Uso do ponto e virgula 
 
Exemplo 03: uso do ponto e vírgula 
 
>> a = 5; 
>> b = 3; 
>> c = 4; 
>> a*b + c 
 ans = 19 
 
Limpando a tela 
 
Exemplo 04: limpando a tela 
 
>> clc 
 
 Esse comando não remove as variáveis criadas. Elas continuam existindo. 
 
Verificação de variáveis 
 
 
 25
Exemplo 05: como verificar quais variáveis estão sendo 
usadas 
 
>> who 
 ans b 
 a c 
 
Visualização de variáveis 
 
Exemplo 06: como visualizar os valores armazenados em cada 
variável 
 
>> a 
 a = 5 
 
Outros comandos 
 
Exemplo 07: outros comandos 
 
Usar teclas <K ou L> 
 
Comentários 
 
• Usar o caractere % 
 
Exemplo 08: 
 
>> % a variável b tem valor inicial = 5 
>> b = 5; 
 
Configuração de Janelas 
 
• Menu View 
 26
o Passo 1: Selecionar Desktop Layout / Default; 
o Passo 2: Desselecionar Command History. 
 
• Comando Clear 
o Apagar uma variável específica; 
o Apagar todas as variáveis. 
 
Exemplo 9: 
 
>> clear b 
>> b 
 
>> clear 
 
Comandos Save/Open 
 
• Salvar e ler os dados e informações digitadas. 
 
Arquivos M de Comandos 
 
 São arquivos usados em problemas mais complexos. São arquivos de texto 
simples. O Seu processamento é feito através da sua execução pelo MATLAB usando, 
para isso, o Menu File/New (M-File). 
 
Exemplo 10: arquivo M 
 
% arquivo M – exemplo 
a = 4; 
b = 5; 
c = 3; 
a * b + c 
 
Observações importantes: 
 
• Salvar no diretório de trabalho (na janela de comandos do MATLAB); 
Erro27
• Executar: >> <nome do arquivo> ou RUN. 
 
Funções de Entrada e Saída 
 
 Comandos usados para fornecer dados ao programa computacional ou imprimir 
resultados na tela do computador. 
• input: Entrada de dados pelo teclado 
 
Exemplo 11: 
 
>> a = input(‘Escreva o numero a: ’); 
>> b = input(‘Entre com um nome: ’, 
‘s’); 
 
• disp: Imprime na tela um valor 
 
Exemplo 12: arquivo M 
 
a = input(‘a: ’); 
b = input(‘b: ’); 
c = input(‘c: ’); 
d = a*b + c; 
disp(d); 
 
3 Tópicos Preliminares 
 
 Esta seção descreve os principais tópicos preliminares usados na elaboração de 
programas computacionais. Esses tópicos serão apresentados e inseridos dentro do 
contexto da linguagem de programação MATLAB, adotada neste curso. Deve-se dedicar 
atenção especial a este capítulo, pois ele contém os fundamentos necessários para a 
compreensão dos seguintes. 
 
RUN 
 28
3.1 Tipos Primitivos 
 São os tipos básicos usados para armazenar as informações relacionadas aos 
dados utilizados pelo programa computacional. Podem ser constantes ou variáveis, 
como podem ser vistos a seguir. 
 
3.2 Constantes 
 Um dado é dito constante quando ele não sofre alterações durante o decorrer do 
tempo, ou seja, seu valor é constante desde o início até o final da execução do 
programa computacional. 
 Uma constante pode ser um número, um valor lógico ou uma seqüência de 
caracteres quaisquer com algum significado para o problema em estudo. Conforme o 
seu tipo, a constante é classificada como sendo numérica, lógica ou literal. 
 
3.2.1 Constante Numérica 
 A representação de uma constante numérica é feita no sistema decimal, 
podendo ser um número com parte fracionária ou não. 
Ex.: 25 
 3.14 
 7.8E3 {7.8 x 103} 
 2.5E-3 {2.5 x 10-3} 
 
3.2.2 Constante Lógica 
 É um valor lógico, isto é, que só pode ser falso ou verdadeiro, usado em 
proposições lógicas, conforme será visto mais adiante. 
 
3.2.3 Constante Literal 
 Uma constante deste tipo pode ser qualquer seqüência de caracteres (letras, 
dígitos ou símbolos especiais) com algum significado para o problema em estudo. 
Ex.: ‘Francisco P.A. Almeida’ 
 ‘12345’ 
 ‘*A!B?-’ 
 ‘15/05/2006’ 
 
 29
 Nota-se que um numeral escrito como literal é considerado como uma seqüência 
de dígitos, e não como uma constante numérica. 
 
3.3 Variáveis 
 Variável é um espaço (endereço) na memória principal do computador usada 
para armazenar um determinado tipo de dado. A uma variável, associa-se um nome 
que serve como referência ao dado armazenado nesse espaço na memória. 
 O conteúdo de uma variável pode ser de diversos tipos: numérico (inteiro e real), 
caractere, lógico, e outros. Normalmente, o estudo de algoritmos trabalha com os tipos 
acima citados. 
 Na maioria das linguagens de programação, as variáveis precisam ser 
explicitamente declaradas. Na declaração de uma variável, o seu tipo e seu nome 
devem ser obrigatoriamente especificados. 
 Quando uma declaração de variável é encontrada no programa, reserva-se um 
espaço na memória para armazenar um dado tipo da variável e associa-se o nome da 
variável a este espaço. 
 
Exemplo 01 – Declaração de variáveis 
inteiro: a; 
real: x; 
caracter: s; 
logico: l; 
a = 5; 
x = 8.34; 
s = ‘c’; 
l = VERDADEIRO; 
 
 Deve-se observar que na linguagem MATLAB, não existe uma diferença entre 
números inteiros e reais. Eles são tratados de uma mesma forma como variáveis 
numéricas. Além disso, o MATLAB não requer a declaração prévia dessas variáveis. Isso 
é feito implicitamente quando a variável está sendo usada pela primeira vez no 
programa computacional. 
 
 30
Exemplo 02 – Variáveis no MATLAB 
a = 5; % variável numérica 
b = 8.35; % variável numérica 
s = ‘c’; % caractere 
l = 1; % variável lógica 
v = ‘casa’; % seqüência de caracteres (string) 
 
 As seguintes regras básicas devem ser atendidas no uso de variáveis no 
MATLAB. 
 
• Palavra única (sem espaços); 
• Maiúscula ≠ Minúscula; 
• Tamanho máximo = 31 caracteres; 
• Nome deve ser iniciado com letra; 
• Palavras-chave (reservadas da linguagem) não podem ser usadas. 
 
Exemplo 03: 
>> function = 8 
 
Exemplo 04: Detalhe interessante 
>> A = ‘1’; % caractere 
>> B = 1; % valor numérico 1 
% A e B são diferentes 
 
3.4 Expressões Aritméticas 
 Expressões aritméticas são aquelas que cujos operadores são aritméticos e os 
operandos são constantes e/ou variáveis do tipo numérico. 
 Os operadores permitem combinar variáveis e constantes, formando uma 
expressão que pode ser avaliada e resultar em um valor. 
 O conjunto de operações básicas adotado é o que se conhece da matemática, ou 
seja: 
 
 
 
Erro: function é uma palavra-chave 
 31
adição subtração 
multiplicação divisão 
potenciação radiciação 
 
 Observação: não é permitido omitir o operador de multiplicação, o que é comum 
nas expressões matemáticas. Isto evita confusão quanto aos nomes de variáveis, pois 
numa expressão da forma AB+C, como saber se AB é o nome de uma variável ou a 
multiplicação de entre os conteúdos de duas variáveis, cujos nomes são A e B? 
 
3.4.1 Operadores Aritméticos 
 Conjunto de símbolos que representam as operações básicas da matemática. Os 
tipos básicos usados no MATLAB são: 
 
Soma + 
Subtração – 
Multiplicação * 
Divisão / 
 
 Observação: por uma questão de uniformidade, na elaboração de algoritmos, 
não é permitido o uso de outros símbolos para as operações acima, a exemplo de “x” e 
“÷” para multiplicação e divisão, respectivamente. 
 
 Além destes, existem outros operadores importantes que podem ser usados na 
elaboração de programas computacionais. 
 
Potenciação ^ 
Resto de divisão mod(x,y) 
Radiciação sqrt(x) 
 
 Outros operadores serão apresentados ao longo do curso. 
 
 
 32
Exemplo 06: 
2^3 
8 
 
Exemplo 07: 
mod(5,3) 
2 
Exemplo 08: 
sqrt(9) 
3 
 
Exemplo 08: 
>> c = 5 + 3; 
 Ou 
>> a = 3; 
>> b = 1; 
>> c = 3 + a*b; 
 
Exemplo 09: 
>> a = ‘teste’ 
>> b = a + 2 
 
3.4.2 Prioridades 
 Existe uma ordem que define a precedência (hierarquia) entre os operadores 
aritméticos, como pode ser visto na tabela abaixo: 
 
Parênteses mais internos 
^, sqrt 
*, /, mod 
+, - 
 
 
Erro: não é uma expressão 
 33
Exemplo 10: 
5 + 9 + 7 + 8/4 
5 + 9 + 7 + 2 
23 
 
Exemplo 11: 
1 + 5 + (2 + 3) * 4 
1 + 5 + 5 * 4 
1 + 5 + 20 
26 
 
3.5 Expressões Lógicas 
 É comum nos algoritmos surgirem situações em que a execução de uma ação, 
ou seqüência de ações, está sujeita a certa condição. Essa condição é representada no 
texto do algoritmo por meio de uma expressão lógica. 
 Assim, expressões lógicas são aquelas cujos operadores são lógicos ou 
relacionais e cujos operandos são relações, constantes e/ou variáveis do tipo lógico. 
 
3.5.1 Operadores Relacionais 
 Os operadores relacionais são usados para realizar comparações entre dois 
valores do mesmo tipo. Esses valores podem ser constantes, variáveis ou expressões 
aritméticas. O resultado produzido por um operador relacional é sempre um valor 
lógico. Como na linguagem C, no MATLAB não existe explicitamente o operador lógico 
VERDADEIRO ou FALSO. Se o resultado de uma comparação for falso, produz o valor 
zero; caso contrário, valor um. 
 Os operadores relacionais são conhecidos da Matemática, a saber: 
 
= igual a < menor que 
≠ diferente de ≥ maiorque ou igual a 
> maior que ≤ menor que ou igual a 
 
 Os operadores relacionais do MATLAB são: 
 
 34
< Menor que 
<= Menor que ou igual a 
> Maior que 
>= Maior que ou igual a 
== Igual a 
~= Diferente de 
 
 
Exemplo 12: 
2 * 4 == 24 / 3 
8 == 8 
1 
 
Exemplo 13: 
>> vf = (4*5+3) + 4 == 20/4 + 15; 
>> vf 
vf = 0 
 
Exemplo 14: 
A = 3; 
B = 2; 
(A + B) > 3 
 
3.5.2 Operadores Lógicos 
 A Álgebra das Proposições define três conectivos usados na formação de novas 
proposições a partir de outras já conhecidas. Estes conectivos são os operadores nas 
expressões lógicas, a saber: 
 
 e – para a conjunção 
 ou – para a disjunção 
 não – para a negação 
Cuidado! 
Expressão Relacional 
 35
 A conjunção de duas proposições é verdadeira se e somente se ambas as 
proposições são verdadeiras. 
 A disjunção de duas proposições é verdadeira se e somente se, pelo menos uma 
delas for verdadeira. 
 Dada uma proposição p qualquer, uma outra proposição, chamada negação de 
p, pode ser formada escrevendo-se “É falso que” antes de p ou, se possível, inserindo a 
palavra “não” em p. 
 O resultado obtido de uma expressão lógica é sempre um valor lógico (V ou F). 
 Os operadores lógicos são utilizados na formação de proposições lógicas 
compostas. No MATLAB, tais operadores são representados pelos seguintes comandos: 
 
& e 
| ou 
~ não 
 
Exemplo 15: (Tabelas-Verdade) 
 
Negação 
A Não A 
Falso Verdadeiro 
Verdadeiro Falso 
 
Conjunção 
A B A & B 
F F F 
F V F 
V F F 
V V V 
 
Disjunção Não-Exclusiva 
A B A ou B 
F F F 
 36
F V V 
V F V 
V V V 
 
 Sejam p e q proposições, as tabelas-verdade podem ser apresentadas 
resumidamente como: 
 
p q p e q p ou q não p 
F F F F V 
F V F V V 
V F F V F 
V V V V F 
 
Exemplo 15: 
2 < 5 & 15/3 == 5 
v & v 
v 
 
2 < 5 | 15/3 == 5 
v | v 
v 
 
2 < 5 | (~(15/3==5)) 
v | (~v) 
v | f 
v 
 
3.5.2 Prioridades 
 É possível ter mais de um operador lógico na mesma expressão. Em alguns 
casos, conforme os valores envolvidos, a ordem em que são efetuadas as operações 
lógicas afeta o resultado final. Assim, igualmente ao que acontece nas expressões 
aritméticas, também existe uma relação de prioridade entre os operadores lógicos. A 
 37
tabela 2 apresenta as prioridades entre todos os operadores conhecidos, visto que 
podem estar presentes na mesma expressão lógica. 
 
Tabela 2 – Prioridades das operações 
 
Prioridade Operações 
1a aritmético 
2a relacional 
3a não 
4a e 
5a ou 
 
 Também nas expressões lógicas, vários níveis de parênteses podem ser 
utilizados com a finalidade de estabelecer uma ordem de execução entre os operadores 
lógicos. 
 
3.6 Expressões Literais 
 Uma expressão literal é aquela formada por operadores literais e operandos que 
são constantes e/ou variáveis do tipo literal. 
 Supondo que A e B são variáveis literais, a operação de concatenação fornece 
como resultado um único literal formado pelo conteúdo de A seguido do conteúdo de B. 
 No MATLAB, isso é feito da seguinte forma: 
 
Exemplo 16: 
>>txt=’Resultado’; 
>>txt1=[txt ‘ da Prova’]; % Concatenação horizontal
>>txt1=strcat(txt,' da Prova') 
txt1 = 
Resultado da Prova 
 
 
 
 38
Exemplo 17: 
>>txt=’Resultado’; 
>>txt1=[txt; ‘ da Prova’] % Concatenação vertical
 
 A concatenação vertical com sinal ‘;’só foi possível porque as duas cadeias de 
caracteres possuem o mesmo tamanho. 
 Cadeias de caracteres com números diferentes de letras não podem ser 
concatenadas com ‘;’: 
 
Exemplo 18: 
>> txt1=[txt; 'da Prova'] 
??? Error using ==> vertcat 
All rows in the bracketed expression must have the same 
number of columns. 
 
 Nesse caso, deve-se usar a função strvcat, que executa a concatenação, 
ajustando os tamanhos das cadeias de caracteres com a inclusão de espaços. 
 
Exemplo 19: 
>> txt1=strvcat(txt, 'da Prova')
txt1 = 
Resultado 
da Prova 
 
 Além da concatenação de literais, é comum a existência de outras operações 
desta natureza. Por exemplo, no MATLAB, a função numel informa o comprimento do 
literal, ou seja, o número de caracteres. 
 
Exemplo 20: 
>> numel(txt) 
ans = 
 9 
 39
 É possível identificar qualquer caractere de um literal. 
 
Exemplo 21: 
>> txt(1) 
ans = 
R 
>> n=numel(txt);
>> txt(n) 
ans = 
o 
 
 O símbolo ‘:’ define intervalos de indexação. 
 
Exemplo 22: 
>> txt(1,1:2) 
ans = 
Re 
>> txt(1,3:5) 
ans = 
sul 
>> txt(1,6:7) 
ans = 
ta 
>> txt(1,8:9) 
ans = 
do 
 
 A palavra-chave ‘end’ indica fim de intervalo. 
Exemplo 23: 
>> txt(1,6:end) 
ans = 
tado 
 40
3.7 Comando de Atribuição 
 Permite fornecer (atribuir) um valor a uma variável. O comando utilizando para 
definir esse operador é =. 
 
Exemplo 24: 
>> A = 5; 
>> B = 4; 
>> C = A+mod(A,B); 
 
 Deve-se observar que à esquerda do comando de atribuição deve existir apenas 
uma variável. 
 
3.8 Comandos de Entrada e Saída 
 Os algoritmos necessitam da entrada de dados para que possam efetuar as 
operações e cálculos a fim de alcançar um resultado desejado (saída de dados). 
 Os comandos de entrada e saída são as ferramentas que determinam o 
momento da entrada dos dados para o programa e a saída dos resultados obtidos pelo 
computador. 
 A finalidade da entrada de dados é atribuir o dado a ser fornecido pelo usuário à 
variável identificada. Nos algoritmos, pode-se utilizar a palavra “leia” para a leitura de 
variáveis. 
 
leia (x1, x2, x3, ..., xn) 
 
onde x1, x2, x3, ..., xn são variáveis, lidas na mesma linha. 
 
Exemplo: 
leia (A); 
leia (altura, peso); 
 
 No MATLAB, a associação de um valor a uma variável pode ser feita, 
basicamente de 3 maneiras, a depender de onde e como a variável é definida: 
 
 41
¾ A variável é definida e associada no editor de programas. 
 
Exemplo 1 
prova_escrita=8; 
prova_pratica=9; 
media=(prova_escrita+prova_pratica)/2
 
¾ A variável é definida e associada na janela de comandos. 
 
Exemplo 2 
media=(prova_escrita+prova_pratica)/2
>> prova_escrita=8; 
>> prova_pratica=9; 
>> ex2 
media = 
 8.5000 
 
¾ A variável é definida no editor de programas, mas um valor específico é atribuído 
na janela de comandos quando o programa é executado. 
 
Exemplo 3 
prova_escrita=input('Prova escrita= '); 
prova_pratica=input('Prova pratica= '); 
media=(prova_escrita+prova_pratica)/2
 
 Para esse último caso, o comando “input” é utilizado para criar a variável. A 
forma do comando “input” é: 
 
nome_da_variavel=input(‘mensagem que é mostrada na janela de comandos’) 
 
 A finalidade da saída de dados é exibir o conteúdo da variável identificada. 
Mostrar a resposta do problema. A palavra-chave “escreva” é utilizada nos algoritmos. 
 42
escreva (x1, x2, x3, ..., xn); 
 
Exemplo: escreva (A); 
escreva (‘Altura = ’, altura, ‘metros’); 
escreva (‘Você tem ’, peso, ‘kilos’); 
 
 No MATLAB, dois comandos são muito usados para a saída de dados: “disp” e 
“fprintf”. O comando “disp” mostra a saída na tela, enquanto que o comando “fprintf” 
pode ser usado para mostrar a saída na tela ou salvar a saída em um arquivo. 
 O comando “disp” é usado para mostrar os elementos de uma variável sem 
mostrar o nome da variável, e para mostrar texto. O formato do comando “disp” é: 
 
disp (nome de uma variável) ou disp(‘texto’) 
 
 Apenas uma variável pode ser mostradaem um comando ‘disp’. 
 
Exemplo 4 
prova_escrita=input('Prova escrita= '); 
prova_pratica=input('Prova pratica= '); 
media=(prova_escrita+prova_pratica)/2;
disp(media); 
 
 O comando ‘fprintf’ pode ser usado para mostrar texto e dados na tela ou para 
salva-los em um arquivo. Com esse comando (diferentemente do comando ‘disp’) a 
saída pode ser formatada. 
 A utilização do comando ‘fprintf’ para mostrar texto tem a seguinte forma: 
 
fprintf (‘texto’) 
 
 
 
 
 43
Exemplo 5 
prova_escrita=input('Prova escrita= '); 
prova_pratica=input('Prova pratica= '); 
media=(prova_escrita+prova_pratica)/2;
fprintf('Media= '); 
disp(media); 
 
Obs.: O comando ‘fprintf’ não inicia uma nova linha. 
 
 Outros comandos podem ser utilizados junto com o comando ‘fprintf’: 
\n começa uma nova linha; 
\b Backspace; 
\t tabulação horizontal 
 A utilização do comando ‘fprintf’ pode ser feita para mostrar uma mistura de 
texto e dados numéricos. Isso acontece, por exemplo, da seguinte forma: 
 
fprintf(‘texto % 5.2f texto adicional’, nome da variável); 
 
onde o símbolo ‘%’ marca onde o número entra no texto; no exemplo, ‘5.2f’ é a 
formatação da variável, no caso, são 5 dígitos, com 2 casas decimais e formatação com 
ponto fixo. Outros exemplos são: 
 
e notação exponencial com letra minúscula; 
E notação exponencial com letra maiúscula; 
f notação com ponto fixo; 
i inteiro. 
 
Exemplo 6 
prova_escrita=input('Prova escrita= '); 
prova_pratica=input('Prova pratica= '); 
media=(prova_escrita+prova_pratica)/2;
fprintf('\nMedia=%6.2f',media); 
 44
 O comando ‘fprintf’ permite inserir mais de uma variável dentro do texto: 
 
fprintf(‘texto %...%...’, variável1,variável2); 
 
3.9 Blocos 
 Um bloco pode ser definido como um conjunto delimitado de ações a serem 
executadas. 
 Para delimitar um bloco em um algoritmo, são utilizados delimitadores: 
 
 início 
 
 fim 
 
4 Estruturas de Controle 
 
 Na construção de algoritmos, utilizamos os conceitos de: 
9 variáveis 
9 constantes 
9 atribuições 
9 operadores e expressões aritméticas, lógicas e relacionais 
9 comandos que traduzem esses conceitos de forma a representar o 
conjunto de ações desejadas. 
 
 Para que esse conjunto de ações se torne viável, é necessário estabelecer o fluxo 
de execução do algoritmo. 
 Isso é possível a partir do uso das estruturas básicas de controle do fluxo de 
execução e das combinações entre elas, permitindo a criação de algoritmos e 
programas computacionais usados na solução dos problemas. Essas estruturas são 
apresentadas na presente seção. 
 
4.1 Estruturas Seqüenciais 
 Correspondem à execução do conjunto de ações primitivas em uma seqüência 
linear de comandos de cima para baixo e da esquerda para direita (ou seja, na mesma 
ordem em que foram escritas). 
 
 45
Exemplo 01: Calcular a média aritmética de quatro notas semestrais 
quaisquer fornecidas por um aluno. 
N1 = input(‘Entre com a nota 1: ’); 
N2 = input(‘Entre com a nota 2: ’); 
N3 = input(‘Entre com a nota 3: ’); 
N3 = input(‘Entre com a nota 4: ’); 
MA = (N1+N2+N3+N4)/4; 
disp(‘A media e: ’); 
disp(MA); 
 
 Neste exemplo, deve-se observar que o fluxo de execução é de cima para baixo, 
da esquerda para a direita. 
 
Exemplo 02: Fazer um programa que leia os coeficientes de uma equação do 
primeiro grau do tipo y = Ax + B e calcule a sua raiz. Imprimir o resultado na 
tela (questão da lista). 
A = input(‘Coeficiente A: ‘); 
B = input(‘Coeficiente B: ‘); 
x = -B/A; 
disp(‘A raiz e: ‘); 
disp(x); 
 
Exemplo 03: O cálculo do ponto de interseção entre duas retas pode ser 
obtido igualando-se as suas equações. Baseado nessa informação, fazer um 
programa que leia os coeficientes das equações das retas e calcule o ponto 
de interseção. As retas são definidas pelas equações y = Ax+B e y = Cx + D. 
Imprimir o resultado. 
A = input(‘Coeficiente A: ‘); 
B = input(‘Coeficiente B: ‘); 
C = input(‘Coeficiente C: ‘); 
D = input(‘Coeficiente D: ‘); 
x = (D-B)/(A-C); 
y = Ax + B; 
disp(‘Coordenada X: ‘); 
disp(x); 
disp(‘Coordenada Y: ‘); 
disp(y); 
 
Exemplo 04: Fazer um programa para calcular a norma do vetor x = (x1, x2, 
x3), onde os coeficientes devem ser lidos. 
x1 = input(‘Coeficiente 1: ‘); 
x2 = input(‘Coeficiente 2: ‘); 
x3 = input(‘Coeficiente 3: ‘); 
n = sqrt(x1*x1 + x2*x2 + x3*x3); 
disp(‘A norma e: ‘); 
disp(n); 
Ax+B = Cx + D; (A-C)x=(D-B) 
 
x=(D-B)/(A-C) 
 
y=Ax+B 
 46
4.2 Estruturas de Controle de Fluxo 
 As estruturas de controle de fluxo são fundamentais para qualquer linguagem de 
programação. São estruturas que alteram o fluxo de execução do programa. Sem elas 
só haveria uma maneira do programa ser executado: de cima para baixo comando por 
comando. Não haveria condições, repetições ou saltos. 
 A linguagem MATLAB possui diversos comandos de controle de fluxo. É possível 
resolver todos os problemas sem utilizar todas elas, mas deve-se notar que a elegância 
e facilidade de entendimento de um programa dependem do uso correto das estruturas 
nos locais certos. 
 
4.2.1 Estruturas de Seleção (Condicional) 
 Essas estruturas permitem a escolha de um grupo de comandos a ser executado 
quando determinadas condições são ou não satisfeitas (verdadeiro ou falso). Aqui, são 
usados os conceitos de expressões lógicas e relacionais vistos anteriormente. 
 
4.2.1.1 Seleção Simples 
 Usada quando precisamos testar uma certa condição antes de executar uma 
ação. Seu modelo é descrito abaixo. 
 
if < condição > 
 comando 1; 
 comando 2; 
 comando n; 
end 
 
Exemplo 01: Cálculo da média com verificação de aprovação. 
N1 = input(‘Entre com a nota 1: ’); 
N2 = input(‘Entre com a nota 2: ’); 
N3 = input(‘Entre com a nota 3: ’); 
N3 = input(‘Entre com a nota 4: ’); 
MA = (N1+N2+N3+N4)/4; 
disp(‘A media e: ’); 
disp(MA); 
If( MA >= 7 ) 
 disp(‘Aluno aprovado!’); 
end 
Expressão Lógica 
e/ou relacional
 47
4.2.1.2 Seleção Composta 
 Usada quando existir situações em que duas alternativas dependem de uma 
mesma condição (uma ser verdadeira e outra falsa). 
 
if < condição é verdadeira > 
 comando a-1; 
 comando a-2; 
 comando a-n; 
else 
 comando b-1; 
 comando b-2; 
 comando b-n; 
end 
 
Exemplo 02: cálculo da média com verificação de aprovação e reprovação. 
N1 = input(‘Entre com a nota 1: ’); 
N2 = input(‘Entre com a nota 2: ’); 
N3 = input(‘Entre com a nota 3: ’); 
N3 = input(‘Entre com a nota 4: ’); 
MA = (N1+N2+N3+N4)/4; 
disp(‘A media e: ’); 
disp(MA); 
if( MA >= 7 ) 
 disp(‘Aluno aprovado!’); 
Else 
 disp(‘Aluno reprovado!’); 
End 
 
Expressão 
Ló i /
 48
4.2.1.2 Seleção Encadeada 
 Usada quando existe a necessidade de agrupar várias seleções de forma 
encadeada. 
 
if < condição1 > 
 comando a-1; 
 comando a-2; 
 comando a-n; 
elseif < condição 2 > 
 comando b-1; 
 comando b-2; 
 comando b-n; 
elseif < condição 3 > 
 if < condição 3-a > 
 comando c-1; 
 comando c-2; 
 comando c-n; 
 end 
else 
 comando d-1; 
 comando d-2; 
 comando d-n; 
end 
 
Exemplo 03: cálculo da média verificando aprovação, reprovação e final. 
N1 = input(‘Entre com a nota 1: ’); 
N2 = input(‘Entre com a nota 2: ’); 
N3 = input(‘Entre com a nota 3: ’); 
N3 = input(‘Entre com a nota 4: ’); 
MA = (N1+N2+N3+N4)/4; 
disp(‘A media e: ’); 
disp(MA); 
if( MA >= 7 ) 
 disp(‘Aluno aprovado!’); 
elseif( MA < 5 ) 
 disp(‘Aluno reprovado!’); 
else 
 disp(‘Aluno na final’); 
end 
 
 
 
 49
4.2.1.4 Seleção de Múltipla Escolha 
 Esse tipo de seleçãoé uma alternativa para o uso da seleção encadeada if-else-
if. 
 
switch( variavel ) 
 case v1: 
 comandos 1; 
 case v2: 
 comandos 2; 
 case vn: 
 comandos n; 
 otherwise: 
 comandos; 
end 
 
 Deve observar que variável não pode ser uma expressão. 
 
Exemplo 04: 
disp(‘digite 1: primeira opcao’); 
disp(‘digite 2: segunda opcao’); 
disp(‘digite 3: terceira opcao’); 
 case 1: 
 disp( ‘Foi digitada a primeira opcao’); 
 case 2: 
 disp( ‘Foi digitada a segunda opcao’); 
 case 3: 
 disp( ‘Foi digitada a terceira opcao’); 
 Otherwise: 
 disp( ‘Opcao nao existente’); 
End 
 
4.2.1.5 Exercícios 
Exercício 01: Escrever um algoritmo que leia 3 valores numéricos e mostre-os 
em ordem crescente. 
A = input(‘Valor 1: ’); 
B = input(‘Valor 2: ’); 
C = input(‘Valor 3: ’); 
if( A < B ) 
 if( B < C ) 
 disp(A); disp(B); disp(C); 
 else 
 if( A < C ) 
 disp(A); disp(C); disp(B); 
 else 
 50
 disp(C); disp(A); disp(B); 
 end 
 end 
elseif( A < C) 
 disp(B); disp(A); disp(C); 
else 
 if( B < C ) 
 disp(B); disp(C); disp(A); 
 else 
 disp(C); disp(B); disp(A); 
 end 
end 
 
Exercício 02 – Ler 3 números, verificar se eles podem ou não ser lados de um 
triângulo. Se sim, classificar o triângulo quanto os seus lados. 
3 lados iguais: Eqüilátero 
2 lados iguais: Isósceles 
Lados desiguais: Escaleno 
A = input(‘Entre c/ o primeiro lado: ’); 
B = input(‘Entre c/ o segundo lado: ’); 
C = input(‘Entre c/ o terceiro lado: ’); 
if( A < B+C & B < A+C & C < A+B ) 
 if A == B & B == C 
 disp(‘Triangulo Eqüilátero!’); 
 elseif A == B | B == C | A == A 
 disp(‘Triangulo Isósceles!’); 
 else 
 disp(‘Triangulo Escaleno!’); 
 end 
 else 
 disp(‘Lados nao formam um triangulo!’); 
end 
 
Exercício 03 – Criar um algoritmo que entre com o valor de x, calcule e 
imprima o valor de f(x), onde 
f(x) = (5x+3) / sqrt(x2 – 16) 
x = input(‘Entre c/ o valor de x: ’); 
d = x^2 – 16; 
if d <= 0 
 disp( ‘Nao existe solucao real!’ ); 
else 
 f = (5x+3)/sqrt(d); 
 disp(‘O valor de f e’: ’); 
 disp(f); 
end 
 
 
 51
Exercício 04 – Escrever um programa que verifique se um dado número é par 
ou ímpar (entre 0 e 100). 
A = input(‘Entre c/ o numero: ’); 
if A < 0 
 disp(‘O numero e menor que zero!’); 
elseif A > 100 
 disp(‘O numero e maior que zero!’); 
else 
 if mod(A,2) == 0 
 disp(‘O numero e par!’); 
 else 
 disp(‘O numero e impar!’); 
 end 
end 
 
4.3 Estruturas de Repetição 
 Considere o seguinte algoritmo para o cálculo da média bimestral de um aluno: 
 
Exemplo 07: 
P1 = input(‘Nota do trabalho: ’);
P2 = input(‘Nota da prova: ’); 
Media = 0.3*P1 + 0.7*P2; 
disp(Media); 
 
 E se eu desejar calcular a média de todos os alunos da turma? (21, por exemplo) 
Uma solução é repetir o código acima 21 vezes; outra opção é “rodar” (executar) o 
programa acima 21 vezes. 
 No entanto, nem sempre essas soluções são viáveis. 
 A idéia, então, é usar o mesmo trecho do código acima sem a necessidade de 
reescrevê-lo. As estruturas usadas para implementar essa idéia são chamadas 
Estruturas de Repetição. Elas podem ser divididas em dois tipos básicos: 
 
9 Estruturas de Repetição Definidas 
9 Estruturas de Repetição Indefinidas 
 
 Essas estruturas são vista na seqüência desta seção. 
 
4.3.1 Estruturas de Repetição Definidas 
 São estruturas de repetição com um número finito de repetições. Sua sintaxe é 
dada por: 
 52
 
para i de vi até vf de passo p faça 
 comando 1; 
 comando 2; 
 M 
 comando n; 
fim 
 
i = variável de controle; 
vi = valor inicial atribuído a i; 
vf = valor final atribuído a i (condição de parada); 
p = incremento/decremento dado à variável i. 
 
Exemplo 01: Calcular a média anual de 10 alunos.
s = 0; 
for i = 1:1:10 
 m = input(‘media: ‘); 
 s = s + m; 
end 
media = s / 10; 
disp(media); 
 
 O funcionamento do código acima é dado pela tabela abaixo: 
 
i m s 
1 10 10 
2 5 15 
3 5 20 
4 8 28 
5 7 35 
6 10 45 
7 5 50 
8 6 56 
9 4 60 
10 3 63 
 53
 Ao final da execução, a variável média vai armazenar o valor 63/10 = 6.3. 
 Se o valor do incremento (p) é omitido, considera-se p=1 (for i = 1:10). 
 Se vi = vf, o “laço” é executado uma vez. 
 Se vi > vf e p > 0 ou se vi < vf e p < 0, o laço não é executado. 
 
Exemplo 02: Calcular a soma dos 6 primeiros números pares não-negativos. 
soma = 0; 
for i = 0:2:10 
 soma = soma + i; 
end 
disp(soma); 
 
Ou 
 
soma = 0; 
for i = 0:1:5 
 soma = soma + 2*i; 
end 
disp(soma); 
 
 E se desejássemos calcular a soma dos 100 primeiros números pares não-
negativos? A alteração seria apenas no limite da estrutura de repetição. Isso mostra a 
importação desse tipo de estrutura. 
 
Exemplo 03: Calcular a média bimestral de 10 alunos.
for i = 1:1:10 
 p1 = input(‘Nota do Trabalho: ’); 
 p2 = input(‘Nota da Prova: ’); 
 media = 0.3*p1 + 0.7*p2; 
 disp(‘Media’); 
 disp(media); 
end 
 
Exemplo 04: Dado um número qualquer, calcular o seu fatorial. 
x = input(‘Entre com um numero: ‘) 
fat = 1; 
for i = 1:1:x 
 fat = fat * i; 
end 
Disp(fat); 
 
 54
4.3.2 Estruturas de Repetição Indefinidas 
 São estruturas onde não se conhece, a priori, quantas execuções serão 
realizadas. Sua sintaxe é dada por: 
 
enquanto ( expressão condicional) 
 comando 1; 
 comando 2; 
 M 
 comando n; 
fim 
 
onde expressão condicional representa a condição de execução do bloco. 
 
 No Matlab, 
 
while ( expressão condicional) 
 comando 1; 
 comando 2; 
 M 
 comando n; 
end 
 
Exemplo 01: Calcular o valor de f(x) = x2 + 2 até que f(x) seja maior que 20. 
f = 0; 
while f <= 20 
 x = input(‘Entre com x: ’); 
 f = x^2 + 2; 
 disp(f); 
end 
 
 As estruturas de repetição indefinida também podem ser usadas em problemas 
definidos. No entanto, o inverso não é verdade. 
 
 
 
 55
Exemplo 02: Calcular a média anual de 10 alunos usando while. 
soma = 0; 
cont = 1; 
while cont <= 10 
 m = input(‘Media: ’); 
 soma = soma + m; 
 cont = cont + 1; 
end 
media = soma/(cont – 1); 
disp(media); 
 
4.3.2.1 Exercícios 
Exercício 01: Jogo do Adivinha: Escolher um número de 0 a 100. Tente 
adivinhar o número gerado. A cada tentativa, deve-se informar mais baixo, 
mais alto ou acertou. Quando acertar, mostrar o número de tentativas. 
Obs.: O comando randint(1,1,[0,100]) deve ser usado para gerar um 
número inteiro aleatório. 
teste = 0; 
soma = 0; 
segredo = randint(1,1,[0,100]); 
while teste == 0 
 chute = input(‘Entre com um numero: ‘); 
 soma = soma + 1; 
 if chute == segredo 
 teste = 1; 
 disp(‘Acertou’); 
 disp(‘Tentativas: ‘); 
 disp(soma); 
 elseif chute < segredo 
 disp( ‘Mais alto...’); 
 else 
 disp(‘Mais baixo…’); 
 end 
end 
 
Exercício 02: Jogo do Adivinha 2: O usuário pensa em um número entre 0 e 
100 e executa o programa. O computador “chuta” um valor. A cada chute, 
deve-se informar se o computador acertou, mais alto ou mais baixo. Ao final, 
deve-se informar o número de tentativas chutadas pelo computador. 
teste = 0; 
soma = 0; 
segredo = input(‘Entre com um numero: ‘); 
if segredo >= 0 & segredo <= 100 
 Min = 0; 
 Max = 100; 
 while teste == 0 
 chute = randint(1,1,[Min,Max]); 
 56
 soma = soma + 1; 
 disp(‘Numero Chutado: ‘); 
 disp(chute); 
 if chute == segredo 
 teste = 1; 
 disp(‘Acertou’);disp(‘Tentativas: ‘); 
 disp(soma); 
 elseif chute < segredo 
 disp( ‘Mais alto...’); 
 Min = chute; 
 else 
 disp(‘Mais baixo…’); 
 Max = chute; 
 end 
 end 
end 
 
Exercício 03: Calcule o valor do cosseno de x (em radianos) usando os 20 
primeiros termos da série 
...
!8!6!4!2
1)cos(
8642
++−+−= xxxxx 
x = input(‘Entre com o valor do ângulo: ‘); 
c = 0; 
sinal = 1; 
for i = 0:1:19 
 fat = 1; 
 for j = 1:1:2*i; 
 fat = fat * j; 
 end 
 c = c + sinal * x^(2*i)/fat; 
 sinal = -1 * sinal; 
end 
disp(c); 
 
Exercício 04: Fazer um programa seguindo as seguintes orientações: 
a) Leia os parâmetros A e B da equação da reta dada por y = Ax+B; 
b) Leia os parâmetros C, D e R da equação do círculo dada por 
Cx2+Dy2=R2; 
c) Leia as coordenadas (x,y) e verifique se esse ponto é um dos pontos 
de interseção entre a reta e o círculo dados. Um ponto é de interseção 
se ele atender as equações das curvas dadas. 
A = input(‘Entre com o parâmetro A: ‘); 
B = input(‘Entre com o parâmetro B: ‘); 
C = input(‘Entre com o parâmetro C: ‘); 
D = input(‘Entre com o parâmetro D: ‘); 
R = input(‘Entre com o parâmetro R: ‘); 
 57
x = input(‘Entre com a coordenada X do ponto: ‘); 
y = input(‘Entre com a coordenada Y do ponto: ‘); 
If A*x + B == y & C*x^2 + D*y^2 == R^2 
 disp(‘Ponto de intersecao.’); 
end 
 
5 Estruturas de Dados 
 
5.1 Introdução 
 Nas seções anteriores, foi feita uma divisão imaginária (numérico, caractere e 
lógico) com o objetivo de tornar mais simples a classificação das informações (dados) 
de um programa. 
 No entanto, em muitas situações, esses recursos são escassos. Esta seção 
descreve novos tipos de dados que são construídos e organizados a partir da 
composição dos tipos primitivos vistos anteriormente. Esses novos tipos são conhecidos 
como Estrutura de Dados e são classificados da seguinte forma: 
 
• Estrutura de Dados 
o Variáveis Compostas Homogêneas; 
ƒ Unidimensionais (Vetores); 
ƒ Multidimensionais (Matrizes). 
o Variáveis Compostas Heterogêneas 
ƒ Registros 
 
 Essas novas variáveis são descritas na seqüência desta seção. 
 
5.2 Variáveis Compostas Homogêneas 
 São estruturas de dados compostas de variáveis do mesmo tipo primitivo, como 
podem ser vistos nos exemplos abaixo: 
 
3 
8.5 
7 
5 
 
C A R R O 
Caractere
 58
 A variável é o todo (ou seja, o conjunto). Cada termo da variável é chamado de 
elemento. Em ambos os exemplos, cada elemento tem o mesmo tipo primitivo 
(números e caracteres). Daí a denominação “homogêneo”. Uma string (cadeia de 
caracteres) é uma variável composta homogênea. 
 Os exemplos acima são variáveis compostas unidimensionais (também chamadas 
de vetores). 
 O exemplo abaixo também ilustra uma variável composta homogênea. No 
entanto, ela é classificada como uma variável composta multidimensional (conhecida 
como matriz). 
 
1 0 4 
5 2 1 
7.5 3 1 
 
 O exemplo abaixo ilustra o exemplo de uma variável composta que não é 
classificada como homogênea. 
 
C 3 5 1 L 
 
5.2.1 Variáveis Compostas Homogêneas Unidimensionais 
 São estruturas de dados compostas de elementos do mesmo tipo primitivo e 
armazenados em matrizes linha ou coluna. O exemplo abaixo ilustra a criação de um 
vetor no MATLAB. 
 
Exemplo 01: 
>> A=(0:2:10) 
>> B=ones(2,3) 
>> C=zeros(3,2) 
 
 O exemplo acima produz o seguinte vetor: 
 
A = 
 0 2 4 6 8 10 
 59
B = 
 1 1 1 
 1 1 1 
C = 
 0 0 
 0 0 
 0 0 
 
 A seguir, é mostrado outro exemplo para ilustrar o uso de vetores. 
 
Exemplo 02: 
>> % imprime o segundo elemento do vetor. 2 é o índice do vetor. 
>> disp(A(2)); 
>> % Alterando o terceiro elemento do vetor. 
>> A(3) = 10; 
for i = 1:10 
 A(i) = 2*i – 1; 
end 
disp(A); 
 
 Mas para que servem os vetores? Os exemplos abaixo servirão para responder 
tal questão. 
 
Exemplo 03: 
% a) Cálculo da média aritmética de 10 notas 
soma = 0; 
for i = 1:10 
 x = input(‘Entre com a nota: ’); 
 soma = soma + x; 
end 
media = soma / 10; 
% b) Quais notas são maiores que a média? 
A1 = input(‘Nota 1: ’); 
A2 = input(‘Nota 2: ’); 
A3 = input(‘Nota 3: ’); 
. 
. 
. 
A10 = input(‘Nota 10: ’); 
media = (A1 + A2 + ... + A10) / 10; 
if A1 > media 
 disp( A1 ); 
1, 3, 5, 7, 9, …, 
 60
end 
if A2 > media 
 disp( A2 ); 
end 
. 
. 
. 
 
 Mas e se tivéssemos 100 notas? A solução acima seria inviável. O exemplo 
abaixo usa vetor para resolver o mesmo problema. 
 
Exemplo 04: Exemplo anterior usando vetores 
soma = 0; 
for i = 1:10 
 nota(i) = input(‘Entre c/ a nota: ’); 
 soma = soma + nota(i); 
end 
media = soma / 10; 
for i = 1:10 
 if nota(i) > media 
 disp(nota(i)); 
 end 
end 
 
Exemplo 05: Fazer um programa que leia, some e imprima o resultado da 
soma entre dois vetores de 10 posições. 
for i = 1:10 
 A(i) = input(‘valor armazenado no vetor A: ’); 
 B(i) = input(‘valor armazenado no vetor B: ’); 
 C(i) = A(i) + B(i); 
end 
disp( C ); 
 
Exemplo 06: Fazer um programa que preencha um vetor de 100 elementos 
colocando 1 na posição correspondente a um número par e 0 a um número 
ímpar. 
for i = 1:100 
 if mod(i,2) == 0 
 a(i) = 1; 
 else 
 a(i) = 0; 
 end 
end 
disp(a); 
 
 61
Exemplo 07: Seja o vetor V = {2, 6, 8, 3, 10, 9, 1, 21, 33, 14}. Seja também x = 2 e y 
= 4. 
 
V(x+1) V(3) = 8 
V(x+2) V(4) = 3 
V(x*4) V(8) = 21 
V(V(x+y)) V(V(6)) = V(9) = 33 
V(x+y) V(6) = 9 
V(V(1)*V(4)) V(2*3) = V(6) = 9 
 
Exemplo 08: Fazer um programa que leia um vetor de 10 posições e coloque-
o em ordem crescente, utilizando a seguinte estratégia: 
• Selecione o elemento do vetor que apresenta o menor valor; 
• Troque este elemento pelo primeiro; 
• Repita essas operações envolvendo agora apenas os 19 elementos 
restantes, até restar um único elemento. 
for i = 1:10 
 a(i) = input(‘A: ’); 
end 
for j = 1:10 
 % inicializacao 
 menor = a(j); 
 posicao = j; 
 % selecionando o menor 
 for i = j:10 
 if a(i) < menor 
 menor = a(i); 
 posicao = i; 
 end 
 end 
 % troca 
 aux = a(j); 
 a(j) = menor; 
 a(posicao) = aux; 
end 
disp(a); 
 
 Sobre o exemplo acima, as seguintes questões devem ser observadas: 
 
a) A variável “posição” armazena a posição do menor valor; 
b) Uso de uma variável auxiliar “aux” para fazer a troca de 2 números. 
 62
5.2.2 Variáveis Compostas Homogêneas Multidimensionais 
 São estruturas de dados compostas de elementos do mesmo tipo primitivo e 
armazenados em formato matricial. 
 
 
 
 
 
 
 O Exemplo abaixo ilustra a diferença entre vetores e matrizes: 
 
• Vetores 
o Um índice (unidimensional) para endereçamento 
 A(1) = 3; 
 A(2) = 7; 
 
• Matrizes 
o Dois índices (bidimensional) para endereçamento 
 A(1,1) = 1; 
 A(2,1) = 5; 
 A(1,2) = 4; 
 A(2,2) = 3; 
 
1 4 
5 3 
 
 Nesse exemplo, 
 
• A é uma matriz bidimensional 2x2; 
• A é uma variável; 
• Cada termo de A é um elemento. 
 
 Para acessar um elemento de uma matriz precisamos de dois índices. O primeiro 
índice corresponde à linha da matriz; o segundo a coluna. 
 
 63
A(i,j) ⇒ linha i, coluna j 
 
>> A(3,4) = 2; 
 
 Aqui, o valor 2 é atribuído ao elemento correspondente a linha 3, coluna 4 da 
matriz A. 
 
 1 2 3 4 
1 
2 
3 2 
 
 Alguns detalhes devem ser observados: