Você está na página 1de 103

Universidade Estadual Paulista "Jlio de Mesquita Filho"

Faculdade de Engenharia de Ilha Solteira


Departamento de Matemtica


Linguagem de Programao
C++








Alan Rodrigo Panosso
Fbio Roberto Chavarette














2014

Sumrio
Apostila C++ ..................................................................................................................................................... 1
1. Introduo ................................................................................................................................................. 1
1.1 Histrico da linguagem C++ ......................................................................................................... 1
1.2 Compilador Tutorial de Instalao ............................................................................................ 2
1.3 Apresentando o Dev-C++ ............................................................................................................. 7
1.4 Compiladores .................................................................................................................................. 9
2. Estrutura de um programa ................................................................................................................... 12
2.1 Controle dos Fluxos de Entrada e de Sada ............................................................................ 13
2.2 Primeiro Programa ....................................................................................................................... 13
2.3 Segundo Programa ...................................................................................................................... 16
2.4 Terceiro Programa ....................................................................................................................... 18
3. Variveis e Tipos de Dados ................................................................................................................. 19
3.1 Identificadores .............................................................................................................................. 19
3.2 Identificadores (nome das variveis)......................................................................................... 19
3.3 Declarao de variveis .............................................................................................................. 20
4. Constantes .............................................................................................................................................. 24
4.1 Definindo Constantes .................................................................................................................. 24
4.2 Classificao de Constantes e Variveis ................................................................................. 25
5. Expresses ............................................................................................................................................. 26
5.1 Instrues ...................................................................................................................................... 26
5.2 Atribuio ....................................................................................................................................... 27
5.3 Expresses Aritmticas ............................................................................................................... 27
5.4 Expresses Lgicas ..................................................................................................................... 29
5.5 Tabela-verdade ............................................................................................................................ 29
5.6 Exemplo 1...................................................................................................................................... 30
5.7 Exemplo 2...................................................................................................................................... 31
5.8 Exemplo 3...................................................................................................................................... 31
6. Formatando as sadas dos programas ............................................................................................... 31
6.1 Exemplo 4...................................................................................................................................... 32
6.2 Exemplo 5...................................................................................................................................... 34
6.3 Preciso Numrica ....................................................................................................................... 35
6.4 Imprimindo Caracteres Grficos ................................................................................................ 36
7. Controle de Fluxo de Execuo - Estrutura Condicional SE ........................................................... 37
7.1 Estrutura if/else ............................................................................................................................. 37
7.2 Exemplo 6...................................................................................................................................... 42
7.3 Estrutura switch/ Escolha (caso selecione) .............................................................................. 44
7.4 Exemplo 7...................................................................................................................................... 45
7.5 Exemplo 8...................................................................................................................................... 46
7.6 Exemplo 9...................................................................................................................................... 46
7.7 Exemplo 10 ................................................................................................................................... 47
8. Laos ....................................................................................................................................................... 48
8.1 O lao for (para) ........................................................................................................................... 48
8.2 Exemplo 11 ................................................................................................................................... 52
8.3 O lao while (enquanto) .............................................................................................................. 53
8.4 O lao do-while (repetir) .............................................................................................................. 57
8.5 Exemplo 12 ................................................................................................................................... 59
8.6 Exemplo 13 ................................................................................................................................... 60
8.7 Exemplo 14 ................................................................................................................................... 60
9. Modularizao ........................................................................................................................................ 61
9.1 Introduo e Histrico .................................................................................................................. 61
9.2 Modularizao em pseudocdigo .............................................................................................. 62
9.3 Ferramentas .................................................................................................................................. 63
9.4 Transferncia de Parmetros ..................................................................................................... 65
9.5 Modularizao em Sub-Rotinas ................................................................................................. 66


UNESP - FEIS
Departamento de Matemtica
2
9.6 Modularizao em C++ - Funes ............................................................................................. 67
10. Tipos de Funes ............................................................................................................................. 69
10.1 Sem passagem de parmetro e sem retorno .......................................................................... 69
10.2 Com passagem de parmetro e sem retorno .......................................................................... 70
10.3 Sem passagem de parmetro e com retorno .......................................................................... 70
10.4 Com passagem de parmetro e com retorno .......................................................................... 71
10.5 Tipos de passagem de parmetro ............................................................................................. 72
10.6 Valores default de parmetros de funes ............................................................................... 75
10.7 Sobrecarga de Funes .............................................................................................................. 76
10.8 Recursividade de Funes ......................................................................................................... 77
11. Estruturas Composta de Dados (Vetores) .................................................................................... 79
11.1 Estrutura de Dados Composta Homognea ............................................................................ 79
11.2 Vetores ........................................................................................................................................... 80
11.3 Inicializao de Vetores .............................................................................................................. 82
11.4 Acessando os elementos dos vetores ...................................................................................... 82
11.5 Exemplo 15 ................................................................................................................................... 84
11.6 Mtodos de ordenao de vetores ............................................................................................ 86
11.7 Exemplo 16 ................................................................................................................................... 89
11.8 Exemplo 17 ................................................................................................................................... 90
11.9 Nmero desconhecidos de elementos ...................................................................................... 91
12. Estruturas Composta de Dados (Matrizes) ................................................................................... 95
13. Referncia bibliogrficas ................................................................... Erro! Indicador no definido.


UNESP - FEIS
Departamento de Matemtica
1
Apostila C++

1. Introduo

1.1 Histrico da linguagem C++

O C++ foi inicialmente desenvolvido por Bjarne Stroustrup dos Bell Labs,
durante a dcada de 1980 com o objetivo de programar uma verso distribuda do
ncleo Unix. Como o Unix era escrito em C, dever-se-ia manter a compatibilidade,
ainda que adicionando novos recursos. Stroustrup observou que a linguagem
Simula possua caractersticas bastante teis para o desenvolvimento de software,
mas que era muito lenta para uso prtico. Por outro lado, a linguagem BCPL era
rpida, mas possua demasiado baixo nvel, dificultando sua utilizao no
desenvolvimento de aplicaes. A partir de sua experincia de doutorado,
comeou a acrescentar elementos do Simula no C.
A linguagem C foi escolhida como base para o desenvolvimento da nova
linguagem, pois possua uma proposta de uso genrico, era rpida e tambm
portvel para diversas plataformas. Algumas outras linguagens que tambm
serviram de inspirao para o cientista da computao foram ALGOL 68, Ada,
CLU e ML.
Ainda em 1983 o nome da linguagem foi alterado de C with Classes para
C++. Antes, implementada usando um pr-processador, a linguagem passou a
exigir um compilador prprio, escrito pelo prprio Stroustrup. Novas caractersticas
foram adicionadas, como funes virtuais, sobrecarga de operadores e funes,
melhorias na verificao de tipo de dado e estilo de comentrio de cdigo de uma
linha (//). Em 1985 foi lanada a primeira edio do livro "The C++ Programming
Language", contendo referncias para a utilizao da linguagem, j que ainda no
era uma norma oficial. A primeira verso comercial foi lanada em outubro do
mesmo ano. Em 1989 a segunda verso foi lanada, contendo novas
caractersticas como herana mltipla, classes abstratas, mtodos estticos,
mtodos constantes e membros protegidos, incrementando o suporte a orientao
a objeto.
Assim como a linguagem, sua biblioteca padro tambm sofreu melhorias
ao longo do tempo. Sua primeira adio foi a biblioteca de E/S, e posteriormente a
Standard Template Library (STL); ambas tornaram-se algumas das principais
funcionalidades que distanciaram a linguagem em relao a C. Criada
primordialmente na HP por Alexander Stepanov no incio da dcada de 1990 para
explorar os potenciais da programao genrica, a STL foi apresentada a um


UNESP - FEIS
Departamento de Matemtica
2
comit unificado ANSI e ISO em 1993 convite de Andrew Koenig. Aps uma
proposta formal na reunio do ano seguinte, a biblioteca recebeu o aval do comit.
Pode-se dizer que C++ foi a nica linguagem, entre tantas outras, que obteve
sucesso como uma sucessora linguagem C, inclusive servindo de inspirao
para outras linguagens como Java, a IDL de CORBA e C#.

1.2 Compilador Tutorial de Instalao

Dentre os vrios compiladores disponveis, escolhemos para adotar na
disciplina o Bloodshed Dev-C++, ou simplesmente Dev-C++ que um ambiente
de desenvolvimento integrado completo para as linguagens C e C++, que utiliza
uma coleo de compiladores GNU. Este tutorial apresenta, de maneira
simplificada, as principais etapas para a instalao do Dev-C++. Sero
apresentadas a instalao no Sistema Operacional Windows 7.

1. Inicialmente Acesse o endereo http://www.bloodshed.net/devcpp.html e
clique na opo "Go to Download Page", como apresentado na imagem
abaixo.


2. Na prxima pgina localize o item Downloads. Faa o download da
verso mais atual do programa, no nosso exemplo, "Dev-C++ 5.0 beta
9.2 (4.9.9.2) (9.0 MB) with Mingw/GCC 3.4.2". Clique na opo
SourceForge, e o download dever iniciar automaticamente.


UNESP - FEIS
Departamento de Matemtica
3


3. Aps o download, localize o instalador do programa na pasta especfica do
seu computador e clique duas vezes para iniciar o processo de
instalao.
.

4. Siga os passos abaixo para a instalao do programa:


a. Selecione a Linguagem "Portugus".


b. Clique em "Aceito".



UNESP - FEIS
Departamento de Matemtica
4

c. Clique em "Seguinte".


d. Selecione "Instalar".


e. Aguarde o assistente terminar a instalao do programa.




UNESP - FEIS
Departamento de Matemtica
5
f. Escolha a opo "Yes".


5. Ao final da instalao, deixe marcado a opo "Executar Dev-C++ ..." e
clique em terminar. Ou, localize o cone do programa, e inicialize-o.
ou

a. Selecione "OK".


b. Selecione a linguagem "Portugues (Brazil)".




UNESP - FEIS
Departamento de Matemtica
6
c. Ecolha a opo "Yes, I want to use this feature".


d. Marque a opo "Yes, create the cache now".


e. Aguarde o programa aplicar as configurao selecionadas.



UNESP - FEIS
Departamento de Matemtica
7

f. Ao final da aplicao, clique em "OK".


g. Na janela de "Dica do Dia", marque a opo "No exibir dicas na inicializao" e clique
em fechar.

1.3 Apresentando o Dev-C++
Aps a realizao das etapas anteriores, ser apresentado ao usurio a
seguinte tela, onde podemos distinguir os seguinte elementos:







Barra de Menu
Barras de
ferramentas
Navegador de
classes/projetos


UNESP - FEIS
Departamento de Matemtica
8
Na barra de Ferramentas Menu, selecione a opo
"Arquivo/Novo/Projeto...", como apresentado na imagem abaixo:



Na janela "Novo Projeto", escolha o cone "Console Application" e em
"Opes de Projeto" digite no campo Nome, o nome do projeto (sem espaos ou
caracteres especiais) e em seguida marque a opo "Projeto C++".


Salve o projeto (.dev) em uma pasta pessoal destinada a armazenar seus
projetos pessoais.


UNESP - FEIS
Departamento de Matemtica
9


Em seguida ser apresentado a Janela "Editor" com os comandos
bsicos para o incio e desenvolvimento de um programa na linguagem C++.


1.4 Compiladores
Um compilador um programa de sistema que traduz um programa
descrito em uma linguagem de alto nvel para um programa equivalente em cdigo
de mquina (baixo nvel) para um processador. Em geral, um compilador no
produz diretamente o cdigo de mquina, mas sim um programa em linguagem
simblica (assembly) semanticamente equivalente ao programa em linguagem de
alto nvel.
O programa em linguagem simblica ento traduzido para o programa
em linguagem de mquina por meio de montadores. Para desempenhar suas
tarefas, um compilador deve executar dois tipos de atividade. A primeira atividade
Barra de Menu
Barras de
ferramentas
Navegador de
classes/projetos
EDITOR


UNESP - FEIS
Departamento de Matemtica
10
a anlise do cdigo fonte, onde a estrutura e significado do programa de alto
nvel so reconhecidos.
A segunda atividade a sntese do programa equivalente em linguagem
simblica. Embora conceitualmente seja possvel executar toda a anlise e
apenas ento iniciar a sntese, em geral estas duas atividades ocorrem
praticamente em paralelo. A figura abaixo apresenta as operaes executas em
um ambiente tpico C++.


No Dev-C++, as opes para compliao e execusso so encontradas
na barra de ferramentas "Compilar e Executar".


UNESP - FEIS
Departamento de Matemtica
11

Compila (Ctrl + F9)
Executar (Ctrl + F10)
Compilar & Executar (F9)
Recompilar Tudo (Ctrl + F11)

Selecione o boto "Compilar & Executar" ou pressione a tecla "F9". A
seguinte tela deve aparecer, indicando que todos os passos anteriormente
apresentados foram executados com sucesso pelo compilador.

Pressione qualquer tecla para continuar, ou feche a janela do console para
voltar ao editor do programa.


UNESP - FEIS
Departamento de Matemtica
12

2. Estrutura de um programa
Todo programa consiste em uma ou mais funes, tendo como
particularidade desse fato a possibilidade de construir programas modulares e
estruturados.

Assim, a estrutura de um programa em C++ :

// Estrutura do C++
[<definies de pr-processamento cabealhos>]
[<declarao das variveis globais>]
[<tipo>] main([<parmetros>])
{
/* Este trecho reservado para o corpo da funo, com a
declarao de suas variveis locais, seus comandos e
funes de trabalho*/
return[<valor>];
}

[<tipo>] funonome([<parmetros>])
{....
[<declarao de parmetros>]
[return; ou return(); ou return(valor);]
}
]



UNESP - FEIS
Departamento de Matemtica
13
2.1 Controle dos Fluxos de Entrada e de Sada
por meio dos fluxos de entrada e de sada que os operadores de acesso
ao teclado e vdeo podem ser efetuados. Assim sendo ser possvel efetuar
entrada (cin console input) e sada de dados (cout console output) para
todas as operaes realizadas por um programa.
cin trabalha com o teclado.
cout trabalha com o monitor.
Para fazer uso bsico dos fluxos cin (fluxo de entrada) e cout (fluxo de
sada), necessrio inserir no incio do programa a chamada ao arquivo de
cabealho correspondente denominado iostream.
Chamada do cabealho:
#include <iostream> ou #include <iostream.h>

2.2 Primeiro Programa
A melhor maneira de iniciarmos o aprendizado de uma nova linguagem de
programao escrevendo nossos prprios programas. Neste material, ser
adotada a seguinte estrutura, o primeiro painel mostra o cdigo fonte para os
nossos programas, e o segundo painel apresenta o resultado do programa uma
vez compilado e executado.

Janela Cdigo Fonte Resultado (aps compilao e execuo)
// Programa em C++
#include <iostream>
using namespace std;
int main(void)
{
cout << "Oi mundo" << endl;
system ("Pause");
}
Oi mundo
Press any key to continue...
O programa principal escrito em linguagem C++ uma funo, por
natureza prpria.


UNESP - FEIS
Departamento de Matemtica
14

