Apostila de AED

Prévia do material em texto

Apostila
GCC101 - Algoritmo e Estrutura de Dados
Lucas Nunes Barbosa
21/08/2013
1
Contents
1 Introduc¸a˜o 5
1.1 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1 O que e´ um Algoritmo. . . . . . . . . . . . . . . . . . . . . . 5
1.1.2 Descric¸a˜o Narrativa . . . . . . . . . . . . . . . . . . . . . . . 6
1.1.3 Fluxograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.1.4 Diagrama de Chapin . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.5 Pseudoco´digo ou Portugol . . . . . . . . . . . . . . . . . . . . 7
1.2 Linguagem de Programac¸a˜o . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.1 O que e´ uma linguagem de programac¸a˜o? . . . . . . . . . . . 8
1.2.2 Para que servem as linguagens de programac¸a˜o? . . . . . . . 8
1.2.3 Porque programar em C++? . . . . . . . . . . . . . . . . . . 8
2 Introduc¸a˜o a Linguagem C++ 9
2.1 Estrutura do Programa . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.1 Hello World! (Passo a Passo) . . . . . . . . . . . . . . . . . . 9
2.2 Palavras reservadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Varia´veis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3.3 Tipos de varia´veis . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.5 Expresso˜es e Operadores . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.5.1 Tipos de Expresso˜es . . . . . . . . . . . . . . . . . . . . . . . 12
2.5.2 Operadores Aritme´ticos . . . . . . . . . . . . . . . . . . . . . 13
2.5.3 Operadores Relacionais . . . . . . . . . . . . . . . . . . . . . 13
2.5.4 Operadores Lo´gicos . . . . . . . . . . . . . . . . . . . . . . . 13
2.6 Bibliotecas padra˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.6.1 <iostream> . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.6.2 <cmath> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.6.3 <string> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.6.4 <cstdlib> e <ctime> . . . . . . . . . . . . . . . . . . . . . . 14
2.6.5 <fstream> . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3 Comando de Entrada e Sa´ıda de Dados 15
3.1 Sa´ıda de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Entrada de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4 Estruturas Condicionais 15
4.1 Comandos IF e ELSE . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.1.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.1.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.1.3 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.2 Comando SWITCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.2.3 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2
5 Estruturas de Repetic¸a˜o 19
5.1 Comando WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.1.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.1.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.1.3 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.2 Comando DO-WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.2.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.2.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.2.3 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.3 Comando FOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.3.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.3.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.3.3 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
6 Arranjos 23
6.1 Vetores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
6.1.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
6.1.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
6.1.3 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.2 Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.2.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.2.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.2.3 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7 Func¸a˜o randoˆmica 26
7.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
7.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
7.3 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
8 Me´todos de Ordenac¸a˜o 27
8.1 Bubble Sort (“Bolha”) . . . . . . . . . . . . . . . . . . . . . . . . . . 27
8.1.1 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
8.1.2 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
8.2 Selection Sort (“Selec¸a˜o”) . . . . . . . . . . . . . . . . . . . . . . . . 29
8.2.1 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.2.2 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.3 Insertion Sort (“Inserc¸a˜o”) . . . . . . . . . . . . . . . . . . . . . . . . 30
8.3.1 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.3.2 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
9 Me´todos de Busca 31
9.1 Busca Sequencial (Linear) . . . . . . . . . . . . . . . . . . . . . . . . 31
9.1.1 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
9.1.2 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
9.2 Busca Bina´ria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.2.1 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.2.2 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
10 Registro 34
10.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
10.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
10.3 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3
11 Modularizac¸a˜o 35
11.1 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
11.2 Porque usar func¸o˜es? . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
11.3 Varia´vel Global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
11.4 Paraˆmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
11.5 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
12 Arquivo 38
12.1 Sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
12.2 Descric¸a˜o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
12.3 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4
1 Introduc¸a˜o
1.1 Algoritmo
1.1.1 O que e´ um Algoritmo.
Embora as vezes na˜o percebemos, utilizamos algoritmos no nosso dia a dia e na˜o
sabemos. Para a execuc¸a˜o de alguma tarefa ou mesmo resolver algum problema,
muitas vezes inconscientemente executamos algoritmos.Mas o que e´ Algoritmo? E´ simplesmente uma “receita” para executarmos uma
tarefa ou resolver algum problema e como toda receita, um algoritmo tambe´m deve
ser finito. Se seguirmos uma receita de bolo corretamente, conseguiremos fazer
o bolo. A computac¸a˜o utiliza muito esse recurso, se voceˆ pretende aprender pro-
gramac¸a˜o, obviamente deve saber o que e´ algoritmo.
Embora esta definic¸a˜o seja correta, podemos definir algoritmo, de uma maneira
mais formal e completa da seguinte forma: Algoritmo e´ uma sequencia lo´gica,
finita e definida de instruc¸o˜es que devem ser seguidas para resolver um
problema ou executar uma tarefa.
Um algoritmo deve sempre possuir pelo menos um resultado, normalmente
chamado de sa´ıda e satisfazer a propriedade da efetividade, isto e´, todas as operac¸o˜es
especificadas no algoritmo devem ser suficientemente ba´sicas para que possam ser
executadas de maneira exata e num tempo finito.
Para se ter um algoritmo e´ necessa´rio:
1. Que se tenha um numero finito de passos.
2. Que cada passo esteja precisamente definido, sem possiveis ambiguidades.
3. Que existam zero ou mais entradas tomadas de conjuntos bem definidos.
4. Que existam uma ou mais sa´ıdas.
5. Que exista uma condic¸a˜o de fim sempre atingida para quaisquer entradas e
num tempo finito.
Para que um computador possa desempenhar uma tarefa e´ necessa´rio que esta
seja detalhada passo a passo, numa forma compreens´ıvel pela ma´quina, utilizando
aquilo que se chama de programa. Neste sentido, um programa de computador
nada mais e´ que um algoritmo escrito numa forma compreens´ıvel pelo computador.
As principais formas de representac¸a˜o de algoritmos sa˜o:
• a Descric¸a˜o Narrativa;
• o Fluxograma;
• o Diagrama de Chapin;
• o Pseudoco´digo, ou Linguagem Estruturada.
5
1.1.2 Descric¸a˜o Narrativa
A descric¸a˜o narrativa utiliza a linguagem natural para representar cada passo de
um algoritmo.
Utilizando essa te´cnica, o algoritmo para ca´lculo da me´dia de um aluno
seria representado da seguinte forma:
• Obter as notas da primeira e da segunda prova.
• Calcular a me´dia aritme´tica entre as duas notas.
• Se a nota for maior ou igual a sete, o aluno foi aprovado, sena˜o reprovado.
Esta representac¸a˜o e´ pouco utilizada na pra´tica, porque o uso de linguagem
natural da´ oportunidade a ma´s interpretac¸o˜es, ambiguidades e impreciso˜es.
1.1.3 Fluxograma
E´ uma representac¸a˜o gra´fica de algoritmos onde formas geome´tricas diferentes im-
plicam ac¸o˜es (instruc¸o˜es, comandos) distintas. Tal propriedade facilita o entendi-
mento das ideias contidas nos algoritmos. Nota-se que os fluxogramas preocupam-se
com detalhes de n´ıvel f´ısico da implementac¸a˜o do algoritmo. Por exemplo, figuras
geome´tricas diferentes sa˜o adotadas para representar operac¸o˜es de sa´ıda de dados
realizadas em dispositivos distintos, como uma unidade de armazenamento de dados
ou um monitor de v´ıdeo.
Figure 1: Algoritmo que imprime a me´dia de dois nu´meros
6
1.1.4 Diagrama de Chapin
O nome dessa representac¸a˜o de algoritmo vem de seu criador, Ned Chapin e sua
func¸a˜o e´ substituir o fluxograma por um diagrama que apresenta uma visa˜o hiera´rquica
e estruturada da lo´gica de programa.
Esse tipo de representac¸a˜o e´ vantajosa para problemas que tem um ponto de
entrada e um ponto de sa´ıda e sa˜o compostas pelas estruturas ba´sicas de controle
de sequeˆncia, selec¸a˜o e repartic¸a˜o. Enquanto e´ dif´ıcil mostrar o embutimento e a
recursividade com o fluxograma tradicional, torna-se mais simples mostra-lo com o
diagrama de Chapin.
Figure 2: Algoritmo que verifica qual despesa e´ maior (de Elisa ou de Sofia) e
apresenta quanto uma deve para a outra
1.1.5 Pseudoco´digo ou Portugol
Esta forma de representac¸a˜o de algoritmos e´ bastante rica em detalhes e, por
assemelhar-se bastante a` forma em que programas sa˜o escritos, encontra muita
aceitac¸a˜o.
Na verdade, esta representac¸a˜o e´ suficientemente geral para permitir uma traduc¸a˜o
praticamente direta de um algoritmo nela representado para uma linguagem de pro-
gramac¸a˜o espec´ıfica.
7
Algoritmo que leˆ dois nu´meros escolhidos pelo usua´rio e escreve o resuldado.
1 Algoritmo le numeros
2 i n t e i r o n1 , n2 , soma ;
3
4 i n i c i o
5 e s c r eva ” ent re com o 1 numero” ;
6 l e i a n1 ;
7
8 e s c r eva ” ent re com o 2 numero” ;
9 l e i a n2 ;
10
11 soma = n1 + n2 ;
12
13 e s c r eva ”a soma dos numeros va l e : ” , soma ;
14 f im
1.2 Linguagem de Programac¸a˜o
1.2.1 O que e´ uma linguagem de programac¸a˜o?
Uma linguagem de programac¸a˜o e´ um me´todo padronizado para expressar instruc¸o˜es
para um computador, ou seja, e´ um conjunto de regras sinta´ticas e semaˆnticas usadas
para definir um programa de computador. Uma linguagem permite que o progra-
mador especifique precisamente sobre quais dados um computador vai atuar, como
estes dados sera˜o armazenados ou transmitidos e quais ac¸o˜es devem ser tomadas
sob va´rias circunstaˆncias.
1.2.2 Para que servem as linguagens de programac¸a˜o?
Voceˆ ja´ deve ter ouvido falar em algo como “o computador e´ burro”, o computador
so´ e´ capaz de entender Sim e Na˜o (para ser mais especifico, 1 e 0 ) e efetuar uma
sequeˆncia de passos programados via hardware (ma´quina), pra resumir isso, todas
as instruc¸o˜es dadas a um computador sa˜o sequeˆncias nume´ricas compostas por 0 e
1 (Ex: 01101100).
Ja´ imaginou o trabalho que da´ escrever um programa inteiro usando instruc¸o˜es
compostas por combinac¸o˜es de 0 e 1? E´ pra isso que existem as linguagens de
programac¸a˜o, para facilitar a comunicac¸a˜o entre programador e hardware, o pro-
gramador escreve instruc¸o˜es em uma linguagem bem pro´xima da que as pessoas
usam pra se comunicar, depois um segundo programa traduz o que o programador
escreveu para sequencias compostas por 0 e 1 (Compiladores1) ou interpreta as
instruc¸o˜es escritas pelo programador e as executa (Interpretador).
1.2.3 Porque programar em C++?
DEFINIC¸A˜O TALES
1Compilador: e´ um programa de computador (ou um grupo de programas) que, a partir de um
co´digo fonte escrito em uma linguagem compilada, cria um programa semanticamente equivalente,
pore´m escrito em outra linguagem co´digo objeto (ou “linguagem de ma´quina”)
8
2 Introduc¸a˜o a Linguagem C++
2.1 Estrutura do Programa
• Um programa em C++ e´ composto por um conjunto de Func¸o˜es. A func¸a˜o
pela qual o programa comec¸a a ser executado chama-se main.
• Apo´s cada comando em C++ deve-se colocar um ; (ponto e v´ırgula).
• Um programa em C++ deve ser Indentado2 para que possa ser lido com mais
facilidade.
2.1.1 Hello World! (Passo a Passo)
E´ comum, no aprendizado de uma linguagem de programac¸a˜o, que seu primeiro pro-
grama fac¸a com que o computador exiba “Hello World!”. Em C++ este primeiro
programa ja´ introduz muitos conceitos sobre a linguagem.
Veja o co´digo do nosso primeiro programa:
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 cout << ” He l lo World ! ” << endl ;
6 r e turn 0 ;
7 }
#include <iostream>
• O s´ımbolo # indica que a pro´xima palavra e´ um comando para o compilador,
na˜o para o processamento.
• include e´ um comando para o compilador incluir uma Biblioteca de func¸o˜es
no programa.
• A Biblioteca iostream, possui va´rias func¸o˜es de fluxo de entrada e sa´ıda
dados. Na maioria das vezes, como entrada padra˜o temos o teclado e como
sa´ıda temos o monitor.
using namespace std;
• namespaces sa˜o espac¸os de nomes dentro do co´digo, eles funcionam, entre
outras coisas, como um meio de evitar duplicac¸a˜o de nomes dentro de um
projeto extenso, que geralmente contam com inu´meros arquivos.
• O C++ usa os namespaces para organizar os diferentes nomes usados nos
programas. Cada nome usado na Biblioteca “standard iostream” faz parte
do “namespace” chamado de std.• O objeto de sa´ıda padra˜o, cout, esta´ definido dentro do “namespace std”, ele
e´ um objeto da classe “ostream” “output stream”, para acessa´-lo temos que
referencia´-lo como “std::cout”. Para evitar que tenhamos que informar “std::”
todas as vezes que precisarmos usar os recursos deste “namespace”, podemos
informar que estamos usando-o dentro do arquivo atual, conforme vemos na
linha declarada no in´ıcio deste to´pico.
2Na maioria das linguagens, a indentac¸a˜o tem um papel meramente este´tico, tornando a leitura
do co´digo fonte muito mais fa´cil, pore´m e´ obrigato´ria em outras. Python, Occam e Haskell, por
exemplo, utilizam-se desse recurso tornando desnecessa´rio o uso identificadores de blocos, tais
como chaves ou as palavras ”begin” e ”end”.
9
Co´digo sem “namespaces”
1 #inc lude <iostream>
2 i n t main ( )
3 {
4 std : : cout << ” He l lo World ! ” << std : : endl ;
5 r e turn 0 ;
6 }
int main() {}
• Como na linguagem C, a func¸a˜o principal de entrada do programa a partir
do sistema operacional e´ a func¸a˜omain. Por isso mesmo ela e´ obrigato´ria
em qualquer programa. Se na˜o existisse uma “main function”, na˜o haveria
entrada para que o sistema iniciasse o programa.
• Todas as func¸o˜es sa˜o declaradas e usadas com o operador ( ), assim e´ que o
compilador reconhece que estas sa˜o func¸o˜es. A ideia de ter func¸o˜es e´ permitir
o encapsulamento de uma ideia ou operac¸a˜o, dar um nome a isso e depois
chamar essa operac¸a˜o de va´rias partes do programa simplesmente usando o
seu nome. As func¸o˜es declaradas como membros de uma classe de objetos
podem ser chamadas de me´todos.
• Do ponto de vista funcional, um co´digo dentro de uma func¸a˜o executa operac¸o˜es
em outra parte do programa, que na˜o e´ aquela de onde foi chamada, por este
motivo as mesmas contam com um mecanismo de passagem de dados, ao
declarar uma func¸a˜o indicamos quais os dados que entram e o que ela deve
fornecer a quem lhe chamou.
• Pode-se dizer que, tal qual uma func¸a˜o matema´tica, a func¸a˜o em C/C++
podera´ ser substitu´ıda, depois de sua execuc¸a˜o, pelo valor que ela retorna,
este valor sera´ especificado antes do nome da func¸a˜o na declarac¸a˜o da mesma,
conforme vemos no in´ıcio deste to´pico.
Obs: O int significa que a func¸a˜o vai retornar um inteiro. Existem outros tipos de
dados como, por exemplo, os seguintes:
• int que e´ a abreviatura de inteiro;
• char que e´ a abreviatura de caractere;
• float que e´ a abreviatura de ”floating point number”, ou seja, uma repre-
sentac¸a˜o para nu´mero real.
cout << ”Hello World!” << endl;
• A palavra cout vem de Console3 OUT (sa´ıda do console), onde geralmente
temos a sa´ıda no monitor. O cout e´ seguido do operador << e da frase que
se quer informar entre aspas: ”Hello World!”, intuitivamente, isso nos leva a
ideia de que a sequeˆncia de caracteres sera´ levada ao cout.
return 0;
• Este comando termina o programa, o estudaremos melhor no cap´ıtulo sobre
func¸o˜es e retornos.
3Console: E´ a unidade que permite que um operador se comunique com um sistema de com-
putador, o console consiste de um dispositivo de entrada como um teclado, e um dispositivo de
sa´ıda como o monitor.
10
2.2 Palavras reservadas
Para uma assimilac¸a˜o inicial as palavras chaves em C++ sa˜o apresentadas abaixo:
asm auto break case catch char
class const continue default delete do
double else enum extern float for
friend goto if inline int long
new operator private protected public register
return short signed sizeof static struct
switch template this throw try typedef
union unsigned virtual void volative while
Esta se´rie na˜o apenas servira´ para a plataforma Linux ou Unix, mas voceˆ podera´
aplicar os conhecimentos aqui adquiridos em plataformas como Windows da Mi-
crosoft e Mac da Apple.
Inicialmente na˜o poderia deixar de colocar nesta introduc¸a˜o, alguns pontos cru-
ciais para se programar em C++. Um destes pontos como boa pra´tica sempre
mantenha o co´digo limpo, identado e de forma apresenta´vel.
2.3 Varia´veis
2.3.1 Sintaxe
1 <t i po da va r i ave l> <nome>;
2.3.2 Descric¸a˜o
Varia´veis sa˜o enderec¸os de me´moria na qual podemos atribuir ou mudar o valor.
Todas as varia´veis utilizadas em C++ devem ser definidas antes de serem uti-
lizadas. Isto se faz necessa´rio para permitir que o compilador fac¸a a alocac¸a˜o4 da
memo´ria.
2.3.3 Tipos de varia´veis
• Todas as varia´veis em C++ tem um tipo.
• Cada tipo define os valores que a varia´vel pode armazenar.
• Cada tipo ocupa uma certa quantidade de nemo´ria.
Tipo Comenta´rio
int Valores inteiros de: -2147483648 a 2147483647.
float Valores “reais” de: 1.2e-308 a 3.4e-38.
double Valores “reias” (dupla precisa˜o do float) de: 2.2e-308 a 3.4e-38.
char Permite armazenar 256 caracteres.
bool Armazena valores true (1, verdadeiro) ou false (0, falso).
void E´ o tipo “vazio”, na˜o retorna nenhum valor.
4Alocac¸a˜o: Enderec¸ar uma varia´vel para um local reservado na memo´ria.
11
2.4 Constantes
2.4.1 Sintaxe
1 #d e f i n e <nome> <tamanho>
2.4.2 Descric¸a˜o
Apesar de serem antoˆnimos no diciona´rio, computacionalmente o conceito de varia´veis
e constantes e´ similar. Assim como uma varia´vel, uma constante deve ter um nome
e um tipo. A diferenc¸a e´ que o valor armazenado pela constante e´ fixo, sendo, em
geral, definido no in´ıcio do programa.
2.5 Expresso˜es e Operadores
2.5.1 Tipos de Expresso˜es
Em computac¸a˜o, o conceito de expressa˜o esta´ intimamente ligado ao conceito de
fo´rmula matema´tica, no qual varia´veis e constantes nume´ricas se relacionam atrave´s
de operadores e produzem um resultado. Entretando, as operac¸o˜es e, consequente-
mente, as expresso˜es na˜o envolvem apenas aritme´tica, mas tambe´m lo´gica e mani-
pulac¸a˜o de caracteres, havendo, portanto, treˆs tipos de expresso˜es:
1. Aritme´ticas: o resultado da avaliac¸a˜o de uma expressa˜o aritme´tica e´ do tipo
nume´rico (inteiro ou real). Nesse tipo de expresso˜es e´ permitido apenas o uso
de operadores aritme´ticos, varia´veis nume´ricas e pareˆnteses, que servem para
alterar a precedeˆncia dos operadores.
2. Lo´gicas: sa˜o aquelas cujo resultado da avaliac¸a˜o e´ um valor lo´gico (ver-
dadeiro ou falso), que e´ representado por 1 e 0. Nestas expresso˜es sa˜o usados
operadores lo´gicos e relacionais, que podem ser combinados com operadores
aritme´ticos.
3. Literais: expresso˜es literais envolvem operac¸a˜o com cadeias alfanume´ricas.
A u´nica expressa˜o literal existente e´ a que envolve a operac¸a˜o de concatenac¸a˜o
(operac¸a˜o de unir o conteu´do de duas strings5).
5String : Em C++ sa˜o tratados como vetores de tamanho determinado que podem armazenar
qualquer caracter. Diferentemente de declarar apenas uma varia´vel do tipo char (que armazena
apenas um caracter) a string e´ uma cadeia de caracteres, ou seja, pode guardar quantos caracteres
no´s determinarmos.
12
2.5.2 Operadores Aritme´ticos
Operador Exemplo Comenta´rio
= x = y O conteu´do da varia´vel Y e´ atribuido a` varia´vel X..
+ x + y Soma o conteu´do de X e de Y.
- x - y Subtra´i o conteu´do de Y do conteu´do de X.
* x * y Multiplica o conteu´do de Y do conteu´do de X.
/ x / y Obte´m o quociente da divisa˜o de X por Y.
% x % y Obte´m o resto da divisa˜o de X por Y.
+= x += y Equivale a X = X + Y.
-= x -= y Equivale a X = X - Y.
*= x *= y Equivale a X = X * Y.
/= x /= y Equivale a X = X / Y.
++ x++ Equivale a X = X + 1.
++ y = ++x Equivale a X = X + 1 e depois Y = X.
++ y = x++ Equivale a Y = X e depois X = X + 1.
−− x−− Equivale a X = X - 1.
−− y = −−x Equivale a X = X - 1 e depois Y = X.
−− y = x−− Equivale a Y = X e depois X = X - 1.
2.5.3 Operadores Relacionais
Operador Exemplo Comenta´rio
== x == y O conteu´do de X e´ igual ao conteu´do de Y.
!= x != y O conteu´do de X e´ diferente do conteu´do de Y.
<= x <= y O conteu´do de X e´ menorou igual ao conteu´do de Y.
>= x >= y O conteu´do de X e´ maior ou igual ao conteu´do de Y.
< x < y O conteu´do de X e´ menor ao conteu´do de Y.
> x > y O conteu´do de X e´ maior ao conteu´do de Y.
2.5.4 Operadores Lo´gicos
Operador Exemplo Comenta´rio
! !x Negac¸a˜o do conteu´do de X.
|| x || y O conteu´do de X OU o conteu´do de Y.
&& x && y O conteu´do de X E o conteu´do de Y.
2.6 Bibliotecas padra˜o
2.6.1 <iostream>
iostream (i de input + o de output + stream), que suporta, entre va´rias funciona-
lidades, o objeto cin para ler da ”standard input” (que e´ usualmente o teclado) e o
objeto cout para ”standard output” (que usualmente e´ o monitor).
13
2.6.2 <cmath>
cmath e´ uma biblioteca pro´pria para ca´lculos matema´ticos um pouco mais com-
plexos, podemos encontrar facilmente func¸o˜es para calcular poteˆncias, ra´ız quadrada,
func¸o˜es trigonome´tricas para ca´lculos que envolvem seno, cosseno e tangente, ale´m
de constantes para nu´meros irracionais como, por exemplo, PI.
Operador Exemplo Comenta´rio
ceil ceil(x) Arredonda um nu´mero real para cima.
sin sin(x) Calcula o seno de X (X deve ser representado em radianos).
cos cos(x) Calcula o cosseno de X (X deve ser representado em radi-
anos).
tan tan(x) Calcula a tangente de X (X deve estar representado em
radianos).
exp exp(x) Obte´m o logaritmo natural elevado a poteˆncia X.
abs abs(x) Obte´m o valor absoluto de X.
floor floor(x) Arredonda um nu´mero real para baixo. Por exemplo,
floor(3.2) vale 3.
log log(x) Obte´m o logaritmo natural de X.
log10 log10(x) Obte´m o logaritmo de base 10 de X.
modf z = modf(X,&Y) Decompo˜e o nu´mero real armazenando em X em duas
partes: Y recebe a parte fraciona´ria e Z, a parte inteira
do nu´mero.
pow pow(X,Y) Calcula a poteˆncia de X elevado a Y.
sqrt sqrt(x) Calcula a raiz quadrada de X.
M PI M PI Retorna o valor de PI (pi).
2.6.3 <string>
string serve para manipulac¸a˜o de cadeias de caracteres, ou seja, uma sequeˆncia
de caracteres.
2.6.4 <cstdlib> e <ctime>
Usamos cstdlib e ctime para func¸a˜o srand(). cstdlib habilita o uso da func¸a˜o,
enquanto ctime permite o uso da func¸a˜o time(num) normalmente usada como
paraˆmetro da func¸a˜o srand() para dar a ideia de ramdoˆmico (rand(time(NULL)).
2.6.5 <fstream>
fstream e´ um manipulador de fluxos de dados de arquivos de computador, per-
mitindo ler (objeto ifstream) e escrever (objeto ofstream) em arquivos.
14
3 Comando de Entrada e Sa´ıda de Dados
3.1 Sa´ıda de Dados
O comando de sa´ıda padra˜o (cout) e´ o meio pelo qual informac¸o˜es contidas na
memo´ria dos computadores sa˜o colocadas nos dispositivos de sa´ıda, normalmente
no monitor
3.2 Entrada de Dados
O comando de entrada padra˜o (cin) e´ o meio pelo qual as informac¸o˜es dos usua´rios
sa˜o transferidas para a memo´ria dos computadores, para que possam ser usadas nos
programas.
3.3 Exemplo
Algoritmo que recebe dois nu´meros inteiros (digitados pelo usua´rio), soma-os e envia
para o dispositivo de sa´ıda (no caso o monitor) o resultado
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 i n t soma , a , b ;
6
7 cout << ” Dig i t e o pr ime i ro num: ” ;
8 c in >> a ;
9
10 cout << ” Dig i t e o segundo num: ” ;
11 c in >> b ;
12
13 soma = a + b ;
14
15 cout << ”O va lo r da soma e : ” << soma << endl ;
16
17 r e turn 0 ;
18 }
• int declara varia´veis do tipo inteiro.
• cin recebe o valor das varia´veis digitado pelo usua´rio.
• cout imprime na tela as instruc¸o˜es e o valor da soma.
• endl e´ o comando de quebra de linha, funciona como apertar a tecla “ENTER”
do teclado.
4 Estruturas Condicionais
Neste tipo de estruturas, o fluxo de instruc¸o˜es a ser seguido e´ escolhido em func¸a˜o do
resultado da avaliac¸a˜o de uma ou mais condic¸o˜es. Uma condic¸a˜o e´ uma expressa˜o
lo´gica .
A classificac¸a˜o das estruturas condicionais e´ feita de acordo com o nu´mero de
condic¸o˜es que devem ser testadas para que se decida qual o caminho a ser seguido.
Os algoritmos puramente sequenciais podem ser usados na soluc¸a˜o de um nu´mero
de problemas, pore´m existem problemas que exigem o uso de alternativas de acordo
com as do mesmo.
15
Nestes algoritmos, as situac¸o˜es sa˜o resolvidas atrave´s de passos cuja execuc¸a˜o e´
subordinada a uma condic¸a˜o. Assim, o algoritmo contera´ passos que sa˜o executados
somente se determinadas condic¸o˜es forem observadas.
Um algoritmo em que se tem a execuc¸a˜o de determinados passos subordinada a
uma condic¸a˜o e´ denominado algoritmo com selec¸a˜o.
4.1 Comandos IF e ELSE
4.1.1 Sintaxe
1 i f (<condicao>)
2 {
3 (<bloco de comandos>) ;
4 }
5
6 e l s e
7 {
8 (<bloco de comandos>) ;
9 }
4.1.2 Descric¸a˜o
O comando if avalia se a condic¸a˜o e´ verdadeira ou falsa (“Se” em portugueˆs), se a
condic¸a˜o for verdadeira o programa executara a sequeˆncia de comando propostos
pelo if, se for falsa o programa executara´ a sequeˆncia de comandos propostos pelo
else (“Sena˜o” em portugueˆs).
4.1.3 Exemplos
Algoritmo que verifica a nota do aluno e mostra se ele foi APROVADO ou RE-
PROVADO.
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 f l o a t nota ;
6
7 cout << ” Dig i t e sua nota : ” ;
8 c in >> nota ;
9
10 i f ( nota < 60 ) {
11 cout << ”Reprovado” << endl ;
12 }
13
14 e l s e {
15 cout << ”Aprovado” << endl ;
16 }
17
18 r e turn 0 ;
19 }
Observamos que a condic¸a˜o ser verificada esta entre pareˆnteses “(nota < 60)” e
que o else na˜o possui condic¸a˜o, justamente por ser executado somente se a condic¸a˜o
no if for falsa. Outra observac¸a˜o esta´ no fato do uso de chaves “{}” apo´s os co-
mandos if e else, mas na˜o sa˜o obrigato´rias neste caso, pois ha´ apenas 1 comando
sendo executado apo´s a estrutura condinal.
16
A seguir teremos outro exemplo de programa usando os comandos if e else, mas
desta vez sem o uso de chaves e mais de uma condic¸a˜o.
Algoritmo que verifica o sala´rio do funciona´rio e aponta o reajuste correto
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 f l o a t s a l a r i o ;
6
7 cout << ” Dig i t e seu s a l a r i o : ” ;
8 c in >> s a l a r i o ;
9
10 i f ( s a l a r i o < 800 )
11 s a l a r i o ∗= 1 . 2 ;
12
13 e l s e i f ( s a l a r i o < 1600)
14 s a l a r i o ∗= 1 . 1 5 ;
15
16 e l s e i f ( s a l a r i o < 2400)
17 s a l a r i o ∗= 1 . 1 0 ;
18
19 e l s e
20 s a l a r i o ∗= 1 . 0 5 ;
21
22 cout << ”Seu novo s a l a r i o s e ra : ” << s a l a r i o << endl ;
23
24 r e turn 0 ;
25 }
4.2 Comando SWITCH
4.2.1 Sintaxe
1 switch (<opcao>)
2 {
3 case <opcao>:
4 (<bloco de comandos>) ;
5 break ;
6 }
4.2.2 Descric¸a˜o
O comando switch funciona quase da mesma forma do comando if, mas seu uso
e´ mais indicado quando se quer dar ao usua´rio a escolha de opc¸o˜es. As “opc¸o˜es”
podem ser do tipo int (inteiro) ou do tipo char (caractere), como podemos ver nos
exemplos a seguir:
17
4.2.3 Exemplos
Algoritmo recebe o raio e calcula o comprimento, a a´rea e o volume de uma esfera
1 #inc lude <iostream>
2 #inc lude <cmath>
3 us ing namespace std ;
4 i n t main ( )
5 {
6 f l o a t r a i o ;
7 cout << ” Dig i t e o va l o r do r a i o : ” ;
8 c in >> r a i o ;
9
10 i n t opcao ;
11 cout << ”O que de s e j a que s e j a ca l cu l ado ?” << endl ;
12 cout << ”\ t1 . Comprimento\n\ t2 . Area\n\ t3 . Volume\n” ;
13
14 c in >> opcao ;
15
16 f l o a t comprimento , area , volume ;
17
18 switch ( opcao )
19 {
20 case 1 :
21 comprimento = 2∗M PI∗ r a i o ;
22 cout << ”O comprimento va l e : ” << comprimento << endl ;
23 break ;
24
25 case 2 :
26 area = M PI∗( pow( ra io , 2 ) ) ;
27 cout << ”A area va l e : ” << area << endl ;
28 break ;
29
30 case 3 :
31 volume = ( 4∗M PI∗(pow( ra io , 3 ) ) ) ;
32 cout << ”O volume val e : ” << volume << endl ;
33 break ;
34 }
35
36 r e turn 0 ;
37 }
• \n possui a mesma func¸a˜o de endl, mas pode ser usado no meio de uma string
(texto).
• \t teˆm a func¸a˜o de inserir o espac¸o de tabulac¸a˜o, tendo a mesma func¸a˜o da
tecla “TAB” do teclado.
• M PI e´ a constante matema´tica que representa o nu´mero PI (pi), esta cons-
tante pertence a biblioteca cmath.
Neste programa temos treˆs opc¸o˜es, cada uma com um nu´mero espec´ıfico para
que o comando seja executado. Se o usua´rio digitar 1, o comprimento da esfera
sera´ calculado e mostrado na tela, se o usua´rio digitar 2, a a´rea sera´ calculada e se
digitar 3, o volume sera´ calculado.
Os comandos selecionados e executados pelo switch esta˜o entre os comandos
case e break (todo case deve ter um break), o nu´mero que segue o comando case
sera´ dado pela opc¸a˜o digitada pelo usua´rio, se o nu´mero for este, os comandos que
sera˜o executados estara˜o entre este case e break.
18
Algoritmo que fornece ao usua´rio a escolha de pagamento a vista ou a prazo,
mostrando ao usua´rio o total da compra e o juros.
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 f l o a t va l o r ;
6 char opcao ;
7
8 cout << ” Dig i t e o va l o r da compra : ” ;
9 c in >> va lo r ;
10
11 cout << ”A compra s e ra f e i t a a v i s t a (V) ou a prazo (P) : ” ;
12 c in >> opcao ;
13
14 switch ( opcao )
15 {
16 case ’V ’ :
17 cout << ”Nao ha j u r o s em compra a v i s t a ! ” << endl ;
18 cout << ”O va lo r a s e r pago : ” << va lo r << endl ;
19 break ;
20
21 case ’P ’ :
22 i f ( va l o r < 800 )
23 {
24 cout << ”O j u r o s s e ra de 10%” << endl ;
25 cout << ”O va lo r a s e r pago : ” << va lo r ∗1 .1 << endl ;
26 }
27
28 e l s e
29 {
30 cout << ”O j u r o s s e ra de 5%” << endl ;
31 cout << ”O va lo r a s e r pago : ” << va lo r ∗1 .05 << endl ;
32 }
33 break ;
34 }
35
36 r e turn 0 ;
37 }
Neste caso o “opc¸a˜o” do switch e´ do tipo char e deve estar entre aspas simples
(‘x’ ).
5 Estruturas de Repetic¸a˜o
Sa˜o muito comuns as situac¸o˜es em que se deseja repetir um determinado trecho de
um programa um certo nu´mero de vezes. As estruturas de repetic¸a˜o sa˜o muitas
vezes chamandas de lac¸os ou tambe´m de loops.
A classificac¸a˜o das estruturas de repetic¸a˜o e´ feito de acordo com o conhecimento
pre´vio do nu´mero de vezes que o conjunto de comandos sera´ executado. Assim os
lac¸os se dividem em:
• Lac¸os Contados: quando se conhece previamente quantas vezes o comando
composto no interior da construc¸a˜o sera´ executado. Em C++, normalmente
se usa o comando for para este tipo de lac¸o, mas tambe´m pode ser usado do
e while
19
• Lac¸os Condicionais: quando na˜o se conhece de antema˜o o nu´mero de vezes
que o conjunto de comandos no interior do lac¸o sera´ repetido, pelo fato do
mesmo estar amarrado a uma condic¸a˜o sujeita a` modificac¸a˜o pelas instruc¸o˜es
do interior do lac¸o. Em C++, neste tipo de lac¸o apenas podemos usar os
comandos do e while.
5.1 Comando WHILE
5.1.1 Sintaxe
1 whi le (<condicao>)
2 {
3 (<bloco de comandos>) ;
4 }
5.1.2 Descric¸a˜o
1. Testa a condic¸a˜o;
2. Se a condic¸a˜o for falsa, enta˜o pula todos os comandos do bloco subordinado
ao while e passa a executar os comandos apo´s o bloco do while.
3. Se a condic¸a˜o for verdadeira enta˜o, executa o bloco de comandos subordi-
nado ao while.
4. Apo´s executar o u´ltimo comando do bloco do while volta ao passo 1.
O comando while deve ser usado sempre que:
• Na˜o soubermos exatamente quantas vezes o lac¸o deve ser repetido.
• O teste deva ser feito antes de iniciar a execuc¸a˜o de um bloco de comandos.
• Houver casos em que o lac¸o na˜o deva ser repetido nenhuma vez.
5.1.3 Exemplo
Algoritmo que soma N nu´meros, quando o nu´mero -1 for digitado a execuc¸a˜o e´
encerrada, se ele for o primeiro nu´mero digitado o bloco subordinado ao comando
while na˜o sera´ executado, apresentando o resultado 0.
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 f l o a t n , soma = 0 ;
6
7 c in >> n ;
8
9 whi le (n != −1)
10 {
11 soma += n ;
12 c in >> n ;
13 }
14
15 cout << soma << endl ;
16
17 r e turn 0 ;
18 }
20
5.2 Comando DO-WHILE
5.2.1 Sintaxe
1 do
2 {
3 (<bloco de comandos>) ;
4 } whi le (<condicao>) ;
5.2.2 Descric¸a˜o
1. Executa os comandos dentro do bloco do-while.
2. Testa a condic¸a˜o.
3. Se a condic¸a˜o for falsa, enta˜o executa o comando que esta´ logo apo´s o bloco
subordinado ao do-while.
4. Se a condic¸a˜o for verdadeira, enta˜o volta ao passo 1.
O comando do-while deve ser usado sempre que:
• Na˜o soubermos exatamente quantas vezes o lac¸o deve ser repetido.
• O teste deva ser feito antes de iniciar a execuc¸a˜o de um bloco de comandos.
• Houver casos em que o lac¸o deva ser executado pelo menos uma vez.
5.2.3 Exemplo
Algoritmo que verifica se o nu´mero digitado e´ par ou ı´mpar. Sempre que o usua´rio
digitar algum nu´mero negativo, o programa repetira´ a pergunta “Digite um nu´mero
positivo:” (criado pelo lac¸o do-while).
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 i n t n ;
6
7 do
8 {
9 cout << ” Dig i t e um numero p o s i t i v o : ” ;
10 c in >> n ;
11 } whi le ( n < 0 ) ;
12
13 i f ( n%2 == 0 )
14 cout << n << ” e um numero par ! ” << endl ;
15
16 e l s e
17 cout << n << ” e um numero impar ! ” << endl ;
18
19 r e turn 0 ;
20 }
21
5.3 Comando FOR
5.3.1 Sintaxe
1 f o r ( < i n i c i a l i z a c a o > ; <condicao> ; <incremento> )
2 {
3 (<bloco de comandos>) ;
4 }
5.3.2 Descric¸a˜o
1. Executa os comandos de inicializac¸a˜o.
2. Testa a condic¸a˜o.
3. Se a condic¸a˜o for falsa enta˜o executa o comando que esta´ logo apo´s o bloco
subordinado ao for.
4. Se condic¸a˜o for verdadeira enta˜o executa os comandos que esta˜o subordinados
ao for.
5. Executa os comandos de incremento/decremento.
6. Volta ao passo 2.
O comando for deve ser usado sempre que:
• Soubermos exatamente quantas vezes o lac¸o deve ser repetido.
• O teste deva ser feito antes da execuc¸a˜o de um bloco de comandos.
• Houver casos em que o lac¸o na˜o deva ser repetido nenhuma vez.
5.3.3 Exemplos
Algoritmo que calcula e mostra o nu´mero N na sequeˆncia de Fibonnaci
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 i n t n ;
6 c in >> n ;
7
8 i n t n1 = 0 , n2 = 1 , f i b ;
9
10 i f (n == 1)
11 f i b = n1 ;
12
13 i f (n == 2)
14 f i b = n2 ;
15
16 f o r ( i n t i = 3 ; i <= n ; i++ )
17 {
18 f i b = n1+n2 ;
19 n1 = n2 ;
20 n2 = f i b ;
21 }
22
23 cout << f i b << endl ;
24
25 r e turn 0 ;
26 }
22
Debora Sousa
Nota
Estrutura de Repetiçãonullnull1) Número definido de repetiçõesnullPara i <= valor inicial até valor final façanull[passo n]nullInicionullComandosnullFimnullnull
Algoritmo que calcula N!
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 i n t n ;
6 c in >> n ;
7
8 i n t f a t = 1 ;
9
10 f o r ( i n t i = 1 ; i <= n ; i++ )
11 f a t ∗= i ;
12
13 cout << f a t << endl ;
14
15 r e turn 0 ;
16 }
6 Arranjos
Arranjos sa˜o agregados homogeˆneos, ou seja, sa˜o um conjunto de elementos que
compartilham o mesmo tipo e possuem acesso aos elementos atrave´s de ı´ndices
nume´ricos inteiros e positivos.
Os arranjos podem possuir n dimenso˜es, veremos nesta apostila apenas arranjos
unidimensionais (conhecidos como vetores) e arranjos bidimencionais (conhecidos
como matrizes).
6.1 Vetores
6.1.1 Sintaxe
1 <t i po da va r i ave l> <nome> [<tamanho> ] ;
6.1.2 Descric¸a˜o
Uma vetor (arranjo unidimensional), e´ um conjunto u´nico de dados alocados sequeˆncialmente
na memo´ria de mesmo t´ıpo. Em C++, o ı´ndice dos vetor comec¸a em 0 (zero). Os
valores aplicados aos itens do vetorpodem ser repetidos ou na˜o, ac¸a˜o a qual ira´
depender totalmente das necessidades da aplicac¸a˜o.
Um vetor que contenha cinco elementos, podemos acessar o primeiro elemento
atrave´z do ı´ndice 0 (zero) e o u´ltimo atraves do ı´ndice 4.
23
6.1.3 Exemplos
Algoritmo que encontra a posic¸a˜o no vetor que possui o maior valor e imprime este
valor para o usua´rio.
1 #inc lude <iostream>
2 #d e f i n e TAM 10
3 us ing namespace std ;
4 i n t main ( )
5 {
6 i n t pMaior = 0 ;
7 f l o a t vet [TAM] ;
8
9 f o r ( i n t i = 0 ; i < TAM ; i++ )
10 c in >> vet [ i ] ;
11
12 f o r ( i n t i = 0 ; i < TAM ; i++ )
13 i f ( vet [ pMaior ] < vet [ i ] )
14 pMaior = i ;
15
16 cout << vet [ pMaior ] << endl ;
17
18 r e turn 0 ;
19 }
Algoritmo que recebe uma palavra de 10 letras e imprime esta palavra ao contra´rio.
1 #inc lude <iostream>
2 #d e f i n e MAX 10
3 us ing namespace std ;
4 i n t main ( )
5 {
6 char pa lavra [MAX] ;
7
8 f o r ( i n t i = 0 ; i < MAX ; i++ )
9 c in >> palavra [ i ] ;
10
11 f o r ( i n t i = MAX−1 ; i >= 0 ; i−− )
12 cout << palavra [ i ] ;
13 cout << endl ;
14
15 r e turn 0 ;
16 }
6.2 Matrizes
6.2.1 Sintaxe
1 <t i po da va r i ave l> <nome> [< l inha >] [<coluna > ] ;
6.2.2 Descric¸a˜o
Uma matriz (arranjo bidimencional), como o pro´prio nome diz, nada mais e´ do que
um arranjo com dois seguimentos de dados em memo´ria, que podem ser acessados
por uma dupla de ı´ndices que identifica o valor em um item na matriz
.
A declarac¸a˜o da matriz e´ efetuada com dois colchetes, que informam a quanti-
dade de elementos6 que a matriz podera´ conter, podendo ser atribuido valores aos
itens em sua declarac¸a˜o inicial ou, atribuir valores durante a demanda do processa-
mento da aplicac¸a˜o de acordo com as necessidades do algoritmo.
6A quantidade de elementos da matriz sera´ igual a NxM, sendo N e M os valores entre os
colchetes da matriz (“linha” e “coluna”).
24
6.2.3 Exemplos
Algoritmo que recebe uma matriz 3x3, acha o maior valor da linha e soma com os
demais valores.
1 #inc lude <iostream>
2 #d e f i n e MAX 3
3 us ing namespace std ;
4 i n t main ( )
5 {
6 i n t mat [MAX] [MAX] ;
7 i n t lMaior [MAX] , cMaior [MAX] ;
8
9 f o r ( i n t i = 0 ; i < MAX ; i++ )
10 {
11 f o r ( i n t j = 0 ; j < MAX ; j++ )
12 c in >> mat [ i ] [ j ] ;
13 lMaior [ i ] = 0 ;
14 cMaior [ i ] = 0 ;
15 }
16
17 f o r ( i n t i = 0 ; i < MAX ; i++ )
18 f o r ( i n t j = 0 ; j < MAX ; j++ )
19 i f ( mat [ lMaior [ i ] ] [ cMaior [ i ] ] < mat [ i ] [ j ] )
20 {
21 lMaior [ i ] = i ;
22 cMaior [ i ] = j ;
23 }
24
25 f o r ( i n t i = 0 ; i < MAX ; i++ )
26 {
27 f o r ( i n t j = 0 ; j < MAX ; j++ )
28 {
29 mat [ i ] [ j ] += mat [ lMaior [ i ] ] [ cMaior [ i ] ] ;
30 cout << mat [ i ] [ j ] << ”\ t ” ;
31 }
32 cout << endl ;
33 }
34
35 r e turn 0 ;
36 }
Algoritmo que recebe uma matriz NxM e imprime seus valores na ordem in-
versa.
1 #inc lude <iostream>
2 us ing namespace std ;
3 i n t main ( )
4 {
5 i n t m, n ;
6
7 c in >> m;
8 c in >> n ;
9
10 i n t mat [m] [ n ] ;
11
12 f o r ( i n t i = 0 ; i < m ; i++ )
13 f o r ( i n t j = 0 ; j < n ; j++ )
14 c in >> mat [ i ] [ j ] ;
15
16 f o r ( i n t i = m−1 ; i >= 0 ; i−− )
17 {
18 f o r ( i n t j = n−1 ; j >= 0 ; j−− )
19 cout << mat [ i ] [ j ] << ”\ t ” ;
20 cout << endl ;
21 }
22 }
25
7 Func¸a˜o randoˆmica
7.1 Sintaxe
1 srand (<seed>) ;
2
3 i n t vetor [<pos icao >] = rand ( ) % <l im i tante> + < i n i c i o >;
7.2 Descric¸a˜o
A func¸a˜o rand() (func¸a˜o nativa da biblioteca <cstdlib>) gera uma sequeˆncia de
valores que se repete igual a si pro´pria sempre que o programa e´ executado. Isto,
porque, a seed7 da sequeˆncia e´ sempre a mesma.
Para que produza-se uma sequeˆncia diferente e´ necessa´rio, mudar a seed usando
a func¸a˜o srand(), cujo argumento inteiro (sem sinal) e´ a nova semente e que na˜o
retorna nenhum valor. Se pretende uma sequeˆncia diferente, sempre que o programa
e´ executado, e o utilizador na˜o seja obrigado a introduzir a semente, podemos usar
uma func¸a˜o time(NULL) (func¸a˜o nativa da biblioteca <ctime>), que retorna o valor
do relo´gio do computador em segundos.
7.3 Exemplo
1 #inc lude <iostream>
2 #inc lude <ctime>
3 #inc lude <c s t d l i b>
4
5 #d e f i n e TAM 10
6
7 us ing namespace std ;
8
9 i n t main ( )
10 {
11 srand ( time (NULL) ) ;
12
13 i n t vet [TAM] ;
14
15 f o r ( i n t i = 0 ; i < TAM ; i++ )
16 vet [ i ] = rand ( ) %100+1;
17
18 f o r ( i n t i = 0 ; i < TAM ; i++ )
19 cout << vet [ i ] << ”\ t ” ;
20 }
7seed e´ o nu´mero usado pela func¸a˜o srand() para gerar uma sequeˆncia “aleato´ria” de nu´meros
inteiros
26
8 Me´todos de Ordenac¸a˜o
8.1 Bubble Sort (“Bolha”)
8.1.1 Descric¸a˜o
O bubble sort, ou ordenac¸a˜o por flutuac¸a˜o (literalmente por “bolha”), e´ um al-
goritmo de ordenac¸a˜o dos mais simples. A ideia e´ percorrer o vetor ou a matriz
diversas vezes, a cada passagem fazendo “flutuar” para o topo o maior elemento da
sequeˆncia. Essa movimentac¸a˜o lembra a forma como as bolhas em um tanque de
a´gua procuram seu pro´prio n´ıvel, e disso vem o nome do algoritmo.
O algoritmo compara os elementos subsequentes, se este for maior (para uma
ordenc¸a˜o crescente) que o anterior ocorre a troca, sena˜o, o algoritmo continua a
percorrer o vetor ou matriz. Apo´s percorrer todo o arranjo verifica-se se ocorreu
alguma troca, se sim, continua executando as trocas ate´ o arranjo ser ordenado,
sena˜o, encerra a execuc¸a˜o.
8.1.2 Exemplos
Algoritmo de ordenac¸a˜o, me´todo Bubble Sort em vetor de tamanho 100.
1 #inc lude <iostream>
2 #inc lude <c s t d l i b>
3 #d e f i n e TAM 100
4 us ing namespace std ;
5 i n t main ( )
6 {
7 i n t i t e r a c o e s = 0 ;
8 srand (10) ;
9
10 i n t vet [TAM] ;
11
12 f o r ( i n t i = 0 ; i < TAM ; i++ )
13 vet [ i ] = rand ( )%TAM+1;
14
15 //INICIO
16 bool t rocou ;
17 i n t aux ;
18
19 do
20 {
21 t rocou = f a l s e ;
22
23 f o r ( i n t i = 0 ; i < TAM−1 ; i++ )
24 {
25 i t e r a c o e s ++;
26
27 i f ( vet [ i ] > vet [ i +1] )
28 {
29 aux = vet [ i ] ;
30 vet [ i ] = vet [ i +1] ;
31 vet [ i +1] = aux ;
32 t rocou = true ;
33 }
34 }
35 } whi le ( t rocou ) ;
36 //FIM
37
38 f o r ( i n t i = 0 ; i < TAM ; i++ )
39 cout << vet [ i ] << ”\ t ” ;
40 cout << endl ;
41
42 cout << ”O numero de i t e r a c o e s f o i : ” << i t e r a c o e s << endl ;
27
43
44 r e turn 0 ;
45 }
Algoritmo de ordenac¸a˜o, me´todo Bubble Sort em uma matriz 5x5.
1 #inc lude <iostream>
2 #inc lude <c s t d l i b>
3 #d e f i n e TAM 5
4 us ing namespace std ;
5 i n t main ( )
6 {
7 srand (10) ;
8
9 i n t mat [TAM] [TAM] ;
10
11 f o r ( i n t i = 0 ; i < TAM ; i++ )
12 f o r ( i n t j = 0 ; j < TAM ; j++ )
13 mat [ i ] [ j ] = rand ( ) %100+1;
14
15 //INICIO
16 bool t rocou ;
17 i n t aux ;
18
19 do
20 {
21 t rocou = f a l s e ;
22
23 f o r ( i n t i = 0 ; i < TAM ; i++ )
24 f o r ( i n t j = 0 ; j < TAM−1 ; j++ )
25 {
26 i f ( mat [ i ] [ j ] > mat [ i ] [ j +1] )
27 {
28 aux = mat [ i ] [ j ] ;
29 mat [ i ] [ j ] = mat [ i ] [ j +1] ;
30 mat [ i ] [ j +1] = aux ;
31 t rocou = true ;
32 }
33 }
34
35 f o r ( i n t i = 0 ; i < TAM−1 ; i++ )
36 i f ( mat [ i ] [TAM−1] > mat [ i + 1 ] [ 0 ] )
37 {
38 aux = mat [ i ] [TAM−1] ;
39 mat [ i ] [TAM−1] = mat [ i + 1 ] [ 0 ] ;
40 mat [ i + 1 ] [ 0 ] = aux ;
41 t rocou = true ;
42 }
43 } whi le ( t rocou ) ;
44 //FIM
45
46 f o r ( i n t i = 0 ; i < TAM ; i++ )
47 {
48 f o r ( i n t j = 0 ; j < TAM ; j++ )
49 cout << mat [ i ] [ j ] << ”\ t ” ;
50 cout << endl ;
51 }
52
53 r e turn 0 ;
54 }
28
8.2 Selection Sort (“Selec¸a˜o”)
8.2.1 Descric¸a˜o
O selection sort, ou ordenac¸a˜o por selec¸a˜o, e´ um algoritmo de ordenac¸a˜o baseadoem se passar sempre o menor valor do arranjo para a primeira posic¸a˜o (ou o maior
dependendo da ordem requerida), depois o de segundo menor valor para a segunda
posic¸a˜o, e assim e´ feito sucessivamente com os elementos restantes.
8.2.2 Exemplo
Algoritmo de ordenac¸a˜o, me´todo Selection Sort em vetor de tamanho 100.
1 #inc lude <iostream>
2 #inc lude <c s t d l i b>
3 #d e f i n e TAM 100
4 us ing namespace std ;
5 i n t main ( )
6 {
7 i n t i t e r a c o e s = 0 ;
8 srand (10) ;
9
10 i n t vet [TAM] ;
11
12 f o r ( i n t i = 0 ; i < TAM ; i++ )
13 vet [ i ] = rand ( )%TAM+1;
14
15 //INICIO
16 i n t pMenor , aux ;
17
18 f o r ( i n t i = 0 ; i < TAM−1 ; i++ )
19 {
20 pMenor = i ;
21
22 f o r ( i n t j = i+1 ; j < TAM ; j++ )
23 {
24 i t e r a c o e s ++;
25 i f ( vet [ pMenor ] > vet [ j ] )
26 pMenor = j ;
27 }
28
29 i f ( pMenor != i )
30 {
31 aux = vet [ pMenor ] ;
32 vet [ pMenor ] = vet [ i ] ;
33 vet [ i ] = aux ;
34 }
35 }
36 //FIM
37
38 f o r ( i n t i = 0 ; i < TAM ; i++ )
39 cout << vet [ i ] << ”\ t ” ;
40 cout << endl ;
41
42 cout << ”O numero de i t e r a c o e s f o i : ” << i t e r a c o e s << endl ;
43
44 r e turn 0 ;
45 }
29
8.3 Insertion Sort (“Inserc¸a˜o”)
8.3.1 Descric¸a˜o
Insertion sort, ou ordenac¸a˜o por inserc¸a˜o, e´ um simples algoritmo de ordenac¸a˜o,
eficiente quando aplicado a um pequeno nu´mero de elementos. Em termos gerais,
ele percorre um vetor de elementos da esquerda para a direita e a` medida que avanc¸a
vai deixando os elementos mais a` esquerda ordenados. O algoritmo de inserc¸a˜o
funciona da mesma maneira com que muitas pessoas ordenam cartas em um jogo
de baralho como o poˆquer.
8.3.2 Exemplo
Algoritmo de ordenac¸a˜o, me´todo Insertion Sort em vetor de tamanho 100.
1 #inc lude <iostream>
2 #inc lude <c s t d l i b>
3 #d e f i n e TAM 100
4 us ing namespace std ;
5 i n t main ( )
6 {
7 i n t i t e r a c o e s = 0 ;
8 srand (10) ;
9
10 i n t vet [TAM] ;
11
12 f o r ( i n t i = 0 ; i < TAM ; i++ )
13 vet [ i ] = rand ( )%TAM+1;
14
15 //INICIO
16 i n t aux ;
17
18 f o r ( i n t i = 1 ; i < TAM ; i++ )
19 {
20 whi le ( ( i != 0) && ( vet [ i ] < vet [ i −1]) )
21 {
22 i t e r a c o e s ++;
23
24 aux = vet [ i ] ;
25 vet [ i ] = vet [ i −1] ;
26 vet [ i −1] = aux ;
27 i−−;
28 }
29 }
30 //FIM
31
32 f o r ( i n t i = 0 ; i < TAM ; i++ )
33 cout << vet [ i ] << ”\ t ” ;
34 cout << endl ;
35
36 cout << ”O numero de i t e r a c o e s do metodo f o i : ” << i t e r a c o e s <<
endl ;
37
38 r e turn 0 ;
39 }
30
9 Me´todos de Busca
9.1 Busca Sequencial (Linear)
9.1.1 Descric¸a˜o
Costuma-se usar o termo busca linear (ou busca sequeˆncial) para expressar um tipo
de pesquisa em arranjos de modo sequencial (elemento por elemento), de modo que
a func¸a˜o do tempo em relac¸a˜o ao nu´mero de elementos e´ linear, ou seja, cresce
proporcionalmente. Num vetor ordenado, essa na˜o e´ a pesquisa mais eficiente, a
busca (ou pesquisa) bina´ria e´ a mais eficiente.
9.1.2 Exemplos
Algoritmo que faz uma busca em vetor de tamanho 100 desordenado.
1 #inc lude <iostream>
2 #inc lude <c s t d l i b>
3 #d e f i n e TAM 100
4 us ing namespace std ;
5 i n t main ( )
6 {
7 i n t i t e r a c o e s = 0 ;
8 srand (10) ;
9
10 i n t vet [TAM] ;
11
12 f o r ( i n t i = 0 ; i < TAM ; i++ )
13 {
14 vet [ i ] = rand ( )%TAM+1;
15 cout << vet [ i ] << ”\ t ” ;
16 }
17 cout << endl ;
18
19 //INICIO
20 i n t busca ;
21 c in >> busca ;
22
23 i n t pos i cao = −1;
24
25 f o r ( i n t i = 0 ; i < TAM ; i++ )
26 {
27 i t e r a c o e s ++;
28 i f ( vet [ i ] == busca )
29 pos i cao = i ;
30 }
31 //FIM
32
33 cout << ”A pos i cao do vetor buscado e : ” << pos i cao << endl ;
34 cout << ”O numero de i t e r a c o e s f o i : ” << i t e r a c o e s << endl ;
35
36 r e turn 0 ;
37 }
31
Algoritmo que faz uma busca em vetor de tamanho 100 ordenado.
1 #inc lude <iostream>
2 #inc lude <c s t d l i b>
3 #d e f i n e TAM 100
4 us ing namespace std ;
5 i n t main ( )
6 {
7 i n t i t e r a c o e s = 0 ;
8 srand (10) ;
9
10 i n t vet [TAM] ;
11
12 f o r ( i n t i = 0 ; i < TAM ; i++ )
13 vet [ i ] = rand ( )%TAM+1;
14
15 bool t rocou ;
16 i n t aux ;
17
18 do
19 {
20 t rocou = f a l s e ;
21
22 f o r ( i n t i = 0 ; i < TAM−1 ; i++ )
23 {
24 i f ( vet [ i ] > vet [ i +1] )
25 {
26 aux = vet [ i ] ;
27 vet [ i ] = vet [ i +1] ;
28 vet [ i +1] = aux ;
29 t rocou = true ;
30 }
31 }
32 } whi le ( t rocou ) ;
33
34 f o r ( i n t i = 0 ; i < TAM ; i++ )
35 cout << vet [ i ] << ”\ t ” ;
36 cout << endl ;
37
38 //INICIO
39 i n t busca ;
40 c in >> busca ;
41
42 i n t pos i cao = −1, i = 0 ;
43
44 whi le ( pos i cao == −1 && vet [ i ] <= busca )
45 {
46 i t e r a c o e s ++;
47
48 i f ( busca == vet [ i ] )
49 pos i cao = i ;
50 e l s e
51 i ++;
52 }
53 //FIM
54
55 cout << ”A pos i cao do vetor buscado e : ” << pos i cao << endl ;
56 cout << ”O numero de i t e r a c o e s f o i : ” << i t e r a c o e s << endl ;
57
58 r e turn 0 ;
59 }
32
9.2 Busca Bina´ria
9.2.1 Descric¸a˜o
A pesquisa ou busca bina´ria e´ um algoritmo de busca em vetores que segue o
paradigma de divisa˜o e conquista. Ela parte do pressuposto de que o vetor esta´
ordenado e realiza sucessivas diviso˜es do espac¸o de busca comparando o elemento
buscado (chave) com o elemento no meio do vetor. Se o elemento do meio do vetor
for a chave, a busca termina com sucesso. Caso contra´rio, se o elemento do meio
vier antes do elemento buscado, enta˜o a busca continua na metade posterior do
vetor. E finalmente, se o elemento do meio vier depois da chave, a busca continua
na metade anterior do vetor.
9.2.2 Exemplo
Algoritmo que faz uma busca bina´ria em vetor de tamanho 100, desta vez o vetor
deve estar ordenado.
1 #inc lude <iostream>
2 #inc lude <c s t d l i b>
3 #d e f i n e TAM 100
4 us ing namespace std ;
5 i n t main ( )
6 {
7 i n t i t e r a c o e s = 0 ;
8 srand (10) ;
9
10 i n t vet [TAM] ;
11
12 f o r ( i n t i = 0 ; i < TAM ; i++ )
13 vet [ i ] = rand ( )%TAM+1;
14
15 i n t pMenor , aux ;
16
17 f o r ( i n t i = 0 ; i < TAM−1 ; i++ )
18 {
19 pMenor = i ;
20
21 f o r ( i n t j = i+1 ; j < TAM ; j++ )
22 {
23 i f ( vet [ pMenor ] > vet [ j ] )
24 pMenor = j ;
25 }
26
27 i f ( pMenor != i )
28 {
29 aux = vet [ pMenor ] ;
30 vet [ pMenor ] = vet [ i ] ;
31 vet [ i ] = aux ;
32 }
33 }
34
35 f o r ( i n t i = 0 ; i < TAM ; i++ )
36 cout << vet [ i ] << ”\ t ” ;
37 cout << endl ;
38
39 //INICIO
40 i n t busca ;
41 c in >> busca ;
42
43 i n t i n i c i o = 0 ;
44 i n t f im = TAM−1;
45 i n t meio ;
46 i n t pos i cao = −1;
47
33
48 do
49 {
50 i t e r a c o e s ++;
51
52 meio = ( i n i c i o+fim ) /2 ;
53
54 i f ( busca == vet [ meio ] )
55 pos i cao = meio ;
56
57 e l s e i f ( busca > vet [ meio ] )
58 i n i c i o = meio+1;
59
60 e l s e
61 f im = meio−1;
62 } whi le ( pos i cao < 0 && i n i c i o <= fim ) ;
63 //FIM
64
65 cout << ”A pos i cao do vetor buscado e : ” << pos i cao << endl ;
66 cout << ”O numero de i t e r a c o e s f o i : ” << i t e r a c o e s << endl ;
67
68 r e turn 0 ;
69 }
10 Registro
10.1 Sintaxe
1 typede f s t r u c t
2 {
3 <dec l a racao de v a r i a e i s >;
4 } <nome de r e g i s t r o >;
10.2 Descric¸a˜o
O registro consiste em criar apenas um dado que conte´m va´rios membros, que nada
mais sa˜o do que outras varia´veis. De uma forma mais simples, e´ como se uma
varia´vel tivesse outras varia´veis dentro dela.
A vantagem em se usar registro e´ que podemos agrupar de forma organizada
va´rios tipos de dados diferentes, por exemplo, dentro de uma estrutura de dados
podemos ter juntos tanto um tipo float, um int, um char e um double. As varia´veis
que ficamdentro do registro sa˜o chamadas de membros.
34
10.3 Exemplo
Algoritmo que recebe o nome, nu´mero de matr´ıcula e o CRA de 5 alunos. Verifica
quem foi aprovado e imprime em ordem crescente, pelo CRA, o nome e o nu´mero
de matr´ıcula dos alunos aprovados.
1 #inc lude <iostream>
2 #inc lude <s t r i ng>
3 #d e f i n e MAX 5
4 us ing namespace std ;
5
6 typede f s t r u c t
7 {
8 s t r i n g nome ;
9 i n t matr i cu la ;
10 f l o a t CRA;
11 } Reg i s t ro ;
12
13 i n t main ( )
14 {
15 Reg i s t ro Aluno [MAX] ;
16
17 f o r ( i n t i = 0 ; i < MAX ; i++ )
18 {
19 c in >> Aluno [ i ] . nome ;
20 c in >> Aluno [ i ] . matr i cu la ;
21 c in >> Aluno [ i ] .CRA;
22 }
23
24 Reg i s t ro Aux ;
25 i n t pMenor ;
26
27 f o r ( i n t i = 0 ; i < MAX−1 ; i++ )
28 {
29 pMenor = i ;
30 f o r ( i n t j = i ; j < MAX ; j++ )
31 i f ( Aluno [ pMenor ] .CRA > Aluno [ j ] .CRA )
32 pMenor = j ;
33
34 i f ( pMenor != i )
35 {
36 Aux = Aluno [ pMenor ] ;
37 Aluno [ pMenor ] = Aluno [ i ] ;
38 Aluno [ i ] = Aux ;
39 }
40 }
41
42 f o r ( i n t i = 0 ; i < MAX ; i++ )
43 i f ( Aluno [ i ] .CRA >= 60 )
44 cout << Aluno [ i ] . nome << ”\ t ” << Aluno [ i ] . matr i cu la <<
endl ;
45
46 r e turn 0 ;
47 }
11 Modularizac¸a˜o
11.1 Descric¸a˜o
Conjunto de comandos agrupados em um bloco que recebe um nome e atrave´s deste
pode ser ativado.
35
11.2 Porque usar func¸o˜es?
1. Permite o reaproveitamento de co´digo ja´ constru´ıdo (por voceˆ ou por outros
programadores).
2. Evita que um trecho de co´digo que seja repetido va´rias vezes dentro de um
mesmo programa.
3. Permite a alterac¸a˜o de um trecho de co´digo de uma forma mais ra´pida. Com
o uso de uma func¸a˜o e´ preciso alterar apenas dentro da func¸a˜o que se deseja.
4. Os blocos do programa na˜o ficam grandes demais e, por consequ¨eˆncia, mais
dif´ıceis de entender.
5. Facilita a leitura do programa-fonte de uma forma mais fa´cil.
6. Separa o programa em partes (blocos) que possam ser logicamente compreen-
didos de forma isolada.
11.3 Varia´vel Global
Uma varia´vel global e´ uma varia´vel acess´ıvel em todos os escopos8 de um programa
de computador. O mecanismo de interac¸a˜o com varia´veis globais e´ chamada ambi-
ente global. Em contraste o ambiente local e´ um mecanismo no qual as varia´veis
sa˜o locais e sem memo´ria compartilhada.
O uso de varia´veis globais e´ geralmente considerado inadequado pois seu conteu´do
pode ser potencialmente modificado de qualquer local, e qualquer parte de um
co´digo pode depender dela.
11.4 Paraˆmetros
A fim de tornar mais amplo o uso de uma func¸a˜o, a linguagem C permite o uso
de paraˆmetros. Este paraˆmetros possibilitam que se definida sobre quais dados a
func¸a˜o deve operar.
Para definir os paraˆmetros de uma func¸a˜o o programador deve explicita´-los como
se estive declarando uma varia´vel, entre os pareˆnteses do cabec¸alho da func¸a˜o.
8Escopo: e´ o local onde a varia´vel declarada e´ va´lida, normalmente dentro do bloco de coman-
dos. No caso da vari global que e´ declarada fora de qualquer bloco, ela sera´ va´lida em qualquer
func¸a˜o abaixo dela.
36
11.5 Exemplo
Algoritmo que preenche um vetor de N posic¸o˜es e faz uma busca de um elemento.
1 #inc lude <iostream>
2 us ing namespace std ;
3
4 i n t Receber ( )
5 {
6 i n t va l o r ;
7
8 c in >> va lo r ;
9
10 r e turn va lo r ;
11 }
12
13 void Preencher ( i n t vet [ ] , i n t n )
14 {
15 f o r ( i n t i = 0 ; i < n ; i++ )
16 vet [ i ] = Receber ( ) ;
17 }
18
19 void Imprimir ( i n t vet [ ] , i n t n )
20 {
21 f o r ( i n t i = 0 ; i < n ; i++ )
22 cout << vet [ i ] << ”\ t ” ;
23 cout << endl ;
24 }
25
26 i n t Busca ( i n t vet [ ] , i n t n )
27 {
28 i n t busca = Receber ( ) ;
29 i n t pos = −1;
30
31 f o r ( i n t i = 0 ; i < n ; i++ )
32 i f ( busca == vet [ i ] )
33 pos = i ;
34
35 r e turn pos ;
36 }
37
38 void Resultado ( i n t r e s )
39 {
40 cout << r e s << endl ;
41 }
42
43 i n t main ( )
44 {
45 i n t n = Receber ( ) ;
46
47 i n t vet [ n ] ;
48
49 Preencher ( vet , n ) ;
50
51 Imprimir ( vet , n ) ;
52
53 Resultado ( Busca ( vet , n ) ) ;
54
55 r e turn 0 ;
56 }
Neste programa temos 5 func¸o˜es externas, todas controladas pela func¸a˜o int
main.
37
int Receber e int Busca.
• As duas func¸o˜es sa˜o do tipo int, portanto, elas retornam um valor inteiro.
Quando a estas func¸o˜es sa˜o chamadas por outra func¸a˜o elas “adquirem” o
valor retornado e podem ser usadas como uma “varia´vel”.
• A func¸a˜o Receber, declara a varia´vel valor e recebe o nu´mero digitado pelo
usua´rio e retorna o valor. Este valor e´ utilizado pelas func¸o˜es Preencher, Busca
e main.
• A func¸a˜o Busca, recebe o vetor e seu tamanho como paraˆmetros, faz a busca
do elemento no vetor e retorna a posic¸a˜o deste elemento.
void Preencher, void Imprimir e void Resultado.
• As treˆs func¸o˜es sa˜o do tipo void, portanto, na˜o retornam nenhum valor. Sendo
assim, estas func¸o˜es devem ter algum tipo de ac¸a˜o, sena˜o na˜o teriam nenhuma
utilidade.
• A func¸a˜o Preencher, como o nome ja´ diz, preenche o vetor de n posic¸o˜es.
• As func¸o˜es Imprimir e Resultado, apresentam os valores para o usua´rio.
int main.
• A func¸a˜o main e´ a principal func¸a˜o de um programa, ela controla quais func¸o˜es
sera˜o executadas.
12 Arquivo
12.1 Sintaxe
1 #inc lude <fstream>
2
3 i f s t r e a m <nome da var i ave l >;
4
5 ofstream <nome da var i ave l >;
12.2 Descric¸a˜o
Ja´ vimos como podemos receber e enviar dados para usua´rio atrave´s do teclado e
da tela, agora veremos tambe´m como ler e gravar dados em arquivos, o que e´ alia´s
muito importante ou ate´ essencial em muitas aplicac¸o˜es.
Assim como as func¸o˜es de entrada/sa´ıda padra˜o (teclado e tela), precisamos de
uma biblioteca para usa-las (biblioteca fstream).
Temos o comando ifstream (seria como o cin), este comando abre um arquivo,
le os dados contidos nele e salva nas varia´veis usadas pelo programa.
Temos tambe´m o comando ofstream (seria como o cout), este comando cria um
arquivo e salva os dados contidos nas varia´veis do programa neste arquivo.
38
12.3 Exemplos
Algoritmo que cria e salva um vetor de 100 posic¸o˜es ordenado em um arquivo.
1 #inc lude <iostream>
2 #inc lude <fstream>
3 #inc lude <c s t d l i b>
4 #inc lude <ctime>
5 #d e f i n e TAM 100
6 us ing namespace std ;
7
8 i n t vet [TAM] ;
9
10 void Preencher ( )
11 {
12 f o r ( i n t i = 0 ; i < TAM ; i++ )
13 vet [ i ] = rand ( )%TAM+1;
14 }
15
16 bool Troca ( i n t a , i n t b )
17 {
18 i n t aux ;
19 aux = vet [ a ] ;
20 vet [ a ] = vet [ b ] ;
21 vet [ b ] = aux ;
22
23 r e turn t rue ;
24 }
25
26 void BubbleSort ( )
27 {
28 bool t rocou ;
29
30 do
31 {
32 t rocou = f a l s e ;
33
34 f o r ( i n t i = 0 ; i < TAM−1 ; i++ )
35 i f ( vet [ i ] > vet [ i +1] )
36 t rocou = Troca ( i , i+1 ) ;
37 } whi le ( t rocou ) ;
38 }
39
40 void SalvarArquivo ( )
41 {
42 ofstream Criador ;
43
44 Criador . open ( ” entrada . txt ” ) ;
45
46 i f ( Criador )
47 {
48 f o r ( i n t i = 0 ; i < TAM ; i++ )
49 Criador << vet [ i ] << ”\ t ” ;
50 Criador . c l o s e ( ) ;
51 }
52
53 e l s e
54 cout << ”Erro ao c r i a r o arquivo ! ” << endl ;
55 }
56
57 i n t main ( )
58 {
59 srand ( time (NULL) ) ;
60 Preencher ( ) ;
61 BubbleSort ( ) ;
62 SalvarArquivo ( ) ;
63 r e turn 0 ;
64 }
39
int vet[TAM].
• Declarando a varia´vel vet acima de todas as func¸o˜es ela se torna global, ou
seja, todas as func¸o˜es podem utiliza-la e modifica-la.
• Neste programa, vet foi declarada como global, pois todas as func¸o˜es a utilizam
e para evitar de usa´-la sempre como paraˆmetro.
bool Troca.
• A func¸a˜o retorna o valor verdadeiro ou falso. Ela executa a troca utilizadanas func¸o˜es de ordenac¸a˜o, em programas de maiores estas func¸o˜es podem ser
usadas va´rias vezes, para evitar de escrever muitas vezes a mesma linha de
comando, usa-se a func¸a˜o externa.
• Tente sempre dividir o seu programa no maior nu´mero de func¸o˜es poss´ıvel,
pois ajuda na legibilidade do seu co´digo.
void SalvarArquivo.
• A func¸a˜o e´ do tipo void pois na˜o retorna nenhum valor.
• Ela cria um arquivo chamado de “entrada.txt”, verifica se o arquivo foi criado.
• Se o arquivo foi criado com sucesso, ela salva o vetor ordenado neste arquivo
e depois o fecha.
• Se na˜o foi poss´ıvel criar o arquivo, ela apresenta a mensagem de erro.
Algoritmo que le o arquivo “entrada.txt” criado anteriormente e faz uma busca
bina´ria.
1 #inc lude <fstream>
2 #inc lude <iostream>
3 #d e f i n e TAM 100
4 us ing namespace std ;
5
6 i n t vet [TAM] ;
7
8 void LerArquivo ( )
9 {
10 i f s t r e a m L e i t o r ;
11
12 L e i t o r . open ( ” entrada . txt ” ) ;
13
14 i f ( L e i t o r )
15 {
16 f o r ( i n t i = 0 ; i < TAM ; i++ )
17 L e i t o r >> vet [ i ] ;
18
19 L e i t o r . c l o s e ( ) ;
20 }
21
22 e l s e
23 cout << ”Arquivo nao e x i s t e ! ! ! ” << endl ;
24 }
25
26 i n t Busca ( )
27 {
28 i n t busca ;
29
30 c in >> busca ;
31
32 r e turn busca ;
40
33 }
34
35 i n t BuscaBinaria ( i n t busca )
36 {
37 i n t pos = −1;
38
39 i n t i n i = 0 ;
40 i n t f im = TAM−1;
41 i n t meio ;
42
43 do
44 {
45 meio = ( i n i+fim ) /2 ;
46
47 i f ( vet [ meio ] < busca )
48 i n i = meio+1;
49
50 e l s e i f ( vet [ meio ] > busca )
51 f im = meio−1;
52
53 e l s e
54 pos = meio ;
55 } whi le ( ( pos < 0) && ( i n i <= fim ) ) ;
56
57 r e turn pos ;
58 }
59
60 void Resposta ( i n t r e spo s t a )
61 {
62 cout << r e spo s ta << endl ;
63 }
64
65 i n t main ( )
66 {
67 LerArquivo ( ) ;
68
69 Resposta ( BuscaBinaria ( Busca ( ) ) ) ;
70 }
41