Apostila CPP

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
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
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
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
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
4

c. Clique em "Seguinte".

d. Selecione "Instalar".

e. Aguarde o assistente terminar a instalao do programa.

UNESP - FEIS
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
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
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
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
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
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
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
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
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
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
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++.

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
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>
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
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
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
18
2.4 Terceiro Programa
Vamos estudar alguns novos comandos bsicos.
#include <iostream>
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
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
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
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
long int (long) Inteiro 4 bytes
signed: -2147483648 to
2147483647
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
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>
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

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>
int main()
{
float a,b, d;
a=5;
b=3;
d=a/b;
cout << d <<endl;
system("Pause");
}
1.66667

UNESP - FEIS
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>
int main()
{
double a, b, d;
a=5;
b=3;
d=a/b;
cout << d << endl;
system("Pause");
}
1.66667
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>
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
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
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>
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

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>
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

UNESP - FEIS
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'
int main()
{
double raio=5, circulo;
circulo=2*PI*raio;
cout << circulo; cout << NL;cout << NL;
system("Pause");
}
31.4159


UNESP - FEIS
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>

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
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
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:
pow(x,y) x elevado a y pow(2,3)
sqrt(x) Raiz quadrada de x sqrt(9)

UNESP - FEIS
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:
% 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
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:
> 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.

! 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>
int main()
{
cout << !(5 == 5) << endl;
cout << !(6 <= 5) << endl;
cout << !true << endl;
cout << !false << endl;
system("pause");
}
0
1
0
1

UNESP - FEIS
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>
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
31
5.7 Exemplo 2
Construa um programa que calcule a mdia aritmtica entre quatro notas
bimestrais fornecidas por um aluno (usurio):
#include <iostream>
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>
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
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>
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
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
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>
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>
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

UNESP - FEIS
35
Observer agora a ao da funo setw().
#include <iostream>
#include <iomanip>
int main(void)
{
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

Observer agora a ao da funo setfill().
#include <iostream>
#include <iomanip>
int main(void)
{
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

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>
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

UNESP - FEIS
36
cout << setprecision(6);
cout << P1 << endl;
cout << P2 << endl;
cout << P3 << endl;
cout << endl;
cout << R1 << endl;
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>
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;
}


UNESP - FEIS
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
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
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
40

Sequncia de aes:

Exemplo de Algoritmos

UNESP - FEIS
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
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>
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
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
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
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
46

#include <iostream>
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>
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>
int main()
{
float a;

UNESP - FEIS
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>
int main()
{
int n;
cin >> n;
if (n%2==0)
{
if(n==0)
{
cout << "nulo" << endl;
}
else
{
cout << "par" << endl;
}
}
else
{
cout<<"impar"<<endl;
}
system("Pause");
}

UNESP - FEIS
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>
int main()
{
int i;
for(i=0; i < 20; i++ )
cout << '*';
cout << endl;
system ("PAUSE");
return 0;
}
********************
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
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>
int main()
{
int i;
for (i = 1; i <= 5; i++)
cout << i;
cout << endl;
system ("PAUSE");
return 0;
}
12345

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

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

UNESP - FEIS
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>
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


UNESP - FEIS
51
Vamos modificar o programa anterior para que a tabuada do 6 seja
impressa de forma invertida.
#include <iostream>
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


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>
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

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>

UNESP - FEIS
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>
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
53
i = i+1;
if (i!=num_termos)
{
num3 = num3*4;
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
54

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

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>
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
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
55
Observe o programa abaixo:
#include <iostream>
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
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>
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!

UNESP - FEIS
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>
int main ()
{
int X = 1, Y=1;
while (X < Y)
{
X = X+1;
}
cout<<"Acabou o while";
cout << endl;
system("Pause");
return 0;
}
Acabou o while
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>
int main ()
{
int X = 1, Y=1;
while (X <= Y)
{
}
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
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>
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
<< X; e X=X+1; sero executados 5 vezes. O teste condicional avaliar X valendo
0,1, 2, 3, 4 e 5.

UNESP - FEIS
58

Observe o exemplo abaixo:
#include <iostream>
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
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
59
#include <iostream>
int main ()
{
int X = 1, Y=1;
do
{
X = X+1;
} while (X < Y);
cout<<"Acabou o repetir";
cout << endl;
system("Pause");
return 0;
}
Valor de X = 1
Acabou o repetir
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>
int main ()
{
int X = 1, Y=1;
do
{
} 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
<< 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>
int main()
{
int n;
cin >> n;
int fat=1;
for(int i=1; i<=n; i++)
fat=fat*i;

UNESP - FEIS
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>
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>
int main()
{
int k, n;
char r;

do
{

UNESP - FEIS
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
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
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
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
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
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
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
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>
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>

UNESP - FEIS
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>
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
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>
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");
}
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>
float multiplicacao()

UNESP - FEIS
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");
}
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>
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
72
cout<<"\nO resultado e "<< resposta<<endl;
system("PAUSE");
}

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
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>
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

UNESP - FEIS
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>
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


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>
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);
cout << "n1= "<<n1<<endl;
system("Pause");
Digite os tres numeros:
50
13
28
n1= 13
n2= 28
n3= 50

UNESP - FEIS
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>
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

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
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>
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

UNESP - FEIS
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>
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
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
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
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)
leia (altura3)
leia (altura4)
leia (altura5)
fimalgoritmo

UNESP - FEIS
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
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
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
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[4]
alturas 1 75 188 195 176
alturas[4]

UNESP - FEIS
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>
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


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[4]

UNESP - FEIS
85
#include <iostream>
#include <math.h>

//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
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
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>
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
88
k=j;
aux=v[k];
}
v[k]=v[i];
v[i]=aux;
}

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>
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[])
{
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
89
for(j=i+1;j<=n-1;j++)
if(v[i] >v[j])
{
aux=v[j];
v[j]=v[i];
v[i]=aux;
}
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>
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
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>
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);
moda(v2,11);
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;
if (v[i]!=v[i+1]) cont++;

UNESP - FEIS
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;
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;
if(vc[j]==v[i]) k++;
hist[j]=k;
}
// buscando a posio do maior elemento em hist
int pm, max;
max=hist[0];
if(max < hist[j]) max=hist[j] ;
//retornando a moda, os elementos de vc cujo respectivo hist igual ao max
cout<< "Moda: \n";
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>

const int N = 100;

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

UNESP - FEIS
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>
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
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>

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
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>

int main()
{
int vetor[10]={11,22,33,44,55,66,77,88,99,1010};
int vr[10]={};
int j=10/2-1;
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;
}

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>

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

UNESP - FEIS
95
int j=10/2-1;
for(int i=0; i <=9;i++)
{
vr[j]=vetor[i];
j=j+int(pow(-1,i))*(i+1);
}

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
96

UNESP - FEIS
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 );

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

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
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;
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
99
const int nc=3;
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 j=0; j<=(nc-1); j++)
R[i][j]=m1[i][j]+m2[i][j];
{
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
100
Assim, o programa ficar:
#include <iostream>
const int nc=3;
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 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 j=0; j<=(nc-1); j++)
cout<< R[i][j] << "\t";
cout << endl;
}
cout <<endl;
}

Apostila CPP

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila CPP

Enviado por

Direitos autorais:

Formatos disponíveis

Universidade Estadual Paulista "Jlio de Mesquita Filho"

Faculdade de Engenharia de Ilha Solteira

Você também pode gostar