Vamos entender linha por linha do programa:
// Programa em C++
Est uma linha de comentrio. Todas as linhas comeando com duas
barras (//) no tem qualquer efeito no comportamento de um
programa. Recomendamos que, no processo de aprendizagem, vrias
linhas de comentrios sejam adicionadas, para explicaes ou
observaes a respeito do cdigo.

C++ apresenta duas maneiras de fazer comentrios
// Linha de comentrio
/*
Bloco de comentrio
que pode abranger
um grande nmero de linhas
*/

A primeira forma de comentrio conhecida como linha de comentrio,
descartando tudo a partir das duas barras (//) at o final da mesma
linha. O segundo tipo conhecido como bloco de comentrio,
descartando tudo entre a instruo /* e a primeira ocorrncia da
instruo */, com a possibilidade da incluso mais de uma linha.

#include <iostream>
Linhas iniciando com o sinal (#) so diretrizes para o pr-processador,
ou seja, instrues para o compilador. Neste caso, estamos dizendo ao
pr-processador para incluir os arquivos padres da biblioteca
iostream. Estes arquivos especficos incluem as declaraes da
biblioteca bsica de controle do fluxo de entrada (cin) e sada de
dados (cout).



UNESP - FEIS
Departamento de Matemtica
15

int main (void)
{
...
}
Definio inicial da funo principal. A funo principal o ponto no
qual todo o programa em C++ inicia a sua execuo. Independente de
sua localizao dentro do cdigo fonte, ou seja, no importa se existem
outras funes definidas (com outros nomes) antes ou depois dela, as
instrues contidas dentro das chaves dessa funo ( { } ) sempre
sero as primeiras a serem executadas.

cout << "Oi mundo" << endl;
Esta uma linha de instruo em C++. Uma instruo, ou declarao,
so expresses simples, ou composta, que realmente produzem algum
efeito no programa. De fato, esta instruo realiza uma nica ao,
gerar um efeito visvel no nosso primeiro programa.

cout representa o fluxo padro de sada em C++, nessa declarao
estamos inserindo a sequencia de caracteres "Oi mundo" na sada de
dados, no caso a tela do computador, por meio do console.

endl essa declarao insere uma nova linha na sada da tela, para
evitar que nosso programa apresente a sada abaixo:
Oi mundoPress any key to continue...

Observe tambm que deve-se utilizar tambm o operador de fluxo <<
(fluxo de sada).

Observe tambm que toda a declarao termina com o caractere
"ponto & vrgula" (;). Representa o final de uma declarao, e precisa
ser adicionado no final de todas as linhas de declarao nos programas
em C++.

using namespace std;
Todos os elementos da biblioteca padro de C++ so declaradas dentro
do que chamamos namespace, com o nome std. Linha muito
frequente em programas em C++. Evita que, por exemplo, quanto
utilizarmos cout <<, seja necessrio escrevermos std::cout <<.



UNESP - FEIS
Departamento de Matemtica
16
system("Pause");
Esta declarao pausa a janela de sada do programa, permitindo, ao
usurio, a sua inspeo.

Observe que a funo principal do nosso primeiro programa poderia ser
escrita da seguinte maneira:
int main () {cout << "Oi mundo" << endl; system ("Pause");}
Sem comprometer o funcionamento do programa. Entretanto, um cdigo
estruturado em diferentes linhas mais legvel para os seres humanos, tornando
muito mais simples a sua inspeo e compreenso.

2.3 Segundo Programa
Vamos estudar alguns novos comandos bsicos.
#include <iostream>
using namespace std;
int main()
{
int a, b, soma;
cout << "Digite o valor de a: ";
cin >> a;
b=2;
soma = a + b;
cout << soma << '\n';
system ("Pause");
}
Digite o valor de a: 5
7
Press any key to continue...
Para o compilador, este segmento nada mais do que uma sequncia
de caracteres em um arquivo texto. O primeiro passo da anlise reconhecer que
agrupamentos de caracteres tm significado para o programa, por exemplo, saber
que int uma palavra-chave da linguagem e que a e b sero elementos
individuais neste programa. Posteriormente, o compilador deve reconhecer que a
sequncia int a, corresponde declarao de uma varivel inteira cujo
identificador recebeu o nome a.
As regras de formao de elementos e frases vlidas de uma
linguagem so expressas na gramtica da linguagem. O processo de reconhecer
os comandos de uma gramtica conhecido como reconhecimento de sentenas.

cin >> varivel;
Fluxo de entrada de dados p/ transferncia do contedo do teclado para
a varivel .O trabalho com a entrada padro no C++ feito aplicando-se
o operador de extrao (>>) no comando cin. Isso precisa ser seguido
pela varivel que ir guardar o dado que ser lido.


UNESP - FEIS
Departamento de Matemtica
17

Declarando a varivel como desejada, ento o programa fica na espera
por uma entrada do cin (teclado) para que possa armazena-la em um espao
reservado da memria. O comando cin s pode processar a entrada do teclado
depois que a tecla ENTER for pressionada. No nosso exemplo, digitamos o
nmero inteiro 5, e esse valor foi guardado dentro da varivel a por meio da
sentena: cin >> a;
Sendo assim, mesmo que voc pea um nico caractere, o cin no ir
processar a entrada at que o usurio pressione ENTER depois que o caractere
tenha sido digitado. Deve-se atentar ao tipo da varivel que estamos utilizando
para guardar o valor extrado pelo cin. Se voc pedir um inteiro, voc receber
um inteiro, se voc pedir um caractere, voc receber um caractere, e se voc
pedir uma string de caracteres, voc receber uma string de caracteres.

cout << soma << '\n';
Observe o uso de execuo do programa com o uso do caractere '\n'
semelhante ao uso do manipulador de sada endl.







UNESP - FEIS
Departamento de Matemtica
18
2.4 Terceiro Programa
Vamos estudar alguns novos comandos bsicos.
#include <iostream>
using namespace std;
int main(void)
{
char NOME[50], SOBRENOME[20];
cout << "Informe seu nome: ";
cin.getline(NOME, sizeof(NOME));
cout << "Informe seu sobrenome: ";
cin >> SOBRENOME;
cout << "Ola, \n " << NOME;
cout << " " << SOBRENOME << endl;
system ("pause");
return 0;
}
Informe seu nome: Jose
Informe seu sobrenome: Silva
Ol
Jose Silva
Press any key to continue...
char NOME[50], SOBRENOME[20];
Nesta instruo estamos declarando duas variveis do tipo caractere,
esses conceitos sero abordados posteriormente de maneira mais
detalhada. Assim, as variveis NOME e SOBRENOME apresentam,
respectivamente, os tamanhos de 50 e 20, os quais representam o
nmero de caracteres que podero ser armazenados nas respectivas
variveis. Se tivssemos declarado char NOME, essa varivel seria
capaz de armazenar apenas um caractere.

cin.getline(NOME, sizeof(NOME));
Observe o uso da funo getline() pertencente ao fluxo de entrada
cin. Efetua a leitura de caracteres at que seja pressionado a tecla
ENTER ou at atingir o valor mximo de caracteres permitidos. J, a
funo sizeof() retorna o tamanho da varivel NOME, que no caso
50.



UNESP - FEIS
Departamento de Matemtica
19

3. Variveis e Tipos de Dados

3.1 Identificadores
Varivel , no sentido de programao, uma regio de memria de um
computador, previamente identificada, que tem por finalidade armazenar as
informaes (dados) de um programa temporariamente. Uma varivel armazena
apenas um valor por vez, sendo considerado valor qualquer contedo
armazenado em uma varivel. Um valor est relacionado ao tipo de dado de uma
varivel, podendo ser numrico (inteiro ou real), lgico ou caractere.

3.2 Identificadores (nome das variveis)
Um identificador (nomes das variveis, ou constantes) vlido uma
sequencia de uma ou mais letras, dgitos ou underline (_). Nomes de varivel
podem ser atribudos com um ou mais caracteres. Caracteres como espaos em
branco, pontuaes e smbolos especiais no podem ser utilizados para formar
os identificadores. Identificadores de variveis devem sempre ser inicializados
por letras, ou mesmo por um underline (_). Os identificadores no devem ser
iniciados por dgitos (nmeros).
Outra regra que devemos considerar que os identificadores no podem
coincidir com palavras-chaves da linguagem C++, ou palavras especficas do
compilador, as quais so reservadas para o seu uso. As palavras-chaves
reservadas so:
asm, auto, bool, break, case, catch, char, class, const,
const_cast, continue, default, delete, do, double, dynamic_cast, else,
enum, explicit, export, extern, false, float, for, friend, goto, if,
inline, int, long, mutable, namespace, new, operator, private, protected,
public, register, reinterpret_cast, return, short, signed, sizeof,
static, static_cast, struct, switch, template, this, throw, true, try,
typedef, typeid, typename, union, unsigned, using, virtual, void,
volatile, wchar_t, while, and, and_eq, bitand, bitor, compl, not, not_eq,
or,or_eq, xor, xor_eq.
Outro aspecto bastante importante que a linguagem C++ sensvel ao
case (case sensitive). Isso significa que um identificador escrito em letra maiscula
no equivalente a outro identificador com o mesmo nome, mas escrito em letras
minsculas. Por exemplo, a varivel RESULTADO, no o mesmo que a varivel
resultado, ou Resultado. Eles so trs diferentes identificadores de variveis.
Na execuo de um programa, as variveis so armazenadas na memria
do computador, entretanto, o computador precisa saber que tipo de dado
queremos armazenar nelas, uma vez que no se vai ocupar a mesma quantidade


UNESP - FEIS
Departamento de Matemtica
20
de memria para armazenar um simples nmero, uma nica letra ou um nmero
muito grande, e eles no sero interpretados da mesma maneira.
A memria dos computadores organizada em bytes. Um byte a menor
quantidade de memria que pode ser manipulada em C++. Um byte pode
armazenar uma pequena quantidade de dados: uma nica letra ou um nmero
inteiro pequeno (entre 0 e 255). Alm disso, o computador tambm capaz de
manipular tipos de dados complexos, oriundos do agrupamento de vrios bytes
como nmeros long ou no inteiros.
Os tipos fundamentais de dados em C++, juntamente com o tamanho em
bytes so:
Nome Descrio Tamanho* Extenso*
char Caractere ou inteiro pequeno 1 byte
signed: -128 to 127
unsigned: 0 to 255
short int
(short)
Inteiro curto 2 bytes
signed: -32768 to 32767
unsigned: 0 to 65535
int Inteiro longo 4 bytes
signed: -2147483648 to
2147483647
unsigned: 0 to 4294967295
long int (long) Inteiro 4 bytes
signed: -2147483648 to
2147483647
unsigned: 0 to 4294967295
bool
Valor booleano, Pode assumir
verdadeiro ou falso
1 bytes true ou false
float Nmero real (ponto flutuante) 4 bytes +/- 3.4e +/- 38 (~7 digits)
double Dupla preciso do nmero real 8 bytes +/- 1.7e +/- 308 (~15 digits)
long double
Valor booleano, Pode assumir
verdadeiro ou falso
8 bytes +/- 1.7e +/- 308 (~15 digits)
Os valores das colunas Tamanho e Extenso dependem do sistema em
que o programa compilado. Os valores apresentados foram encontrados na
maioria dos sistemas de 32 bits. As variveis numricas podem ser declaradas
como signed ou unsigned dependendo da extenso numrica necessria a ser
armazenada. Variveis declaradas como signed podem representar ambos
valores positivos e negativos, enquanto unsigned pode representar apenas
valores positivos.

3.3 Declarao de variveis
Apesar de a linguagem C++ permitir a declarao de variveis em qualquer
parte do programa, o bom hbito de programar nos diz que todo dado a ser
armazenado na memria de um computador por meio de uma varivel deve ser
previamente declarado no incio do programa. Primeiro necessrio saber o
seu tipo para depois fazer o armazenamento. Armazenando o dado ele pode ser
utilizado e manipulado a qualquer momento durante a execuo do programa.


UNESP - FEIS
Departamento de Matemtica
21
Quando definimos uma varivel em C++, precisamos informar ao compilador
o tipo da varivel: um nmero inteiro, um nmero de ponto flutuante (real), um
caractere, e assim por diante. Essa informao diz ao compilador quanto espao
deve ser reservado na memria para a varivel, e o tipo de valor que ser
armazenado nela. Os tipos fundamentais de variveis utilizadas so:

int
O tipo de dado int (inteiro) serve para armazenar valores numricos inteiros
positivos, ou negativos, e zero (0) excluindo-se qualquer valor fracionrio. Existem
vrios tipos de inteiros, com tamanhos diferentes (dependendo do sistema
operacional e/ou arquitetura do processador): int, pode possuir 16 bits, 32 bits ou
64 bits short int, deve possuir tamanho de no mnimo 16 bits e no pode ser maior
que int. long int, deve possuir tamanho mnimo de 32 bits. long long int, deve
possuir tamanho mnimo de 64 bits.
#include <iostream>
using namespace std;
int main()
{
int idade;
cout<< "Digite a sua idade: ";
cin>> idade;
cout<< "Sua idade daqui 10 anos sera "
<< idade+10 << " anos" << endl;
system("Pause");
}
Digite a sua idade: 20
Sua idade daqui 10 anos sera 30 anos
Press any key to continue...

float
O tipo de dado float serve para armazenar nmeros reais (de ponto
flutuante), ou seja, com casas decimais. So tipos reais de dados numricos
positivos, negativos e nmeros fracionrios e inteiros. O float usado para definir
nmero de ponto flutuante com seis dgitos decimais de preciso absoluta (32
bits).
#include <iostream>
using namespace std;
int main()
{
float a,b, d;
a=5;
b=3;
d=a/b;
cout << d <<endl;
system("Pause");
}
1.66667
Press any key to continue...




UNESP - FEIS
Departamento de Matemtica
22
double
O tipo de dado double serve para armazenar nmeros de ponto flutuante de
dupla preciso, normalmente tem o dobro do tamanho e capacidade do float.
#include <iostream>
using namespace std;
int main()
{
double a, b, d;
a=5;
b=3;
d=a/b;
cout << d << endl;
system("Pause");
}
1.66667
Press any key to continue...
Utilizando a varivel double, teremos um nmero mais significativo de
sada. O double utilizado quando necessitamos de uma aproximao maior e
mais exata do resultado. O double consome 64 bits de memria para o seu
armazenamento. Esse consumo explicado pela alta preciso de seu nmero
(cerca de 15 decimais de preciso absoluta). O long double usado para definir
nmero de ponto flutuante (nmeros fracionrios com quinze dgitos decimais de
preciso absoluta) de 80 bits.

char
O tipo char ocupa 1 byte, e serve para armazenar caracteres ou inteiros. Isso
significa que o programa reserva um espao de 8 bits na memria RAM ou em
registradores do processador para armazenar um valor (char de tamanho maior
que 8 bits permitido pela linguagem, mas os casos so raros).
#include <iostream>
using namespace std;
int main()
{
char nome[8];
cout << "Digite seu nome: ";cin >> nome;
cout << "Seu nome e: " << nome << endl;
system("Pause");
}
Digite seu nome: Marcos
Seu nome e: Marcos
Press any key to continue...
No nosso exemplo, pode-se guardar uma varivel do tipo caractere com at
20 caracteres de comprimento, caso exceda o nmero mximo de caracteres,
ocasionar erro no compilador. Caso fosse declarado apenas "char nome", a
varivel nome armazenaria apenas uma letra, por exemplo, se o usurio digitasse
um nome com 7 letras, a varivel apenas armazenaria a primeira letra digitada. A
linguagem de programao C++ utiliza de duas formas: Utilizando apenas um
caractere delimitado por apstrofos 'e'; Ou uma sequncia de caracteres
delimitador por aspas "ee";



UNESP - FEIS
Departamento de Matemtica
23
string
So variveis tipo caracteres que podem armazenar valores maiores que um
caractere simples. A biblioteca <string> fornece esse suporte. No tipo
fundamental de varivel, mas se comporta como um tipo fundamental. Para
declararmos variveis como string precisamos incluir uma linha adicional no
cabealho do programa, o arquivo #include <string>.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string nome;
nome = "Marcos da Silva";
cout << nome << endl;
nome = "Podemos mudar uma string";
cout << nome << endl;
system("Pause");
}
Marcos da Silva
Podemos mudar uma string
Press any key to continue...

bool
Os tipos de dados lgicos (tipo booleano) possuem apenas um de dois
valores: true (verdadeiro = 1) e false (falso = 0) e so referenciados pela palavra-
chave bool. Eles so utilizados para verificar o resultado de uma notificao ou
expresso lgica.
#include <iostream>
using namespace std;
int main()
{
bool t1, t2, t3;
t1 = (4>=6);//falso
t2 = true;//verdadeiro
t3 = (true || 5==25/5;//verdadeiro
cout << t1 << endl;
cout << t2 << endl;
cout << t3 << endl;
system("Pause");
}
0
1
1
Press any key to continue...









UNESP - FEIS
Departamento de Matemtica
24
4. Constantes

Constante tudo aquilo que fixo ou estvel. Em programao existir
vrios momentos em que este conceito dever estar em uso.
Por exemplo, o valor 1.23 da frmula seguinte uma constante
explcita:
RESULTADO = ENTRADA * 1.23.

necessrio para programar, ter conhecimento de constantes e seus
respectivos significado, praticamente todos os programas fazem uso delas. So
indispensveis para a criao de programas de forma rpida e mais eficiente.
Assim, as constantes so expresses com valor fixo.
A linguagem C++ introduz um novo modificador chamado const, que tem
comportamento variado dependendo do local onde est sendo declarado. Sua
funo, basicamente, estabelecer um vnculo entre declarao e obrigatoriedade
da coerncia no uso do smbolo declarado. A princpio, quando declaramos uma
constante com este modificador fazemos com que seja obrigatrio o uso do
smbolo de forma que o mesmo no possa ter seu valor alterado. Assim, se
fizermos:

const int x = 4;

O inteiro x no poder deixar de ter valor igual a 4. Qualquer tentativa de
modificar o valor da constante ao longo do programa ser reportada como erro
pelo compilador.


4.1 Definindo Constantes
Podemos definir os nomes de nossas constantes sem o consumo de
memria, simplesmente utilizando o comando #define do pr-processador.

#define identificador value
#include <iostream>
#define PI 3.14159
#define NL '\n'
using namespace std;
int main()
{
double raio=5, circulo;
circulo=2*PI*raio;
cout << circulo; cout << NL;cout << NL;
system("Pause");
}
31.4159

Press any key to continue...



UNESP - FEIS
Departamento de Matemtica
25

4.2 Classificao de Constantes e Variveis
Tanto variveis como constantes podem ser locais, ou globais. Uma
varivel global aquela declarada no corpo principal do cdigo fonte do programa,
fora de todas as funes, enquanto uma varivel local aquela declarada dentro
do corpo de uma funo ou de um bloco. Assim, temos que:

Locais
Podem ser usadas apenas na funo onde foi declarada, sendo inutilizveis para
as demais funes.

Globais
Podem ser usadas em qualquer lugar do programa.

Observe o exemplo:
#include <iostream>
using namespace std;

int Inteiro;
char aNome;
char string[20]; Variveis Globais
unsigned int nFilhos;

int main()
{
unsigned short idade; Variveis Locais
float aNumero, outraVar;
cout << "Entre com a sua idade: "; Instrues
cin >> idade;
...
}


UNESP - FEIS
Departamento de Matemtica
26

5. Expresses
Tanto variveis como constantes podem ser utilizadas na elaborao de
clculos matemticos com a utilizao de operadores aritmticos. muito
comum a necessidade de trabalhar com expresses aritmticas, uma vez que, na
sua maioria, todo trabalho computacional est relacionado e envolve a utilizao
de clculos matemticos. Essas expresses so definidas pelo relacionamento
existente entre variveis e constantes numricas com a utilizao dos operadores
aritmticos.
Considere a frmula:
AREA = *RAIO
2
para o clculo da rea de uma circunferncia, onde:
AREA e RAIO so variveis.
uma constante (pi = 3.14159)
Multiplicao e a potncia so os operadores aritmticos.
Neste caso, a expresso a ser escrita para a execuo em um computador :
AREA = 3.14159 * RAIO * RAIO
ou
AREA = 3.14159 * pow(RAIO,2)
Assim, temos que as expresses abaixo


dever ser escrita como AREA=(BASE*ALTURA)/2


X=(43*(55/(30+2)))

5.1 Instrues
As instrues so representadas pelo conjunto de palavras-chave
(vocabulrio) de uma linguagem de programao que tem por facilidade
comandar, em um computador, o seu funcionamento (fluxo do programa) e a
forma como os dados armazenados devem ser tratados. As instrues da
linguagem de programao C++ caracterizam-se por serem na sua maioria
funes internas, e devem ser escritas com letras minsculas, e terminadas com
ponto e vrgula " ; ".

2
ALTURA BASE
AREA

=
( ) [ ] { } 20 30 55 43 + = X


UNESP - FEIS
Departamento de Matemtica
27
5.2 Atribuio
Um comando de atribuio permite-nos fornecer um valor a uma
varivel, em que o tipo de dado deve ser compatvel com o tipo da varivel, isto ,
somente podemos atribuir um valor lgico a uma varivel capaz de comport-lo.
Em C++ o sinal de igual "=" o smbolo de atribuio, por meio dele
armazenamos valores ou resultados de expresses nas variveis anteriormente
declaradas com o mesmo tipo primrio do dado que estamos atribuindo a ela.
Exemplo:
A = 5;
Esta instruo atribu o valor inteiro 5 varivel A. A parte a esquerda
do sinal de igual (=) deve sempre ser uma varivel, enquanto a parte direita do
sinal de atribuio pode ser uma constante, uma varivel, um resultado de uma
operao, ou qualquer combinao destes. A regra mais importante que a
atribuio realizada da direita-para-a-esquerda, e nunca no outro sentido.
5 = A;
No faz sentido essa atribuio, ento, o programa retorna um erro.

5.3 Expresses Aritmticas
Expresses aritmticas so aquelas cujos operadores so aritmticos
e cujos operandos so constantes, ou variveis do tipo numrico (inteiro ou real).
Chamamos de operadores aritmticos o conjunto de smbolos que representa as
operaes bsicas da matemtica, em C++ os principais operadores so:

Operator Funo Exemplos
+ Adio 2 + 3, X + Y
- Subtrao 4 2, N M
* Multiplicao 3 * 4, A * B
/ Diviso 10/2, X1/X2
++ Incremento i++ equivale a i=i+1
-- Decremento i-- equivale a i=i-1

Demais operaes esto disponveis em C++, por exemplo, as operaes
de radiciao e potenciao, observe a tabela:
Operator Funo Exemplos
pow(x,y) x elevado a y pow(2,3)
sqrt(x) Raiz quadrada de x sqrt(9)



UNESP - FEIS
Departamento de Matemtica
28
Tais funo podem ser utilizadas desde que adicionado ao cabealho do
programa a biblioteca <math.h>, a qual apresenta vrias funes matemticas e
trigonomtricas, dentre elas temos tambm:
sin(): Retorna o valor do seno. Recebe como argumento o valor dos graus em
double.
cos(): Retorna o valor do co-seno. Recebe como argumento o valor dos graus em
double.
tan(): Retorna o valor da tangente. Recebe como argumento o valor dos graus
em double.
log(): Retorna o valor do logaritmo na base 2. Exige um argumento do tipo
double.
log10(): Retorna o valor do logaritmo na base 10. Exige um argumento do tipo
double.

Usaremos outras operaes matemticas no-convencionais, porm,
muito teis na construo de programas, que so o resto e o quociente de diviso
inteira:
Operator Funo Exemplos
% Resto da diviso
9 % 4 resulta em 1
27 % 5 resulta em 2
int(x/y) Quociente da diviso
int(9/4) resulta em 2
int(27/5) resulta em 5
No caso do quociente da diviso, se as variveis x e y forem reais (float
ou double) ser necessrio utilizar a funo int(x/y) para obteno do
quociente da diviso, caso contrrio, se as variveis forem inteiros (int ou long),
o resultado da expresso x/y ser o quociente da diviso.

Na resoluo das expresses aritmticas, as operaes guardam uma
hierarquia entre si:
Prioridade Operadores
1 Parnteses mais internos
2 Potenciao, radiciao e funes trigonomtricas
3 * / int() %
4 + -
Em caso de empate (operadores de mesma prioridade), a resoluo
ocorre da esquerda para a direita, conforme a sequncia existente na expresso
trigonomtrica. Para alterar a prioridade, utilizamos os parnteses mais internos.



UNESP - FEIS
Departamento de Matemtica
29
5.4 Expresses Lgicas
Denominamos expresso lgica aquela cujos operadores so lgicos
ou relacionais e cujos operandos so relaes ou variveis do tipo lgico.
Utilizamos os operadores relacionais para realizar comparaes entre
dois valores de mesmo tipo primitivo. Tais valores so representados por
constantes, variveis, ou expresses aritmticas. Os operadores relacionais so
comuns para construirmos equaes. Em C++ so eles:
Operator Funo Exemplos
> Maior que 5 > 4, x > y
>= Maior ou igual a 5 >= 3, X >= y
< Menor que 3 < 6, x < y
<= Menor ou igual a 3 <= 5, x <= y
== Igual a 3==3, x == y
!= No igual (diferente) 8 != 9, x != y
O resultado obtido de uma relao sempre um valor lgico. Por
exemplo, analisando a relao numrica A + B == C, o resultado ser verdade
(1) ou falsidade (0) medida que o valor da expresso aritmtica A + B seja igual
ou diferente do contedo da vaivel C, respectivamente.
Utilizamos trs operadores lgicos bsicos para a formao de novas
proposies lgicas compostas a partir de outras proposies lgicas simples. Os
operadores lgicos so descrito na tabela abaixo.

Operator Funo Exemplos
! No (negao) ! (3 > 5)
&& E (conjuno) 3 > 5 && 4 < 8
|| Ou (disjuno) 3 > 5 || 4 < 8

5.5 Tabela-verdade
Tabela-verdade o conjunto de todas as possibilidades combinatrias entre os valores
de diversas variveis lgicas, as quais se encontram em apenas duas situaes Verdadeiro (true
equivale a 1) ou Falso (false equivale a 0), e um conjunto de operadores lgicos.
Observe o programa abaixo:
#include <iostream>
using namespace std;
int main()
{
cout << !(5 == 5) << endl;
cout << !(6 <= 5) << endl;
cout << !true << endl;
cout << !false << endl;
system("pause");
}
0
1
0
1
Press any key to continue...


UNESP - FEIS
Departamento de Matemtica
30
cout << !(5 == 5) << endl; // retorna falso (0), pois 5 == 5 verdadeiro
cout << !(6 <= 5) << endl; //retorna verdadeiro (1), pois 6<= 5 falso
cout << !true << endl; //retorna falso, ou seja, 0
cout << !false << endl;//retorna verdadeiro, ou seja, 1

Operao de conjuno.


Operao de disjuno ou no-excluso.


5.6 Exemplo 1
Desenvolva um programa que receba a massa e o volume de uma amostra
qualquer e calcule sua densidade.
#include <iostream>
using namespace std;
int main()
{
float massa, vol, den;
cout << "Digite a massa do material: ";
cin >> massa;
cout << "Digite o volume do material: ";
cin >> vol;
den = massa/vol;
cout << "A densidade do material sera " << den << endl;
system("Pause");
}







UNESP - FEIS
Departamento de Matemtica
31
5.7 Exemplo 2
Construa um programa que calcule a mdia aritmtica entre quatro notas
bimestrais fornecidas por um aluno (usurio):
#include <iostream>
using namespace std;
int main()
{
float N1, N2, N3, N4, media;
cout << "Nota do Primeiro Bimestre: "; cin >> N1;
cout << "Nota do Segundo Bimestre: "; cin >> N2;
cout << "Nota do Terceiro Bimestre: "; cin >> N3;
cout << "Nota do Quarto Bimestre: "; cin >> N4;
media = (N1+N2+N3+N4)/4;
cout << "Media final= " << media << endl;
system("Pause");
}

5.8 Exemplo 3
Construa um algoritmo que, tendo como dados de entrada as
coordenadas de dois pontos quaisquer do plano P(x1, y1) e Q(x2, y2), imprima a
distncia (d) entre eles.
Lembre-se que:

#include <iostream>
#include <math.h>
using namespace std;
int main()
{
float x1, y1, x2, y2,d;
cout << "Digite X do ponto P: "; cin >> x1;
cout << "Digite Y do ponto P: "; cin >> y1;
cout << "Digite X do ponto Q: "; cin >> x2;
cout << "Digite Y do ponto Q: "; cin >> y2;
d=sqrt(pow((x2-x1),2)+pow((y2-y1),2));
cout << "A ditancia entre pontos = " << d << endl;
system("Pause");
}

6. Formatando as sadas dos programas
O objeto cout permite estabelecer o tamanho de um campo para a
impresso. Isso significa que podemos definir o nmero de colunas que ser
ocupado por um valor ou texto a ser impresso. Em geral, a definio de tamanho
de campo usada para alinhamento e esttica de um relatrio.

( ) ( )
2
1 2
2
1 2
y y x x d + =


UNESP - FEIS
Departamento de Matemtica
32
6.1 Exemplo 4
Faa um programa que calcule o salrio lquido de um profissional que
trabalhe por hora. Para tanto, necessrio possuir alguns dados bsicos, tais
como valor da hora de trabalho, nmero de horas trabalhadas no ms e o
percentual de desconto do INSS, para que seja possvel apresentar os resultados
do valor do salrio bruto, valor de desconto e o valor do salrio liquido.
Aps o programa escrito, Entre com : 10.33, 12.5 e 6.5 e a sada deve ser:
129.125, 8.39312 e 120.732.

# include <iostream>
using namespace std;
int main(void)
{
float HT, VH, PD, TD, SB, SL;
cout << "Entre com a quantidade de horas trabalhadas.: "; cin >> HT;
cout << "Entre com o valor da hora de trabalho..............: "; cin >> VH;
cout << "Entre com o valor do percentual de desconto..: "; cin >> PD;
SB = HT * VH;
TD = (PD / 100) * SB;
SL = SB - TD;
cout << "O Salario Bruto....: " << SB << endl;
cout << "Desconto..............: " << TD << endl;
cout << "O Salario Liquido.: " << SL << endl;
system ("pause");
return 0;
}

Sada do programa:

Apesar das sadas do programa estarem certas, elas esto sem nenhum
formato. Para utilizar esses recursos, necessrio fazer a incluso do arquivo de
cabealho <iomanip>.
Para definir a quantidade de casas decimais a ser apresentada em um
fluxo de sada aps o ponto decimal, deve-se utilizar o manipulador
setprecision(), o qual possui como parmetro o nmero de casas decimais a
ser definido.
Para fixar a apresentao do ponto decimal (valor decimal), mesmo
quando o resultado for um valor de formato inteiro, deve-se fazer o uso do
manipulador setiosflag(), o qual deve-se utilizar como parmetro o sinalizador


UNESP - FEIS
Departamento de Matemtica
33
de formato (flag) ios:fixed, que direciona a sada para apresentar o ponto
decimal.
Parmetros do manipulador setiosflag():


setiosflags acionar diversos recursos de sinalizao de formatos.
resetiosflags desativar o recurso.

Assim, os manipuladores de tamanho so:

setw
Seleciona o tamanho de prximo campo a ser impresso.

setprecision
Define o nmero de casas decimais a ser impressas para um nmero em
ponto flutuante.

setfill
Seleciona o caractere que dever preencher as colunas em branco iniciais
de um campo.

setiosflags
Seleciona o modo de apresentao de um nmero (com ponto decimal,
notao cientfica etc.).



UNESP - FEIS
Departamento de Matemtica
34
6.2 Exemplo 5
Vamos reescrever o programa anterior definindo o formato da sado do
programa para duas casas decimais. Entre com : 10.33, 12.5 e 6.5 e a sada deve
ser: 129.13, 8.39 e 120.73.
#include <iostream>
#include <iomanip>
using namespace std;
int main(void)
{
float HT, VH, PD, TD, SB, SL;
cout << setprecision(2); //Fixa em duas casas decimais
cout << setiosflags(ios::right); //Tabulao a partir da direita
cout << setiosflags(ios::fixed); //Estabelece a apresentao do ponto decimal
cout << "Entre com a quantidade de horas trabalhadas.: "; cin >> HT;
cout << "Entre com o valor da hora de trabalho..............: "; cin >> VH;
cout << "Entre com o valor do percentual de desconto..: "; cin >> PD;
SB = HT * VH;
TD = (PD / 100) * SB;
SL = SB - TD;
cout << "O Salario Bruto....: " << setw(8) << SB << endl;
cout << "Desconto..............: " << setw(8) << TD << endl;
cout << "O Salario Liquido.: " << setw(8) << SL << endl;
system ("pause");
return 0;
}

Sada do programa:

Compare a sada atual com a sada do programa escrito no exemplo
anterior. A definio da largura do campo realizada pela funo setw(8).
Observe o programa abaixo que exemplifica a funo setw().
#include <iostream>
#include <iomanip>
using namespace std;
int main(void)
{
int lapis=45, borrachas=2354, cadernos=8;
cout << "Lapis " << lapis << endl;
cout << "Borrachas " << borrachas << endl;
cout << "Cadernos " << cadernos << endl;
system ("pause");
return 0;
}
Lapis 45
Borrachas 2354
Cadernos 8
Press any key to continue...


UNESP - FEIS
Departamento de Matemtica
35
Observer agora a ao da funo setw().
#include <iostream>
#include <iomanip>
using namespace std;
int main(void)
{
int lapis=45, borrachas=2354, cadernos=8;
cout << "Lapis " << setw(12)
<< lapis << endl;
cout << "Borrachas " << setw(12)
<< borrachas << endl;
cout << "Cadernos " << setw(12)
<< cadernos << endl;
system ("pause");
return 0;
}
Lapis 45
Borrachas 2354
Cadernos 8
Press any key to continue...

Observer agora a ao da funo setfill().
#include <iostream>
#include <iomanip>
using namespace std;
int main(void)
{
int lapis=45, borrachas=2354, cadernos=8;
cout << setfill('.');
cout << "Lapis " << setw(12)
<< lapis << endl;
cout << "Borrachas " << setw(12)
<< borrachas << endl;
cout << "Cadernos " << setw(12)
<< cadernos << endl;
system ("pause");
return 0;
}
Lapis ..........45
Borrachas ........2354
Cadernos ...........8
Press any key to continue...

6.3 Preciso Numrica
Diferena entre os tipos de dados com ponto flutuante. Float utiliza seis
dgitos de preciso absoluta e os tipos double e long double utilizam quinze.
# include <iostream>
#include <iomanip>
using namespace std;
int main(void)
{
float P1 = 7.0/3.0;
double P2 = 7.0/3.0;
long double P3 = 7.0/3.0;
float R1 = 10.0/9.0;
double R2 = 10.0/9.0;
long double R3 = 10.0/9.0;
2.33333
2.333333333333333
2.333333333333333

1.11111
1.111111111111111
1.111111111111111
Press any key to continue...


UNESP - FEIS
Departamento de Matemtica
36
cout << setprecision(6);
cout << P1 << endl;
cout << setprecision(15);
cout << P2 << endl;
cout << P3 << endl;
cout << endl;
cout << setprecision(6);
cout << R1 << endl;
cout << setprecision(15);
cout << R2 << endl;
cout << R3 << endl;
system ("pause");
return 0;
}

6.4 Imprimindo Caracteres Grficos
Todo o caractere (letra, dgito, pontuao etc.) representado no
computador por um nmero, o cdigo ASCII dispes de nmeros de 0 a 127
abrangendo letras, dgitos entre 0 a 9, caracteres de pontuao e caracteres de
controle como salto de linha, tabulao etc. Os computadores usam 129
caracteres adicionais, com os cdigos ASCII de 128 a 255, que consistem em
smbolos de lnguas estrangeiras e caracteres grficos.

\xdd

Onde dd representa o cdigo do caractere na base hexadecimal.
Observe o programa a seguir:
#include <iostream>
using namespace std;
int main()
{
cout << "\n\n";
//impresso do carro
cout << "\n\t\xDC\xDC\xDB\xDB\xDB\xDB\xDC\xDC";
cout << "\n\t\xDFO\xDF\xDF\xDF\xDFO\xDF";
cout <<"\n\n";
//impresso da caminhonete
cout << "\n\t\xDC\xDC\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB";
cout << "\n\t\xDFO\xDF\xDF\xDF\xDF\xDFOO\xDF";
cout <<"\n\n";
//impresso do avio
cout << "\n\t"<<" "<<"\xDB";
cout << "\n\t"<<" "<<"\xDC\xDB\xDB\xDB\xDC";
cout << "\n\t\xDB\xDB\xDF\xDB\xDF\xDB\xDB";
cout << "\n\t\xDF"<<" "<<"\xDB"<<" "<<"\xDF";
cout << "\n\t"<<" "<<"\xDC\xDF\xDB\xDF\xDC";
cout <<"\n\n";
system("Pause");
return 0;
}

Press any key to continue...



UNESP - FEIS
Departamento de Matemtica
37

7. Controle de Fluxo de Execuo - Estrutura
Condicional SE
Tambm conhecidos como comando de desvio, a estrutura condicional
SE permite que o programa decida autonomamente entre dois caminhos
possveis, qual ir executar.

Os mtodos de tomada de deciso no C++, esto presentes para as
tarefas mais corriqueiras que o programa deve executar. Alm desta forma de
controle de decises, C++ prov certas funcionalidades relacionadas a objetos
que modificam a forma como o cdigo estruturado e, por consequncia, decidem
como o programa deve se comportar em determinadas situaes. Examinemos os
mtodos bsicos e analisemos de forma simples as estruturas de deciso, para
entender como isso poder nos ajudar a tornar o cdigo mais bem construdo.
Neste contexto, precisamos definir os chamados Blocos de Comandos,
os comandos na nossa linguagem so escritos um por linhas, j um bloco de
comandos uma srie de comandos, portanto, em um bloco ou todos os
comandos so executados ou nenhum executado. Em C++ os blocos de
comandos so definidos entre chaves ({ }). Esse conceito fundamental para o
desenvolvimento de programas em C++, uma vez que o fluxo de execuo de um
programa muitas vezes se divide onde somente um dos blocos de comando
executado.

7.1 Estrutura if/else
Uma ao muito importante que o processador de qualquer computador
executa, e que o torna diferente de qualquer outra mquina, a tomada de
deciso definindo o que verdadeiro e o que falso. Se quisermos fazer um bom
programa, esse programa deve ser capaz de definir caminhos diferentes de
acordo com decises que o prprio programa toma. Para isso, precisamos de uma
estrutura seletiva da qual o nico valor possvel o bit 1 ou 0, resumindo: retornar
o valor VERDADEIRO (true) ou FALSO (false).


UNESP - FEIS
Departamento de Matemtica
38


Forma Geral do comando SE em pseudocdigos pode ser definida como:

Caso o bloco de comandos depois do seno seja vazio, esta parte pode
ser omitida. A forma geral simplificada , portanto:


Em muitas linguagens de programao, quem faz isso o "if", ou seja,
se uma dada condio for verdadeira, faa tal ao. O "else" o que chamamos
de caso contrrio, ou seja, se for falso execute o que est no ELSE.
A Ideia selecionaremos apenas uma ao ou um nico conjunto de
aes (bloco de comandos), no podendo realizar 2 condies diferentes. Assim,
a estrutura de seleo permite a escolha de um grupo de aes (bloco) a ser
executado quando determinadas condies, representadas por expresses lgicas


UNESP - FEIS
Departamento de Matemtica
39
e/ou relacionais, so satisfeitas ou no. Os tipos de seleo so: Simples,
Composta, Encadeada e Mltipla Escolha.

Seleo Simples: Quando precisamos testar 01 condio antes de
executar uma ao. Ocorre somente se a condio for VERDADEIRA.
if (condio)
{
Declarao;
}
Neste caso o bloco de comandos executado somente se a condio for
verdadeira, caso contrrio o algoritmo prossegue normalmente.


Seleo Composta: Utilizadas em situaes em que duas alternativas
dependem de uma mesma condio, uma da condio VERDADEIRA, e outra da
condio FALSA.
if (condio)
{
declarao 1;
}
else
{
declarao 2;
}

Exemplo de Comando SE.


UNESP - FEIS
Departamento de Matemtica
40

Sequncia de aes:

Exemplo de Algoritmos







UNESP - FEIS
Departamento de Matemtica
41
Comandos Aninhados: As duas formas do comando SE podem aparecer
dentro de outros comandos SE. Diz-se que o comando SE interno est aninhado
no comando SE externo.
if(condio)
{
if(condio)
{
declarao 1;
}
}


Observe as seguintes construes:

ou


As duas construes so equivalentes. Ento, quando usar comandos
aninhados?
A resposta a essa pergunta simples, pois utilizamos os comandos
aninhados quando tivermos que executar blocos de comandos diferentes para a
clusula seno (else) das duas condies, observe o exemplo:





O fim se estar relacionado com
o se mais prximo.


UNESP - FEIS
Departamento de Matemtica
42
Como construir sem aninhamento
Exemplo anterior Sem aninhamento


7.2 Exemplo 6
Uma empresa vai dar um abono aos empregados que tenham mais de 1
ano de casa:10% para os que tenham menos de 10 anos e 25% para os demais.
Calcule o abono de um dado funcionrio, dado o seu salrio e o tempo de casa.


O algoritmo acima em C++ ser:
#include <iostream>
using namespace std;
int main(void)
{
float tempo, salario;
cout << "Entre com o salario: ";
cin >> salario;
cout << "Entre com o tempo de servico: ";
cin >> tempo;
if(tempo>1)
if(tempo <10)
salario=1.1*salario;
else
salario=1.25*salario;


UNESP - FEIS
Departamento de Matemtica
43
cout << " Salario com abono = "<< salario << endl;
system ("pause");
return 0;
}

Seleo Composta: o agrupamento de vrias selees, ocorre quanto
uma determinada ao, ou bloco deve ser executado se um grande conjunto de
possibilidades ou combinaes de situaes for satisfeito.

if(condio 1)
{
declarao1;
}
else if(condio 2)
{
declarao 2;
}
...
else if(condio (N-1))
{
declarao (N-1)
}
else
{
declarao N;
}

Observe que podemos criar um programa com quantas condies
desejarmos, restringindo a cada condio, uma ao ou um conjunto de aes.
Um dos erros mais comuns criar condies redundantes, como mostra o
seguinte exemplo:

Elabore um programa que diga qual ao, ou aes foram escolhidas:
a) Ao 1: caso o nmero seja maior ou igual a 2.
b) Ao 2: caso o nmero seja maior que 1.
c) Ao 3: caso no seja satisfeita nenhuma condio.

cin>>a;
if (a>=2)
{
cout<<"Ao 1 escolhida"<<endl;
}
else if (a>1)
{
cout<<" Ao 2 escolhida"<<endl;
}
else
{
cout<<" Ao 3 escolhida"<<endl;
}


UNESP - FEIS
Departamento de Matemtica
44

Observe que o erro encontra-se no uso do "else if, com ele, exclumos
possibilidades possveis de respostas. Por exemplo, se a varivel a=3, o
compilador nos dar como sada apenas a primeira condio ("Ao 1
escolhida), onde na verdade temos duas respostas, pois satisfaz a ao 1 e 2
simultaneamente.
Se substituirmos o if no lugar do else if, o compilador nos dar as 2
respostas possveis ("Ao 1 escolhida e "Ao 2 escolhida), com isso,
corrigiramos o problema da redundncia do nosso exemplo. Com o uso apenas
do if e do else possvel que compilador execute vrias condies que ocorram
simultaneamente.

7.3 Estrutura switch/ Escolha (caso selecione)
Textualmente conhecida como alternativa de mltiplas escolhas, uma
alternativa para os SES aninhados, deixando o algoritmo com uma estrutura
melhor.


Quando um conjunto de valores discretos precisa ser testado e aes
diferentes so associadas a esses valores, pode-se utilizar a seleo de mltipla
escolha (switch). O objetivo testar vrios valores constantes possveis para uma
expresso, semelhante seleo composta. Ou seja, quase que um if com
vrias possibilidades, mas com algumas diferenas importantes:
Primeira diferena: Os cases no aceitam operadores lgicos. Portanto,
no possvel fazer uma comparao. Isso limita o case a apenas valores
definidos.


UNESP - FEIS
Departamento de Matemtica
45
Segunda diferena: O switch executa seu bloco em cascata. Ou seja, se
a varivel indicar para o primeiro case e dentro do switch tiver 5 cases, o
switch executar todos os outros 4 cases a no ser que utilizemos o comando
para sair do switch ( ao break).
A estrutura avalia a expresso e verifica se ela equivalente
constante1, se for, ala executa o grupo de instrues do caso 1, at encontrar a
instruo break. Quando se encontra com a instruo break, o programa salta
para o final da estrutura switch.
switch (expresso)
{
case constante1:
grupo de instrues 1;
break;
case constante2:
grupo de instrues 2;
break;
...
default:
grupo de instrues default
}

A instruo default, do ingls padro, o case que ativado caso no
tenha achado nenhum case definido. Ou seja, o que aconteceria em ltimo caso.
Vamos imaginar o seguinte cenrio: Seu programa pede para que o usurio digite
apenas duas opes (S ou N) para reiniciar o programa. Mas, propositalmente ou
por engano, o usurio digita uma opo totalmente diferente. E agora? O que seu
programa deve fazer? aqui que o default entra. Geralmente o default quando
previsto um erro, uma entrada de dado incorreta ou no de acordo com o
contexto. O default tem seu papel parecido com o else, da estrutura if/else,
caso nenhuma condio for feita, far os comandos definidos no default.

A maior utiliza dessa estrutura encontra-se na construo de MENUS,
fornece uma viso esclarecedora das opes do programa, mostra efetivamente a
estrutura do menu onde cada ramificao pode ser uma opo do menu.

7.4 Exemplo 7
Construa um programa que dado o tipo gentico (de 1 a 8) de
determinada espcie animal, seja capaz de classificar a sua regio de procedncia
de acordo com a tabela abaixo.
Tipo gentico Procedncia
1 Sul
2 Norte
3 Leste
4 a 7 Oeste
Caso contrrio Extica


UNESP - FEIS
Departamento de Matemtica
46

#include <iostream>
using namespace std;
int main()
{
int gene;
cout << "Digite o tipo Genetico: ";
cin >> gene;
switch (gene)
{
case 1: cout<< "Regiao Sul\n";
break;
case 2: cout<< "Regiao Norte\n";
break;
case 3: cout<< "Regiao Leste\n";
break;
case 4:
case 5:
case 6:
case 7: cout<< "Regiao Oeste\n";
break;
default: cout << "Exotica\n";
}
system("Pause");
}

7.5 Exemplo 8
Dados dois nmeros reais quaisquer, desenvolva um programa que diga
se eles so iguais ou diferentes.

#include <iostream>
using namespace std;
int main()
{
float a,b;
cout << "digite o primeiro numero: "; cin >> a;
cout << "digite o segundo numero: "; cin >> b;
if (b==a)
cout<<"Os nmeros digitados sao iguais"<<endl;
else
cout<<"Os numeros digitados sao diferentes"<<endl;
system("Pause");
}


7.6 Exemplo 9
Dado um nmero qualquer, determinar se este neutro, positivo ou
negativo.
#include <iostream>
using namespace std;
int main()
{
float a;


UNESP - FEIS
Departamento de Matemtica
47
cout << "digite o numero: ";
cin >> a;
if (a==0)
cout << "O nmero digitado e nulo" << endl;
else if (a>0)
cout << "O nmero digitado e positivo" << endl;
else
cout << "O nmero digitado e negativo" << endl;
system("Pause");
}


7.7 Exemplo 10
Elabore um programa que identifique se um nmero inteiro digitado par,
impar ou nulo.
#include <iostream>
using namespace std;
int main()
{
int n;
cout << "digite o numero: ";
cin >> n;
if (n%2==0)
{
if(n==0)
{
cout << "nulo" << endl;
}
else
{
cout << "par" << endl;
}
}
else
{
cout<<"impar"<<endl;
}
system("Pause");
}



UNESP - FEIS
Departamento de Matemtica
48
8. Laos
Laos so comandos usados sempre que uma ou mais instrues devam
ser repetidas enquanto uma certa condio estiver sendo satisfeita.
Em C++ existem trs comandos de laos:
for
while
do-while

8.1 O lao for (para)
O lao for em gral usando quando queremos repetir algo um nmero
fixo de vezes. Isso significa que utilizamos um lao for quando sabemos de
antemo o numero de vezes a repetir. O exemplo seguinte imprime uma linha com
20 asteriscos (*) utilizando um lao for na sua forma mais simples.
#include <iostream>
using namespace std;
int main()
{
int i;
for(i=0; i < 20; i++ )
cout << '*';
cout << endl;
system ("PAUSE");
return 0;
}
********************
Press any key to continue...
A sintaxe consiste na palavra-chave for seguida de parnteses que
contm trs expresses separadas por ponto-e-vrgula. Chamaremos a primeira
dessas expresses de inicializao, a segunda de teste e a terceira de
incremento. Qualquer uma das trs pode conter qualquer instrues em C++.
Em sua forma mais simples, a inicializao uma instruo de atribuio
(i = 0) e sempre executada uma nica vez, antes que o lao seja iniciado.
O teste uma condio avaliada como verdadeira ou falsa e controla o
lao (i < 20). Essa expresso avaliada toda vez que o lao iniciado ou
reiniciado. Se verdadeira (diferente de zero), a instruo do corpo do lao
executada (cout << '*'). Quando o teste torna-se falso (igual a zero), o lao
encerrado e o controle passa para a instruo seguinte ao lao.
O incremento geralmente define a maneira pela qual a varivel de controle
ser alterada cada vez que o lao for repetido (i++ o mesmo que i=i+1). Essa
expresso executada sempre, logo aps a execuo do corpo do lao.









UNESP - FEIS
Departamento de Matemtica
49







for(i=0; i < 20; i++ )
{
cout << '*';
}


No nosso exemplo, o lao for executado 20 vezes. Na primeira vez, a
inicializao assegura que i vale zero. Na ltima vez, i vale 19; a informao
dada no teste (i<20). Em seguida, i passa a valer 20 e o lao termina. O corpo
do lao no executado quando i vale 20.

O programa abaixo escreve os nmeros e 1 a 5.
#include <iostream>
using namespace std;
int main()
{
int i;
for (i = 1; i <= 5; i++)
cout << i;
cout << endl;
system ("PAUSE");
return 0;
}
12345
Press any key to continue...

O programa abaixo a mesma operao que o anterior, entretanto, observe
o incremento.
#include <iostream>
using namespace std;
int main()
{
int i;
for (i = 1; i <= 5; i=i+1)
cout << i;
cout << endl;
system ("PAUSE");
return 0;
}
12345
Press any key to continue...



Inicializao
Ponto-e-vrgula
Incremento Teste
No tem Ponto-e-vrgula aqui
Corpo do lao


UNESP - FEIS
Departamento de Matemtica
50
O mesmo raciocnio pode ser empregado nas instrues abaixo.


O incremento/decremento poder ser realizado em mais de uma unidade,
observe os trechos de cdigo abaixo:


Observe e analise o programa que imprime a tabuada do 6.
#include <iostream>
using namespace std;
int main()
{
int i;
for(i=1; i<10; i++)
cout << '\n' << i << "x6= " << (i*6);
cout << endl;
system ("PAUSE");
return 0;
}

1x6=6
2x6=12
3x6=18
4x6=24
5x6=30
6x6=36
7x6=42
8x6=48
9x6=54

Press any key to continue...





UNESP - FEIS
Departamento de Matemtica
51
Vamos modificar o programa anterior para que a tabuada do 6 seja
impressa de forma invertida.
#include <iostream>
using namespace std;
int main()
{
for(int i=9; i>0; i--)
cout << '\n' << i << "x6= " << (i*6);
cout << endl;
system ("PAUSE");
return 0;
}

9x6=54
8x6=48
7x6=42
6x6=36
5x6=30
4x6=24
3x6=18
2x6=12
1x6=6

Press any key to continue...

Observe que a varivel i foi declarada no interior da expresso da
inicializao do lao for do programa anterior. Essa construo bastante
comum em C++, pois, geralmente, declaramos as variveis to prximo quando
possvel do pondo onde elas sero usadas.
#include <iostream>
using namespace std;
int main()
{
for(int i=9; i>0; i--)
cout << '\n' << i << "x6= " << (i*6);
cout << endl;
system ("PAUSE");
return 0;
}

9x6=54
8x6=48
7x6=42
6x6=36
5x6=30
4x6=24
3x6=18
2x6=12
1x6=6

Press any key to continue...
Se um lao for deve executar vrias instrues a cada iterao, elas
devem estar entre chaves:
for(i=0; i<10; i++)
{
Instruo ;
Instruo ;
Instruo ;
}

Como dito anteriormente, em C++ um bloco de cdigo uma srie de
instrues entre chaves e tratado como um grupo de instrues em uma nica
unidade. Isso significa que um bloco de cdigo tratado como uma nica
instruo.
#include <iostream>
using namespace std;


UNESP - FEIS
Departamento de Matemtica
52
int main() // Incio;
{
float soma=0.0;
const int max=10;
for(int i =0; i< max; i++)
{
cout << "\nDigite a nota " << (i+1) <<" : ";
float nota;
cin >> nota;
soma+=nota;//soma=soma+nota;
}
cout << "\nMedia = " << (soma/max) << endl;
system("Pause");
return(0);
}

Um aspecto importante dos blocos de cdigo o de que uma varivel
declarada dentro de um bloco no visvel fora dele. Ou seja, no programa
anterior, declaramos a varivel nota dentro do bloco do cdigo do lao for. Essa
varivel s poder se acessada pelas instrues desse mesmo bloco e que esto
aps a sua declarao.

8.2 Exemplo 11
Faa um programa que leia o nmero de termos, determine e mostre os
valores de acordo com a srie a seguir:

Dica:

#include <iostream>
using namespace std;
int main()
{
int i, num_termos=0, num1=2, num2=7, num3=3;
cout << "Entre com o numero de termos da serie: ";
cin >> num_termos;
cout << num1 << endl << num2 << endl << num3 <<endl;
for (i=4; i<=num_termos; i++)
{
num1 = num1*2;
cout << num1 <<endl;
i=i+1;
if (i!=num_termos)
{
num2 = num2*3;


UNESP - FEIS
Departamento de Matemtica
53
cout << num2 <<endl;
i = i+1;
if (i!=num_termos)
{
num3 = num3*4;
cout << num3 <<endl;
i = i+1;
}
}
}
system("PAUSE");
return EXIT_SUCCESS;
}

8.3 O lao while (enquanto)
O segundo comando de lao em C++ o while (do ingls que significa
enquanto). primeira vista, o lao parece simples se comparado ao lao for,
utiliza os mesmo elementos, mas eles so distribudos de maneira diferentes no
programa. Utilizamos o lao while quando o lao pode ser terminado
inesperadamente, por condio desenvolvida dentro do corpo do lao.
Trata-se de uma estrutura de repetio que pode ser utilizada quando o
nmero de repeties necessrias no fixo.
Assim, os comandos sero repetidos at a condio assumir o valor falso.
Nesse tipo de estrutura, o teste condicional ocorre no incio. Isto significa que
existe a possibilidade da repetio no ser executada quando a condio assumir
valor falso logo na primeira verificao.
O comando while consiste na palavra-chave while seguida de uma
expresso de teste entre parnteses. Se a expresso de teste for verdadeira, o
corpo do lao while executado uma vez, e a expresso de teste vlida
novamente. Esse ciclo de teste e execuo repetido at que a expresso de
teste se torne falsa, ento, o lao termina e o controle do programa passa para a
linha seguinte ao lao.
O corpo de um while pode ter uma nica instruo terminada por um
ponto-e-vrgula, vrias instrues entre chaves ou ainda uma nenhuma instruo
mantendo o ponto-e-vrgula.
Em geral, um lao while pode substituir um lao for da seguinte
maneira em um programa:
Inicializao;
while( Teste)
{
.
.
Incremento;
.
}


UNESP - FEIS
Departamento de Matemtica
54

Em geral, um lao while pode substituir um lao for da seguinte
maneira em um programa:
#include <iostream>
using namespace std;
int main()
{
int i=0; //Incicializao
while(i < 20) //Teste
{
cout << '*';
i++; //Incremento
}
cout << endl;
system ("PAUSE");
return 0;
}
********************
Press any key to continue...

Em situao em que o nmero de iteraes conhecido o lao for a
escolha mais natural. Enquanto a condio for verdadeira, os comandos que esto
dentro das chaves sero executados, observe o programa abaixo:
#include <iostream>
using namespace std;
int main ()
{
int X = 0;
while (X != 5)
{
cout << "Valor de X = " << X << endl;
X = X+1;
}
cout<<"X depois de sair do while = " << X;
cout << endl;
system("Pause");
return 0;
}
Valor de X = 0
Valor de X = 1
Valor de X = 2
Valor de X = 3
Valor de X = 4
X depois de sair do while = 5
Press any key to continue...
Neste programa, os comandos cout << "Valor de X = " << X; e X
= X+1; sero executados 5 vezes. O teste condicional avaliar X valendo 0,1, 2,
3, 4 e 5.



UNESP - FEIS
Departamento de Matemtica
55
Observe o programa abaixo:
#include <iostream>
using namespace std;
int main ()
{
int X = 1, Y=10;
while (Y > X)
{
cout << "Valor de Y = " << Y << endl;
Y = Y-2;
}
cout<<"Y depois de sair do while = " << Y;
cout << endl;
system("Pause");
return 0;
}
Valor de Y = 10
Valor de Y = 8
Valor de Y = 6
Valor de Y = 4
Valor de Y = 2
X depois de sair do while = 0
Press any key to continue...
Neste programa, os comandos cout << "Valor de Y = " << Y; e Y
= Y-2; sero executados 5 vezes. O teste condicional avaliar Y valendo 10, 8, 6,
4, 2 e 0.



Analise a estrutura abaixo:
#include <iostream>
using namespace std;
int main ()
{
int n;
cout << "Digite o numero inicial: ";
cin >> n;
while(n>0)
{
cout << n << ", ";
n--;
}
cout << "FOGO!\n";
system("Pause");
return 0;
}
"Digite o numero inicial: 7
7, 6, 5, 4, 3, 2, 1, FOGO!
Press any key to continue...


UNESP - FEIS
Departamento de Matemtica
56
Quando criamos um lao do tipo while, devemos sempre considerar que
ele deve terminar em algum momento. Entretanto, devemos fornecer dentro do
bloco algum mtodo para forar a condio se tornar falsa em algum ponto. Por
outro lado, o loop continuar para sempre. No Programa anterior, inclumos a
instruo n--; que decrementa a varivel que avaliada no teste em um (n--
equivale a n=n-1) e torna a condio (n>0) falsa depois de um nmero de
iteraes (loops). Assim, quando n torna-se 0, quando o nosso while e a nossa
contagem termine.

Analise o exemplo:
#include <iostream>
using namespace std;
int main ()
{
int X = 1, Y=1;
while (X < Y)
{
cout << "Valor de X = " << X << endl;
X = X+1;
}
cout<<"Acabou o while";
cout << endl;
system("Pause");
return 0;
}
Acabou o while
Press any key to continue...
No trecho de programa acima, os comandos cout << "Valor de X =
" << X; e X=X+1; no sero executados, pois, para os valores iniciais de X e Y
a condio falsa, logo, no ocorrer a entrada na estrutura de repetio para
execuo de seus comandos.

Agora, observe um exemplo de lao infinito:
#include <iostream>
using namespace std;
int main ()
{
int X = 1, Y=1;
while (X <= Y)
{
cout << "Valor de X = " << X << endl;
}
cout<<"Acabou o while";
cout << endl;
system("Pause");
return 0;
}
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
No trecho de programa acima, o comando cout << "Valor de X = "
<< X; e executados infinitamente, pois o valor de X ou Y no modificado em
nenhum momento do meu programa, no contrariando a condio do lao,
tornando-o um lao infinito.



UNESP - FEIS
Departamento de Matemtica
57
8.4 O lao do-while (repetir)
Este o terceiro e ltimo comando de lao em C++. Este bastante
similar ao lao while e utilizado em situaes em que necessrio executar o
corpo do lao uma primeira vez e depois avaliar a expresso de teste e criar um
ciclo repetido. Trata-se de uma estrutura de repetio que pode ser utilizada
quando o nmero de repeties necessrias no fixo. Os comandos sero
repetidos at a condio assumir o valor falso.
A sintaxe do lao do-while :
Inicializao;
do
{
.
.
Incremento;
.
}while(Teste);

O comando do-while consiste na palavra-chave do seguida de um bloco
de uma ou mais instrues entre chaves e termina pela palavra-chave while
seguida de uma expresso de teste entre parnteses terminada por um ponto-e-
vrgula.
Primeiro, o bloco de cdigo executado; em seguida, a expresso de
teste entre parnteses avaliada; se verdadeira, o corpo do lao mais uma vez
executado e a expresso de teste avaliada novamente. O ciclo de execuo do
bloco e teste repetido at que a expresso se torne falsa (igual a zero), ento o
lao termina e o controle do programa passa para a linha seguinte ao lao.

Observe o exemplo abaixo:
#include <iostream>
using namespace std;
int main ()
{
int X = 0;
do
{
cout << "\nValor de X = " << X;
X = X+1;
}while (X != 5);
cout << "\nX depois de sair do repetir" << X;
cout << endl;
system("Pause");
return 0;
}

Valor de X = 0
Valor de X = 1
Valor de X = 2
Valor de X = 3
Valor de X = 4
X depois de sair do repetir = 5
Press any key to continue...
No trecho de programa acima, o comando cout << "Valor de X = "
<< X; e X=X+1; sero executados 5 vezes. O teste condicional avaliar X valendo
0,1, 2, 3, 4 e 5.


UNESP - FEIS
Departamento de Matemtica
58


Observe o exemplo abaixo:
#include <iostream>
using namespace std;
int main ()
{
int X = 1, Y=10;
do
{
cout << "\nValor de Y = " << Y;
Y = Y-1;
}while (Y > X);
cout << "\nY depois que sair do repetir = " << Y;
cout << endl;
system("Pause");
return 0;
}

Valor de Y = 10
Valor de Y = 8
Valor de Y = 6
Valor de Y = 4
Valor de Y = 2
X depois de sair do while = 0
Press any key to continue...
No trecho de programa acima, os comandos cout << Valor de Y =
<< Y; e Y = Y-2; sero executados 5 vezes. O teste condicional avaliar Y
valendo 10, 8, 6, 4, 2 e 0.





Analise o exemplo:


UNESP - FEIS
Departamento de Matemtica
59
#include <iostream>
using namespace std;
int main ()
{
int X = 1, Y=1;
do
{
cout << "Valor de X = " << X << endl;
X = X+1;
} while (X < Y);
cout<<"Acabou o repetir";
cout << endl;
system("Pause");
return 0;
}
Valor de X = 1
Acabou o repetir
Press any key to continue...
No trecho de programa acima, os comandos cout << "Valor de X =
" << X; e X=X+1; sero executados 1 vez independente da condio ser falsa,
pois os valores iniciais de X e Y sero verificados no final da estrutura.

Agora, observe um exemplo de lao infinito:
#include <iostream>
using namespace std;
int main ()
{
int X = 1, Y=1;
do
{
cout << "Valor de X = " << X << endl;
} while (X <= Y);
cout<<"Acabou o repetir";
cout << endl;
system("Pause");
return 0;
}
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
Valor de X = 1
No trecho de programa acima, o comando cout << "Valor de X = "
<< X; e executados infinitamente, pois os valores de X ou Y no so modificados
em nenhum momento do lao de repetio, no contrariando a condio do lao,
tornando-o um lao infinito.

8.5 Exemplo 12
Elabore um programa que calcule o fatorial de um nmero dado.
#include <iostream>
using namespace std;
int main()
{
int n;
cout << "digite o numero: ";
cin >> n;
int fat=1;
for(int i=1; i<=n; i++)
fat=fat*i;


UNESP - FEIS
Departamento de Matemtica
60
cout << fat << endl;
system("Pause");
return 0;
}

8.6 Exemplo 13
Elabore um programa que imprima os termos da serie abaixo, o programa
deve parar o processamento quando for impresso um termo negativo.
15, 30, 60, 12, 24, 48, 9, 18, 36, 6, 12, 24, ...
#include <iostream>
using namespace std;
int main()
{
int i, j, n;
for(j=15; j>0; j-=3)
{
i=0;
n=j;
while(i<3)
{
cout<<n<<"\t";
n=n+n;
i++;
}
}
cout<<endl;
system("Pause");
return 0;
}

8.7 Exemplo 14
Faa um programa que analise se o nmero k, fornecido pelo usurio
maior que o numero n, tambm fornecido pelo usurio, se isso for verdadeiro, e
imprima todos os valores de k a n, se k for igual a n calcule o fatorial de k, e caso k
for menor que n, apenas informe ao usurio. Ao final do programa, faa uma
pergunta se o usurio quer informar novamente os valores de k e n, para o
programa executar mais uma vez.
#include <iostream>
using namespace std;
int main()
{
int k, n;
char r;

do
{


UNESP - FEIS
Departamento de Matemtica
61
cout<<"Digite o valor de k: ";
cin>>k;
cout<<"Digite o valor de n: ";
cin>>n;
if(k>n)
for(int i=k; i>=n; i--)
cout << i << endl;
else if(k==n)
{
int fat=1;
for(int i=1; i<=k; i++)
fat=fat*i;
cout << "Fatorial de " << k;
cout << " = " << fat << endl;
}
else
cout << "k e menor do que n" << endl;
cout<<"Deseja digidar dois numeros novamente (s/n): ";
cin>>r;
}while(r=='s');
system("Pause");
return 0;
}

9. Modularizao

9.1 Introduo e Histrico
No fim da dcada de 60, alguns problemas no desenvolvimento de
sistemas de programao levaram os pases desenvolvidos a um evento chamado
"crise de software".
Os custos das atividades de programao mostravam a cada ano uma
clara tendncia a se elevarem muito em relao aos custos dos equipamentos, e
isto era devido ao avano tecnolgico na fabricao dos equipamentos de
computao e a lenta evoluo de tcnicas aplicadas ao desenvolvimento de
software. A ausncia de uma metodologia para a construo de programas
conduzia a programas geralmente cheios de erros e com altos custos de
desenvolvimento que, consequentemente, exigiam custos elevados para a sua
correo e manuteno futuras.
A programao estruturada foi o resultado de uma serie de estudos e
propostas de metodologias para desenvolvimento de software. Uma das tcnicas
aplicadas na programao estruturada, a modularizao de programas e uma
ferramenta para a elaborao de programas visando, os aspectos de
confiabilidade, legibilidade, manutenibilidade e flexibilidade, dentre outros.
A modularizao e um processo que aborda os aspectos da
decomposio de algoritmos em mdulos. Mdulo e um grupo de comandos,
constituindo um trecho do algoritmo, com uma funo bem definida e o mais
independente possvel em relao ao resto do algoritmo.


UNESP - FEIS
Departamento de Matemtica
62

9.2 Modularizao em pseudocdigo
Seja um algoritmo para calcular o salrio liquido de um empregado, com
as seguintes etapas:

incio
Leia os dados do empregado
Determine o salrio
Escreva o salrio
fim.

Onde "Determine o salrio" pode ser refinado como:
Calcule as vantagens
Calcule as dedues

SALARIOLIQ VANTAGENS DEDUCOES

No refinamento sem modularizao no houve preocupao de como o
processo de clculo das vantagens e dedues seria efetuado. Essas aes
constituem funes bem definidas e que sero executadas por mdulos
especficos, neste caso, o algoritmo anterior ficaria:
incio
Leia os dados do empregado
Ative o mdulo "Calculo das vantagens"
Ative o mdulo "Calculo das dedues"
SALARIOLIQ VANTAGENS DEDUCOES
Escreva o salrio
fim.

Exemplo da descrio estrutural da modularizao:

Mdulo Principal
Mdulo Vantagens Mdulo Dedues




UNESP - FEIS
Departamento de Matemtica
63
A maneira mais intuitiva de proceder a modularizao de problemas e feita
definindo um mdulo principal de controle e mdulos especficos para as
funes do algoritmo.
Recomenda-se que os mdulos de um programa tenham um tamanho
limitado, pois mdulos muito grandes so difceis de ser compreendidos e, em
geral, so multifuncionais.

LEMA :
"Dividir para conquistar"
Nunca divida de menos e nunca divida de mais

As linguagens de programao dispem de recursos que facilitam a
construo e manipulao de mdulos, permitindo no s a modularizao dos
comandos do programa, como tambm dos dados utilizados. Cada mdulo pode
definir as prprias estruturas de dados, suficientes e necessrias apenas para
atingir o objetivo final do mdulo. Todo mdulo e constitudo por uma sequncia
de comandos que operam sobre um conjunto de objetos, que podem ser globais
ou locais.
Objetos globais so entidades que podem ser usadas em mdulos
internos a outro modulo do algoritmo onde foram declaradas.
Objetos locais so entidades que s podem ser usadas no mdulo do
algoritmo onde foram declaradas. Estes objetos no possuem nenhum
significado fora deste mdulo.
So exemplos de objetos globais ou locais: variveis, arquivos, outros
mdulos, etc.
A comunicao entre mdulos devera ser feita atravs de vnculos,
utilizando-se objetos globais ou transferncia de parmetros.

Os benefcios da modularizao so que a independncia do mdulo
permite uma manuteno mais simples e evita efeitos colaterais no restante do
algoritmo.
A elaborao do modulo pode ser feita independentemente e em pocas
diferentes do restante do algoritmo;
Testes e correes dos mdulos podem ser feitos separados;
Um mdulo pode ser utilizado em outros algoritmos que requeiram o
mesmo processamento por ele executado.

9.3 Ferramentas
Sub-rotinas e funes so mdulos que servem aos objetivos:

Evitar que em certa sequncia de comandos necessria em vrios locais
de um algoritmo tenha que ser escrita repetidamente nesses locais;
Dividir e estruturar um algoritmo em partes fechadas e logicamente
coerentes;
Aumentar a legibilidade de um algoritmo.


UNESP - FEIS
Departamento de Matemtica
64

Sub-rotinas e funes so mdulos hierarquicamente subordinados a um
algoritmo, comumente chamado de mdulo principal. Da mesma forma uma sub-
rotina ou uma funo pode conter outras sub-rotinas e funes aninhadas.
A sub-rotina e a funo so criadas atravs das suas declaraes em
um algoritmo e para serem executadas, necessitam de ativao por um comando
de chamada. A declarao de uma sub-rotina ou funo e constituda de um
cabealho, que a identifica e contem seu nome e uma lista de parmetros
formais, e de um corpo que contem declaraes locais e os comandos.

Sub-rotinas
Criao de sub-rotina:

subrotina NOME (lista-de-parmetros-formais)
declaraes dos objetos locais a sub-rotina
comandos da sub-rotina
fim subrotina;

Chamada da sub-rotina:
NOME (lista-de-parmetros-atuais);

Funes
As funes tm a caracterstica de retornar ao algoritmo que as chamou
um valor associado ao nome da funo.

- Criao de funo:

funo tipo NOME (lista-de-parmetros-formais)
declaraes dos objetos locais a funo
comandos da funo
retorno valor
fim funo;

- Chamada da funo:
NOME (lista-de-parmetros-atuais);

Como esta funo ira retornar (retorno) um valor, este pode ser atribudo
a alguma varivel, contanto que esta seja de tipo compatvel.

A NOME (lista-de-parmetros-atuais);

Ao terminar a execuo dos comandos de uma sub-rotina ou funo, o
fluxo de controle retorna ao comando seguinte quele que provocou a chamada.



UNESP - FEIS
Departamento de Matemtica
65
9.4 Transferncia de Parmetros
Os parmetros de uma sub-rotina ou funo classificam-se em:

de entrada so aqueles que tm seus valores estabelecidos fora da
sub-rotina ou funo e no podem ser modificados dentro dela.
de sada so aqueles que tm seus valores estabelecidos dentro da
sub-rotina ou funo.
de entrada-sada so aqueles que tm seus valores estabelecidos fora
da sub-rotina ou funo, mas podem ter seus valores alterados dentro
dela.

A vinculao entre mdulos pode ser feita atravs da transferncia ou
passagem de parmetros, que associam parmetros atuais (argumentos) com
parmetros formais. Dentre os modos de transferncia de parmetros, pode se
destacar: a passagem por valor, a passagem por resultado e a passagem por
referencia.
Na passagem de parmetros por valor, as alteraes feitas nos
parmetros formais, dentro da sub-rotina ou funo, no se refletem nos
parmetros atuais. O valor do parmetro atual e copiado no parmetro formal, na
chamada da sub-rotina ou funo. Assim, quando a passagem e por valor significa
que o parmetro e de entrada.
Na passagem de parmetros por resultado, as alteraes feitas nos
parmetros formais, na sub-rotina ou funo, refletem-se nos parmetros atuais. O
valor do parmetro formal copiado no parmetro atual, ao retornar da sub-rotina
ou funo. Assim, quando a passagem e por resultado significa que o parmetro
e de sada.
Na passagem de parmetros por referencia, a toda alterao feita num
parmetro formal corresponde a mesma alterao feita no seu parmetro atual
associado. Neste caso, quando a passagem e por valor significa que o parmetro
e de entrada-sada.
Exemplo: Leia um nmero inteiro e escreva o seu fatorial. Lembrando que
o fatorial de um nmero e o produto de todos os nmeros anteriores e inclusive
ele.
5! = 1*2*3*4*5 = 120
0! = 1 (por definio)

Pseudocdigo sem modularizao:
Inicio
{declarao de variveis}
inteiro N, fat = 1, cont
{comandos de entrada de dados}
leia (N)
{processo e sada de dados}
para cont 1 at N faa
fat fat * cont


UNESP - FEIS
Departamento de Matemtica
66
fim-para
{comandos de sada de dados}
escreva(fat)
fim.


Pseudocdigo com modularizao:


































9.5 Modularizao em Sub-Rotinas

Sub-rotinas, tambm chamada de subprogramas, so blocos de
instrues que realizam tarefas especificas. O cdigo de uma sub-rotina


UNESP - FEIS
Departamento de Matemtica
67
carregado uma vez e pode ser executado quantas vezes forem necessrias. As
principais vantagens da utilizao se sub-Rotinas so que como o problema pode
ser subdividido em pequenas tarefas, os programas tendem a ficar menores e
mais organizados.
Os programas em geral so executados linearmente, uma linha aps a
outra, at o fim. Entretanto, quando so utilizadas sub-rotinas, possvel a
realizao de desvios na execuo dos programas.

Sintaxe:
funo nome ()
entradas: nono, nonono[], nono, ...
sadas: nono, nonono, nono[], ...)
inicio
{ comandos }
nome ...
fim

O exemplo abaixo mostra a utilizao de uma sub-rotina que recebe um
parmetro (o valor atual do salrio) e que, ao final, retorna um valor (aumento
que ser dado ao salrio) para quem a chamou. Porm, as sub-rotinas podem
no receber parmetros nem retornar valor.

















9.6 Modularizao em C++ - Funes

Um programa em C/C++ tem no mnimo uma funo de chamada main,
por onde a execuo comea. Existem as funes pr-definidas pelo compilador,
que so includas pela diretiva #include.
ALGORITMO
DECLARE sal NUMERICO
LEIA sal
aum calculo(sal)
novosal sal + aum
ESCREVA "Novo salrio ", novosal
FIM_ALGORITMO


SUB-ROTINA calculo (sal NUMERICO)
DECLARE perc, valor NUMERICO
LEIA perc
Valor sal * perc / 100
RETORNE valor
FIM_SUB_ROTINA
Variveis Globais
Variveis Locais
Programa Principal
Sub-Rotina


UNESP - FEIS
Departamento de Matemtica
68
Uma funo um conjunto de instrues desenhadas para cumprir
determinado trabalho e agrupadas em uma unidade com um nome para referi-la.
Vamos comear mostrando uma funo que converte a temperatura de graus
Fahrenheit para Celsius.

#include <iostream>
using namespace std;
int celsius(int fahr); // prottipo
int main()
{
int c, f;
cout << "Digite a temperatura em graus Fahrenheit: ";
cin >> f;

c = celsius(f); // chamada funo

cout << "Celsius = " << c << endl;

system("PAUSE");
return 0;
}

int celsius(int fahr) // definio da funo
{
int c;
c=(fahr-32)*5/9;
return c;
}

Como podemos identificar, a estrutura de uma funo C++ semelhante
da funo main(). A diferena que a main() possui um nome especial. Os
componentes necessrios para adicionar uma funo a um programa so: o
prottipo da funo, a chamada da funo e a sua definio. Uma funo no
pode ser chamada antes de ter sido declarada, sua declarao dita prottipo da
funo, uma instruo colocada no incio do programa (vide exemplo anterior),
permitindo que o compilador verifique a sintaxe de sua chamada. Assim, a linha de
cdigo:

int celsius(int fahr); // prottipo

informa que a funo de nome celsius() do tipo int e recebe como argumento
um valor int que ser armazenado na varivel fahr.

Em C++ as funes podero ser escritas antes de sua instruo de
chamada, nesse caso, seu prottipo no ser obrigatrio assim, nosso exemplo
anterior poderia ser escrito da seguinte maneira, sem a necessidade de definirmos
o prottipo da funo no incio do programa:

#include <iostream>
using namespace std;


UNESP - FEIS
Departamento de Matemtica
69
int celsius(int fahr)
{
int c;
c=(fahr-32)*5/9;
return c;
}

int main()
{
int c, f;
cout << "Digite a temperatura em graus Fahrenheit: ";
cin >> f;

c = celsius(f); // chamada funo

cout << "Celsius = " << c << endl;

system("PAUSE");
return 0;
}
Entretanto, bons programadores escrevem os prottipos de todas as suas
funes, pois no futuro elas podero ser armazenadas em arquivos de bibliotecas
e necessitaro dos prottipos.

10. Tipos de Funes

As que iremos trabalhar so funes definidas pelo programador, do tipo:
Sem passagem de parmetro e sem retorno.
Com passagem de parmetro e sem retorno.
Sem passagem de parmetro e com retorno.
Com passagem de parmetro e com retorno.

10.1 Sem passagem de parmetro e sem retorno
o tipo mais simples (no recebe e no repassa valor).
#include <cstdlib>
#include <iostream>
using namespace std;
void soma()
{
int a,b,s;
cout<<"Digite o primeiro numero "; cin>>a;
cout<<"\nDigite o segundo numero "; cin>>b;
s=a+b;
cout<<"\nA soma e "<< s <<"\n";
getchar();
}

int main()
{
soma();
system("PAUSE");


UNESP - FEIS
Departamento de Matemtica
70
}
Obs.: no momento em que a funo soma foi chamada no programa
principal (main), nenhum valor foi colocado entre parnteses, indicando que no
houve passagem de parmetros. Alm disso, no foi utilizado o comando return,
sinalizando que ela no retornou valor para quem a chamou. Por est razo, seu
tipo void.

10.2 Com passagem de parmetro e sem retorno
representado por aquelas que recebem valores no momento em que
so chamadas (parmetros), mas que no final no retornam valor para quem as
chamou (retorno).
#include <cstdlib>
#include <iostream>
using namespace std;
void calcula_media( float numero1, float numero2)
{
float media;
media = (numero1+numero2)/2;
cout << "\nA media e = " << media << endl;
getchar();
}

int main(int argc, char *argv[])
{
float n1, n2;
cout<<"Digite o primeito numero: ";
cin>>n1;
cout<<"\nDigite o segundo numero: ";
cin>>n2;
calcula_media(n1, n2);
system("PAUSE");
return EXIT_SUCCESS;
}
Obs.: no momento em que a funo calcula_media foi chamada, duas
variveis foram colocadas entre parnteses, indicando que houve passagem de
parmetros.
Os valores so copiados para as variveis numero1 e numero2, descritas
no cabealho da funo. Alm disso, no foi utilizado o comando return,
sinalizando que ela no retornou valor para quem a chamou.
Por est razo, seu tipo void.

10.3 Sem passagem de parmetro e com retorno
representado por aquelas que no recebem valores no momento em
que so chamadas (parmetros), mas que, no final, retornam valor para quem as
chamou (retorno).
#include <cstdlib>
#include <iostream>
using namespace std;
float multiplicacao()


UNESP - FEIS
Departamento de Matemtica
71
{
float n1, n2, produto;
cout<<"Digite o primeiro numero ";
cin>>n1;
cout<<"\nDigite o segundo numero ";
cin>>n2;
produto = n1*n2;
return produto;
}

int main()
{
float resposta;
resposta = multiplicacao();
cout<<"\nO resultado e : "<< resposta <<endl;
system("PAUSE");
return EXIT_SUCCESS;
}
Obs.: no momento em que a funo multiplicacao foi chamada,
nenhum valor foi colocado entre parnteses, indicando que no houve passagem
de parmetros.
Chegando no final da funo o comando return encontrado. Isto indica
que a execuo da funo chegou ao fim e que o contedo da varivel produto
ser devolvido para quem a chamou.
Retornando ao programa principal, o valor armazenado na varivel
resposta. Por est razo, seu tipo float, exatamente igual ao tipo de valor
retornado.

10.4 Com passagem de parmetro e com retorno
representado por aquelas que recebem valores no momento em que
so chamadas (parmetros), e no final, retornam valor para quem as chamou
(retorno).
#include <cstdlib>
#include <iostream>
using namespace std;
int divisao(int d1, int d2)
{
int q;
q = d1/d2;
return q;
}

int main(int argc, char *argv[])
{
int n1, n2;
int resposta;
cout<<"Digite o primeiro numero ";
cin>>n1;
cout<<"\nDigite o segundo numero ";
cin>>n2;
resposta = divisao(n1, n2);


UNESP - FEIS
Departamento de Matemtica
72
cout<<"\nO resultado e "<< resposta<<endl;
system("PAUSE");
return EXIT_SUCCESS;
}

Obs.: no momento em que a funo divisao foi chamada, duas variveis
foram colocadas entre parnteses, indicando que houve passagem de parmetros.
Os valores so copiados para as variveis d1 e d2, descritas no
cabealho da funo.
Chegando no final da funo, o comando return encontrado. Isto
indica que a execuo da funo chegou ao fim e que o contedo da varivel q
ser devolvido para quem a chamou.
Retornando ao programa principal, o valor armazenado na varivel
resposta.
Por est razo, seu tipo int, exatamente igual ao tipo de valor
retornado.

10.5 Tipos de passagem de parmetro
Os tipos de passagem de parmetros so por valor e por referncia.

Valor: So todos os exemplo vistos at aqui. A figura abaixo ilustra a
passagem de parmetro por Valor:



Referncia: Significa que os parmetros so passados para uma funo
correspondente a endereos de memria ocupados por variveis. Dessa
maneira, toda vez que for necessrio acessar determinado valor, isso ser feito
por meio de referncia, ou seja, apontando o seu endereo. A figura abaixo
ilustra a passagem de parmetro por referncia.


UNESP - FEIS
Departamento de Matemtica
73


Quando argumentos so passados por valor, a funo chamada cria
variveis e copia nelas o valor dos argumentos passados. Dessa forma, a funo
no tem acesso s variveis originais da funo que chamou, portanto, ela no
poder efetuar qualquer modificao nelas. Na passagem por referncia, a funo
pode acessar as variveis da funo que as chamou. Esse mecanismo possibilita
que uma funo retorne mais de um valor para a funo que chama. Os valores a
serem retornados so colocados na referncia de variveis da funo chamada.

O Operador Unrio de Referncia &: Com esse operador podemos
montar novos tipos de dados, chamados de referncias. Referncia um outro
nome para uma varivel j existente. As instrues:

Int n;
Int& A = n;

Informa que A um outro nome para n. Toda a operao em qualquer um dos
nomes tem o mesmo resultado. A referncia no uma cpia da varivel que se
refere, a mesma varivel sobre nomes diferentes.

#include <iostream>
using namespace std;
int main ()
{
int n;
int& A =n;
n=5;
cout << "O valor de A e = " << A << endl;
A = 8;
cout << "O valor de n e = " << n << endl;
system("Pause");
return 0;
}
O valor de A e = 5
O valor de n e = 8
Press any key to continue...


UNESP - FEIS
Departamento de Matemtica
74
Obs.: Toda a referncia deve ser obrigatoriamente inicializada

int n;
int& A; // Errado
int& A =n; // Certo

O prximo e exemplo mostra o uso simples de referncia como argumento
de uma funo.

#include <iostream>
using namespace std;
void reajusta20(float& p, float& r);
int main ()
{
float preco, val_reaj;
do
{
cout << "Insira o preco atual ";
cout << "ou 0 para terminar: ";
cin >> preco;
reajusta20(preco,val_reaj);
cout << "Preco novo = " << preco;
cout << endl;
cout << "Aumento = " << val_reaj;
cout << "\n\n";
}while(preco!=0.0);
system("Pause");
return 0;
}
void reajusta20(float& p, float& r)
{
r=p*0.2;
p=p*1.2;
}
Insira o preco atual ou 0 para terminar: 50
Preco novo = 60
Aumento = 10

Insira o preco atual ou 0 para terminar: 0
Preco novo = 0
Aumento = 0

Press any key to continue...

No exemplo a seguir, criaremos uma funo que troca o contedo de duas
variveis, por meio da funo troca() para ordenar uma lista de 3 nmeros
fornecidos pelo usurio. Utilize os nmeros 50, 13 e 28 respectivamente para as
variveis n1, n2 e n3.
#include <iostream>
using namespace std;
void troca(float& n, float& m);
int main ()
{
float n1, n2, n3;
cout << "Digite os tres numeros: "<<endl;
cin >> n1 >> n2 >> n3;
if (n1>n2) troca(n1,n2);
if (n1>n3) troca(n1,n3);
if (n2>n3) troca(n2,n3);
cout << "n1= "<<n1<<endl;
cout << "n2= "<<n2<<endl;
cout << "n3= "<<n3<<endl;
system("Pause");
Digite os tres numeros:
50
13
28
n1= 13
n2= 28
n3= 50
Press any key to continue...


UNESP - FEIS
Departamento de Matemtica
75
return 0;
}
void troca(float& n, float& m)
{
float aux;
aux=n;
n=m;
m=aux;
}

10.6 Valores default de parmetros de funes
Quando declaramos uma funo, podemos especificar o valor default de
cada um de seus parmetros. Este valor ser usado se o argumento
correspondente a esse parmetro for deixado em branco no momento em que a
funo for chamada. Pra fazer isso, simplesmente utilizamos o operador de
atribuio ( = ) e o valor para o argumento no prottipo da funo. Assim, se o
valor para o parmetro no for passado quando a funes for chamada, o default
ser usado, entretanto, se um valor for especificado, este default ser ignorado e o
valor passado ser utilizado.

#include <iostream>
using namespace std;
int divide(int a=2, int b=1);
int main()
{
cout << divide() << endl;
cout << divide(12) << endl;
cout << divide(12,4)<< endl;
system("pause");
return 0;
}

int divide(int a, int b)
{
int r;
r=a/b;
return (r);
}
2
12
3
Press any key to continue...

Como podemos ver, existem trs chamadas funo divide(), na
primeira:

divide()

no foram especificados argumentos, mas funo permite a utilizao de dois
argumentos. Ento, a funo assume como valores de seus parmetros: 2 para o
primeiro e 1 para o segundo, como definido no prottipo da funo. Portanto o
resultado 2 (2/1)

int divide(int a=2, int b=1);



UNESP - FEIS
Departamento de Matemtica
76
Na segunda chamada funo, foi especificado somente o primeiro
argumento da funo:

divide(12)

Nesse caso, a funo assume que o valor do segundo parmetro 1, uma
vez que esse parmetro no foi passado. Portanto o resultado retornado 12
(12/1).
Na terceira chamada funo:

divide(12,4)

Os dois parmetros foram fornecido, assim, os valores default para a (int
a=2) e b (int b=1) foram ignorados, assim o retorno da funo 3 (12/4).

Obs.: Podemos escrever prottipos de funes que tenham parmetros
com um valor default e parmetros sem valor default, mas, aps a primeira
especificao do valor default, todos os parmetros seguintes devem ser
especificados com valores defaults. Observe tambm que, nas chamadas s
funes, se o primeiro argumento for omitido, todos os subsequentes devero s-
lo. Se o segundo argumento for omitido, todos os subsequentes devero s-lo e
assim por diante, portanto, a seguinte instruo ilegal e retornar um erro:

divide(,4) // ERRADO

10.7 Sobrecarga de Funes
Sobrecarregar funes significa criar uma famlia de funes com o
mesmo nome, mas com a lista de argumentos diferentes. Funes
sobrecarregadas devem ter a lista de argumentos diferentes ou em nmero ou em
tipo. Pois, por meio dos argumentos que o sistema reconhece qual funo
dever ser chamada.
#include <iostream>
using namespace std;
int opere (int a, int b)
{
return(a*b);
}
float opere (float a, float b)
{
return(a/b);
}
int main ()
{
int x=5,y=2;
float n=5.0, m=2.0;
cout << opere (x,y);
cout << "\n";
cout << opere (n,m);
10
2.5
Press any key to continue...


UNESP - FEIS
Departamento de Matemtica
77
cout << "\n";
system("pause");
return 0;
}

No exemplo acima definimos duas funes com o mesmo nome, opere()
mas uma delas aceita dois argumentos do tipo int e a outra aceita os argumentos
do tipo float. O compilador sabe qual deve chamar em cada caso pela inspeo
do tipo de valor passado como argumento quanto a funo chamada. Se ela for
chamada com dois inteiros como seus argumentos ser utilizada a funo que
possui dois inteiros como argumentos no prottipo. O mesmo raciocnio segue
para o caso dos argumentos utilizados forem floats.
Observe que o sistema considera somente a lista de argumentos para
escolher a funo apropriada a cada chamada, e no o valor de retorno.

10.8 Recursividade de Funes
Recursividade a propriedade que uma funo tem de ser chamada por
ela mesma, ou seja, uma funo dita recursiva se definida em termos dela
mesma. Isto til em muitas tarefas, como em ordenao ou clculos de fatoriais
de nmeros. Por exemplo, para obtermos o fatorial de um nmero (n!) a frmula
matemtica deve ser:

n! = n * (n-1) * (n-2) * (n-3) ... * 1

assim, observe o exemplo do fatorial de 5:

5! = 5 * 4 * 3 * 2 * 1 = 120

e a funo recursiva para calcular o fatorial em C++ poderia ser escrita como:
#include <iostream>
using namespace std;
long fatorial(int a)
{
if(a>1)
return (a*fatorial(a-1));
else
return (1);
}

int main ()
{
long n;
cout << "Digite um numero: ";
cin >> n;
cout << n <<"! = "<< fatorial(n) << endl;
system("Pause");
return 0;
}
Digite um numero: 5
5! = 120
Press any key to continue...
Note que na funo fatorial ns inclumos uma chamada a ela mesma,
mas somente se o argumento passado for maior que 1, caso contrrio a funo


UNESP - FEIS
Departamento de Matemtica
78
realizaria um loop recursivo infinito, pois, uma vez atingido o zero (0) a
multiplicao continuaria por todos os nmeros negativos o que provocaria um
estouro de memria ou um erro no tempo de execuo.
O cdigo gerado por uma funo recursiva exige a utilizao de mais
memria, o que torna a execuo mais lenta. Ao escrevermos uma funo
recursiva, trs pontos devem ser lembrados:
1. Definir o problema em termos recursivos, ou seja, definir o problema
em termos dele mesmo.
2. Encontrar uma condio bsica de trmino para evitarmos
problemas de estouro de memria e erro de tempos de execuo.
3. Cada vez que uma funo chamada recursivamente, deve estar
mais prxima de satisfazer a condio bsica, isso garante que o
programa no girar em uma sequncia infindvel de chamadas.



UNESP - FEIS
Departamento de Matemtica
79
11. Estruturas Composta de Dados (Vetores)

Geralmente, os algoritmos so elaborados para manipulao de dados.
Quando estes dados esto organizados (dispostos) de forma coerente,
caracterizam uma forma, uma estrutura de dados.
A organizao dos dados chamada de estrutura composta de dados
que se divide em duas formas fundamentais:
homogneas (vetores e matrizes)
heterogneas (registros).

11.1 Estrutura de Dados Composta Homognea
As estruturas de dados homogneas possibilitam o armazenamento de
grupos de valores em uma nica varivel que ser armazenada na memria do
computador. Essas estruturas so ditas "homogneas" porque os valores que
sero armazenados so de um mesmo tipo de dado.
Estas estruturas homogneas so divididas em unidimensionais e
multidimensionais. Normalmente, as estruturas unidimensionais so chamadas
de vetores e as multidimensionais so chamadas de matrizes. De fato, um
vetor tambm uma matriz, porm varia em somente uma dimenso.





















O algoritmo acima demostra a utilizao de 5 variveis para armazenar as
alturas dos atletas, no caso de estruturas de dados homogneas, todas as alturas
seriam armazenadas em uma nica varivel.

algoritmo "alturas de atletas"
// Sntese
// Objetivo: armazenar 5 alturas de atletas de basquete
// Entrada: 5 alturas
// Sada: -
// Declaraes
var
altura1,altura2,altura3,altura4,altura5 : real
inicio
escreva("Informe a altura do 1 atleta: ");
leia (altura1)
escreva("Informe a altura do 2 atleta: ")
leia (altura2)
escreva("Informe a altura do 3 atleta: ")
leia (altura3)
escreva("Informe a altura do 4 atleta: ")
leia (altura4)
escreva("Informe a altura do 5 atleta: ")
leia (altura5)
fimalgoritmo


UNESP - FEIS
Departamento de Matemtica
80
11.2 Vetores
Um vetor uma srie de um mesmo tipo de dados alocados de maneira
contgua na memria do computador que podem ser individualmente
referenciados por um nmero. Portanto, uma coleo de elementos de um
mesmo tipo. Cada um dos elementos unicamente identificado por um nmero
inteiro.



Isso significa que poderamos armazenar a altura dos 5 atletas de
basquete, do exemplo anterior, em um vetor sem termos que declarar 5 diferentes
variveis, cada uma com um identificador (nome) diferente. Ao invs disso,
utilizando um vetor podemos armazenar os 5 valores de altura de um mesmo tipo
de dado, int por exemplo, em um nico identificador.
Por exemplo, um vetor contendo 5 valores de alturas chamado alturas
pode ser representado por:

nesse vetor cada espao em branco representa um elemento do vetor, que nesse
caso so valores inteiros das alturas dos atletas em centmetros (185, 201, 188,
195 e 176). Estes elementos so numerados de 0 a 4, observe que em C++ os
vetores o primeiro ndice ser sempre o Zero, independentemente do seu
comprimento (nmero total de elementos). O valor do ndice no deve ser
confundido com o contedo da posio do vetor. O ndice identifica o elemento
dentro do conjunto. O ndice tem de ser obrigatoriamente inteiro. O elemento do
vetor pode ser um nmero inteiro, um nmero real, uma varivel booleana, um
caractere, uma string, etc. O ndice de um vetor corresponde numerao das
casas numa rua.
alturas
185 201 188
195 176


UNESP - FEIS
Departamento de Matemtica
81

O nmero de uma casa nada tem a ver com o seu contedo.

Representao Grfica de um Vetor:
num[1] 4


Assim como uma varivel comum, o vetor deve ser declarado antes de ser
utilizado. Uma declarao tpica de um vetor em C++ :

tipo nome [elementos];

Onde o tipo qualquer tipo de dado vlido, visto at agora (int,
float...), nome um identificador vlido e o elementos, que deve ser sempre
definido dentro de colchetes ( [ ] ) especifica a quantidade de elementos que o
vetor deve possuir.
Portanto, para declararmos o vetor chamado alturas como aquele
apresentado no diagrama anterior, simplesmente utilizamos:

int alturas [5];

E o vetor ser criado como:


alturas


UNESP - FEIS
Departamento de Matemtica
82
11.3 Inicializao de Vetores
Quando declaramos um vetor em um escopo local (dentro de uma funo,
por exemplo), se no especificado, seus elementos no sero inicializados como
algum valor default, portanto, seu contedo ser indeterminado at o momento em
que armazenaremos algum valore nele. Os elementos de vetores globais ou
estticos, por outro lado, sero automaticamente inicializados com valores default,
o que para todos os tipos de dados fundamentais, significa que sero preenchido
com zero (0).
Em ambos os casos, globais e locais, quando declaramos um vetor,
devemos possibilitar a atribuio de valores iniciais para cada um dos seus
elementos pela encerrando os valores em chaves ( { } ).

int alturas [5] = {185, 201, 188, 195, 176};

Dessa maneira, nosso vetor altura apresentar, finalmente, a seguinte
conformao.

A quantidade de elementos entre chaves ( { } ) deve ser to grande
quanto o tamanho de elementos que declaramos entre colchetes ( [ ] ) . Por
exemplo, quando declaramos o vetor:

int alturas [5];

especificamos que ele tem 5 elementos e na lista de alturas:

{185, 201, 188, 195, 176}

temos 5 elementos.
Em C++ podemos iniciar um vetor da seguinte forma:

int alturas [ ] = {185, 201, 188, 195, 176};

Observe que deixamos vazio os colchetes ([ ]), nesse caso, o
compilador assumir que o tamanho para o vetor ser o nmero de elementos
includos entre chaves ( { } ). Aps a declarao, portanto, o nosso vetor alturas
ter o tamanho de 5 uma vez que fornecemos 5 elementos dentro das chaves.

11.4 Acessando os elementos dos vetores
Em qualquer ponto de um programa, poderemos acessar individualmente
qualquer um dos elementos de um vetor, como se este elemento fosse uma
alturas 185 201 188 195 176


UNESP - FEIS
Departamento de Matemtica
83
varivel normal, assim, somos capazes de ler e modificar esses valor. O formato
para acessar um elemento simples:

nome [ndice];

Seguindo o exemplo anterior, nosso vetor alturas apresenta 5 elementos,
e cada um desses elementos so do tipo inteiro (int), os nomes que poderemos
utilizar para nos referirmos a cada um dos seus elementos so:


por exemplo, para armazenarmos o valor 190 no terceiro elemento do vetor
alturas, ns poderemos escrever a seguinte declarao:

alturas [2] = 190;

e, se quisermos passar o valor do terceiro elemento do vetor alturas para a
varivel a, poderes utilizar a instruo:

a = alturas [2];

Abaixo sero apresentadas mais algumas operaes vlidas para vetores:

a = 1;
alturas [0] = a;


alturas [a] = 75;

b = alturas[a+2]; //portanto b = 195
alturas[alturas [0]] = alturas[2] + 5;

alturas
185 201 188 195 176
alturas[0] alturas[1] alturas[2] alturas[3]
alturas[4]
alturas 1 201 188 195 176
alturas[0] alturas[1] alturas[2] alturas[3]
alturas[4]
alturas 1 75 188 195 176
alturas[0] alturas[1] alturas[2] alturas[3]
alturas[4]


UNESP - FEIS
Departamento de Matemtica
84

Seguindo o exemplo anterior, nosso vetor alturas apresenta 5 elementos,
e cada um desses elementos so do tipo inteiro (int), os nomes que poderemos
utilizar para nos referirmos a cada um dos seus elementos so:

O programa abaixo calcula a soma dos valores de alturas de jogadores de
basquete presentes no vetor alturas.
#include <iostream>
using namespace std;
int alturas [5] = {185, 201, 188, 195, 176};
int i, soma=0;
int main ()
{
for (i=0; i <=5; i++)
soma += alturas[i]; // soma = soma + alturas[i]
cout << "Soma das alturas = " << soma;
cout << "\n\n";
system("Pause");
return 0;
}
Soma das alturas = 945

Press any key to continue...


11.5 Exemplo 15
Elabore um programa, utilizando modularizao, que calcule a mdia ( x ),
a varincia (s
2
), o desvio padro (s), o mnimo, o mximo e o coeficiente de
variao (cv) das alturas dos atletas:
x=

i =1
n
x
i
n

s
2
=

i= 1
n
x
i
2

i =1
n
x
i
)
2
n
n 1

s= s
2
=

i =1
n
x
i
2

i= 1
n
x
i
)
2
n
n 1

cv=
100 s
x

Onde n o nmero de elementos do vetor e x o vetor de alturas. Para auxiliar,
programe as funes para calcular:
soma=

i= 1
n
x
i
e
soma aoquadrado=

i= 1
n
x
i
2

alturas
1 193 188
195 176
alturas[0] alturas[1] alturas[2] alturas[3]
alturas[4]


UNESP - FEIS
Departamento de Matemtica
85
#include <iostream>
#include <math.h>
using namespace std;

//prottipos
float soma(float v[]);
float somaquad(float v[]);
float media(float v[]);
float variancia(float v[]);
float desvpad(float v[]);
float minimo(float v[]);
float maximo(float v[]);
float cv(float v[]);

//vairveis globais
float dados[10] = {21.5, 25.5, 14.5, 15.8, 17.6, 8.9, 9.6, 18.6, 17, 12};
int n=10;

//funo principal
int main()
{
cout << "Soma : " << soma(dados) << endl;
cout << "Soma de Quadrados : " << somaquad(dados) << endl;
cout << "Media : " << media(dados) << endl;
cout << "Variancia Amostral: " << variancia(dados) << endl;
cout << "Desvio Padrao : " << desvpad(dados) << endl;
cout << "Minimo : " << minimo(dados) << endl;
cout << "Maximo : " << maximo(dados) << endl;
cout << "CV : " << cv(dados) << endl;
system("Pause");
return 0;
}

//funo que calcula a soma dos elementos de um vetor
float soma(float v[])
{
float soma=0.0;
for(int i=0; i<=9; i++)
soma+=v[i]; // media = mdia + v[i]
return soma;
}

//funo que calcula a soma dos quadrados do vetor
float somaquad(float v[])
{
float somaquad=0.0;
for(int i=0; i <=9; i++)
somaquad+=v[i]*v[i];
return somaquad;
}
//funo que calcula a mdia aretimtica do vetor
float media(float v[])
{
float media=0.0;
for(int i=0; i<=9; i++)
media+=v[i]; // media = mdia + v[i]
media/=10; // media = media/5
return media;
}

//funo que calcula a variancia amostral dos dados
float variancia(float v[])
{
float variancia;
variancia=(somaquad(v) - soma(v)*soma(v)/10)/(10-1);
return variancia;
}

//funo que calcula o desvio padrao amostral dos dados


UNESP - FEIS
Departamento de Matemtica
86
float desvpad(float v[])
{
float desvpad;
desvpad=sqrt(variancia(v));
return desvpad;
}

//funo que retorna o menor valor dos dados
float minimo(float v[])
{
float minimo=v[1];
for(int i =0; i <=n-1; i++)
if(minimo>v[i]) minimo = v[i];
return minimo;
}

//funo que retorna o maior valor dos dados
float maximo(float v[])
{
float maximo=v[1];
for(int i =0; i <=n-1; i++)
if(maximo<v[i]) maximo = v[i];
return maximo;
}

//funo que calcula o desvio padro dos dados
float cv(float v[])
{
float cv;
cv=100*desvpad(v)/media(v);
return cv;
}


11.6 Mtodos de ordenao de vetores
ORDENAO uma das tarefas bsicas em processamento de dados. A
ordenao de um vetor significa classificar os seus elementos, ou seja, colocar os
elementos do vetor em ordem de acordo com algum critrio (ordem crescente, ou
ordem decrescente). Existem vrios algoritmos de ordenao que se diferenciam
pela velocidade da ordenao e complexidade de implementao:
Mtodos de ordenao Simples:
Mtodo da Seleo
Mtodo de Bolha
Mtodo da Insero


UNESP - FEIS
Departamento de Matemtica
87

Mtodos de ordenao Sofisticados:
Mtodo Shell Sort
Mtodo Quick Sort
Mtodo Heap Sort

Vamos colocar em ordem crescente os valores de alturas dos atletas.
Para isso, inicialmente, nosso programa deve:
Mtodo Seleo
Selecionar o elemento do vetor (10 posies) que apresenta o menor
valor;
Trocar esse elemento pelo primeiro;
Repetir essas operaes, envolvendo agora somente os 9 elementos
restantes (selecionando o de menor valor com a segunda posio,
depois o 8 elementos (trocando o de menor valor com a terceira
posio), depois os 7, os 6 e assim por diante, at restar um nico
elemento, o maior deles.
#include <iostream>
using namespace std;
void imprime(float v[]);
void organiza(float v[]);
//vairveis globais
float dados[10] = {21.5, 25.5, 14.5, 15.8, 17.6,
8.9, 9.6, 18.6, 17, 12};
int n=10;
//funo principal
int main()
{
cout<< "Vetor dados original: \n";
imprime(dados);
cout<< "\n\nVetor dados organizado: \n";
organiza(dados);
system("Pause");
return 0;
}
//funo para imprimir vetor
void imprime(float v[])
{
cout<<"Indice\tElemento\n";
for(int i=0; i<= n-1; i++)
cout << "["<<i<<"]\t"<<v[i] << endl;
}
//funo para organiza e imprimir vetor
void organiza(float v[])
{
float aux;
int i, j, k;
for(i=0; i<=n-2;i++)
{
k=i;
aux=v[i];
for(j=i+1; j<=n-1;j++)
if (v[j]<aux)
{



UNESP - FEIS
Departamento de Matemtica
88
k=j;
aux=v[k];
}
v[k]=v[i];
v[i]=aux;
}

cout<<"Indice\tElemento\n";
for(int i=0; i<= n-1; i++)
cout << "["<<i<<"]\t"<<v[i] << endl;
}

Mtodo da Bolha
Neste mtodo de ordenao, o programa utiliza a seguinte estratgia para
ordenar o vetor:
Comparar os pares de elementos adjacentes, permutando-os quando
estiverem foram de ordem, at que todos estejam ordenados. O
objetivo da funo colocar o menor item da lista nessa varivel na
primeira posio do vetor a ser ordenado v[0]. A funo percorre
um por um dos elementos seguintes a fim de encontrar o menor
deles. Sempre que encontra um elemento menor, eles so
trocados. Terminado essa operao, tomado o prximo item,
v[1]; ele dever conter o prximo menor valor. Novamente, so
realizadas as comparaes e trocas. O processo continua at que a
lista toda seja ordenada.
#include <iostream>
using namespace std;
void imprime(float v[]);
void organiza(float v[]);
//vairveis globais
float dados[10] = {21.5, 25.5, 14.5, 15.8, 17.6,
8.9, 9.6, 18.6, 17, 12};
int n=10;
int main()
{
cout<< "Vetor dados original: \n";
imprime(dados);
cout<< "\n\nVetor dados organizado: \n";
organiza(dados);
system("Pause");
return 0;
}
//funo para imprimir vetor
void imprime(float v[])
{
cout<<"Indice\tElemento\n";
for(int i=0; i<= n-1; i++)
cout << "["<<i<<"]\t"<<v[i] << endl;
}
//funo para organiza e imprimir vetor
void organiza(float v[])
{
int i, j;float aux;
for(i=0;i<=n-1;i++)



UNESP - FEIS
Departamento de Matemtica
89
for(j=i+1;j<=n-1;j++)
if(v[i] >v[j])
{
aux=v[j];
v[j]=v[i];
v[i]=aux;
}
cout<<"Indice\tElemento\n";
for(int i=0; i<= n-1; i++)
cout << "["<<i<<"]\t"<<v[i] << endl;
}
O processo de ordenao feito por meio de dois laos. O lao mais
externo determina qual elemento do vetor ser usado como base
de comparao. O lao mais interno compara cada item seguinte
com o de base e, quando encontra um elemento menor que o de
base, faz a troca, realizada no corpo do if por meio de uma
varivel auxiliar (aux).

11.7 Exemplo 16
Elabore um programa, utilizando modularizao, que calcule a mediana
das alturas dos atletas. A mediana o valor que ocupa a posio central do vetor
ordenado dos dados, o valor precedido e seguido pelo mesmo nmero de
observaes e nem sempre pertence ao conjunto de dados.

+
=
|

\
|
+ |

\
|
|

\
| +
. par n se ,
2
x x
; mpar n se , x
Md
1
2
n
2
n
2
1 n

Onde x o vetor de alturas e n o nmero de elementos do vetor.

#include <iostream>
using namespace std;
float mediana(float v[]);
//vairveis globais
float dados[10] = {21.5, 25.5, 14.5, 15.8, 17.6,
8.9, 9.6, 18.6, 17, 12};
int n=10;
int main()
{
cout << "Mediana: " << mediana(dados) << endl;
system("Pause");
return 0;
}

//funo para clculo da mediana
float mediana(float v[])
{
float mediana;
int i, j;
float aux;
// ordenando o vetor
for(i=1;i<=n-1;i++)


UNESP - FEIS
Departamento de Matemtica
90
for(j=n-1;j>=0;j--)
if(v[j-1] >v[j])
{
aux=v[j-1];
v[j-1]=v[j];
v[j]=aux;
}
if (n%2 ==1)
mediana= v[(n-1)/2];
else
mediana=(v[(n/2)-1]+v[n/2])/2;
return mediana;
}

11.8 Exemplo 17
Elabore um programa, utilizando modularizao, que calcule a moda de
um vetor de elementos numricos, lembre que a moda o valor que ocorre com
maior frequncia no vetor. Portanto, podemos ter vetores, com uma (unimodal) ou
mais moda (plorimodal), ou mesmo sem valor de moda (amodal). Teste o
programa com os vetores:
V1={1,6,8,9,9,5,9,7,9,9,5,6,4}
V2={5,5,8,6,5,8,5,7,8,4,8}
V3={1,8,4,5,9,7,6,3,2,0}

#include <iostream>
using namespace std;
void moda(int v[], int n);

int v1[13]={1,6,8,9,9,5,9,7,9,9,5,6,4};
int v2[11]={5,5,8,6,5,8,5,7,8,4,8};
int v3[10]={1,8,4,5,9,7,6,3,2,0};

int main()
{
cout << "\nModa do vetor 1" << endl;
moda(v1,13);
cout << "\nModa do vetor 2" << endl;
moda(v2,11);
cout << "\nModa do vetor 3" << endl;
moda(v3,10);
system("Pause");
return 0;
}
// funo para o clculo da moda
void moda(int v[],int n)
{
// ordenando o vetor
float aux;
for(int i=1;i<=n-1;i++)
for(int j=n-1;j>=0;j--)
if(v[j-1] >v[j])
{
aux=v[j-1];
v[j-1]=v[j];
v[j]=aux;
}
//contar quantas classes de elementos
int cont=0;
for(int i=0;i<=n-2;i++)
if (v[i]!=v[i+1]) cont++;


UNESP - FEIS
Departamento de Matemtica
91
cont++; //somando 1 ao numero de classes
//criando o vetor com o numero de elementos
int vc[cont], hist[cont];
//preenchendo o vetor contagem com os elementos se n for diferente de cont
if(n==cont)
cout << "Vetor amodal"<<endl;
else
{
int j=0;
for(int i=0;i<=n-2;i++)
if (v[i]!=v[i+1])
{
vc[j]=v[i];
j++;
}
vc[j]=v[n-1];
//contar os elementos das classes
for(int j=0;j<=cont-1;j++)
{
int k=0;
for(int i=0;i<=n-1;i++)
if(vc[j]==v[i]) k++;
hist[j]=k;
}
// buscando a posio do maior elemento em hist
int pm, max;
max=hist[0];
for(int j=0;j<=cont-1;j++)
if(max < hist[j]) max=hist[j] ;
//retornando a moda, os elementos de vc cujo respectivo hist igual ao max
cout<< "Moda: \n";
for(int j=0;j<=cont-1;j++)
if(hist[j]==max) cout<<vc[j]<<endl;
}
}

11.9 Nmero desconhecidos de elementos
Nos exemplos anteriores, utilizamos um nmero fixo de elementos do
vetor. Como faramos se conhecemos de antemo quantos itens entrariam no
vetor? Para exemplificar, vamos escrever um programa que aceita at 100 valores
de altura, que pode ser modificado para aceitar qualquer valor de altura.

#include <iostream>
#include <iomanip>
using namespace std;

const int N = 100;

int main()
{
float alturas[N], media=0.0;
int i=0;
cout << setprecision(4);
do
{
cout << "Digite o valor de altura " << i+1 << " : ";
cin >> alturas[i];
} while(alturas[i++]>=0.0);
i--;



UNESP - FEIS
Departamento de Matemtica
92
for(int j=0; j<i;j++)
media+=alturas[j] ;// media=media+alturas[j]
cout << "Medias das alturas: " <<(media/i)<<endl;
system("Pause");
return 0;
}

O lao for foi substitudo pelo lao do-while. Esse lao repete a
solicitao da altura ao usurio, armazenando-a no vetor alturas[], at que
seja fornecido um valor menor que zero. Quando o ltimo elemento for digitado, a
vaivel i ter alcanado um valor acima do total de elementos. Isso verdadeiro,
pois contado o nmero negativo de finalizao da entrada. Assim devemos
subtrair 1 do valor contido em i para encontrar o nmero correto de elementos.
Entretanto, a linguagem C++ no realiza verificao de limites em vetores,
por isso, se o usurio decidir inserir mais de 100 valores de alturas, devemos
expulsar os valores excedentes. Para providenciar a verificao do limite de uma
matriz de responsabilidade do programa. Portanto, no podemos permitir que o
usurio digite dados acima do limite, assim, temos:

do
{
if( i>= N)
{
cout << "BUFFER LOTADO" << endl;
i++;
break; // Saida do lao do-while
}
cout << "Digite o valor de altura " << i+1 << " : ";
cin >> alturas[i];
} while(alturas[i++]>=0.0);

Assim, quando i atingir 100, que 1 acima do ltimo ndice do vetor, a
mensagem " BUFFER LOTADO " ser impressa e o comando break far que o
controle saia do lao do-while e passe para a segunda parte do programa, ou
seja, o clculo da mdia.

Obs.: A linguagem C/C++ no permite que vetores e matriz sejam
passados na ntegra como parmetro para uma funo. Para resolver esse
problema, deve-se passar apenas o endereo da posio inicial do vetor ou da
matriz. Esse endereo obtido utilizando-se o nome do vetor (ou da matriz) sem o
ndice entre colchetes.

#include <iostream>
using namespace std;
void soma_linhas(int m[ ][5], int v[ ])
{
int i, j;
for (i=0;i<3;i++)
for (j=0;j<5;j++)
v[i]=v[i]+m[i][j];


UNESP - FEIS
Departamento de Matemtica
93

}

int main()
{
int i, j;
int mat[3][5], vet[3];
for (i=0;i<3;i++)
{ vet[i]=0;
system("cls");
for (j=0;j<5;j++)
{
cout<<"\nDigite o elemento Coluna: "<<i+1<<" e Linha: "<<j+1 <<" ";
cin >> mat[i][j];
}
}
soma_linhas(mat, vet);
for (i=0;i<3;i++)
cout << "\nSoma da coluna " << i+1 << " = " << vet[i];
cout << "\n\n";
system("PAUSE");
return 0;
}

11.10 Exemplo 18
Elabore um programa que dado um vetor de 10 valores inteiros, crie e
imprima outro vetor, armazenando os elementos do primeiro a partir do centro
para as bordas, de modo alternado (vetor inteiro com 10 posies tambm).
Nesta primeira forma de resoluo, utilizaremos a varivel inteira j para
receber os ndices do vetor resposta (vr), inicializando-a com o valor do ndice do
elemento central, ou seja, a posio 4 (10/2-1). Observe que dentro do lao for
utilizamos um if com a seguinte condio, se o resto da diviso de i (ndice do
vetor original) por 2 for igual a zero, j ser incrementado em i+1 (lembre que o
primeiro valor de i zero), caso contrrio j ser decrementado em i+1.

#include <iostream>
using namespace std;

int main()
{
int vetor[10]={11,22,33,44,55,66,77,88,99,1010};
int vr[10]={};
int j=10/2-1;
//preenchimento de vr
for(int i=0; i <=9;i++)
{
if(i%2==0)
{
vr[ j ]=vetor[i];
j=j+(i+1);
}
else
{
vr[ j ]=vetor[i];


UNESP - FEIS
Departamento de Matemtica
94
j=j-(i+1);
}
}
//Impresso dos vetores
cout<<"vetor\tvr"<<endl;
for(int i=0;i<=9;i++)
cout<<vetor[i]<<"\t"<<vr[i]<<endl;

system("pause");
return 0;

}
Na segunda forma de resoluo desse problema, vamos utilizar um
segundo lao for, ao invs do if. Para isso vamos precisar de mais duas
variveis (l e k). O lao for realizar sucessivas multiplicaes de k (iniciado com
o valor de -1) l vezes, com l variando de 0 at o valor de i, fazendo k variar
entre 1 e -1 a cada contagem do primeiro lao. Portanto, quando k=1, j ser
incrementado em i+1 e, quando k=-1 ,j ser decrementado em i+1.

#include <iostream>
using namespace std;

int main()
{
int vetor[10]={11,22,33,44,55,66,77,88,99,1010};
int vr[10]={};
int j=10/2-1;
//preenchimento de vr
for(int i=0; i <=9;i++)
{
vr[j]=vetor[i];
int k=-1;
for(int l=0;l<=i;l++) k=k*(-1);
j=j+(i+1)*k;
}
//Impresso dos vetores
cout<<"vetor\tvr"<<endl;
for(int i=0;i<=9;i++)
cout<<vetor[i]<<"\t"<<vr[i]<<endl;

system("pause");
return 0;
}
Na ltima forma de resoluo, utilizaremos a funo potncia (pow()) da
biblioteca math.h, para substituir o segundo for do programa anterior,
implementando a expresso
j = j +( 1)
i
(i +1)
.

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

int main()
{
int vetor[10]={11,22,33,44,55,66,77,88,99,1010};
int vr[10]={};


UNESP - FEIS
Departamento de Matemtica
95
int j=10/2-1;
//preenchimento de vr
for(int i=0; i <=9;i++)
{
vr[j]=vetor[i];
j=j+int(pow(-1,i))*(i+1);
}
//Impresso dos vetores
cout<<"vetor\tvr"<<endl;
for(int i=0;i<=9;i++)
cout<<vetor[i]<<"\t"<<vr[i]<<endl;

system("pause");
return 0;
}

12. Estruturas Composta de Dados (Matrizes)

As estruturas multidimensionais so chamadas de matrizes, podem ter
duas ou mais dimenses e, assim como em vetores, apresenta o mesmo tipo de
dados (estrutura homognea), referenciados por n variveis inteiras (ndices)
iguais ao nmero de dimenses da matriz, ou seja, cada uma referenciar uma
dimenso da matriz.



12.1 Declarao
Para declararmos uma matriz de duas dimenses, por exemplo, utiliza-se
dois pares de colchetes. Cada par de colchetes adicionais obtemos matrizes com
uma dimenso a mais. A lista de valores usada para inicializar a matriz uma lista
de constantes separadas por vrgulas e envolta por chaves.


UNESP - FEIS
Departamento de Matemtica
96







UNESP - FEIS
Departamento de Matemtica
97
Exemplo:

int soma[3][3];
float nota[2][3]={{9,8,7},{6.5,4,2}};

Da mesma maneira como, ocorre com os vetores, os ndices comeam
sempre em 0 (zero).
Observe o programa abaixo que imprime as duas matrizes anteriores.
Para isso utilizamos uma funo para realizar a impresso das matrizes. Pra isso
devemos declarar o segundo ndice da matriz como constante, observe o prottipo
da funo.
void imprimeMatriz(float m[][nc],int nl );

#include <iostream>
const int nc=3;
void imprimeMatriz(float m[][nc],int nl );
using namespace std;

int main()
{
float soma[3][3]={};
float nota[2][3]={{9,8,7},{6.5,4,2}};
cout<<"Matriz soma: "<<endl;
imprimeMatriz(soma,3);
cout<<"Matriz nota: "<<endl;
imprimeMatriz(nota,2);
system("pause");
return 0;
}
//funao para a impressao de matrizes bidimensionais
void imprimeMatriz(float m[][nc], int nl)
{
for(int i=0; i<=(nl-1);i++)
{
for(int j=0; j<=(nc-1); j++)
cout<< m[i][j] << "\t";
cout << endl;
}
cout <<endl;
}
Matriz soma:
0 0 0
0 0 0
0 0 0

Matriz nota:
9 8 7
6.5 4 2

Press any key to continue...
Observe que foi informado somente a segunda dimenso da matriz, como
no h verificao de limites, uma matriz com a primeira dimenso de qualquer
valor pode ser passada para a funo chamadora. Mas uma funo que recebe
uma matriz bidimensional dever ser informada do comprimento da segunda
dimenso para poder operar com declaraes do tipo:
nota[2][1]
pois, para encontrar a posio de memria onde nota[2][1] est
guardada, a funo multiplica o primeiro ndice (2) pelo nmero de elementos da
segunda dimenso (nc) e adiciona o segundo ndice (1), para, por fim, somar ao
endereo da matriz(nota). Caso o comprimento da segunda dimenso no seja
conhecido, ser impossvel saber onde esto os valores.


UNESP - FEIS
Departamento de Matemtica
98
Observe o prximo exemplo, onde vamos declarar, atribuir valores e
imprimir uma matriz com 3 dimenses:
#include <iostream>
const int nc=4, p=5;
using namespace std;
void imprimeMatriz2(int m[][nc][p],int nl);
int main()
{
int m1[3][4][5]={
{
{3,2,3,2,4},
{6,5,3,6,4},
{6,5,4,8,9},
{6,6,6,6,6}
},
{
{6,6,6,6,6},
{4,5,3,7,6},
{6,7,5,1,6},
{9,6,5,6,4}
},
{
{1,1,1,1,1},
{2,2,2,2,2},
{3,4,3,2,6},
{7,8,6,7,8}
}
};
imprimeMatriz2(m1,3);

system("pause");
return 0;
}
//Imprimento matriz de 3 dimenses
void imprimeMatriz2(int m[][nc][p], int nl)
{
for(int k = 0; k<=nl-1;k++)
{
cout <<"["<< k << "]"<< endl;
for(int i=0; i<=nc-1;i++)
{
for(int j=0;j<=p-1;j++)
cout<<" "<<m[k][i][j];
cout<<endl;
}
cout<<endl;
}
}




12.2 Exemplo 19
Construa um programa, utilizando modularizao, que efetue a soma e a
impresso do resultado entre a multiplicao de duas matrizes inteiras com 9
elementos:
#include <iostream>


UNESP - FEIS
Departamento de Matemtica
99
const int nc=3;
using namespace std;
void somaMat(int m1[][nc], int m2[][nc], int nl);
int main()
{
int MAT1[3][nc]={{2,4,6},{1,3,5,},{7,8,9}};
int MAT2[3][nc]={{1,3,5,},{7,8,9},{2,4,6}};
somaMat(MAT1,MAT2,3);
system("pause");
return 0;
}
//soma e imprime duas matrizes de 9 elementos
void somaMat(int m1[][nc], int m2[][nc], int nl)
{
int R[nl][nc];
for(int i=0; i<=(nl-1);i++)
for(int j=0; j<=(nc-1); j++)
R[i][j]=m1[i][j]+m2[i][j];
for(int i=0; i<=(nl-1);i++)
{
for(int j=0; j<=(nc-1); j++)
cout<< R[i][j] << "\t";
cout << endl;
}
cout <<endl;
}

12.3 Exemplo 20
Construa um programa que multiplique as Matrizes A e B do tipo ( 3 x 3) e
guardando e imprimindo o resultado em uma matriz R, ou seha R = A*B. Lembre-
se:
(
R
11
R
12
R
13
R
21
R
22
R
23
R
31
R
32
R
33
)
=
(
A
11
A
12
A
13
A
21
A
22
A
23
A
31
A
32
A
33
)
+
(
B
11
B
12
B
13
B
21
B
22
B
23
B
31
B
32
B
33
)


O mtodo de multiplicao de matrizes deve ser:
R
11
= A
11
B
11
+A
12
B
21
+A
13
B
31
R
12
= A
11
B
21
+A
12
B
22
+A
13
B
32
R
13
= A
11
B
13
+A
12
B
23
+A
13
B
33
R
21
= A
21
B
11
+A
22
B
21
+A
23
B
31
R
11
= A
21
B
12
+A
22
B
22
+A
23
B
32
... ...
R
32
= A
31
B
12
+A
32
B
22
+A
33
B
32
R
33
= A
31
B
13
+A
32
B
23
+A
33
B
33



UNESP - FEIS
Departamento de Matemtica
100
Assim, o programa ficar:
#include <iostream>
const int nc=3;
using namespace std;
void mat_mult(int m1[][nc], int m2[][nc], int nl);
int main()
{
int MAT1[3][nc]={{2,4,6},{1,3,5,},{7,8,9}};
int MAT2[3][nc]={{1,3,5,},{7,8,9},{2,4,6}};
mat_mult(MAT1,MAT2,3);
system("pause");
return 0;
}
//Multiplica e imprime duas matrizes de 9 elementos
void mat_mult(int m1[][nc], int m2[][nc], int nl)
{
int R[nl][nc];
for(int i=0; i<=(nl-1);i++)
for(int j=0; j<=(nc-1); j++)
{
R[i][j]=0;
for(int k=0; k<=(nc-1);k++)
R[i][j]+=m1[i][k]*m2[k][j];
}

for(int i=0; i<=(nl-1);i++)
{
for(int j=0; j<=(nc-1); j++)
cout<< R[i][j] << "\t";
cout << endl;
}
cout <<endl;
}