Aprendendo Lógica com a Linguagem

Prévia do material em texto

Material de Apoio às aulas de “Linguagem de Programação 1”
Aprendendo Lógica com a Linguagem
de Programação C++
Prof. MSc. Claudia Akemi Izeki
Bacharelado em Ciência da Computação
26 de Fevereiro de 2007
Sumário
1 Introdução à Linguagem C++ 1
1.1 Lógica de Programação, Algoritmo, Linguagem de programação e Compilador . . . . 1
1.1.1 Lógica de Programação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.2 Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.3 Linguagem de programação e Compilador . . . . . . . . . . . . . . . . . . . . 2
1.2 Ambiente de programação Borland C++ 3.1 . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Estrutura básica de um programa em C++ . . . . . . . . . . . . . . . . . . . . . . . 4
1.4 Primeiro programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5 Instruções de programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.6 Comandos iniciais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6.1 cout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6.2 cin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6.3 clrscr() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6.4 getch() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6.5 Caracter que imita a tecla [ENTER] . . . . . . . . . . . . . . . . . . . . . . . . 6
1.7 Uso de comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.8 Teste de mesa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.9 Exerćıcios de Lógica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2 Variáveis e tipos de dados 10
2.1 Declaração de variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Tipos de dados variáveis (ou tipos de dados) . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3.1 Análise e implementação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
i
2.3.2 Verificação do programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4 Declaração de valores constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 Operadores 16
3.1 Operador de atribuição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2 Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2.1 Precedência de operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . 17
3.3 Operadores de incremento e de decremento . . . . . . . . . . . . . . . . . . . . . . . 18
3.4 Operadores aritméticos de atribuição . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.5 Operadores relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.6 Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.6.1 Precedência de operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . 24
3.7 Precedência entre os operadores aritméticos, relacionais e lógicos . . . . . . . . . . . 25
3.8 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4 Estruturas Condicionais 26
4.1 Estrutura condicional simples: if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.2 Estrutura condicional composta: if - else . . . . . . . . . . . . . . . . . . . . . . . 28
4.2.1 Exemplos utilizando estrutura condicional composta . . . . . . . . . . . . . . 29
4.3 Alternativa de estrutura condicional composta: switch . . . . . . . . . . . . . . . . . 31
4.3.1 Exemplos utilizando switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.4 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5 Estruturas de Repetição 37
5.1 O laço for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.1.1 Exemplo – Cálculo e impressão da tabuada do 4 . . . . . . . . . . . . . . . . 38
5.2 O laço while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.2.1 Exemplos utilizando o laço while . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.3 O laço do - while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.3.1 Exemplo usando o laço do - while . . . . . . . . . . . . . . . . . . . . . . . 42
5.4 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
ii
6 Vetores 46
6.1 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7 Strings 50
7.1 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
7.2 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8 Matrizes 55
8.1 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.2 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
9 Funções 59
9.1 Escopo de variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
9.2 Protótipo de função . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.3 Chamada de função . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.4 Definição de função . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9.5 Retorno de função . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9.6 Funções com passagem de parâmetro . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.6.1 Passagem de parâmetro por valor . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.6.2 Passagem de parâmetro por referência . . . . . . . . . . . . . . . . . . . . . . 64
9.7 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
10 Registros 68
Referências Bibliográficas 70
A Erros comuns na programação usando o ambiente Borland C/C++ 3.1 71
A.1 Erros comuns na compilação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
A.2 Erros comuns de lógica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
B Boas práticas de programação 75
C Revisão de conceitos matemáticos muito utilizados 83
iii
Lista de Exemplos
2.1 Declaração de uma variável do tipo inteiro . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Declaração de mais de uma variável do tipo inteiro . . . . . . . . . . . . . . . . . . . 10
3.1 Um caso de uso do operador maior ou igual que (>=). . . . . . . . . . . . . . . . . . 20
3.2 Precedência de operador aritmético sobre relacional. . . . . . . . . . . . . . . . . . . 21
3.3 Um caso de uso do operador lógico E . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.4 Um caso de uso do operador lógico OU . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.5 Um caso de uso do operador lógico NÃO . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.1 Trecho de código que utiliza a condicional simples sem chaves. . . . . . . . . . . . . . 27
4.2 Trecho de código que utiliza a condicional simples com chaves. . . . . . . . . . . . . 27
4.3 Trecho de código que utiliza seqüencialmente várias condicionais simples sem chaves. 28
6.1 Exemplo de vetor de números reais com cinco posições. . . . . . . . . . . . . . . . . 47
6.2 Alguns acessos de elementos do vetor notas. . . . . . . . . . . . . . . .. . . . . . . 47
8.1 Alguns acessos de elementos da matriz mat. . . . . . . . . . . . . . . . . . . . . . . . 55
iv
Licença e uso da obra
Este material trata-se de uma obra derivada de várias outras obras existentes a respeito da
área de Lógica e Linguagem de Programação. O mesmo é utilizado em disciplinas ministradas pela
autora.
Este material foi produzido usando o formatador de textos LATEX(versão MikTEX2
a) no sistema opera-
cional Microsoft Windows com o editor TEXnicCenter
b. O autor disponibiliza a obra no formato PDF
e os arquivos-fonte compactados em um arquivo ZIP. Qualquer mudança ou uso deste material deve
ser informado ao autor pelo e-mail: cizeki@hotmail.com.
aO compilador MikTEXpode ser obtido no endereço: http://www.miktex.org.
bO editor de texto LATEXTEXnicCenter pode ser obtido no endereço http://www.toolscenter.org/.
v
CAṔITULO
1
Introdução à Linguagem C++
1.1 Lógica de Programação, Algoritmo, Linguagem de programação e Compi-
lador
1.1.1 Lógica de Programação
Pode-se pensar em lógica como a “arte de bem pensar” ou “a ordem correta do pensamento”.
No dia-a-dia utiliza-se lógica para organizar os pensamentos, como:
1. A gaveta está fechada.
O grampeador está dentro da gaveta.
Assim, deve-se abrir a gaveta para pegar o grampeador.
ou, ainda,
2. Luciane é mais velha que Claudia.
Claudia é mais velha que Marcos.
Portanto, Luciane é mais velha que Marcos.
Já a lógica na programação envolve o uso correto do racioćınio objetivando o desenvolvimento
de técnicas que cooperem para a produção de soluções logicamente válidas e coerentes, resolvendo
com qualidade os problemas que se deseja programar.
Da mesma forma que um mesmo racioćınio pode ser respresentado em diversos idiomas, a lógica
de programação independe da linguagem utilizada, sendo, portanto, empregado o uso de algoritmos.
1.1.2 Algoritmo
Para resolver um problema computacional utiliza-se algoritmo, que é uma seqüência finita de
passos para atingir um objetivo bem definido. No dia-a-dia, algoritmos são utilizados constante-
mente em situações como trocar pneu de um carro, fazer uma omelete, buscar as crianças na escola,
etc.
1
Na elaboração de um algoritmo devem ser especificados passos claros e precisos, que partindo
de um estado inicial, após um peŕıodo de tempo finito, produzem um estado final previśıvel e bem
definido.
A descrição de um algoritmo pode ser feita através de pseudocódigo – linguagem semelhante
à natural, com algumas regras comuns às linguagens de programação – ou de fluxogramas – re-
presentados por desenhos. A implementação de um algoritmo é chamado de programa, ou seja, a
codificação de um algoritmo em alguma linguagem de programação.
1.1.3 Linguagem de programação e Compilador
Da mesma forma que nós, seres humanos, precisamos de uma linguagem para nos comunicar,
uma linguagem de programação serve de comunicação entre o indiv́ıduo que deseja resolver um
determinado problema e o computador escolhido para ajudá-lo na solução.
Entretanto, o computador entende apenas a linguagem de máquina, dita de baixo ńıvel, que
consiste de seqüências de zeros e uns. Assim, programar em uma linguagem de baixo ńıvel é mais
dif́ıcil e trabalhoso para o programador.
Atualmente, as linguagens de programação mais utilizadas são aquelas ditas de alto ńıvel,
consideradas mais próximas da linguagem humana, sendo, portanto, mais fáceis que linguagens de
baixo ńıvel. C++ é um exemplo de linguagem de alto ńıvel.
Todavia, linguagem de alto ńıvel não é a linguagem que o computador entende. Assim, o
programador deve usar um compilador para converter o programa feito em linguagem de alto ńıvel
para código em linguagem de máquina. Caso existam erros de sintaxe no programa, a conversão
não é realizada.
1.2 Ambiente de programação Borland C++ 3.1
É um ambiente de desenvolvimento de programas em linguagem C++. Com ele, pode-se editar
um programa, compilá-lo e executá-lo. Um programa é uma seqüência de instruções codificadas
em uma linguagem de programação e para ser executado precisa ser armazenado na memória do
computador.
A seguir são apresentados os passos básicos para a execução de um programa escrito em lin-
guagem C++ no ambiente Borland C++ 3.1.
1. Abra o ambiente de programação pelo ı́cone no desktop ou pelo Menu Iniciar.
2. Caso queira que o ambiente ocupe todo o espaço da tela, pressione Alt+Enter.
3. Crie um novo arquivo pelo Menu File⇒New.
4. Salve-o dando um nome de no máximo 8 caracteres. A extensão de um arquivo C++ é .cpp.
Tenha o hábito de sempre salvar o arquivo pelo Menu File⇒Save ou tecla F2.
5. Edite-o.
6. Compile-o e execute-o pelo Menu Run⇒Run ou Ctrl+F9.
Se houver erros na compilação, serão apresentadas a quantidade de erros, a linha e a descrição
do posśıvel erro, conforme as Figuras 1.1 e 1.2.
2
Figura 1.1: Informações de erros no programa. Pressionando-se qualquer tecla, são apresentados
os erros do programa conforme especificados na Figura 1.2. Fonte: captura de tela.
Figura 1.2: Apresentação de erros na janela Message. Verifique que há indicação do número da
linha do erro e o que o ocasionou, a fim de que possa corrigi-lo. Fonte: captura de tela.
3
1.3 Estrutura básica de um programa em C++
Um programa C++ consiste na definição de uma ou mais funções. Em Listing 1.1 é apresentada
a forma geral de definição de função, que possui um tipo de dado e um nome acompanhado de
parênteses. A seguir, deve-se inserir uma chave de abertura de bloco ({), escrever as instruções no
corpo da função e terminar com uma chave de fechamento de bloco (}).
Listing 1.1: Forma geral de definição de função C++
t ipo nome da funç ão ( )
{
i n s t r u ç ã o 1 ;
i n s t r u ç ã o 2 ;
. . .
i n s t ru ç ã o n ;
}
Todo programa C++ deve possuir uma função chamada main – do inglês “principal” (Listing
1.2), na qual a execução se inicia com a chave de abertura e, após executar as instruções contidas
no corpo da função, termina quando é encontrada a chave de fechamento. Verifique que no ińıcio
do programa há inclusão de biblioteca, que é um arquivo necessário para a execução de comandos
utilizados no decorrer do programa. Caso haja mais de uma biblioteca, deve-se inclui-la com
#include<nome da biblioteca>.
Listing 1.2: Estrutura básica de um programa em C++
#include <nome de uma b i b l i o t e c a >
void main ( )
{
i n s t r u ç ã o 1 ;
i n s t r u ç ã o 2 ;
. . .
i n s t ru ç ã o n ;
}
1.4 Primeiro programa
Em Listing 1.3 é apresentado o primeiro exemplo de programa, cuja finalidade é calcular e
imprimir a soma de dois números inteiros passados pelo usuário.
Listing 1.3: Primeiro programa
1 #include <i o s t ream . h>
2 #include <con io . h>
3
4 void main ( )
5 {
6 c l r s c r ( ) ;
7
8 int num1 , num2 , soma ;
4
9
10 cout << "Soma de dois numeros" ;
11
12 cout << "Entre com o primeiro numero: " ;
13 c in >> num1 ;
14
15 cout << "Entre com o segundo numero: " ;
16 c in >> num2 ;
17
18 soma = num1 + num2 ;
19
20 cout << "A soma é: " ;
21 cout << soma ;
22
23 getch ( ) ;
24 }
Pode-se digitar o código e salvá-lo com o nome “soma.cpp” – sem as aspas. O sufixo .cpp
indica programa-fonte em C plus plus – do inglês “C mais mais”.
O programa acima possui apenas uma definição de função, a main(). O nome de uma função
pode ser qualquer um, com exceção de main(), reservado para a função que inicia a execução do
programa. Se um programa for constitúıdo de uma única definição de função, esta será main(). O
programa termina quando for encerrada a execução dessa função.
A função main() do programa apresentado é do tipo void, que indica que a função não possui
valor de retorno, ou seja, não retorna nada.
1.5 Instruções de programa
Geralmente, as instruções C++ terminam em um ponto-e-v́ırgula (;). O primeiro programa
possui várias instruções e sãoexecutadas na ordem em que são escritas:
i. A execução do programa se inicia pela função main. A chave de abertura na linha 5 indica
o ińıcio da função main.
ii. A chamada à função clrscr() na linha 6 faz com que a tela de sáıda seja limpa.
iii. Na linha 8 são declaradas três variáveis inteiras (tipo int).
iv. Na linha 10 o comando cout seguido de “<<” imprime na tela tudo o que está entre aspa
dupla, ou seja, a frase “Soma de dois números”.
v. Na linha 12 é impressa uma frase que pede ao usuário um número inteiro.
vi. Na linha 13 o comando cin seguido de “>>” e do nome da variável num1 espera o usuário
entrar com algum dado, que é colocado na variável indicada.
vii. As instruções das linhas 15 e 16 seguem a mesma explicação das linhas 12 e 13.
viii. Na linha 18, como as variáveis num1 e num2 possuem valores passados pelo usuário, é realizada
a soma, inserindo o resultado na variável soma.
5
ix. Na linha 20 é impressa a frase “A soma é: ”.
x. Na linha 21 é impresso o valor que está na variável soma. Perceba que neste caso não foi
utilizada aspas, foi apenas escrito o nome da variável. Caso se utilizassem as aspas, seria
impressa a palavra soma e não o valor que está na variável soma.
xi. A chamada à função getch() faz com que se espere a digitação de alguma tecla para continuar
a execução do programa, ou seja, faz com que o usuário consiga ver o resultado na tela.
xii. A chave na linha 24 denota o fim da função main, ou seja, o fim da execução do programa.
1.6 Comandos iniciais
1.6.1 cout
cout (pronuncia-se C out – sáıda) está associado à sáıda padrão, geralmente o v́ıdeo. O operador
“<<” conecta a mensagem a ser impressa à cout. As definições e declarações necessárias para seu
uso estão contidas na biblioteca iostream.h que também contém os elementos necessários para a
execução de operações de leitura e impressão (I/O – Input/Output).
1.6.2 cin
cin (pronuncia-se C in – entrada) manipula toda a entrada do teclado por meio do operador
“>>” que conecta a entrada de dados à variável que a conterá. As definições necessárias ao uso de
cin e “>>” estão na biblioteca iostream.h.
1.6.3 clrscr()
A chamada à função clrscr() faz com que a tela seja limpa. Caso não seja invocada, a tela
aparecerá com caracteres impressos anteriormente. Deve-se incluir a biblioteca conio.h.
1.6.4 getch()
A chamada à função getch() faz com que se espere a digitação de alguma tecla para continuar
a execução do programa, ou seja, faz com que o usuário consiga ver o resultado na tela. Caso a
função não seja chamada, o usuário não conseguirá ver a sáıda pois a janela é fechada. Também
está definida na biblioteca conio.h.
1.6.5 Caracter que imita a tecla [ENTER]
Além da tecla [ENTER], vários outros caracteres não podem ser digitados do teclado para dentro
do programa. Esses caracteres que não podem ser obtidos diretamente do teclado são codificados
em C++ por meio da combinação do sinal \ (barra invertida) com outros caracteres. Para imitar
a tecla [ENTER], use o caracter ‘\n’.
6
1.7 Uso de comentários
Comentários são textos que podem ser inseridos em programas com o objetivo de documentá-lo.
Os comentários não são analisados pelo compilador.
Os comentários podem ocupar uma ou várias linhas, podendo ser utilizados de duas formas:
1. A região de comentários é aberta pelos śımbolos “//” e é encerrada automaticamente ao final
da linha
2. A região de comentários é aberta com os śımbolos “/*” e é encerrada com os śımbolos “*/”
A seguir é apresentado o primeiro programa utilizando as duas formas de comentários.
Listing 1.4: Primeiro programa comentado
/ ∗
P r o g r a m a d o r : C l a u d i a A . I z e k i
D a t a : 7 / 1 2 / 2 0 0 5
D e s c r i ç ã o : P r o g r a m a q u e c a l c u l a a s oma d e d o i s n ú m e r o s i n t e i r o s
p a s s a d o s p e l o u s u á r i o .
∗ /
/ / I n c l u s ã o d e b i b l i o t e c a s
#include <i o s t ream . h> / / P a r a o u s o d e c i n e c o u t
#include <con io . h> / / P a r a o u s o d e c l r s c r ( ) e g e t c h ( )
/ / F u n ç ã o p r i n c i p a l
void main ( )
{
c l r s c r ( ) ; / / F u n ç ã o q u e l i m p a a t e l a
/ / D e c l a r a ç ã o d e v a r i á v e i s
int num1 , num2 , soma ;
/ / I m p r i m e a f i n a l i d a d e d o p r o g r a m a a o u s u á r i o
cout << "Soma de dois numeros" ;
/ / P e d e um n ú m e r o a o u s u á r i o
cout << "Entre com o primeiro numero: " ;
c in >> num1 ; / / O q u e o u s u á r i o d i g i t a r é i n s e r i d o em num1
/ / P e d e a o u s u á r i o o u t r o n ú m e r o
cout << "Entre com o segundo numero: " ;
c in >> num2 ; / / O q u e o u s u á r i o d i g i t a r é i n s e r i d o em num2
/ / C a l c u l a a s oma
soma = num1 + num2 ;
/ / I m p r i m e a s oma
cout << "A soma é: " ;
cout << soma ;
7
/ / E s p e r a o p r e s s i o n a m e n t o d e a l g u m a t e c l a . Com i s s o , o
/ / u s u á r i o c o n s e g u e v i s u a l i z a r o r e s u l t a d o
getch ( ) ;
}
1.8 Teste de mesa
Um recurso muito utilizado para verificar erros de lógica em um algoritmo é a simulação ou teste
de mesa. Segundo Salvetti e Barbosa (1998), a partir de dados escolhidos com resposta conhecida
simula-se a execução do algoritmo e compara-se a resposta obtida com a resposta esperada. Se não
houver coincidência está detectado um erro, embora a rećıproca não seja verdadeira.
Saber escolher os dados para os testes é de muita importância na simulação. Assim, deve-se
escolher amostras de dados de forma que provoquem a execução de todas as instruções presentes
no algoritmo, testando todas as diferentes possibilidades de sáıda.
Para realizar o teste de mesa são listadas todas as variáveis utilizadas no algoritmo e registrados
todos os valores assumidos pelas variáveis, na ordem em que ocorrem.
Para localizar facilmente a variável que foi definida ou alterada em um dado momento, é con-
veniente identificar com um número cada uma das instruções contidas no algoritmo.
Na Tabela 1.1 é apresentado um teste de mesa do primeiro programa (Listing 1.3 – pág. 4).
Verifique que o śımbolo # indica a ordem de execução das instruções; [] indica o número da
instrução sendo executada; o sublinhado indica valor definido ou modificado; o pontilhado indica
impressão e a sáıda é alguma impressão com o comando cout.
Tabela 1.1: Teste de mesa do primeiro programa apresentado em Listing 1.3. Suponha que os
valores entrados pelo usuário para as variáveis num1 e num2 sejam, respectivamente, 12 e 7.
Variáveis Sáıda
# [ ] num1 num2 soma
1 8 lixo lixo lixo
2 10 lixo lixo lixo Soma de dois números
3 12 lixo lixo lixo Entre com o primeiro número
4 13 12 lixo lixo
5 15 12 lixo lixo Entre com o segundo número
6 16 12 7 lixo
7 18 12 7 19
8 20 12 7 19 A soma é:
9 21 12 7 19 19
10 23 12 7 19 Espera o pressionamento de alguma tecla...
1.9 Exerćıcios de Lógica
1. Elabore um algoritmo que mova três discos de uma Torre de Hanói, que consiste em três
hastes (a, b, c), sendo que a haste a serve de suporte para três discos de tamanhos diferentes
(1, 2, 3), os menores sobre os maiores. A haste b serve de intermediária. Pode-se mover
8
um disco de cada vez para qualquer haste, contanto que nunca seja colocado um disco maior
sobre um menor. O objetivo é transferir os três discos para a haste c.
2. Um homem precisa atravessar um rio com um barco que possui capacidade apenas para
carregar ele mesmo e mais uma de suas três cargas, que são: um lobo, um bode e um maço
de alfafa. O que o homem deve fazer para conseguir atravessar o rio sem perder suas cargas?
Escreva um algoritmo mostrando a resposta, ou seja, indicando todas as ações necessárias
para efetuar uma travessia segura. Note que: o lobo come o bode, e este come alfafa quando
o homem não está por perto.
3. Três jesúıtas e três canibais precisamatravessar um rio; para tal, dispõem de um barco com
capacidade para duas pessoas. Por medida de segurança, não se deve permitir que em alguma
margem a quantidade de jesúıtas seja inferior à de canibais. Qual a solução para efetuar a
travessia com segurança? Elabore um algoritmo mostrando a resposta, indicando as ações
que concretizam a solução deste problema.
9
CAṔITULO
2
Variáveis e tipos de dados
Variáveis são os aspectos fundamentais de qualquer linguagem de computador. Segundo Mizrahi
(1994), uma variável em C++ é um espaço de memória reservado para armazenar um certo tipo de
dado e possui um nome para referenciar seu conteúdo. Uma variável pode conter, a cada tempo,
valores diferentes.
Na Seção 1.4 (4) foi apresentado um programa com três variáveis do tipo inteiro: num1, num2 e
soma, utilizadas para armazenar, respectivamente, as entradas do usuário e o resultado da adição.
2.1 Declaração de variáveis
Antes de começar a armazenar dados em uma variável, deve-se declará-la escrevendo-se seu tipo
seguido por um ou mais espaços, um nome e um ponto-e-v́ırgula.
Exemplo 2.1 Declaração de uma variável do tipo inteiro
int num;
Pode-se criar mais de uma variável do mesmo tipo em uma instrução escrevendo-se o tipo e
então os nomes das variáveis separados por v́ırgulas e um ponto-e-v́ırgula no final.
Exemplo 2.2 Declaração de mais de uma variável do tipo inteiro
int num1, num2, soma;
É boa prática de programação utilizar nomes significativos para variáveis, tornando-as fáceis de
entender – o que facilita a manutenção do programa.
O nome de uma variável é utilizado para sua identificação e posterior uso dentro de um pro-
grama. Assim, é necessário estabelecer algumas regras de utilização das mesmas:
1. O primeiro caracter do nome da variável deve ser sempre uma letra ou o caracter ‘ ’ (subli-
nhado);
2. Nomes de variáveis podem conter letras, números e o caracter ‘ ’;
3. Nomes de variáveis não podem ser iguais às palavras reservadas da linguagem;
10
4. A linguagem C++ distingue as letras maiúsculas e minúsculas, ou seja, é case sensitive. Por
exemplo, ABC e abc são diferenciadas pela linguagem.
2.2 Tipos de dados variáveis (ou tipos de dados)
O tipo de uma variável informa a quantidade de memória, em bytes, que a variável ocupará e
a forma como um valor deverá ser armazenado e interpretado.
1. Tipos de dados inteiros: são dados numéricos positivos e negativos. Não podem ser fra-
cionários e são representados pelo tipo int. Por exemplo, idades de pessoas podem ser
consideradas do tipo inteiro, como 18, 25 e 68.
2. Tipos de dados reais: são dados numéricos positivos e negativos. Podem ser fracionários e
são representados pelos tipos float e double. Por exemplo, saldos de contas de banco são
do tipo real, como -120.45, 0.0 e 345.98; alturas de pessoas também são do tipo real, como
1.0 e 1.54.
3. Tipos de dados caracter: relacionado a um único caracter ou a uma seqüência de caracteres.
É representado pelo tipo char. Exemplos de caracteres: letras, números, sinais de pontuação
e caracteres especiais. Uma seqüência de caracteres é chamada de string. Para diferenciar um
caracter de uma string, usa-se apóstrofo para o primeiro e aspa para o segundo. Exemplo:
‘s’ é um caracter; “Hello World!” é uma string.
Na Tabela 2.1 são apresentados alguns tipos de dados em C++. Pode-se considerar que os cinco
primeiros tipos são os básicos da linguagem; os demais utilizam os modificadores unsigned, long
e short. O modificador unsigned significa que se pode armazenar somente números positivos. O
modificador short normalmente se refere a um inteiro de 2 bytes e o long mais freqüentemente a
um inteiro de 4 bytes, mas nenhum desses é certo. A linguagem exige apenas que um short seja
mais curto ou igual a um inteiro, e que um inteiro seja mais curto ou igual a um long.
Tabela 2.1: Alguns tipos de dados em C++.
Tipo Tamanho Valores (aproximados)
int 2 bytes -32.768 a 32.767
char 1 byte 256 valores de caracteres
float 4 bytes 3,4e-38 a 3,4e38
double 8 bytes 1,7e-308 a 1,7e308
void 0 Nenhum valor
unsigned int 2 bytes 0 a 65.535
short int 2 bytes -32.768 a 32.767
unsigned short int 2 bytes 0 a 65.535
long int 4 bytes -2.147.483.648 a 2.147.483.647
unsigned long int 4 bytes 0 a 4.294.967.295
2.3 Exemplo
Um produto sofrerá um aumento de 10%. Faça um programa que peça ao usuário o preço de
um produto, calcule e mostre qual será o valor do aumento e o valor reajustado do produto.
11
2.3.1 Análise e implementação
Para resolver esse e outros problemas, deve-se ter em mente os seguintes passos:
1. Quais são as entradas do programa – geralmente são pedidas ao usuário, mas também podem
vir de outras fontes como um banco de dados ou um arquivo.
2. Qual é o processamento: o que se deve fazer com essas entradas – verificar, calcular, modificar,
etc.
3. Quais são as sáıdas.
Neste exemplo, a entrada do programa é o preço de um produto – no enunciado do exerćıcio:
“...peça ao usuário o preço de um produto...”. De que tipo ele é para se fazer a declaração? Preço
é um número real, assim, utiliza-se o tipo float.
O que se deve fazer com a entrada? Calcular o aumento de 10% e o preço reajustado – no
enunciado: “calcule ... qual será o valor do aumento e o valor reajustado do produto”. Como fazer
isso? Pode-se empregar a regra de três:
prod→ 100 (2.1)
aum← 10 (2.2)
aum× 100 = prod× 10 (2.3)
aum =
prod× 10
100
(2.4)
aum = prod× 0, 10 (2.5)
Assim, pode-se chegar à equação 2.4:
aum = (prod*10)/100;
ou simplesmente à equação 2.5:
aum = 0.10 * prod;
Perceba que na equação 2.5 foi utilizado o ponto no lugar da v́ırgula em 0.10. Assim, toda vez
que for utilizar número fracionário, não use v́ırgula, use o ponto.
Tendo-se o valor do aumento é só somá-lo com o valor do produto que se encontra o preço
reajustado. Os nomes de variáveis utilizadas para armazenar esses valores, foram, respectivamente:
aum, prod e preco reaj.
Por último, é só imprimir o que o exerćıcio pede; no enunciado: “mostre qual será o valor do
aumento e o valor reajustado do produto”.
Analise como esse problema foi solucionado em Listing 2.1.
Listing 2.1: Resolução do problema de reajuste de preço de um produto.
1 #include <i o s t ream . h>
2 #include <con io . h>
3
12
4 void main ( )
5 {
6 c l r s c r ( ) ;
7
8 f loat prod , aum, p rod r ea j ;
9
10 cout << "Entre com o valor do produto: " ;
11 c in >> prod ;
12
13 aum = prod ∗ 0 . 1 0 ;
14
15 prod r ea j = prod + aum;
16
17 cout << "Valor do aumento: " << aum;
18 cout << "Valor do produto reajustado: " << prod r ea j ;
19
20 getch ( ) ;
21 }
2.3.2 Verificação do programa
A execução do programa segue os seguintes passos, mas pode ser observada no teste de mesa
da Tabela 2.2. Suponha que o usuário tenha entrado com o valor 55.3 para o preço de produto.
i. Limpa a tela.
ii. Quando ocorre a declaração de variáveis na função main, estas estão com valor de lixo, ou
seja, estão com algum valor que estão naquelas posições de memória.
iii. Imprime na tela: “Entre com o valor do produto: ”.
iv. O usuário deve entrar com algum valor, por exemplo: 55.3. Lembre-se que o usuário deverá
entrar com o ponto ao invés da v́ırgula.
v. Calcula-se o aumento: aum ficará com o valor 5.53. Como há uma atribuição, o produto
substitui o valor de lixo que existia anteriormente em aum.
vi. Calcula-se o valor do preço reajustado, inserindo-o na variável prod reaj, que armazenará o
valor 60.83.
vii. A seguir, são impressos os valores contidos nas variáveis aum e prod reaj.
13
Tabela 2.2: Teste de mesa do programa apresentado em Listing 2.1. Suponha que o usuário tenha
entrado com o valor 55.3 para o preço de produto.
Variáveis Sáıda
# [ ] prod aum prod reaj
1 8 lixo lixo lixo
2 10 lixo lixo lixo Entre com o valor do produto:
3 11 55.3 lixo lixo
4 13 55.3 5.53 lixo
5 15 55.3 5.53 60.83
6 17 55.35.53 60.83 Valor do aumento: 5.53
7 18 55.3 5.53 60.83 Valor do produto reajustado: 60.83
8 20 55.3 5.53 60.83 Espera pressionamento de alguma tecla...
2.4 Declaração de valores constantes
A palavra-chave const é utilizada para declarar valores constantes. Ela assegura que a variável
associada não será alterada em todo o programa. Em Listing 2.2 é apresentado um exemplo.
A sintaxe de declaração de valores constantes é:
const tipodaconstante nomedaconstante = valor ;
Listing 2.2: Exemplo de declaração e uso de constante para representar o valor de pi.
1 / / D e s c r i ç ã o d o p r o g r a m a : C a l c u l a a á r e a d e um c ı́ r c u l o e o p e r ı́ m e t r o
2 / / d e s u a c i r c u n f e r ê n c i a .
3
4 void main ( )
5 {
6 c l r s c r ( ) ;
7
8 const f loat pi =3.141592;
9 f loat area , r a i o ;
10
11 cout << "Cálculo da área de um cı́rculo e do perı́metro "
12 << "de sua circunferência." ;
13 cout << "Por favor, entre com o raio: " ;
14 c in >> r a i o ;
15
16 area = pi ∗ r a i o ∗ r a i o ;
17
18 comp = 2 ∗ pi ∗ r a i o ;
19
20 cout << "A área do cı́rculo é: " << area ;
21 cout << "O comprimento de sua circunferência é: " << comp ;
22
23 getch ( ) ;
24 }
Verifique que na linha 8 foi declarado o valor 3.141592 para pi. Assim, pode-se utilizá-lo em
várias partes do programa, como nas linhas 16 e 18. Como pi é uma constante, não se pode
14
modificá-lo no decorrer no programa.
2.5 Exerćıcios
1. Faça um programa que calcule a média aritmética entre 4 notas bimestrais quaisquer forneci-
das por um aluno (usuário).
2. Em um curso semestral de uma instituição de ensino, a média final é composta por três notas
e é ponderada, ou seja, possui peso 2 para a primeira nota, peso 1 para a segunda e peso 3
para a terceira. Faça um programa que peça as notas para o usuário e calcule a média final.
3. Seja a seguinte fórmula de cálculo de média final em um curso: Mf = (N1 + 2.N2)/3, na
qual o aluno deverá obter no mı́nimo 5, 0 para passar direto. Sabendo-se a N1, quanto no
mı́nimo o aluno deverá tirar na N2 para passar direto? Assim, faça um programa que peça
ao usuário a N1 e calcule a nota mı́nima que o aluno deverá tirar na N2 para passar direto.
4. Faça um programa que receba o salário de um funcionário e o percentual de aumento. Calcule
o valor do aumento e do novo salário.
5. Um trabalhador recebeu seu salário e o depositou em sua conta corrente bancária. Esse
trabalhador emitiu dois cheques e agora deseja saber seu saldo atual. Sabe-se que cada
operação bancária de retirada paga CPMF de 0,38% e o saldo inicial da conta está zerado.
6. O ı́ndice de massa corporal (IMC) é uma fórmula que indica se um indiv́ıduo está acima do
peso, se está obeso ou abaixo do peso ideal considerado saudável. A fórmula para calcular o
IMC é dividir o peso, medido em quilos, pelo quadrado da altura, em metros. Assim, faça
um programa que peça ao usuário um peso e uma altura, calcule e mostre o IMC. Imprima
as informações da tabela para o usuário verificar o significado do valor de seu IMC. Não se
preocupe com a impressão dessas informações; apenas utilize o caracter ‘\n’ para melhorar a
visualização.
IMC Significa
Menos de 18,5 Abaixo do peso
De 18,5 a menor que 25 Peso ideal
De 25 a menor que 30 Sobrepeso
Maior ou igual a 30 Obesidade
15
CAṔITULO
3
Operadores
3.1 Operador de atribuição
Em C++, o sinal de igual não tem a interpretação dada em matemática. Representa a atribuição
da expressão à sua direita à variável à sua esquerda. Por exemplo:
x = 0;
atribui o valor zero à variável de nome x. A ação é executada da direita para a esquerda. Lê-se:
“x recebe o valor zero”.
Mesmo em expressões mais complexas, como em delta = b*b-4*a*c, primeiro é realizado
cálculo da expressão à direita do operador de atribuição para depois atribuir o resultado à variável
delta.
3.2 Operadores aritméticos
C++ oferece cinco operadores aritméticos binários (que operam sobre dois operandos) e um
operador aritmético unário (que opera sobre um operando). São eles:
Binários
+ Soma
- Subtração
* Multiplicação
/ Divisão
% Módulo
Unário
- Menos unário
O operador módulo opera somente com operandos inteiros e dá como resultado o resto da
divisão do inteiro à sua esquerda pelo inteiro à sua direita. Por exemplo:
17 % 5
16
possui o valor 2, pois quando se divide 17 por 5, resta o valor 2.
O operador menos unário é usado somente para indicar a troca do sinal algébrico do valor.
Pode também ser pensado como o operador que multiplica seu operando por −1. Por exemplo:
x = -8;
x = -x;
Depois destas duas instruções, o conteúdo de x será 8.
3.2.1 Precedência de operadores aritméticos
Tabela 3.1: Precedência entre operadores aritméticos
Prioridade Operadores
1a parênteses mais internos
2a ∗ / %
3a + −
Os operadores que possuem a mesma prioridade devem ser executados da esquerda para a
direita. Para alterar a prioridade da tabela devem-se utilizar parênteses mais internos.
Exemplos
1. Suponha que se deseje calcular o valor final de uma compra de acordo com a fórmula a seguir.
Os valores dos produtos e do desconto são, respectivamente, 23.50, 14.00, 5.00 e 2.00. Como
existem apenas os operadores de soma e de subtração, que possuem a mesma precedência, a
execução começará da esquerda para a direita.
valor final compra = valor produto1 + valor produto2 + valor produto3− desconto;
valor final compra = 23.50 + 14.00︸ ︷︷ ︸
37.50
+5.00− 2.00;
valor final compra = 37.50 + 5.00︸ ︷︷ ︸
42.50
−2.00;
valor final compra = 42.50− 2.00︸ ︷︷ ︸
40.50
;
valor final compra = 40.50;
2. Sejam 1, 6 e 8 os valores de a, b e c, respectivamente. Na fórmula de delta existem os
operadores de subtração e de multiplicação, este último tendo precedência sobre o primeiro.
Assim, a última operação a ser realizada é a subtração, e todas as multiplicações são resolvidas
da esquerda para a direita.
delta = b ∗ b− 4 ∗ a ∗ c;
delta = −6 ∗ −6︸ ︷︷ ︸
36
−4 ∗ 1 ∗ 8;
delta = 36− 4 ∗ 1︸︷︷︸
4
∗8;
delta = 36− 4 ∗ 8︸︷︷︸
32
;
delta = 4;
17
3. Seja a seguinte fórmula que calcula a nota que um aluno deverá tirar no exame, onde Ma é a
média anual. Suponha que Ma seja 4.0. Verifique que os operadores com maior precedência
são o da multiplicação e o da divisão. Note ainda que há parênteses, o que indica que o que
está em seu interior deve ser resolvido primeiro.
E = (50− 6 ∗Ma)/4;
E = (50− 6 ∗ 4.0︸ ︷︷ ︸
24.0
)/4;
E = (50− 24.0︸ ︷︷ ︸
26.0
)/4;
E = 26.0/4︸ ︷︷ ︸
6.5
;
E = 6.5;
3.3 Operadores de incremento e de decremento
O operador de incremento ++ é um operador unário que adiciona 1 à variável operando. O
operador de incremento pode ser usado de duas formas: pré-fixado quando aparece antes do
nome da variável e pós-fixado quando aparece em seguida ao nome da variável.
A instrução
x = x + 1;
adiciona 1 ao valor de x e é equivalente a
++x; // pré-fixado
que é equivalente a
x++; // pós-fixado
A diferença entre as operações executadas pelo operador pré-fixado e pós-fixado aparece em
instruções que fazem mais do que somente incrementar a variável operando. Por exemplo:
n = 5 ;
x = ++n ;
cout << "O valor de n é: " << n ;
cout << "O valor de x é: " << x ;
A sáıda será:
O va lo r de n é : 6
O va lo r de x é : 6
O operador de incremento pré-fixado incrementa a variável operando antes de executar a ins-
trução em que ele aparece. Desta forma, n terá seu valor incrementado de 1 antes de ser atribúıdo
a x.
18
Observe agora o próximo exemplo:
n = 5 ;
x = n++;
cout << "O valor de n é: " << n ;
cout << "O valor de x é: " << x ;
A sáıda será:
O va lo r de n é : 6
O va lo r de x é : 5
O operador de incremento pós-fixado incrementa a variável operando logo após a instrução em
que ele aparece. Desta forma, n é atribúıdo a x e depois seu valor é incrementado de 1.
Quando o operador de incremento aparecesozinho em uma instrução não faz diferença o uso
pré-fixado ou pós-fixado.
A sintaxe e modo de uso do operador de decremento (--) pré-fixado e pós-fixado é idêntica à
do operador de incremento, exceto porque a variável é decrementada de 1.
3.4 Operadores aritméticos de atribuição
Esses operadores são binários e combinam as operações aritméticas com atribuição. O operando
da esquerda é sempre o nome de uma variável e o da direita, uma expressão qualquer. A operação
consiste em atribuir um novo valor à variável que dependerá do operador e da expressão à direita.
Como regra geral, se x é uma variável, exp uma expressão e op um operador aritmético, então
x op= exp equivale a x = x op (exp)
As expressões com estes operadores são mais compactas e normalmente muito usadas em C++.
Tabela 3.2: Exemplos de operadores aritméticos de atribuição
i += 2; equivale a i = i + 2;
x *= y + 1; equivale a x = x * (y+1);
t /= 2.5; equivale a t = t / 2.5;
p %= 5; equivale a p = p % 5;
d -= 3; equivale a d = d - 3;
3.5 Operadores relacionais
Operadores relacionais são utilizados para fazer comparações conforme apresentados na Tabela
3.3, sempre necessitando de dois operandos. Uma atenção especial (Exemplo 3.1) é dada quanto
ao uso dos operadores maior ou igual que (>=) e menor ou igual que (<=).
19
Tabela 3.3: Operadores relacionais. Sejam op1 e op2 operandos.
Operador relacional com os operandos Significado
op1 == op2 op1 é igual a op2?
op1 != op2 op1 é diferente de op2?
op1 > op2 op1 é maior que op2?
op1 < op2 op1 é menor que op2?
op1 >= op2 op1 é maior ou igual que op2?
op1 <= op2 op1 é menor ou igual que op2?
Exemplo 3.1 Um caso de uso do operador maior ou igual que (>=).
Suponha que seja de interesse verificar se a média final (Mf) é no mı́nimo 7, 0. Isso significa que
Mf deve ser igual ou maior que 7, 0. Sejam três situações com os seguintes valores para Mf : 7.0,
8.5 e 6.8.
Mf >= 7.0
7.0 >= 7.0
Verdadeiro
Mf >= 7.0
8.5 >= 7.0
Verdadeiro
Mf >= 7.0
6.8 >= 7.0
Falso
Atenção: Os operadores aritméticos têm precedência sobre os operadores relacionais. No
Exemplo 3.2 é verificado se n é um número par.
(continua na próxima página...)
20
Exemplo 3.2 Precedência de operador aritmético sobre relacional.
Suponha duas situações em que os valores para n sejam 13 e 8. Deseja-se checar se n é um número
par. Verifique que primeiro é feito o cálculo do resto e depois a checagem de igualdade.
n % 2 == 0
13 % 2 == 0
1 == 0
Falso
n % 2 == 0
8 % 2 == 0
0 == 0
Verdadeiro
3.6 Operadores lógicos
Operadores lógicos também fazem comparações. A diferença entre comparações lógicas e rela-
cionais está na forma como os operadores avaliam seus operandos. Operandos de operadores lógicos
são avaliados como lógicos (falso ou verdadeiro) e não como numéricos. C++ oferece três operadores
lógicos:
• && : significa E lógico
• || : significa OU lógico
• ! : significa NÃO lógico
Se e1 e e2 são duas expressões, então:
• e1 && e2: resulta verdadeiro somente se e1 e e2 forem verdadeiras. Em qualquer outra
situação, resulta falso. Verifique a Tabela 3.4 e o Exemplo 3.3.
Tabela 3.4: Tabela-verdade do E lógico
Expressão lógica Resultado
V && V V
V && F F
F && V F
F && F F
(continua na próxima página...)
21
Exemplo 3.3 Um caso de uso do operador lógico E
Suponha que se deseje verificar se a nota de um aluno é maior ou igual a 7,0 mas abaixo de 8,0.
Para nota com valor 8, 0:
nota >= 7.0 && nota < 8.0
8.0 >= 7.0 && 8.0 < 8.0
V && F
F
Para nota com valor 7, 0:
nota >= 7.0 && nota < 8.0
7.0 >= 7.0 && 7.0 < 8.0
V && V
V
Para nota com valor 6, 5:
nota >= 7.0 && nota < 8.0
6.5 >= 7.0 && 6.5 < 8.0
F && V
F
• e1 || e2: resulta falso somente se e1 e e2 forem falsas. Em qualquer outra situação, resulta
verdadeiro. Verifique a Tabela 3.5 e o Exemplo 3.4.
Tabela 3.5: Tabela-verdade do OU lógico
Expressão lógica Resultado
V || V V
V || F V
F || V V
F || F F
(continua na próxima página...)
22
Exemplo 3.4 Um caso de uso do operador lógico OU
Suponha que se deseje verificar se sexo é válido. Sexos válidos são ‘f’ (de feminino) e ‘m’ (de
masculino).
Para sexo com valor ‘f’:
sexo == ‘f’ || sexo == ’m’
‘f’ == ‘f’ || ‘f’ == ’m’
V || F
V
Para sexo com valor ‘m’:
sexo == ‘f’ || sexo == ‘m’
‘m’ == ‘f’ || ‘m’ == ‘m’
F || V
V
Para sexo com valor ‘p’:
sexo == ‘f’ || sexo == ‘m’
‘p’ == ‘f’ || ‘p’ == ‘m’
F || F
F
• !e1: resulta verdadeiro somente se e1 for falsa e vice-versa. Verifique a Tabela 3.6 e o Exemplo
3.5.
Tabela 3.6: Tabela-verdade do NÃO lógico
Expressão lógica Resultado
!V F
!F V
(continua na próxima página...)
23
Exemplo 3.5 Um caso de uso do operador lógico NÃO
Suponha que se deseje encontrar o nome de uma pessoa em uma lista telefônica e que exista uma
variável chamada achou que possa ter os valores 0 ou 1, o primeiro indicando que não encontrou a
pessoa e o segundo indicando que a encontrou. Suponha também que interessa saber se a pessoa
não foi encontrada.
Para achou com valor 0:
!achou
!0
V
Para achou com valor 1:
!achou
!1
F
Atenção: na linguagem C++, 0 (zero) representa o valor booleano falso, e tudo que for diferente
de 0 é verdadeiro.
Segundo Forbellone e Eberspächer (2005), tabela-verdade é o conjunto de todas as possibili-
dades combinatórias entre os valores de diversas variáveis lógicas, as quais se encontram em apenas
duas situações (V ou F), em um conjunto de operadores lógicos.
Como exemplos mais elucidativos dos operadores E e OU podem-se citar:
1. Se tiver febre e dor no corpo vou ao médico.
Quando vou ao médico?
Observa-se na tabela-verdade do E que “vou ao médico” quando os termos “tiver febre” e
“tiver dor no corpo” forem simultaneamente verdade.
2. Se tiver febre ou dor no corpo vou ao médico.
Quando vou ao médico?
Observa-se na tabela-verdade do OU que as possibilidades de “vou ao médico” se tornam
maiores, pois será verdadeiro em três situações: somente “ter febre”, somente “ter dor no
corpo” e “ter febre e dor no corpo”.
3.6.1 Precedência de operadores lógicos
Tabela 3.7: Precedência entre os operadores lógicos
Prioridade Operadores
1a N~AO: !
2a E: &&
3a OU: ||
24
3.7 Precedência entre os operadores aritméticos, relacionais e lógicos
Tabela 3.8: Precedência entre os operadores aritméticos, relacionais e lógicos
Prioridade Operadores
1a parênteses mais internos
2a operador lógico N~AO: !
3a operadores aritméticos
4a operadores relacionais
5a operadores lógicos E: && e OU: ||
3.8 Exerćıcios
1. Seja a seguinte expressão: n = z + y ∗ x;
Se desejarmos somar z com y e depois multiplicar seu resultado com x, o que devemos
acrescentar na expressão acima?
2. Escreva e verifique expressões genéricas utilizando variáveis que representem as seguintes
situações:
(a) idade inválida, ou seja, negativa ou igual a zero;
(b) idade válida;
(c) sexo inválido, ou seja, diferente de ‘f’ e de ‘m’;
(d) sexo válido;
(e) idade ou sexo inválidos;
(f) idade e sexo válidos;
(g) idade a partir de 18;
(h) idade de 20 a 30 anos;
(i) número par;
(j) número ı́mpar;
(k) número diviśıvel por 9;
(l) número diviśıvel por 5.
3. Idade e sexo válidos é representado em C++ como:
(idade > 0 && (sexo == ‘F’ || sexo == ‘M’)).
Por que essa expressão não é equivalente à
(idade > 0 && sexo == ‘F’ || sexo == ‘M’)?
4. De acordo com a sua experiência no jogo da forca, responda:
(a) quando é que o jogo termina?
(b) quando é que o jogo continua?
25
CAṔITULO
4
Estruturas Condicionais
As estruturas condicionais permitem determinar qual é a ação a ser tomada com base no resul-
tado de uma expressão condicional. Por exemplo, em um curso de ciência da computação a média
final (Mf) para se passar em uma disciplina é 7, 0. Caso o aluno não a alcance, vai para exame e
terá que tirar no mı́nimo (50− 6×Mf)/4. Caso não passe no exame irá para recuperação, tendo
que tirar pelo menos10 −Mf . Neste exemplo, dependendo do resultado da verificação, a ação a
ser tomada pode ser uma dentre várias; assim, é necessário o uso de estruturas condicionais.
C++ oferece três estruturas condicionais:
1. if: estrutura condicional simples.
2. if - else: estrutura condicional composta.
3. switch: alternativa de estrutura condicional composta, mas possui algumas limitações em
relação à estrutura if - else.
4.1 Estrutura condicional simples: if
Na estrutura condicional simples sem chaves, cuja forma geral é apresentada em Listing 4.1,
a instrução no corpo do if só será executada se a expressão condicional for verdadeira. Uma
expressão condicional é uma comparação que possui dois valores posśıveis: verdadeiro ou falso.
Verifique o Exemplo 4.1.
Listing 4.1: Forma geral da estrutura condicional simples sem chaves
i f ( expres s ã o c ond i c i ona l )
i n s t ru ç ã o ; / / c o r p o d o i f
26
Exemplo 4.1 Trecho de código que utiliza a condicional simples sem chaves.
Suponha que se deseje parabenizar as mulheres pelo seu dia (8 de março). Caso não seja o dia das
mulheres ou o usuário seja homem, não emite mensagem.
if(sexo_usuario==‘f’ && dia==8 && mes==3)
cout << "Parabens, mulher, pelo seu dia!";
Para imprimir a frase de congratulações, o sexo deverá ser ‘f’, o dia 8 e o mês 3, resultando em
verdadeira a expressão condicional.
Em C++, é obrigatória a utilização de chaves quando houver mais de uma instrução a ser
executada quando a expressão condicional for verdadeira. A forma geral da estrutura condicional
simples com chaves é apresentada em Listing 4.2. As instruções entre as chaves { e }, que fazem
parte do corpo do if, só serão executadas se a expressão condicional for verdadeira. A chave de
abertura indica ińıcio do bloco (corpo) que será executado se a expressão condicional for verdadeira.
A outra chave indica o fim do bloco (corpo). Verifique o Exemplo 4.2.
Listing 4.2: Forma geral da estrutura condicional simples com chaves
i f ( expres s ã o c ond i c i ona l )
{
/ / c o r p o d o i f ( i n s t r u ç ã o 1 a i n s t r u ç ã o n )
i n s t ru ç ã o 1 ;
i n s t ru ç ã o 2 ;
in s t ru ç ã on ;
}
Exemplo 4.2 Trecho de código que utiliza a condicional simples com chaves.
Seja o exemplo anterior e suponha que se deseje calcular e imprimir a quantidade de mulheres que
acessaram o sistema no dia 8 de março.
if(sexo_usuario==‘f’ && dia==8 && mes==3)
{
cout << "Parabéns, mulher, pelo seu dia!";
cout << "Você é a " << cont + 1 << "a. mulher a acessar o sistema hoje.";
cont++; // ou cont = cont + 1. Inicialmente, cont receberá o valor 0.
}
Verifique que há três instruções no corpo da instrução if: dois cout e um incremento de variável
contadora. Assim, devem-se utilizar as chaves.
Atenção: Um contador é uma variável que, dado um valor inicial (geralmente zero), é incre-
mentada (somada) a um valor constante, geralmente 1.
No Exemplo 4.3 é apresentado problema que utiliza contador em uma seqüência de estruturas
condicionais simples.
27
Exemplo 4.3 Trecho de código que utiliza seqüencialmente várias condicionais simples sem chaves.
Suponha que se deseje verificar quantas notas de um total de quatro são maiores que 9.0.
cont = 0;
if (N1 > 9.0)
cont++; // cont = cont + 1
if (N2 > 9.0)
cont++; // cont = cont + 1
if (N3 > 9.0)
cont++; // cont = cont + 1
if (N4 > 9.0)
cont++; // cont = cont + 1
cout << "A quantidade de notas maiores que 9,0 é: " << cont;
Verifique que há a necessidade de se verificar cada uma das notas, que sendo maior que 9,0,
incrementa-se a variável contadora.
4.2 Estrutura condicional composta: if - else
A forma geral da estrutura condicional composta sem chaves é apresentada em Listing 4.3. Se
a expressão condicional for verdadeira, será executada a instrução 1; caso contrário – a expressão
condicional é falsa, será executada a instrução 2.
Listing 4.3: Forma geral da estrutura condicional composta sem chaves
i f ( expres s ã o c ond i c i ona l )
i n s t ru ç ã o 1 ; / / c o r p o d o i f
else
i n s t ru ç ã o 2 ; / / c o r p o d o e l s e
Já a forma geral da estrutura condicional composta com chaves é apresentada em Listing 4.4.
Se a expressão condicional for verdadeira, as instruções 1 e 2 (corpo do if) serão executadas; caso
contrário, as instruções 3 e 4 (corpo do else) serão executadas.
Listing 4.4: Forma geral da estrutura condicional composta com chaves
i f ( expres s ã o c ond i c i ona l )
{
/ / c o r p o d o i f
i n s t ru ç ã o 1 ;
i n s t ru ç ã o 2 ;
}
else
{
/ / c o r p o d o e l s e
i n s t ru ç ã o 3 ;
i n s t ru ç ã o 4 ;
}
28
4.2.1 Exemplos utilizando estrutura condicional composta
1. Programa que faz a divisão de dois números inteiros passados pelo usuário. Lembre-se que é
imposśıvel fazer divisão por zero. Emita uma mensagem caso isso ocorra.
Listing 4.5: Programa que faz a divisão de dois números inteiros.
1 void main ( )
2 {
3 int dividendo , d i v i s o r ;
4 f loat quoc i ente ;
5
6 cout << "Entre com o dividendo e o divisor, respectivamente: " ;
7 c in >> div idendo >> d i v i s o r ;
8
9 i f ( d i v i s o r != 0)
10 {
11 quoc i ente = ( f loat ) d iv idendo / d i v i s o r ;
12 cout << "O quociente é: " << quoc i ente ;
13 }
14 else
15 cout << "Impossı́vel fazer a divis~ao. O divisor é igual a zero." ;
16
17 getch ( ) ;
18 }
Neste exemplo, deve-se verificar se o divisor é diferente de zero, pois só assim é posśıvel fazer a
divisão. Um dado importante é que o quociente da divisão entre números inteiros pode ser um
número real. Assim, mesmo declarando a variável quociente como float, é necessário que
se converta o valor do dividendo ou do divisor para um número real. Isso é feito colocando-se
o tipo float entre parênteses antes da variável, neste caso dividendo.
Note que há duas instruções (nas linhas 11 e 12 ) que serão executadas caso o divisor seja
diferente de zero. Assim, as chaves devem ser utilizadas.
Nas Tabelas 4.1 e 4.2 são apresentados dois testes de mesa para o programa da divisão.
Tabela 4.1: Teste de mesa do programa de divisão utilizando dividendo 21 e divisor 0.
Variáveis Comparação Sáıda
# [ ] dividendo divisor quociente divisor != 0
1 3 lixo lixo
2 4 lixo lixo lixo
3 6 lixo lixo lixo Entre com o dividendo e o divisor...
4 7 21 0 lixo
5 9 21 0 lixo Falso
6 15 21 0 lixo Imposśıvel fazer a divisão. O divisor ....
7 17 21 0 lixo Espera o pressionamento de alguma tecla
29
Tabela 4.2: Teste de mesa do programa de divisão utilizando dividendo 21 e divisor 4.
Variáveis Comparação Sáıda
# [ ] dividendo divisor quociente divisor != 0
1 3 lixo lixo
2 4 lixo lixo lixo
3 6 lixo lixo lixo Entre com o dividendo e o divisor...
4 7 21 4 lixo
5 9 21 4 lixo Verdadeiro
6 11 21 4 5.25
7 12 21 4 5.25 O quociente é: 5.25
8 17 21 4 5.25 Espera o pressionamento de alguma tecla
2. Programa de uma calculadora de 4 operações aritméticas: adição, subtração, multiplicação e
divisão. A entrada segue o seguinte formato: operando operador operando. Exemplo: se o
usuário entrar com 5∗7 será impresso “O resultado da multiplicação é: 35”. Caso o operador
seja inválido, emita uma mensagem.
Listing 4.6: Programa que simula uma calculadora de 4 operações aritméticas.
1 void main ( )
2 {
3 f loat n1 , n2 , r e s ;
4 char op ;
5
6 cout << "Digite NUMERO OPERADOR NUMERO: " ;
7 c in >> n1 >> op >> n2 ;
8
9 i f ( op == ’+’ )
10 {
11 r e s = n1 + n2 ;
12 cout << "O resultado da soma é: " << r e s ;
13 }
14 else i f ( op == ’-’ )
15 {
16 r e s = n1 − n2 ;
17 cout << "O resultado da subtraç~ao é: " << r e s ;
18 }
19 else i f ( op == ’/’ )
20 {
21 r e s = n1 / n2 ;
22 cout << "O resultado da divis~ao é: " << r e s ;
23 }
24 else i f ( op == ’*’ )
25 {
26 r e s = n1 ∗ n2 ;
27 cout << "O resultado da multiplicaç~ao é: " << r e s ;
28 }
29 else
30 cout << "Operador inválido!" ;
31
32 getch ( ) ;
33 } / / f i m ma i n
Nesteexemplo, existem várias expressões condicionais que, a partir do momento em que uma
é verdadeira, não há a necessidade de se verificar as demais, pois a variável op só pode ser
30
um dos operadores aritméticos ou um operador inválido (diferente dos demais). Assim, a
construção mais adequada para a resolução deste problema é o uso de estruturas condicionais
compostas encadeadas if - else. Por exemplo, se op é o caracter ‘#’ (teste de mesa na
Tabela 4.3), a expressão condicional da linha 9 resulta em falsa. Dáı a execução vai para
a linha 14, na qual é verificada outra expressão condicional, que também resulta em falsa.
Como op não é igual aos caracteres ‘/’ e ‘∗’, chega-se ao último else, no qual é impresso que
o operador é inválido.
Tabela 4.3: Teste de mesa da calculadora utilizando n1 igual a 15, n2 igual a 6 e op igual a ‘#’.
Variáveis Comparações Sáıda
# [ ] n1 n2 res op op == ‘+’ op == ‘-’ op == ‘/’ op == ‘+’
1 3 lixo lixo lixo
2 4 lixo lixo lixo lixo
3 6 lixo lixo lixo lixo Digite NUMERO ...
4 7 15 6 lixo ‘#’
5 9 15 6 lixo ‘#’ Falso
6 14 15 6 lixo ‘#’ Falso
7 19 15 6 lixo ‘#’ Falso
8 24 15 6 lixo ‘#’ Falso
9 29 15 6 lixo ‘#’
10 30 15 6 lixo ‘#’ Operador inválido!
11 32 15 6 lixo ‘#’ Espera o pressionamento...
Caso op seja o caracter ‘-’ (teste de mesa na Tabela 4.4), a expressão condicional da linha
9 resulta em falsa. Dáı a execução vai para a instrução de linha 14, na qual resulta em
verdadeira. Assim, como as demais instruções possuem else, a execução do programa vai
para a próxima instrução após eles, o getch(), que está na linha 32.
Tabela 4.4: Teste de mesa da calculadora utilizando n1 igual a 15, n2 igual a 6 e op igual a ‘-’.
Variáveis Comparações Sáıda
# [ ] n1 n2 res op op == ‘+’ op == ‘-’ op == ‘/’ op == ‘+’
1 3 lixo lixo lixo
2 4 lixo lixo lixo lixo
3 6 lixo lixo lixo lixo Digite NUMERO ...
4 7 15 6 lixo ‘-’
5 9 15 6 lixo ‘-’ Falso
6 14 15 6 lixo ‘-’ Verdadeiro
7 16 15 6 9 ‘-’
8 17 15 6 9 ‘-’ O resultado da subtração...
9 32 15 6 9 ‘-’ Espera o pressionamento...
4.3 Alternativa de estrutura condicional composta: switch
Embora construções if - else possam executar testes para escolha de uma entre várias alter-
nativas, muitas vezes são deselegantes. O comando switch tem um formato limpo e claro. Sua
forma geral é apresentada em Listing 4.7.
31
Listing 4.7: Forma geral da estrutura condicional switch
switch (nome da va r i á v e l )
{
case constante1 :
i n s t ru ç ã o 1 ;
i n s t ru ç ã o 2 ;
. . .
break ;
case constante2 :
i n s t ru ç ã o 3 ;
i n s t ru ç ã o 4 ;
. . .
break ;
default :
i n s t ru ç ã o 5 ;
i n s t ru ç ã o 6 ;
. . .
}
O comando switch possui as seguintes regras:
• O corpo de um switch deve estar entre chaves;
• Pode haver nenhuma, uma ou mais instruções seguindo cada caso. Geralmente, a última
instrução de um caso é break, que causa a sáıda imediata de todo o corpo do switch. Na
falta dele, todas as instruções após o caso escolhido serão executadas, mesmo as que pertencem
aos casos seguintes;
• switch testa a variável que deve ser do tipo int ou char;
• Não se pode usar uma variável ou expressão lógica como rótulo de caso (que vem após o
case). É apenas permitido constantes do tipo int ou char;
• Cada um dos cases pode ser considerado um if;
• Um caso default é opcional. Pode ser encarado como o else de todos os ifs. Ou seja, se
nenhum caso for satisfeito e existir um caso default, a execução começará nele.
4.3.1 Exemplos utilizando switch
1. Resolução da calculadora (Exemplo 2 da Seção 4.2.1 – pág. 30) utilizando switch.
Listing 4.8: Programa da calculadora de 4 operações aritméticas utilizando switch.
1 void main ( )
2 {
3 f loat n1 , n2 , r e s ;
4 char op ;
5
6 cout << "Digite NUMERO OPERADOR NUMERO: " ;
7 c in >> n1 >> op >> n2 ;
8
32
9 switch ( op )
10 {
11 case ’+’ :
12 r e s = n1 + n2 ;
13 cout << "O resultado da soma é: " << r e s ;
14 break ;
15 case ’-’ :
16 r e s = n1 − n2 ;
17 cout << "O resultado da subtraç~ao é: " << r e s ;
18 break ;
19 case ’/’ :
20 r e s = n1 / n2 ;
21 cout << "O resultado da divis~ao é: " << r e s ;
22 break ;
23 case ’*’ :
24 r e s = n1 ∗ n2 ;
25 cout << "O resultado da multiplicaç~ao é: " << r e s ;
26 break ;
27 default :
28 cout << "Operador inválido!" ;
29 } / / f i m s w i t c h
30
31 getch ( ) ;
32 } / / f i m ma i n
Os operadores são caracteres, por isso estão entre apóstrofos. Se a variável a ser analisada fosse
do tipo inteiro, não se deveria colocar apóstrofos entre as constantes. Verifique o comando
break após cada caso. Verifique também o default como última alternativa, ou seja, caso
op não seja igual a nenhum dos caracteres anteriores.
2. Suponha que se deseje permitir que o usuário do programa da calculadora utilize o sinal * ou
x para indicar multiplicação e o sinal / ou \ para indicar divisão.
Listing 4.9: Programa da calculadora de 4 operações aritméticas utilizando switch com alguns
casos sem break.
1 void main ( )
2 {
3 f loat n1 , n2 , r e s ;
4 char op ;
5
6 cout << "Digite NUMERO OPERADOR NUMERO: " ;
7 c in >> n1 >> op >> n2 ;
8
9 switch ( op )
10 {
11 case ’+’ :
12 r e s = n1 + n2 ;
13 cout << "O resultado da soma é: " << r e s ;
14 break ;
15 case ’-’ :
16 r e s = n1 − n2 ;
17 cout << "O resultado da subtraç~ao é: " << r e s ;
33
18 break ;
19 case ’\\’ :
20 case ’/’ :
21 r e s = n1 / n2 ;
22 cout << "O resultado da divis~ao é: " << r e s ;
23 break ;
24 case ’x’ :
25 case ’*’ :
26 r e s = n1 ∗ n2 ;
27 cout << "O resultado da multiplicaç~ao é: " << r e s ;
28 break ;
29 default :
30 cout << "Operador inválido!" ;
31 } / / f i m s w i t c h
32
33 getch ( ) ;
34 } / / f i m ma i n
Neste exemplo, alguns casos devem executar as mesmas instruções, dáı a construção de casos
sem break (linhas 19 e 24 ).
4.4 Exerćıcios
1. Faça um programa que apresente o menu de opções a seguir, permita ao usuário escolher a
opção desejada, receba os dados necessários para executar a operação e mostre o resultado.
Verifique a possibilidade de opção inválida e não se preocupe com restrições como salário
negativo. Faça duas soluções diferentes, uma com e outra sem switch.
Menu de opç~oes:
1. Imposto
2. Novo Salário
3. Classificaç~ao
Digite a opç~ao desejada
Na opção 1, receba o salário de um funcionário e calcule o valor do imposto usando as regras
a seguir:
Salários Percentual do imposto
Menor que R$500,00 5,00%
De R$500,00 a R$850,00 10,00%
Acima de R$850,00 15,00%
Na opção 2, receba o salário de um funcionário e calcule o valor do novo salário, usando as
regras a seguir:
34
Salário Aumento
Maiores que R$1500,00 R$ 25,00
De R$750,00 a R$1500,00 R$ 50,00
Abaixo de R$750,00 a R$450,00 R$ 75,00
Menores que R$450,00 R$ 100,00
Na opção 3, receba o salário de um funcionário e mostre sua classificação usando a tabela a
seguir:
Salário Classificação
Até R$700,00 Mal remunerado
Superior a R$700,00 Bem remunerado
2. A nota final de uma disciplina é calculada a partir de três notas atribúıdas respectivamente
a uma avaliação bimestral, a um trabalho de laboratório e a um seminário. A média das três
notas mencionadas anteriormente obedece aos pesos a seguir, respectivamente: 5, 3 e 2.
Faça um programa que receba as três notas, calcule e mostre a média ponderada e o conceito
que segue a tabela abaixo:
Média Ponderada Conceito
De 8,0 a 10,0 A
Abaixo de 8,0 até 7,0 B
Abaixo de 7,0 até 6,0 C
Abaixo de 6,0 até 5,0 D
Abaixo de 5,0 E
3. Nos cursos seqüenciais da Barão de Mauá a média final (MF ) de uma disciplina é calculada da
seguinte forma: MF = (NP +2×NE)/3, onde NP é a nota da prova e NE a nota do exame.
Para passar direto na disciplina a MF deverá ser no mı́nimo 5,0. Caso contrário, o aluno vai
para recuperação necessitando tirar pelo menos 5,0 pontos. Assim, faça um programa que
peça ao usuário o valor da NP , calcule e imprima a nota mı́nima que o aluno deverátirar na
NE. Em seguida, peça ao usuário a NE e verifique se o aluno está de recuperação ou não,
emitindo as mensagens correspondentes.
4. Uma definição precisa do peso ideal deve levar em conta vários fatores, como o sexo, a idade, a
atividade f́ısica e a constituição do organismo da pessoa. Existe, no entanto, um cálculo mais
simples, indicado pela Organização Mundial da Saúde, que é chamado de Índice de Massa
Corporal, ou IMC, que relaciona o peso e a altura do indiv́ıduo. Para chegar a esse número,
deve-se dividir o peso, medido em quilos, pelo quadrado da altura, em metros. Conforme o
valor de IMC, pode-se fazer parte de quatro faixas de peso. Uma delas indica o peso ideal,
que proporciona mais saúde.
(continua na próxima página...)
35
IMC Significa
Menos de 18,5 Abaixo do peso
De 18,5 a menor que 25 Peso ideal
De 25 a menor que 30 Sobrepeso
Maior ou igual a 30 Obesidade
Assim, faça um programa que calcule o IMC de dados passados pelo usuário, imprimindo a
qual faixa pertence.
5. Denomina-se equação do segundo grau a que possui a forma ax2 + bx + c, com coeficientes
numéricos a, b e c com a 6= 0. A fórmula do delta é: ∆ = b2 − 4ac. Após verificar a tabela
de exemplos e de propriedades, faça um programa que resolva equações do 2o grau pedindo
ao usuário os coeficientes e mostrando os devidos resultados. Para resolver raiz quadrada,
utilize a função sqrt(numero) da biblioteca math.h.
Tabela 4.5: Exemplos de coeficientes para equação do 20 grau.
Equação a b c
x2 + 2x + 1 1 2 1
5x− 2x2 − 1 5 -2 -1
Tabela 4.6: Propriedades
∆ = 0 Duas ráızes reais e iguais: x′ = x′′ = −b/(2a)
∆ < 0 Nenhuma raiz real
∆ > 0 Duas ráızes reais e diferentes: x′ = (−b +
√
∆)/(2a), x′′ = (−b−
√
∆)/(2a)
6. Faça um programa que, a partir de um mês fornecido (número inteiro de 1 a 12), apresente
o nome dele por extenso ou uma mensagem de mês inválido.
7. Faça um programa que seja capaz de dar a classificação oĺımpica de 3 páıses informados. Para
cada páıs é informada a quantidade de medalhas de ouro, prata e bronze. Considere que cada
medalha de ouro tem peso 3, cada prata tem peso 2 e cada bronze, peso 1.
36
CAṔITULO
5
Estruturas de Repetição
Existem situações em que é necessário repetir um determinado trecho de programa um número
de vezes ou até que algo aconteça. Veja os seguintes exemplos:
1. Suponha que um usuário deseje verificar a área de um número não determinado de triângulos.
O problema é que não se sabe a quantidade exata de triângulos. Se fosse implementado um
programa que verificasse a área de apenas um triângulo, o usuário teria que executá-lo quantas
vezes fosse necessário, saindo e entrando novamente no programa. Assim, será que é posśıvel
implementar um programa que repetisse a verificação enquanto o usuário desejasse, fazendo-
lhe uma pergunta como “Deseja verificar área de outro triângulo?”.
2. Suponha que o objetivo de um programa seja calcular e imprimir a tabuada do 4. Verifique
que existem repetições, como a impressão “4×” e o cálculo da multiplicação. Se fosse im-
plementado um programa com o conhecimento até agora adquirido, seria repetido 11 vezes
(4× 0,..., 4× 10) o mesmo código da multiplicação.
3. Suponha que se deseje calcular a soma de idades de um número indeterminado de pessoas em
que o usuário digita uma idade inválida (0 ou um número negativo) quando deseja encerrar
a entrada das idades. Assim, repetem-se a entrada e o cálculo da soma, terminando quando
o usuário digita uma idade inválida.
Assim, toda vez que se identifica um comportamento de repetição, seja expĺıcito ou não, devem-
se utilizar as estruturas de repetição para generalizar tal comportamento, utilizando, assim, uma
correta lógica de programação. Caso o programador não utilize essas estruturas, estará repetindo
trechos de códigos várias vezes, o que é trabalhoso, deselegante e muitas vezes inviável.
C++ possui três tipos de estruturas de repetição, também chamadas de loops ou laços:
1. for: recomendado quando há um número determinado de repetições.
2. while: recomendado quando há um número indeterminado de repetições.
3. do - while: também é recomendado quando há um número indeterminado de repetições,
mas possui diferença em relação ao while.
Apesar de cada laço ter a sua recomendação, todo problema pode ser resolvido com qualquer
laço. Existem diferenças entre eles, como na sintaxe e em seu próprio uso.
37
5.1 O laço for
Engloba três expressões em uma única e é útil principalmente quando se quer repetir algo um
número fixo de vezes.
Listing 5.1: Forma geral do laço for
for ( i n i c i a l i z a ç ã o ; expres s ã o c ond i c i ona l ; in /decremento )
i n s t ru ç ã o ; / / c o r p o d o l a ç o
Devem-se usar chaves se o corpo do laço tiver mais de uma instrução. Os parênteses seguindo
a palavra-chave for contêm três expressões separadas por pontos-e-v́ırgulas:
1. Inicialização: em sua forma mais simples, é uma instrução de atribuição (i = 0 em Listing
5.2) e é sempre executada uma única vez antes do laço ser iniciado.
2. Expressão condicional: é uma instrução de condição que controla o laço (i<=10 em Listing
5.2). Essa expressão é avaliada como verdadeira ou falsa toda vez que o laço for iniciado ou
reiniciado. Se verdadeira (diferente de zero), o corpo do laço é executado. Quando a expressão
tornar-se falsa (igual a zero), o laço é terminado e o controle passa para a instrução seguinte
ao laço.
3. in/decremento: define a maneira como a variável de controle do laço será alterada cada vez
que o laço é repetido (i++ em Listing 5.2), que pode ser um incremento ou decremento. Essa
instrução é executada, toda vez, imediatamente após a execução do corpo do laço.
5.1.1 Exemplo – Cálculo e impressão da tabuada do 4
Esse é um problema em que o laço for se adequa melhor: existe um número fixo de repetições.
Perceba que a tabuada pode ser generalizada para 4 × i, onde i varia de 0 a 10. Na Tabela 5.1 é
apresentado seu teste de mesa.
Listing 5.2: Resolução da tabuada do 4.
1 void main ( )
2 {
3 int i , prod ;
4
5 cout << "Tabuada do 4" ;
6 for ( i =0; i <=10; i++)
7 {
8 prod = 4 ∗ i ;
9 cout << "4 x " << i << " = " << prod ;
10 }
11 getch ( ) ;
12 }
38
Tabela 5.1: Teste de mesa para o programa da tabuada do 4 utilizando o laço for.
Variáveis Condição Sáıda
# [ ] i prod i <= 10
1 3 lixo lixo
2 5 lixo lixo Tabuada do 4
3 6 0 lixo V
4 8 0 0
5 9 0 0 4 x 0 = 0
6 6 1 0 V
7 8 1 4
8 9 1 4 4 x 1 = 4
9 6 2 4 V
10 8 2 8
11 9 2 8 4 x 2 = 8
... ... ... ... ... ...
6 10 36 V
8 10 40
9 10 40 4 x 10 = 40
6 11 40 F
11 11 40 Espera o pressionamento de alguma tecla...
5.2 O laço while
Se a expressão condicional for verdadeira (diferente de zero), o corpo do laço while é executado
uma vez e a expressão de teste é avaliada novamente. Quando há uma única instrução no corpo do
laço while, não é necessário o uso de chaves; porém, quando há mais de uma instrução é obrigatório
seu uso.
Listing 5.3: Forma geral do laço while
while ( expres s ã o c ond i c i ona l )
i n s t ru ç ã o ; / / c o r p o d o l a ç o
O ciclo de teste e execução é repetido até que a expressão de teste se torne falsa (igual a zero).
Então, o laço termina e o controle do programa passa para a linha seguinte ao laço.
O laço while pode utilizar os mesmos elementos do laço for, mas eles são distribúıdos de
maneira diferente no programa. Em geral, um laço while pode substituir um laço for da seguinte
forma:
Listing 5.4: Como o laço while pode substituir o laço for
i n i c i a l i z a ç ã o ;
while ( expres s ã o c ond i c i ona l )
{
. . .
in /decremento ;
. . .
}
39
5.2.1 Exemplos utilizando o laço while
1. O exemplo da tabuada do 4 resolvido com o laço while.
Listing 5.5: Programa da tabuada do 4 utilizando o laço while.
1 void main ( )
2 {
3 int i , prod ;
45 cout << "Tabuada do 4" ;
6 i =0; / / i n i c i a l i z a ç ã o
7 while ( i <=10) / / e x p r e s s ã o c o n d i c i o n a l
8 {
9 prod = 4 ∗ i ;
10 cout << "4 x " << i << " = " << prod ;
11 i++; / / i n c r e m e n t o
12 }
13 getch ( ) ;
14 }
Tabela 5.2: Teste de mesa para o programa da tabuada do 4 que utiliza while.
Variáveis Condição Sáıda
# [ ] i prod i <= 10
1 3 lixo lixo
2 5 lixo lixo Tabuada do 4
3 6 0 lixo
4 7 0 lixo V
5 9 0 0
6 10 0 0 4 x 0 = 0
7 11 1 0
8 7 1 0 V
9 9 1 4
10 10 1 4 4 x 1 = 4
11 11 2 4
... ... ... ... ... ...
7 10 36 V
9 10 40
10 10 40 4 x 10 = 40
11 11 40
7 11 40 F
13 11 40 Espera o pressionamento de alguma tecla...
2. A solução do terceiro exemplo do ińıcio deste caṕıtulo: “Suponha que se deseje calcular a
soma de idades de um número indeterminado de pessoas em que o usuário digita uma idade
inválida (0 ou um número negativo) quando deseja encerrar a entrada das idades”.
Listing 5.6: Programa que resolve o problema das idades.
1 void main ( )
2 {
3 int idade , soma ;
40
4
5 cout << "Entre com uma idade: " ;
6 c in >> idade ;
7
8 soma = 0 ;
9
10 while ( idade > 0)
11 {
12 soma = soma + idade ;
13
14 cout << "Entre com outra idade: " ;
15 c in >> idade ;
16 }
17
18 cout << "A soma das idades é: " << soma ;
19 getch ( ) ;
20 }
Verifique que na linha 12 foi utilizada a variável acumuladora soma para somar as idades
válidas. Note que há uma semelhança muito grande com contadores. A única diferença é
que na acumulação o valor adicionado pode variar (variável idade, no exemplo), enquanto
que na contagem o valor adicionado é constante (geralmente 1).
Foram realizados dois testes de mesa para esse programa nas Tabelas 5.3 e 5.4.
Tabela 5.3: Teste de mesa do programa das idades com as entradas 12, 20, 18 e 0, nesta ordem.
Variáveis Condição Sáıda
# [ ] idade soma idade > 0
1 3 lixo lixo
2 5 lixo lixo Entre com uma idade:
3 6 12 lixo
4 8 12 0
5 10 12 0 V
6 12 12 12
7 14 12 12 Entre com outra idade:
8 15 20 12
9 10 20 12 V
10 12 20 32
11 14 20 32 Entre com outra idade:
12 15 18 32
13 10 18 32 V
14 12 18 40
15 14 18 40 Entre com outra idade:
16 15 0 40
17 10 0 40 F
18 18 0 40 A soma das idades é: 40
19 19 0 40 Espera o pressionamento de alguma tecla...
41
Tabela 5.4: Teste de mesa do programa das idades com uma única entrada: zero.
Variáveis Condição Sáıda
# [ ] idade soma idade > 0
1 3 lixo lixo
2 5 lixo lixo Entre com uma idade:
3 6 0 lixo
4 8 0 0
5 10 0 0 F
18 18 0 0 A soma das idades é: 0
19 19 0 0 Espera o pressionamento de alguma tecla...
5.3 O laço do - while
É bastante similar ao while. O laço do - while cria um ciclo repetido até que a expressão de
teste seja falsa (igual a zero).
A diferença entre os dois laços é que no laço do - while o teste de condição é avaliado depois
do corpo do laço ser executado. Assim, o corpo do laço do - while é executado pelo menos uma
vez.
Listing 5.7: Forma geral do laço do - while
do{
/ / c o r p o d o l a ç o
i n s t ru ç ã o ;
}while ( expres s ã o c ond i c i ona l ) ;
Atenção: Não esqueça do ponto-e-v́ırgula após o fechamento de parêntese.
5.3.1 Exemplo usando o laço do - while
Suponha o primeiro exemplo do ińıcio deste caṕıtulo: “Suponha que um usuário deseje verificar
a área de um número não determinado de triângulos...”.
1 void main ( )
2 {
3 c l r s c r ( ) ;
4 f loat area , base , a l t u r a ;
5 char re sp ;
6
7 cout << "Calculo da area de triangulo\n" ;
8
9 do{
10 cout << "\nEntre com a base:" ;
11 c in >> base ;
12 cout << "Entre com a altura:" ;
13 c in >> a l tu r a ;
14
15 area = ( base ∗ a l tu r a ) / 2 ;
16
42
17 cout << "Resultado: " << area ;
18
19 cout << "\n\nDeseja calcular a area de outro triangulo?" ;
20 c in >> re sp ;
21 }while ( re sp == ’s’ ) ;
22
23 getch ( ) ;
24 }
Verifique que o corpo do laço do - while é executado pelo menos a primeira vez antes da
verificação da condição do laço. Acompanhe seu teste de mesa na Tabela 5.5.
Tabela 5.5: Teste de mesa para o programa de área de triângulos.
Variáveis Condição Sáıda
# [ ] area base altura resp resp == ‘s’
1 4 lixo lixo lixo
2 5 lixo lixo lixo lixo
3 7 lixo lixo lixo lixo Calculo da area de triangulo
4 10 lixo lixo lixo lixo Entre com a base:
5 11 lixo 10 lixo lixo
6 12 lixo 10 lixo lixo Entre com a altura:
7 13 lixo 10 5 lixo
8 15 25 10 5 lixo
9 17 25 10 5 lixo Resultado: 25
10 19 25 10 5 lixo Deseja calcular a area de outro triangulo?
11 20 25 10 5 s
12 21 25 10 5 s V
13 10 25 10 5 s Entre com a base:
14 11 25 20 5 s
15 12 25 20 5 s Entre com a altura:
16 13 25 20 3 s
17 15 30 20 3 s
18 17 30 20 3 s Resultado: 30
19 19 30 20 3 s Deseja calcular a area de outro triangulo?
20 20 30 20 3 n
21 21 30 20 3 n F
22 23 30 20 3 n Espera o pressionamento de alguma tecla...
43
5.4 Exerćıcios
1. Faça um programa que leia um número inteiro e calcule e mostre a tabuada desse número.
2. Faça um programa que leia a altura de 5 pessoas. Calcule e mostre a média das alturas
fornecidas pelo usuário. Faça duas soluções diferentes, uma com o laço for e outra com o
laço while.
3. Faça um programa que verifique e mostre quantos e quais números de 1000 a 2000 são diviśıveis
por 4.
4. Faça um programa que leia a idade e o sexo de um número não determinado de pessoas. A
digitação de entradas termina quando a idade ou o sexo for inválido. Idade inválida é aquela
negativa ou igual a zero. Sexo inválido é aquele diferente de ‘f ’ e de ‘m’. Calcule e mostre:
(a) a média de idade de todas as pessoas;
(b) a média de idade das mulheres;
(c) a média de idade dos homens.
5. Faça um programa que permita calcular a média final em uma disciplina de um número
não determinado de alunos. O programa deverá ser executado até que o usuário não deseje
mais verificar médias, aceitando como resposta válida ‘s’ ou ‘S’. A fórmula da média final é
ponderada e possui apenas duas notas, com pesos 1 e 2, respectivamente.
6. Faça um programa que apresente o seguinte menu ao usuário:
Menu:
1 verificar se numero é par ou ı́mpar
2 verificar se número é divisı́vel por 5 e por 7 ao mesmo tempo
3 - sair
O programa só será finalizado quando o usuário entrar com a opção 3. Caso a opção seja
inválida, emita uma mensagem.
7. Faça um programa que receba números inteiros, um por vez, calcule e mostre:
(a) a média dos números digitados;
(b) o maior número digitado;
(c) o menor número digitado;
(d) a média dos números pares.
A última entrada, que não entrará nos cálculos, contém valor superior a 1000 ou menor que
1.
8. Faça um programa que leia um número não determinado de pares de valores [m,n] inteiros,
um par de cada vez e calcule e mostre a soma de todos os números de m a n. A digitação de
pares termina quando m for maior ou igual a n.
9. Faça um programa que mostre as tabuadas dos números de 2 a 10.
10. Em um campeonato de futebol existem cinco times e cada time possui onze jogadores. Faça
um programa que leia a idade, o peso e a altura de cada um dos jogadores. Calcule e mostre:
(a) a quantidade de jogadores com idade inferior a 18 anos;
44
(b) a média das idades dos jogadores de cada time;
(c) a média das alturas de todos os jogadores do campeonato;
(d) a porcentagem de jogadores com mais de 80 quilos entre todos os jogadores do campe-
onato.
11. Imagine uma brincadeira entre dois colegas, na qual um pensa um número e o outro deve
fazer chutes até acertar o número imaginado. Como dica, a cada tentativa é dito se o chute
foi alto ou foi baixo. Faça um programa dentro deste contexto, que leia o número imaginado
e os chutes, ao final mostre quantas tentativas foram necessárias para descobrir o número.
12. Faça um programa que permita fazer um levantamento do estoque de vinhos de uma adega,
tendo como dados de entrada tipos de vinho, sendo: ‘T’ para tinto, ‘B’ para branco e ‘R’ para
rosê. Especifique a porcentagem de cada tipo sobre o total geral de vinhos; a quantidade de
vinhosé desconhecida, utilize como finalizador ‘F’ de fim.
13. Faça um programa que efetue a soma de todos os números ı́mpares que são múltiplos de 3 e
que se encontram no conjunto dos números de 1 até 50.
14. Foi realizada uma pesquisa sobre algumas caracteŕısticas f́ısicas da população de uma certa
região, a qual coletou os seguintes dados referentes a cada habitante para análise:
• sexo (‘M’ - masculino ou ‘F’ - feminino);
• cor dos olhos (‘A’ - azuis, ‘V’ - verdes ou ‘C’ - castanhos);
• cor dos cabelos (‘L’ - loiros, ‘C’ - castanhos ou ‘P’ - pretos);
• idade.
Faça um programa que determine e imprima:
(a) a maior idade dos habitantes;
(b) a porcentagem entre os indiv́ıduos do sexo masculino, cuja idade é de 18 a 30 anos;
(c) a porcentagem do total de indiv́ıduos do sexo feminino cuja idade é de 18 a 30 anos e
que tenham olhos verdes e cabelos loiros;
O final do conjunto de habitantes é reconhecido pelo valor -1 entrando como idade.
45
CAṔITULO
6
Vetores
São um tipo de dado em C++ usado para representar uma coleção de variáveis do mesmo tipo.
Imagine o seguinte problema: calcular a média aritmética das notas de provas de cinco alunos.
Assim, poder-se-ia escrever o seguinte programa:
Listing 6.1: Programa que calcula média de cinco alunos sem utilizar vetor.
void main ( )
{
f loat nota1 , nota2 , nota3 , nota4 ,
nota5 , media ;
cout << "Digite a nota do aluno 1: " ;
c in >> nota1 ;
cout << "Digite a nota do aluno 2: " ;
c in >> nota2 ;
cout << "Digite a nota do aluno 3: " ;
c in >> nota3 ;
cout << "Digite a nota do aluno 4: " ;
c in >> nota4 ;
cout << "Digite a nota do aluno 5:" ;
c in >> nota5 ;
media = ( nota1+nota2+nota3+nota4+nota5 ) / 5 ;
cout << "Média das notas: " << media ;
}
Imagine agora se se pretendesse encontrar a média aritmética das notas de uma classe de 50
alunos ou da escola toda com 2000 alunos? Seria uma tarefa bastante volumosa!
É evidente que é necessária uma maneira conveniente para referenciar tais coleções de dados
similares. Vetor é um tipo de dado oferecido para esse propósito.
Um vetor é um conjunto de variáveis capazes de armazenar vários valores do mesmo tipo. Cada um
desses valores é identificado pelo mesmo nome (o nome dado ao vetor), sendo diferenciado apenas
por um ı́ndice.
46
Os ı́ndices utilizados em C++ para identificar as posições de um vetor começam sempre em 0
e vão até o tamanho do vetor menos um.
A declaração de vetor segue o seguinte formato:
tipo nomedovetor [númeromáximodeposiçoes];
Exemplo 6.1 Exemplo de vetor de números reais com cinco posições.
float notas[5];
O vetor chamado notas possui 5 posições, começando pelo ı́ndice 0 e indo até o ı́ndice 4
(tamanhodovetor − 1). Em cada posição poderão ser armazenados números reais, conforme es-
pecificado pelo tipo float na declaração.
Exemplo:
0 1 2 3 4
6.5 4.0 9.0 6.0 8.5
Para acessar cada elemento do vetor deve-se utilizar o nome do vetor e indicar o ı́ndice entre o
par de colchetes. Assim,
nomedovetor [ı́ndice]
Exemplo 6.2 Alguns acessos de elementos do vetor notas.
• Para acessar o terceiro elemento: notas[2], com valor 9.0
• Para acessar o primeiro elemento: notas[0], com valor 6.5
• Qual o valor de notas[5]? Não existe, pois não há o ı́ndice 5, que seria o sexto elemento
• Qual o valor de notas[4]? 8.5
A seguir, é apresentado um programa que reescreve o anterior (Listing 6.1) usando um vetor.
Verifique que o acúmulo da soma é realizado dentro do laço e a média é calculada fora dele. Seu
teste de mesa é apresentado na Tabela 6.1.
1 void main ( )
2 {
3 f loat notas [ 5 ] , soma , media ;
4 int i ;
5
6 soma = 0 ;
7 for ( i = 0 ; i < 5 ; i++)
8 {
9 cout << "Digite a nota do aluno " << i+1 << ": " ;
10 c in >> notas [ i ] ;
11 soma = soma + notas [ i ] ;
12 }
13 media = soma / 5 ;
14 cout << "Media das notas: " << media ;
15 getch ( ) ;
16 }
47
Tabela 6.1: Teste de mesa para o programa de média de notas usando vetor. Suponha que os
valores a serem inseridos no vetor são, na ordem: 6.5, 4.0, 9.0, 6.0 e 8.5.
Variáveis Condição Sáıda
# [ ] notas soma media i i < 5
0 1 2 3 4
1 3 lixo lixo lixo lixo lixo lixo lixo
2 4 lixo lixo lixo lixo lixo lixo lixo lixo
3 6 lixo lixo lixo lixo lixo 0 lixo lixo
4 7 lixo lixo lixo lixo lixo 0 lixo 0 V
5 9 lixo lixo lixo lixo lixo 0 lixo 0 Digite a nota do aluno 1:
6 10 6.5 lixo lixo lixo lixo 0 lixo 0
7 11 6.5 lixo lixo lixo lixo 6.5 lixo 0
8 7 6.5 lixo lixo lixo lixo 6.5 lixo 1 V
9 9 6.5 lixo lixo lixo lixo 6.5 lixo 1 Digite a nota do aluno 2:
10 10 6.5 4.0 lixo lixo lixo 6.5 lixo 1
11 11 6.5 4.0 lixo lixo lixo 10.5 lixo 1
12 7 6.5 4.0 lixo lixo lixo 10.5 lixo 2 V
13 9 6.5 4.0 lixo lixo lixo 10.5 lixo 2 Digite a nota do aluno 3:
14 10 6.5 4.0 9.0 lixo lixo 10.5 lixo 2
15 11 6.5 4.0 9.0 lixo lixo 19.5 lixo 2
16 7 6.5 4.0 9.0 lixo lixo 19.5 lixo 3 V
17 9 6.5 4.0 9.0 lixo lixo 19.5 lixo 3 Digite a nota do aluno 4:
18 10 6.5 4.0 9.0 6.0 lixo 19.5 lixo 3
19 11 6.5 4.0 9.0 6.0 lixo 25.5 lixo 3
20 7 6.5 4.0 9.0 6.0 lixo 25.5 lixo 4 V
21 9 6.5 4.0 9.0 6.0 lixo 25.5 lixo 4 Digite a nota do aluno 5:
22 10 6.5 4.0 9.0 6.0 8.5 25.5 lixo 4
23 11 6.5 4.0 9.0 6.0 8.5 34.0 lixo 4
24 7 6.5 4.0 9.0 6.0 8.5 34.0 lixo 5 F
25 13 6.5 4.0 9.0 6.0 8.5 34.0 6.8 5
26 14 6.5 4.0 9.0 6.0 8.5 34.0 6.8 5 A média das notas é: 6.8
27 15 6.5 4.0 9.0 6.0 8.5 34.0 6.8 5 Espera o pressionamento de alguma tecla
6.1 Exerćıcios
1. Dado o vetor alturas a seguir, responda:
Tabela 6.2: vetor chamado alturas.
0 1 2 3
1.50 1.78 1.96 2.10
(a) Qual é a declaração do vetor alturas?
(b) Qual é o valor e o ı́ndice do último elemento do vetor? Como você pode acessá-lo?
(c) Qual é o valor e o ı́ndice do primeiro elemento do vetor? Como você pode acessá-lo?
(d) Qual o valor de alturas[2]?
2. Faça um programa que leia um vetor de números reais de 10 posições. Em seguida, solicite
ao usuário um elemento a ser buscado no vetor. Caso o elemento exista, informar em qual
ı́ndice do vetor ele se encontra. Caso o elemento não exista, informar ao usuário: “Elemento
não encontrado!”. Observação: interrompa o laço logo que o elemento é encontrado no vetor.
3. Faça um programa que inverta os valores de um vetor de 5 números inteiros sem utilizar um
vetor auxiliar e sem imprimir de trás pra frente.
4. Sejam 2 vetores, vet1 e vet2, com 4 e 6 elementos, respectivamente. Verifique quais elementos
de vet1 também estão em vet2. Suponha que os elementos de vet1 não sejam repetidos.
48
5. Faça um programa que peça ao usuário números inteiros para serem inseridos em um vetor de
10 posições. Gere um segundo vetor seqüencialmente a partir do primeiro vetor com números
que são ao mesmo tempo pares e diviśıveis por 4. Gerar um vetor seqüencialmente significa
inserir elementos um após o outro. Se sobrar espaços no vetor gerado, estes devem estar
preenchidos com -1 (menos 1). Imprimir o vetor gerado.
6. Faça um programa que peça ao usuário 10 números inteiros, sendo que o usuário pode entrar
com valores repetidos, mas o programa é que deve controlar a inserção não repetida dos
valores.
7. Faça um programa que leia 10 notas de alunos. Calcule quantas estão acima da média.
8. Faça um programa que apresente o seguinte menu ao usuário:
Menu:
1 - Inserir um elemento no vetor
2 - Excluir um elemento do vetor
3 - Procurar um elemento no vetor
4 - Imprimir o vetor
5 - Sair
Observações:
(a) O programa só deverá ser finalizado com a opção 5. Caso a opção seja inválida, emita
uma mensagem de erro.
(b) A verificação de opções de menu deverá ser implementada com a estrutura condicional
switch.
(c) Utilize a palavra-chave const para criar uma constante de tamanho máximo do vetor.
(d) Na opção 1, não devem ser inseridos elementos iguais. A inserção é de um elemento a
cada vez que a opção 1 é escolhida.
(e) Na opção 2, deverá ser realizado um remanejamento do vetor a cada vez que um
elemento é removido, de forma a respeitar a ordem de inserção.(f) Não se esqueça de imprimir mensagens adequadas a cada situação. Por exemplo,
i. Se o vetor estiver vazio e o usuário escolher as opções de exclusão, procura e im-
pressão, deve-se emitir uma mensagem de vetor vazio.
ii. Se o vetor estiver lotado e o usuário escolher a opção de inserção, deve-se emitir
uma mensagem de vetor lotado.
49
CAṔITULO
7
Strings
Strings são utilizadas para representar seqüências de caracteres, como frases, nomes de pessoas,
cidades, ruas, páıses, etc.
O conteúdo deste caṕıtulo possui várias informações novas, mas o uso de strings foi empregado
desde as primeiras aulas quando se imprimia uma frase com o uso do comando cout. No exemplo
a seguir, tudo o que está entre as aspas é uma string, mas é uma string constante.
cout << "Digite sua idade:";
Entretanto, algumas vezes houve a necessidade de se armazenar strings em variáveis como, por
exemplo o nome e o sexo (com as palavras “feminino” ou “masculino” e não simplesmente ‘f’ ou
‘m’) de uma pessoa.
O primeiro passo é a declaração de string, mas não existe um tipo de dado com esse nome.
Conhecendo-se a definição apresentada a seguir, pode-se deduzir como é a declaração.
Uma string é um vetor de caracteres terminado por um caracter nulo. Um caracter nulo é especi-
ficado como ‘\0’ (lê-se “barra zero”).
Assim, a declaração de uma string é:
char nomedastring [tamanhomáximo];
É preciso declarar vetores de caracteres como sendo um caracter mais longo que a maior string
que eles devem guardar. Por exemplo, para declarar um vetor s que guarda uma string de 10
caracteres, deve-se escrever:
char s[11];
Isso reserva espaço para o caracter nulo no final da string.
Apesar de uma string ser um vetor, sua manipulação difere de vetores numéricos em várias
situações, como na leitura, impressão, cópia e comparação.
50
Tarefa Comandos
Leitura cin >> nomedastring; ou gets(nomedastring);
Impressão cout << nomedastring;
Cópia de uma string (s2 ) em outra (s1 ) strcpy(s1, s2)
Comparação entre duas strings strcmp(s1, s2)
Cálculo do tamanho de uma string strlen(nomedastring)
Para a leitura em uma string existem duas opções: o comando cin caso a string não possua
espaços em branco, ou a função gets() da biblioteca stdio.h, caso contrário. Em qualquer caso o
usuário pode entrar com a string inteira finalizando com a tecla ENTER. Mesmo declarando um
tamanho máximo de string, o usuário poderá entrar com caracteres a mais. Assim, é o programador
quem deve prever o tamanho máximo para que este não seja ultrapassado.
Na impressão, o comando cout imprime todos os caracteres até encontrar o caracter de fim de
string, o ‘\0’.
Para comparar, copiar e encontrar o tamanho de uma string são utilizadas as seguintes funções,
respectivamente: strcmp(), strcpy() e strlen(), todas da biblioteca string.h. A função strcmp()
retorna 0 se as strings são iguais e diferente de 0 caso contrário. Já a strlen() retorna o tamanho de
uma string, que não é o tamanho máximo especificado na declaração, verificando quantos caracteres
existem antes do caracter nulo.
7.1 Exemplos
1. Faça um programa que peça ao usuário o nome de um mês. Faça a abreviação desse nome
copiando em uma outra string seus três primeiros caracteres seguidos de um ponto. Imprima
o mês abreviado.
Listing 7.1: Resolução
1 const int MAX CHAR MES = 15 , / / Q u a n t i d a d e m á x ima d e
2 / / c a r a c t e r e s p a r a o me s .
3 MAX CHAR ABREV = 3 ; / / P a r a 3 p r i m e i r o s c a r a c t e r e s .
4
5 void main ( )
6 {
7 / / D e c l a r a ç ã o d e v a r i á v e i s
8 char mes [MAX CHAR MES] ,
9 abrev [MAX CHAR ABREV+2] ;
10 int i ;
11
12 / / L e i t u r a d o me s
13 / / P o d e s e r u s a d o o c i n p o r q u e nome d e me s n ã o p o s s u i e s p a ç o
14 / / em b r a n c o .
15 cout << "Entre com um mês do ano: " ;
16 c in >> mes ;
17
18 / / p a r a c o p i a r o s t r ê s p r i m e i r o s c a r a c t e r e s
19 for ( i =0; i<MAX CHAR ABREV; i++)
20 abrev [ i ] = mes [ i ] ;
21
51
22 / / C o p i a o s c a r a c t e r e s p o n t o e b a r r a z e r o
23 abrev [ i ] = ’.’ ;
24 i++;
25 abrev [ i ] = ’\0’ ;
26
27 / / I m p r e s s ã o d o m ê s a b r e v i a d o
28 cout << "\n\nAbreviatura do mês: " << abrev ;
29 } / / f i m ma i n
Quando a instrução da linha 16 é executada, é inserido o caracter ‘\0’ ao final da string
digitada.
Tabela 7.1: Vetor mes após a leitura da string “Abril”
ı́ndice [0] [1] [2] [3] [4] [5] ... [14]
caracter A b r i l \0 lixo lixo
Quando uma string é declarada dentro de uma função, neste caso a main, ela possui lixo.
Tabela 7.2: Vetor abrev antes da abreviação
ı́ndice [0] [1] [2] [3] [4]
caracter lixo lixo lixo lixo lixo
Após as instruções das linhas 19 a 25:
Tabela 7.3: Vetor abrev após a abreviação
ı́ndice [0] [1] [2] [3] [4]
caracter A b r . \0
Deve-se inserir o caracter ‘\0’ para indicar que a string termina após o caracter ponto. Na
instrução de linha 28, o comando cout imprimirá todos os caracteres da string até encontrar o
‘\0’, mesmo que exceda o tamanho máximo declarado na string. Por isso, caso não se coloque
o ‘\0’, o comando cout poderá imprimir vários caracteres lixo até encontrar seu delimitador
de fim.
2. Faça um programa que peça ao usuário o nome da cidade onde nasceu e o nome da cidade na
qual reside. Verifique se são as mesmas, emitindo as mensagens correspondentes. A seguir,
verifique e imprima a quantidade de vogais no nome da segunda cidade, substituindo-as pelo
caracter ‘?’. Imprima o nome da segunda cidade alterada.
Listing 7.2: Resolução
1 const int MAXCHAR = 50 ; / / q u a n t i d a d e m á x ima d e c a r a c t e r e s
2
3 void main ( )
4 {
5 / / D e c l a r a ç ã o d e v a r i á v e i s
6 char c id1 [MAXCHAR] , c id2 [MAXCHAR] ;
7 int i , quant , tam ;
8
9 / / L e i t u r a d a s c i d a d e s
10 cout << "Entre com o nome da cidade onde nasceu: " ;
11 ge t s ( c id1 ) ; / / s t d i o . h
52
12 cout << "Entre com o nome da cidade na qual reside: " ;
13 ge t s ( c id2 ) ;
14
15 / / V e r i f i c a ç ã o d a s c i d a d e s , i m p r i m i n d o a s m e n s a g e n s
16 / / c o r r e s p o n d e n t e s
17 i f ( strcmp ( cid1 , c id2 ) == 0 ) / / i f ( ! s t r c m p ( c i d 1 , c i d 2 ) )
18 cout << "\n\nAs cidades s~ao as mesmas." ;
19 else
20 cout << "\n\nAs cidades s~ao diferentes." ;
21
22 / / C á l c u l o d o t a m a n h o d o nome d a 2 a c i d a d e
23 tam = s t r l e n ( c id2 ) ; / / s t r i n g . h
24
25 / / V a r r e d u r a no nome d a 2 a c i d a d e , v e r i f i c a n d o q u a i s c a r a c t e r e s
26 / / s ã o v o g a i s , s u b s t i t u i n d o − a s p o r ’ ? ’ e c o n t a n d o − s e a q u a n t i d a d e
27 / / d e s u b s t i t u i ç õ e s
28 quant = 0 ;
29 for ( i =0; i<tam ; i++)
30 {
31 i f ( c id2 [ i ] == ’a’ | | c id2 [ i ] == ’e’ | | c id2 [ i ] == ’i’ | |
32 c id2 [ i ] == ’o’ | | c id2 [ i ] == ’u’ )
33 {
34 c id2 [ i ] = ’?’ ;
35 quant++;
36 }
37 }
38
39 / / I m p r e s s ã o d o nome d a 2 a c i d a d e a l t e r a d a e a q u a n t i d a d e d e
40 / / s u b s t i t u i ç õ e s
41 cout << "\n\nNome alterado da cidade na qual reside: " << c id2 ;
42 cout << "\n\nQuantidade de substituiç~oes realizadas: " << quant ;
43
44 } / / f i m ma i n
Quando as instruções das linhas 11 e 13 são executadas, é inserido o caracter ‘\0’ ao final da
string digitada. Nas outras posições, após esse caracter, existem lixos na memória.
Tabela 7.4: Vetor cid1 após a entrada da string “Araraquara”.
ı́ndice [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] ... 49
caracter A r a r a q u a r a \0 lixo lixo
Tabela 7.5: Vetor cid2 após a entrada da string “Boa Vista”.
ı́ndice [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] ... 49
caracter B o a V i s t a \0 lixo lixo
Ao passar pela instrução de linha 23, tam recebe o valor 9, que é o tamanho da string passada
pelo usuário. Dáı a variável ivai de 0 a tam − 1, que é o valor 8. Se i variasse de 0 a 49,
poderiam ser encontradas outras vogais lixo do ı́ndice 10 ao 49. Para comparar cada caracter
da string com as vogais, deve-se acessá-lo da mesma forma que se acessa elementos de um
vetor numérico: nomedovetor[ı́ndice]. Para comparar com cada vogal constante deve-se
colocá-la entre apóstrofos.
53
Tabela 7.6: Vetor cid2 após as substituições
ı́ndice [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] ... 49
caracter B ? ? V ? s t ? \0 lixo lixo
7.2 Exerćıcios
1. Faça um programa que inverta uma frase passada pelo usuário. Substitua todas as vogais da
frase invertida pelo caracter de ponto de interrogação. Imprima a quantidade de cada vogal
e a frase invertida após as substituições. ATENÇÃO: inverter uma string não é imprimir de
trás para frente; se desejar, utilize uma string auxiliar.
Exemplo:
Frase passada pelo usuário: FELIZ NATAL!
Frase invertida após as substituições: !L?T?N Z?L?F
2. Faça um programa que verifica se uma palavra é palindroma, ou seja, que apresenta a mesma
grafia quando lida a partir do ińıcio ou de trás para frente. Exemplos: AMA, ASA, SOLOS,
ARARA.
54
CAṔITULO
8
Matrizes
São similares aos vetores, sendo compostas por linhas e colunas.
No exemplo a seguir é apresentada uma matriz denominada mat com 3 linhas e 6 colunas e que
contém números reais.
float mat[3][6]; // declaraç~ao da variável mat
0 1 2 3 4 5
0
1
2
1.2 5.6 9.8 3.4 1.5 8.9
5.9 7.8 4.7 1.4 3.6 8.5
6.5 2.3 1.2 9.6 7.8 1.0
A declaração de uma matriz segue o seguinte formato:
tipo nomedamatriz [númerodelinhas] [númerodecolunas];
Da mesma forma que ocorre com os vetores, os ı́ndices começam sempre em 0, tanto da linha
quanto da coluna. Sendo assim, com a declaração anterior, criou-se uma variável chamada mat
contendo três linhas (́ındices de 0 a 2) e seis colunas (́ındices de 0 a 5), capaz de armazenar
números reais.
Para acessar cada elemento da matriz deve-se utilizar o nome da matriz e indicar os ı́ndices de
linha e de coluna entre cada par de colchetes. Assim,
nomedamatriz [ı́ndicedalinha] [ı́ndicedacoluna]
Exemplo 8.1 Alguns acessos de elementos da matriz mat.
1. Para acessar o terceiro número que está na segunda linha: mat[1][2], com valor 4.7
2. Para acessar o primeiro número da terceira linha: mat[2][0], com valor 6.5
3. Qual o valor de mat[3][0]? Não existe, pois não há o ı́ndice 3 de linha
4. Qual o valor de mat[1][6]? Não existe, pois não há o ı́ndice 6 de coluna
Desta forma, como seria o código em que se pedem valores para serem inseridos em uma matriz?
55
Depende do problema, se a matriz é preenchida de uma vez ou aos poucos, se é preciso inserir
valores de linha a linha ou de coluna a coluna, etc.
O código a seguir insere de uma vez valores de linha a linha em uma matriz, ou seja, fixa-se a
linha e varia-se a coluna.
/ / i l i n é o ı́ n d i c e d a l i n h a e i c o l é o ı́ n d i c e d a c o l u n a
for ( i l i n = 0 ; i l i n < quant l i nha s ; i l i n ++)
for ( i c o l = 0 ; i c o l < quant co lunas ; i c o l++)
c in >> nomedamatriz [ i l i n ] [ i c o l ] ;
}
Como a matriz possui quant linhas linhas, o for externo deve variar de 0 a quant linhas−1 (per-
correndo, assim, as quant linhas linhas da matriz) e o for interno deve variar de 0 a quant colunas−1
(percorrendo, assim, as quant colunas colunas da matriz). Exemplificando, quando i lin é zero, i col
varia de 0 a quant colunas− 1, varrendo, assim, a primeira linha; quando i lin é 1, i col varia de
0 a quant colunas − 1, varrendo, assim, a segunda linha; e assim por diante, até quando i lin é
quant linhas− 1 com i col variando de 0 a quant col − 1.
O código a seguir insere de uma vez valores de coluna a coluna em uma matriz. Perceba que
para cada coluna são varridos todos os ı́ndices de linhas, ou seja, fixa-se a coluna e varia-se a linha.
for ( i c o l = 0 ; i c o l < quant co lunas ; i c o l++)
for ( i l i n = 0 ; i l i n < quant l i nha s ; i l i n ++)
c in >> nomedamatriz [ i l i n ] [ i c o l ] ;
8.1 Exemplo
1. Faça um programa que receba do usuário notas de um aluno em 8 disciplinas por 4 bimestres,
inserindo-as em uma matriz 9 x 4. A última linha deverá conter a média por bimestre,
conforme apresentada na figura a seguir. Imprima as médias da seguinte forma: “A média
no X bimestre foi Y.”
1o Bim 2o Bim 3o Bim 4o Bim
Disciplina 1
Disciplina 2
Disciplina 3
Disciplina 4
Disciplina 5
Disciplina 6
Disciplina 7
Disciplina 8
Média Bimestral
6.5 5.5 5.0 8.0
4.0 5.0 3.0 10.0
3.5 7.0 10.0 9.5
8.0 6.5 6.0 4.5
4.0 3.0 9.5 2.0
2.5 4.0 3.5 1.5
5.5 4.5 10.0 8.0
5.25 5.31 6.12 5.93
Listing 8.1: Resolução
1 const int NUM BIM = 4 , / / n u m e r o d e b i m e s t r e s
2 NUM DISCIP = 8 ; / / n u m e r o d e d i s c i p l i n a s
3
4 void main ( )
5 {
6 / / D e c l a r a ç ã o d e v a r i á v e i s
56
7 f loat notas [NUM DISCIP+1] [NUM BIM] ,
8 soma , media ;
9 int i d i s c i p , i b im ;
10
11 / / L e i t u r a d a s n o t a s
12 cout << "LEITURA DE NOTAS" ;
13 for ( i b im =0; i bim<NUM BIM; i b im++)
14 {
15 soma = 0 ;
16 cout << "\n\n" << i b im+1 << "o. Bimestre: " ;
17 for ( i d i s c i p =0; i d i s c i p <NUM DISCIP ; i d i s c i p++)
18 {
19 cout << "\nEntre com a nota da disciplina " << i d i s c i p+1
20 << ": " ;
21 c in >> notas [ i d i s c i p ] [ i b im ] ;
22 soma = soma + notas [ i d i s c i p ] [ i b im ] ;
23 }
24 media = soma / NUM DISCIP ;
25 notas [ i d i s c i p ] [ i b im ] = media ;
26 }
27
28 / / I m p r e s s ã o d a s m é d i a s b i m e s t r a i s
29 for ( i b im =0; i bim<NUM BIM; i b im++)
30 cout << "\nA media no " << i b im+1 << "o. Bimestre foi "
31 << notas [NUM DISCIP ] [ i b im ] ;
32 } / / f i m ma i n
8.2 Exerćıcios
1. Dada a matriz M a seguir, responda:
1.2 5.6 9.8 3.4 1.5
5.9 7.8 4.7 1.4 3.6
7.5 6.3 9.4 3.6 1.0
(a) Qual é a declaração da matriz M ?
(b) A matriz possui quantas linhas e quantas colunas?
(c) Qual é o valor de M[2][4]?
(d) Qual é o valor de M[4][2]?
(e) Qual é o valor de M[0][0]?
(f) Qual é o valor de M[1][3]?
(g) Faça um trecho de código que peça ao usuário números para serem inseridos de coluna
a coluna. Imprima o valor contido em uma posição da matriz solicitada pelo usuário.
(h) Repita o item anterior mas insira cada elemento de linha a linha.
2. Faça um programa que peça ao usuário números inteiros para serem inseridos em uma matriz
de 20 linhas por 50 colunas. Encontre o maior elemento de cada linha e multiplique cada
57
elemento da linha (incluindo o maior) pelo maior valor, alterando a matriz lida. Imprima a
matriz resultante.
3. Faça um programa que receba do usuário uma matriz de 30 linhas por 45 colunas. Gere uma
segunda matriz contendo os valores pares da matriz lida. Esses valores devem ser inseridos
na seqüência, sem espaços entre eles. Se sobrar espaços na matriz gerada preenchê-los com
zero. Imprima a matriz gerada.
4. Faça um programa que peça ao usuário notas de 6 disciplinas em 4 bimestres inserindo-as em
uma matriz de 6 linhas por 5 colunas. Calcule a média final em cada disciplina, inserindo-a
na última coluna. Verifique qual a maior média final, imprimindo seu valor e a disciplina.
Seu algoritmo deve funcionar caso haja mais de uma média igual à maior.
5. Faça um programa que peça ao usuário números inteiros para serem inseridos em uma matriz
5x5. A seguir, faça a soma dos números que estão nas diagonais principal e secundária,
conforme a figura a seguir.
o
58
CAṔITULO
9
Funções
Um recurso importante em linguagens de programação é a modularização, na qual um programa
pode ser particionado em pedaços menores. A linguagem C++ possibilita a modularização por meio
de funções.
Algumas razões para o uso de funções:
• Dividir a tarefa original em pequenas tarefas que simplificam e organizam o programa como
um todo;
• Reduzir o tamanho do programa. Qualquer seqüência de instruções que apareça no programa
maisde uma vez é candidata a ser uma função.
Como mencionado na Seção 1.3 do Caṕıtulo 1 (pág. 4), um programa em C++ consiste na
definição de uma ou mais funções e se o programa tiver apenas uma, está será a main().
Apenas a função principal foi definida nos programas apresentados até agora. Além disso,
foram utilizadas algumas chamadas a funções com finalidades como: esperar o pressionamento de
alguma tecla – getch(), limpar a tela – clrscr(), calcular o tamanho de uma string – strlen(),
obter uma string do teclado – gets(), entre outras.
Retome o programa apresentado em Listing 7.2 (pág. 52) sobre strings. Nas linhas 11, 13, 17 e
23 são chamadas as seguintes funções, respectivamente: gets(), gets(), strcmp() e strlen().
Já o primeiro programa apresentado neste material no Caṕıtulo 1, em Listing 1.3 (pág. 4), nas
linhas 6 e 23 são chamadas, respectivamente, as funções clrscr() e getch().
Essas funções já foram pré-definidas na linguagem C++ e o programador só tem que chamá-
las. Entretanto, se o programador quiser utilizar uma função que não exista, ele é que deverá
implementá-la.
Assim, para criar e utilizar uma função, deve-se (não necessariamente nessa ordem):
• Escrever seu protótipo;
• Chamá-la;
• Defini-la.
Juntamente com cada uma dessas partes é apresentado um conceito novo: o escopo de variáveis.
59
9.1 Escopo de variáveis
O escopo ou abrangência de uma variável refere-se a sua visibilidade perante as diversas funções
integrantes do algoritmo. As variáveis que são definidas no ińıcio do programa – fora de qualquer
função – são denominadas globais por serem viśıveis, ou seja, podem ser utilizadas por qualquer
função do programa. Há casos em que uma variável é utilizada apenas por uma função espećıfica,
o que não justifica uma definição global, pois somente se fazem necessários o conhecimento e a
utilização dessa variável dentro dos limites desse bloco lógico. Esta situação ocorre quando a
variável é declarada internamente à função e é denominada variável local. Até agora, todos os
exemplos possúıam apenas variáveis locais, declaradas na função main.
Em Listing 9.1 é apresentado um programa que utiliza variáveis local e global, cujo objetivo é
desenhar uma linha de tamanho passado pelo usuário.
Listing 9.1: Programa que mostra o escopo de variáveis.
1 #include<i o s t ream . h>
2 #include<con io . h>
3
4 void desenha l inha ( ) ; / / p r o t ó t i p o d a f u n ç ã o d e s e n h a l i n h a
5
6 / / V a r i á v e l g l o b a l , v i s ı́ v e l em t o d a s a s f u n ç õ e s
7 int tam ;
8
9 void main ( ) / / d e f i n i ç ã o d a f u n ç ã o m a i n
10 {
11 c l r s c r ( ) ;
12
13 cout << "Entre com o tamanho da linha: " ;
14 c in >> tam ;
15
16 / / Chamada à f u n ç ã o
17 desenha l inha ( ) ;
18 getch ( ) ;
19 } / / f i m ma i n
20
21 void desenha l inha ( ) / / d e f i n i ç ã o d a f u n ç ã o d e s e n h a l i n h a
22 {
23 int i ; / / V a r i á v e l l o c a l , v i s ı́ v e l a p e n a s n e s s a f u n ç ã o
24 for ( i =0; i<tam ; i++)
25 cout << ’\xc4’ ;
26 } / / f i m d e s e n h a l i n h a
Verifique que a variável inteira tam foi declarada no ińıcio do programa, fora de qualquer função;
assim, ela possui escopo global e pode ser acessada por qualquer função – neste caso a main() e a
desenha linha().
A main() não possui qualquer declaração de variável. Na desenha linha() é declarada apenas
a variável i, acessada apenas nessa função.
Veja o teste de mesa para esse programa na Tabela 9.1. Verifique que a variável tam existe
no decorrer de toda a execução do programa, sendo que a variável i existe apenas na função
desenha linha().
60
Tabela 9.1: Teste de mesa para o programa apresentado em Listing 9.1 com tam igual a 1 para
facilitar o teste de mesa.
Variáveis Condição Observações Sáıda
# [ ] tam i i < tam
1 7 lixo @
2 9 lixo @ Definição da função main()
3 10 lixo @ Ińıcio da função main()
4 11 lixo @ Chama a função clrscr()
5 13 lixo @ Entre com o tamanho da linha
6 14 1 @
7 17 1 @ Chama a função desenha linha()
8 21 1 @ Definição da função desenha linha()
9 22 1 @ Ińıcio da função desenha linha()
10 23 1 lixo
11 24 1 0 V
12 25 1 0
13 24 1 1 F
14 26 1 1 Fim da função desenha linha()
15 18 1 @ Espera o pressionamento de alguma tecla...
16 19 1 @ Fim da função main()
Atenção: o uso de variáveis globais em programas não é recomendado porque se qualquer
função definida pode acessá-las a qualquer momento, é mais dif́ıcil a sua manutenção e checagem
de erros de lógica.
9.2 Protótipo de função
Da mesma forma que para uma variável, não se pode usar uma função sem antes declará-la. A
declaração de uma função é chamada protótipo e é uma instrução colocada no ińıcio do programa
que estabelece o tipo da função e os tipos dos parâmetros 1 (também chamados de argumentos)
que ela recebe.
O protótipo de uma função tem a mesma forma da definição da função anterior a seu corpo,
exceto por terminar com ponto-e-v́ırgula após o fechamento do parêntese.
O objetivo principal de escrever protótipos de funções em C++ é o de fornecer ao compilador
informações necessárias sobre o tipo de retorno da função e o número e o tipo de parâmetros.
O programa-exemplo apresentado em Listing 9.1 (pág. 60) possui o protótipo da função na
linha 4, que informa que o retorno da função é do tipo void, ou seja, não possui retorno, e não
recebe nada como parâmetro.
9.3 Chamada de função
Chamada à função é o meio pelo qual o programa é solicitado que desvie o controle e passe
para a definição da função, execute suas instruções e depois volte à instrução seguinte à chamada
à função.
Chama-se uma função pelo seu nome seguido de abertura de parêntese, zero ou mais parâmetros
sem os tipos, e o fechamento de parêntese. Exemplo: na linha 17 de Listing 9.1 (pág. 60) chama-se
a função escrevendo-se desenha linha().
1Quando existem, os parâmetros são informações imprescind́ıveis e são declarados na linha de definição da função
entre os parênteses após o nome da função.
61
9.4 Definição de função
É o código C++ que descreve o que a função faz. Sua forma geral foi apresentada anteriormente
na Seção 1.3 do Caṕıtulo 1 (pág. 4) e é:
t i po nomedafunção ( dec l a ra ç ã o dos parâmetros )
{
i n s t r u ç õ e s ;
}
Em Listing 9.1 (pág. 60) as definições da funções main() e desenha linha() foram implemen-
tadas nas linhas 9 a 19 e 21 a 26, respectivamente.
9.5 Retorno de função
O tipo de retorno de uma função é definido pelo tipo de valor que ela retorna por meio do
comando return.
O comando return termina a execução da função e retorna o controle para a instrução seguinte
do código de chamada.
A instrução return não é obrigatória. Uma função sem esse comando é do tipo void e é
terminada quando encontrar a chave }, que indica fim da função. Em Listing 9.1 (pág. 60) não há
função com return, por isso são do tipo void.
Os tipos de funções C++ são os mesmos tipos de variáveis, exceto quando a função não retorna
nada, que é do tipo void.
O valor de retorno de uma função é acessado, na instrução de chamada, por meio do nome
dela seguido de parênteses contendo ou não parâmetros. No programa apresentado em Listing 9.2
a chamada à função verifica maior() possui dois parâmetros inteiros e retorna um número que
é o maior deles. O valor retorno é atribúıdo à variável maior na linha 17. Verifique que não há
variáveis globais e as variáveis locais à main() são: n1, n2 e maior. As variáveis locais à função
verifica maior() são: a, b e m. Seu teste de mesa está na Tabela 9.5.
O comando return pode retornar somente um único valor para a função que chama.
Listing 9.2: Programa que possui uma função que retorna o maior de dois números inteiros.
1 #include<io s t ream . h>
2 #include<con io . h>
3
4 int v e r i f i c a ma i o r ( int , int ) ; / / P r o t ó t i p o d a f u n ç ã o v e r i f i c a m a i o r
5
6 void main ( ) / / D e f i n i ç ã o d a f u n ç ã o m a i n
7 {
8 int n1 , n2 , maior ; / / V a r i á v e i s l o c a i s à m a i n
9
10 c l r s c r ( ) ;
11
12 cout << "Entre com dois números inteiros: " ;
13 c in >> n1 >> n2 ;
62
14
15 / / Chamada à f u n ç ã o v e r i f i c a m a i o r e a t r i b u i ç ã o d o s e u v a l o r
16 / / d e r e t o r n o à v a r i á v e l m a i o r
17 maior = v e r i f i c a ma i o r (n1 , n2 ) ;
18
19 cout << "O maior número é " << maior ;
20
21 getch ( ) ;
22 } / / f i m ma i n
23
24 int v e r i f i c a ma i o r ( int a , int b) / / D e f i n i ç ã o d a f u n ç ã o v e r i f i c a m a i o r
25 {
26 int m;
27
28 i f ( a > b)
29 m = a ;
30 else
31 m = b ;
32
33 return m; / / r e t o r n a o v a l o r d e m
34 } / / f i m v e r i f i c a m a i o r
Tabela 9.2: Teste de mesa com valores 15 e 67 para as variáveis n1 e n2.
Variáveis Observações Condições Sáıda
# [ ] n1 n2 maior a b m a > b
1 6 @ @ @ @ @ @ Definição da função main()
2 7 @ @ @ @ @ @ Ińıcio da função main()
3 8 lixo lixo lixo @ @ @
4 12 lixo lixo lixo @ @ @ Entre com dois números inteiros:
5 13 15 67 lixo @ @ @
6 17 15 67 lixo @ @ @ Chamada à função verifica maior()
7 24 @ @ @ 15 67 @ Ińıcio da função verifica maior()
8 26 @ @ @ 15 67 lixo
9 28 @ @ @ 15 67 lixo F
10 31 @ @ @ 15 67 67
11 33 @ @ @ 15 67 67 Retorna o valor de m
12 17 15 67 67 @ @ @ O valor de retorno é atribúıdo à maior
13 19 15 67 67 @ @ @ O maior número é: 67
14 21 15 67 67 @ @ @ Espera o pressionamento de alguma tecla...
9.6 Funções com passagem de parâmetro
Algumas funções pré-definidas na linguagem que foram utilizadas neste material possuem parâmetros
e outras não. Por que isso ocorre?
Dessas funções que não possuem parâmetros, foram utilizadas clrscr() e getch(). E das
funções de possuem parâmetros, podem-se citar: gets(str), strcpy(str1, str2), strlen(str),
strcmp(str1, str2) e sqrt(num).
Suponha que em um programa existam quatro strings e o programador deseje comparar se duas
delas são iguais. Se a função strcmp() não tivesse parâmetros e pudesse acessar as variáveis do
programador, quais ela compararia?
Suponha também que em um programa existam oito variáveis do tipo float e que o progra-
63
mador desejasse calcular a raiz quadrada de um deles. Como a função sqrt() saberia de qual
variável dever-se-ia calcular a raiz?
Já a função clrscr() limpa a tela toda, por isso não há parâmetros. E a função getch() obtém
o caracter que o usuário digitou retornando seu valor; por isso, também, não há parâmetros.
9.6.1 Passagem de parâmetro por valor
Significa que, para a execução da função chamada, serão geradas cópias dos valores de cada um
dos parâmetros.
Seja o exemplo apresentado em Listing 9.2 (pág. 62): verificar e imprimir o maior valor de
dois números. Na Figura 9.1 é feita uma representação gráfica de como ocorre uma passagem de
parâmetros por valor apresentada no programa.
Figura 9.1: Ilustração da chamada à função com passagem de parâmetros por valor e seu retorno.
Suponha que os valores armazenados nas variáveis n1 e n2, por meio da execução da linha 13
do programa foram, respectivamente, 15 e 67.
Quando a linha 17 é executada, esses valores são copiados para as variáveis a e b, pertencentes
à função verifica maior().
Depois disso, é verificado qual é o maior dos valores de a e b, copiando em m o maior deles.
O resultado dessa comparação é devolvido à função main() pela execução da linha 33, onde o
maior valor (67) recai sobre a variável maior na função main.
No momento em que a função verifica maior() chega ao fim, as variáveis a, b e m são des-
trúıdas.
9.6.2 Passagem de parâmetro por referência
Na passagem de parâmetro por valor ocorre a cópia dos valores dos parâmetros; assim, mo-
dificações na cópia não afetam o valor original da variável na função que efetuou a chamada.
Já quando parâmetros são passados por referência, a função chamada pode modificar o valor
original da variável.
Existem duas formas de passagem de parâmetro por referência: ponteiros e alias. O primeiro é
foco de estudo para o próximo ano, sendo o segundo apresentado neste caṕıtulo.
64
Assim, pode-se definir um alias como um apelido para a variável passada como parâmetro.
Para utilizar esse tipo de passagem de parâmetro, deve-se:
• no protótipo da função e no cabeçalho de definição da função colocar um “e comercial”
(&) depois do tipo do parâmetro;
• na chamada à função simplesmente mencionar o nome da variável que será passada por
referência.
Assim, qualquer alteração no valor desse parâmetro no corpo da função chamada alterará o
valor da variável original na função que chamou.
Em Listing 9.3 é apresentado um programa que faz a troca de valores de duas variáveis. Na
Tabela 9.3 é apresentado o teste de mesa para o mesmo.
Listing 9.3: Programa que mostra o uso de passagem de parâmetro por referência.
1 #include <i o s t ream . h>
2 #include <con io . h>
3
4 void t roca ( int &, int &); / / P r o t ó t i p o d a f u n ç ã o t r o c a ( )
5
6 void main ( ) / / D e f i n i ç ã o d a f u n ç ã o m a i n ( )
7 {
8 c l r s c r ( ) ; / / Chamada à f u n ç ã o c l r s c r ( )
9
10 int a=9, b=7; / / V a r i á v e i s l o c a i s à f u n ç ã o m a i n ( ) e s u a s a t r i b u i ç õ e s
11
12 cout << "Antes da troca\n" ;
13 cout << "a: " << a << endl ;
14 cout << "b: " << b << endl << endl ;
15
16 t roca (a , b ) ; / / Chamada à f u n ç ã o t r o c a ( )
17
18 cout << "Depois da troca\n" ;
19 cout << "a: " << a << endl ;
20 cout << "b: " << b << endl ;
21
22 getch ( ) ; / / Chamada à f u n ç ã o g e t c h ( )
23 }
24
25 void t roca ( int &x , int &y) / / D e f i n i ç ã o d a f u n ç ã o t r o c a ( )
26 {
27 int aux ;
28
29 aux = x ;
30 x = y ;
31 y = aux ;
32 }
65
Tabela 9.3: Teste de mesa com valores 9 e 7 para as variáveis a e b.
Variáveis Observações Sáıda
# [ ] a b x y aux
1 6 @ @ @ @ @ Definição da função main
2 10 9 7 @ @ @
3 12 9 7 @ @ @ Antes da troca
4 13 9 7 @ @ @ a: 9
5 14 9 7 @ @ @ b: 7
6 16 9 7 @ @ @ Chamada à função troca
7 25 @ @ 9 7 @ Ińıcio da função troca
8 27 @ @ 9 7 lixo
9 29 @ @ 9 7 9
10 30 @ @ 7 7 9
11 31 @ @ 7 9 9
12 16 7 9 @ @ @ Voltando à chamada à função
13 18 7 9 @ @ @ Depois da troca
14 19 7 9 @ @ @ a: 7
15 20 7 9 @ @ @ b: 9
Passando vetores e matrizes como parâmetros
Passar vetores e matrizes como parâmetros é sempre por referência, mas não no esquema alias,
não se utilizando o “e comercial” (&) no protótipo e nem no cabeçalho de definição da função.
Deve-se, então:
• colocar apenas o nome do vetor (ou matriz) na chamada à função como parâmetro;
• declarar o vetor (tipo – nome – tamanho do vetor entre colchetes) no protótipo e no cabeçalho
de definição da função. Siga o mesmo racioćınio para matriz.
Em Listing 9.4 é apresentado um exemplo de programa passando um vetor como parâmetro.
Listing 9.4: Programa que mostra o uso de vetor como parâmetro.
1 #include <i o s t ream . h>
2 #include <con io . h>
3
4 void dobro ( int v [ 5 ] ) ; / / P r o t ó t i p o d a f u n ç ã o d o b r o ( )
5
6 void main ( ) / / D e f i n i ç ã o d a f u n ç ã o m a i n ( )
7 {
8 c l r s c r ( ) ; / / Chamada à f u n ç ã o c l r s c r ( )
9
10 int idades [ 5 ] , i ; / / V a r i á v e i s l o c a i s à m a i n
11
12 cout << "Entre com 5 idades\n" ;
13
14 for ( i =0; i < 5 ; i++)
15 c in >> idades [ i ] ;
16
66
17 dobro ( idades ) ; / / Chamada à f u n ç ã o d o b r o ( )
18
19 cout << "Dobro de cada idade\n" ;
20
21 for ( i =0; i < 5 ; i++)
22 cout << idades [ i ] << endl ;
23
24 getch ( ) ; / / Chamada à f u n ç ã o g e t c h ( )
25 }
26
27 void dobro ( int v [ 5 ] ) / / D ef i n i ç ã o d a f u n ç ã o d o b r o ( )
28 {
29 int i ; / / v a r i á v e l l o c a l à f u n ç ã o d o b r o
30
31 for ( i = 0 ; i < 5 ; i++)
32 v [ i ] = 2 ∗ v [ i ] ;
33 }
9.7 Exerćıcios
1. Em relação aos programas apresentados em Listing 9.1 (pág. 60), Listing 9.2 (pág. 62),
Listing 9.3 (pág. 65) e Listing 9.4 (pág. 66), responda:
(a) Quais parâmetros foram passados por valor (se houver)?
(b) Quais parâmetros foram passados por referência (se houver)?
(c) Indique quais são as variáveis globais (se houver).
(d) Indique quais são as variáveis locais por função (se houver).
(e) Indique as linhas dos protótipos, chamadas e definição de funções.
(f) Quais são os valores de retorno das funções (se houver)?
2. Implemente uma função que receba como parâmetros a altura (alt) e o sexo de uma pessoa
e retorne seu peso ideal. Para homens calcular o peso ideal usando a fórmula a seguir:
pesoideal = 72.7∗alt−58; e, para mulheres: pesoideal = 62.1∗alt−44.7. Chame essa função
na main().
3. Implemente três funções que recebam como parâmetro o raio de uma esfera: na função area()
deve-se calcular a área da esfera (area = πraio2); na função volume() deve-se calcular o
volume da esfera (volume = (3πraio3)/4); e na função comprimento() deve-se calcular o
comprimento da esfera (comprimento = 2πraio). Cada uma delas deve retornar o resultado
do cálculo. Chame todas essas funções na main(). Observação: utilize a constante π como
global.
4. Implemente uma função que receba como parâmetro um vetor de 10 inteiros e calcule e retorne
o maior deles. Chame essa função na main.
5. Implemente uma função que receba como parâmetros 3 vetores de 10 inteiros. Efetue a soma
dos dois primeiros no terceiro. Chame essa função na main.
67
CAṔITULO
10
Registros
Até o presente momento só foi posśıvel a manipulação de coleção de dados do mesmo tipo, ou
seja, quando se declara um vetor de inteiros, todos os seus elementos são desse tipo; o mesmo ocorre
com matrizes.
Já com registros, também chamados de estruturas, é posśıvel agregar informações de tipos
diferentes, criando-se um novo tipo de dado. Um registro é, portanto, uma coleção de campos, em
que cada campo pode ser de um tipo diferente.
A forma geral para se criar um tipo de dado registro é apresentada a seguir.
struct tipo_registro{
tipo_campo1 nome_campo1;
tipo_campo2 nome_campo2;
...
tipo_campon nome_campon;
};
Como exemplo, pode-se criar um tipo de dado para representar produto que possui os campos
de código e descrição.
struct tProduto{
int cod;
char desc[50];
};
Assim, foi criado o tipo registro tProduto composto de campos dos tipos numérico (cod) e
caracter (desc). Mas como se declara uma variável desse tipo? É simples, segue o mesmo
racioćınio de uma declaração qualquer:
tipo registro nome variável;
68
Verifique as seguintes declarações:
• tProduto prod;
Criou-se uma variável simples chamada prod do tipo registro tProduto.
Figura 10.1: Ilustração de um produto com código e descrição.
• tProduto produtos[10];
Criou-se um vetor de 10 produtos do tipo registro tProduto. Isso é o que se chama de vetor
de registros.
Figura 10.2: Ilustração de um vetor de produtos com código e descrição. É um vetor de registros.
Mas como se acessa os campos do registro? (no exemplo, como se acessa o código e a
descrição do produto?)
• Se for uma variável simples como prod, deve-se escrever o nome da variável seguido de um
ponto e seguido do nome do campo:
prod.cod – acessa-se o código do produto.
• Se for um vetor ou uma matriz de registros, deve-se escrever o elemento do vetor (ou
matriz) seguido de um ponto e seguido do nome do campo:
produtos[3].cod – acessa-se o código do quarto produto.
69
Referências Bibliográficas
A. F. G. Ascencio and E. A. V. de Campos. Fundamentos da Programação de Computadores:
Algoritmos, Pascal e C/C++. Prentice Hall, 2002.
H. M. Deitel and P. J. Deitel. C++ Como Programar - Apresentando Projeto Orientado a Objeto
com UML. Bookman, 2001.
A. L. V. Forbellone and H. F. Eberspächer. Lógica de Programação – A Construção de Algoritmos
e Estrutura de Dados. Pearson Prentice Hall, 2005.
V. V. Mizrahi. Treinamento em Linguagem C++ - Módulos 1 e 2. Makron Books, 1994.
D. D. Salvetti and L. M. Barbosa. Algoritmos. Makron Books, 1998.
70
APÊNDICE
A
Erros comuns na programação usando o
ambiente Borland C/C++ 3.1
A.1 Erros comuns na compilação
Erros na compilação também são chamados de erros de sintaxe, que ocorrem quando o compi-
lador não reconhece um comando.
1. Digitar main incorretamente:
Undefined symbol main in module c0.ASM
2. Não salvar o arquivo com extensão .cpp:
Error directive: Must use C++ for the type iostream
3. Esquecer de incluir a biblioteca iostream.h:
Undefined symbol ’cout’
Undefined symbol ’cin’
4. Esquecer de incluir as bibliotecas correspondentes das funções:
Function ‘clrscr’ should have a prototype
Function ‘getch’ should have a prototype
Function ‘gets’ should have a prototype
Function ‘strlen’ should have a prototype
Function ‘strcpy’ should have a prototype
Function ‘strcmp’ should have a prototype
Function ‘strcat’ should have a prototype
5. Digitar incorretamente um comando (a intenção era digitar ‘cout’):
Undefined symbol ‘cot’
6. Trocar para letras maiúsculas as palavras-chave reservadas da linguagem, tais como while, if,
for e else que contêm somente letras minúsculas. C++ é case sensitive, ou seja, senśıvel a
letras maiúsculas e minúsculas:
Function While should have a prototype
Function If should have a prototype
71
Function For should have a prototype
Undefined symbol Else
7. Digitar incorretamente o nome de uma variável (por exemplo: declarou-se como num e utilizou-
se Num):
Undefined symbol ‘Num’
8. Digitar espaço em branco em nome de variável (por exemplo: nome pessoa):
Declaration syntax error
9. Começar o nome de uma variável com número (por exemplo: 1num):
Declaration terminated incorrectly
10. Esquecer o ponto-e-v́ırgula ao final de um comando (acusa-se erro na linha posterior):
Statement missing ;
11. Usar o operador módulo % com operandos não inteiros:
Illegal use of floating point
12. Colocar espaços entre os dois śımbolos dos operadores ==, !=, >=, <=, +=, -=, /=, %= e ++, --:
Expression syntax
13. Inverter a ordem do par de śımbolos dos operadores >= e <= para => e =<, respectivamente.
Expression syntax
14. Colocar um ponto-e-v́ırgula logo após parêntese da direita do comando if na estrutura condi-
cional if-else, como em:
1 i f ( idade > 18 ) ;
2 cout << "Idade superior a 18 anos." ;
3 else
4 cout << "Idade até 18 anos." ;
que é o mesmo que:
1 i f ( idade > 18)
2 ;
3 cout << "Idade superior a 18 anos." ;
4 else
5 cout << "Idade até 18 anos." ;
O ponto-e-v́ırgula faz com que o corpo da estrutura if seja considerado vazio. Assim, o
próximo comando na seqüência é o cout, fazendo com que o else esteja relacionado a ele, e
não ao if, por isso a seguinte mensagem, que quer dizer “else perdido”:
Misplaced else
15. Usar v́ırgula no lugar de ponto-e-v́ırgula no cabeçalho do comando for, como em for (i=0,
i<10, i++):
For statement missing ;
16. Colocar um ponto-e-v́ırgula após o parêntese direito ao encerrar a lista de parâmetros de uma
definição de função, como em:
Listing A.1: Definição de função INCORRETA
1 int ca l cu la soma ( int num1 , int num2 ) ;
2 {
72
3 int soma ;
4
5 soma = num1 + num2 ;
6
7 return soma ;
8 }
O correto é eliminar o ponto-e-v́ırgula da linha 1.
Declaration terminated incorrectly
17. Declarar parâmetros da função do mesmo tipo como float n1, n2 ao invés de float n1,
float n2:
) expected
18. Definir um parâmetro de função novamente como variável local dentro da função, como em:
1 int ca l cu la soma ( int num1 , int num2)
2 {
3 int num1 , num2 , / / INCORRETO
4 soma ;
5
6 soma = num1 + num2 ;
7
8 return soma ;
9 }
emitirá os seguinteserros:
Multiple declaration for num1
Multiple declaration for num2
19. Esquecer do ponto-e-v́ırgula no final de um protótipo causa um erro de sintaxe.
Declaration syntax error
A.2 Erros comuns de lógica
Os erros de lógica não são indicados pelo compilador, mas pelo resultado errado do programa.
São erros da estruturação lógica do pensamento.
1. Dividir por zero no ambiente Borland C/C++ 3.1 causa erro durante a execução do pro-
grama, produzindo um erro fatal, ou seja, causa o término imediato do programa sem este
ter executado com sucesso seu trabalho. Pode-se verificar as seguintes mensagens na tela de
sáıda com ALT+F5:
Floating point error: Divide by 0
Abnormal program termination
2. Confundir o operador de atribuição = com o operador relacional de igualdade ==. Seja o
seguinte exemplo de erro muito comum: if (n1 = n2). A intenção era comparar os valores
das variáveis, mas o que ocorre é uma atribuição do valor de n2 para n1.
3. Colocar um ponto-e-v́ırgula logo após parêntese da direita do comando if, como em:
73
1 i f ( idade > 18 ) ;
2 cout << "Idade superior a 18 anos." ;
3 getch ( ) ;
O ponto-e-v́ırgula faz com que o corpo da estrutura if seja considerado vazio. Assim, inde-
pendente da condição ser verdadeira ou falsa, o cout é executado, pois é o próximo comando
na seqüência.
4. Colocar um ponto-e-v́ırgula logo após parêntese da direita do cabeçalho do comando while,
tornando o corpo do while vazio.
5. Colocar um ponto-e-v́ırgula logo após parêntese da direita do cabeçalho do comando for,
tornando o corpo do for vazio.
6. Não inicializar contador ou acumulador pode resultar em erro.
7. Embora 4 < y < 8 seja uma condição matematicamente correta, ela não é avaliada cor-
retamente em C++. Use (4 < y && y < 8) ou (y > 4 && y < 8) para obter a avaliação
apropriada.
8. Acessar um elemento além dos limites de um vetor é um erro de lógica que ocorre durante a
execução. Exemplo: se foi declarado int vet[10];, então não existe o elemento vet[10].
74
APÊNDICE
B
Boas práticas de programação
1. Comece seu programa com um comentário descrevendo o(s) nome(s) do(s) programador(es),
a data de implementação e o seu propósito. Exemplo:
Listing B.1: soma.cpp
1 / ∗
2 P r o g r a m a d o r a : C l a u d i a A . I z e k i
3 D a t a : 7 / 1 2 / 2 0 0 5
4 D e s c r i ç ã o : P r o g r a m a q u e c a l c u l a a s oma d e d o i s n ú m e r o s i n t e i r o s
5 p a s s a d o s p e l o u s u á r i o .
6 ∗ /
7 #include<i o s t ream . h>
8 #include<con io . h>
9
10 void main ( )
11 . . .
2. Escolha nomes de variáveis significativos, pois torna o programa mais fácil de ser entendido,
ao invés de ter que ler manuais ou usar comentários em excesso.
3. Evite usar variáveis com mesmo nome para propósitos diferentes em um programa, pois pode
gerar confusão.
4. Alguns programadores preferem declarar cada variável em uma linha separada. Este formato
permite a fácil inserção de comentário descritivo após cada declaração.
5. Solicite explicitamente ao usuário cada entrada pelo teclado. O lembrete deve indicar a
forma da entrada e quaisquer valores de entrada especiais que devam ser fornecidos (como
por exemplo o valor que o usuário deve digitar para terminar um laço). Exemplo:
cout << "Entre com uma idade (digite -1 para sair):" ;
c in >> idade ;
6. Coloque espaços dos dois lados de um operador binário. Isso faz com que o operador se
destaque, tornando o programa mais leǵıvel. Exemplo: escreva (num >= 8) ao invés de
(num>=8).
75
7. Coloque uma linha em branco para separar instruções com objetivos diferentes, tornando os
programas mais leǵıveis.
8. Insira um espaço após cada v́ırgula para tornar os programas mais leǵıveis.
9. Consulte a precedência de operadores quando escrever expressões contendo muitos operadores.
Confirme que os operadores na expressão são executados na ordem que se espera. Caso não
tenha certeza da ordem de execução de uma expressão complexa, separe-a em comandos
menores ou use parênteses para forçar a ordem.
10. Indente 1 em um ńıvel o corpo inteiro de cada função. Isso faz com que a estrutura funcional
de um programa se destaque e ajuda a tornar os programas mais fáceis de ler. Compare os
dois exemplos:
Listing B.2: Programa sem indentação na função main - INCORRETO
1 #include <i o s t ream . h>
2 #include <con io . h>
3
4 int ca l cu la soma ( int num1 , int num2)
5 {
6 int soma ;
7
8 soma = num1 + num2 ;
9
10 return soma ;
11 }
12
13 void main ( )
14 {
15 c l r s c r ( ) ;
16
17 int num1 , num2 , soma ;
18
19 cout << "Soma de dois numeros" ;
20
21 cout << "Entre com o primeiro numero: " ;
22 c in >> num1 ;
23
24 cout << "Entre com o segundo numero: " ;
25 c in >> num2 ;
26
27 soma = ca lcu la soma (num1 , num2 ) ;
28
29 cout << "A soma é: " ;
30 cout << soma ;
31
32 getch ( ) ;
33 }
1Indentação é um espaçamento fundamentalmente utilizado por programadores para destacar os conteúdos de
funções e de estruturas condicionais e de repetição, tornando os programas mais fáceis de ler pelo programador.
76
Listing B.3: Programa com indentação na função main - CORRETO
1 #include <i o s t ream . h>
2 #include <con io . h>
3
4 int ca l cu la soma ( int num1 , int num2)
5 {
6 int soma ;
7
8 soma = num1 + num2 ;
9
10 return soma ;
11 }
12
13 void main ( )
14 {
15 c l r s c r ( ) ;
16
17 int num1 , num2 , soma ;
18
19 cout << "Soma de dois numeros" ;
20
21 cout << "Entre com o primeiro numero: " ;
22 c in >> num1 ;
23
24 cout << "Entre com o segundo numero: " ;
25 c in >> num2 ;
26
27 soma = ca lcu la soma (num1 , num2 ) ;
28
29 cout << "A soma é: " ;
30 cout << soma ;
31
32 getch ( ) ;
33 }
11. Estabeleça um padrão nos tamanhos da indentação. Se teclar espaços em branco para a
indentação, use-os sempre, sendo prefeŕıvel 3 espaços. Caso use a tabulação (tecla Tab),
verifique se o ambiente está configurado para o mesmo tamanho de tabulação (Menu Options
- Environment - Editor - tab Size), sendo 3 o prefeŕıvel.
12. Indente em um ńıvel o corpo de uma estrutura if para fazer com que o seu corpo se destaque,
melhorando a legibilidade. Compare os exemplos:
77
Listing B.4: Corpo de uma estrutura if sem indentação - INCORRETO
1 i f ( op == 1)
2 {
3 cout << "Cálculo de novo salário" ;
4 cout << "Entre com seu salário: " ;
5 c in >> s a l ;
6
7 novo sa l = s a l ∗ 1 . 4 5 ;
8
9 cout << "Seu novo salário é: " << novo sa l ;
10 }
11 else i f ( op == 2)
12 {
13 cout << "Cálculo de imposto sobre o salário" ;
14 cout << "Entre com seu salário: " ;
15 c in >> s a l ;
16
17 imp = s a l ∗ 0 . 0 2 ;
18
19 cout << "O imposto é de: " << imp ;
20 }
21 else
22 cout << "Opç~ao inválida!" ;
Listing B.5: Corpo de uma estrutura if com indentação - CORRETO
1 i f ( op == 1)
2 {
3 cout << "Cálculo de novo salário" ;
4 cout << "Entre com seu salário: " ;
5 c in >> s a l ;
6
7 novo sa l = s a l ∗ 1 . 4 5 ;
8
9 cout << "Seu novo salário é: " << novo sa l ;
10 }
11 else i f ( op == 2)
12 {
13 cout << "Cálculo de imposto sobre o salário" ;
14 cout << "Entre com seu salário: " ;
15 c in >> s a l ;
16
17 imp = s a l ∗ 0 . 0 2 ;
18
19 cout << "O imposto é de: " << imp ;
20 }
21 else
22 cout << "Opç~ao inválida!" ;
13. Indente em um ńıvel o corpo de uma estrutura while para fazer com que o seu corpo se
destaque, melhorando a legibilidade. Compare os exemplos:
78
Listing B.6: Corpo de uma estrutura while sem indentação - INCORRETO
1 i = 0 ;
2 while ( i < 10)
3 {
4 r e s = num ∗ i ;
5 cout << num << " x " << i << " = " << r e s ;
6 i++;
7 }
Listing B.7: Corpo de uma estrutura while com indentação - CORRETO
1 i = 0 ;
2 while ( i < 10)
3 {
4 r e s = num ∗ i ;
5 cout << num << " x " << i << " = " << r e s ;
6 i++;
7 }
14. Indente em um ńıvel o corpo de uma estrutura for para fazer com que o seu corpo se destaque,
melhorando a legibilidade. Compare os exemplos:
Listing B.8: Corpo de uma estrutura for sem indentação -INCORRETO
1 for ( i = 0 ; i < 10 ; i++)
2 {
3 r e s = num ∗ i ;
4 cout << num << " x " << i << " = " << r e s ;
5 }
Listing B.9: Corpo de uma estrutura for com indentação - CORRETO
1 for ( i = 0 ; i < 10 ; i++)
2 {
3 r e s = num ∗ i ;
4 cout << num << " x " << i << " = " << r e s ;
5 }
15. Indente em um ńıvel o corpo de uma estrutura do..while para fazer com que o seu corpo se
destaque, melhorando a legibilidade. Compare os exemplos:
Listing B.10: Corpo de uma estrutura do..while sem indentação - INCORRETO
do{
cout << "Menu de opç~oes:" ;
cout << "1 - Cálculo de soma" ;
cout << "2 - Cálculo de subtraç~ao" ;
cout << "3 - Sair" ;
c in >> op ;
. . .
}while ( op != 3 ) ;
79
Listing B.11: Corpo de uma estrutura do..while com indentação - CORRETO
1 do{
2 cout << "Menu de opç~oes:" ;
3 cout << "1 - Cálculo de soma" ;
4 cout << "2 - Cálculo de subtraç~ao" ;
5 cout << "3 - Sair" ;
6 c in >> op ;
7
8 . . .
9 }while ( op != 3 ) ;
16. Mantenha a indentação mesmo em estruturas que compõem outras. Por exemplo, no corpo
de uma função main existe um laço do..while sendo que no corpo deste existem estruturas
encadeadas if - else. Compare os exemplos:
Listing B.12: Programa sem indentação - INCORRETO
1 void main ( )
2 {
3 int op , soma , d i f , n1 , n2 ;
4
5 c l r s c r ( ) ;
6
7 do{
8 cout << "Menu de opç~oes:" ;
9 cout << "1 - Cálculo de soma" ;
10 cout << "2 - Cálculo de subtraç~ao" ;
11 cout << "3 - Sair" ;
12 c in >> op ;
13
14 i f ( op == 1)
15 {
16 cout << "Soma de dois números:" ;
17 cout << "Entre com dois números inteiros: " ;
18 c in >> n1 >> n2 ;
19 soma = n1 + n2 ;
20 cout << "A soma é: " << soma ;
21 }
22 else i f ( op == 2)
23 {
24 cout << "Subtraç~ao de dois números:" ;
25 cout << "Entre com dois números inteiros: " ;
26 c in >> n1 >> n2 ;
27 d i f = n1 − n2 ;
28 cout << "A diferença é: " << d i f ;
29 }
30 else
31 cout << "Opç~ao inválida!" ;
32 }while ( op != 3 ) ;
33
34 getch ( ) ;
35 }
80
Listing B.13: Programa com indentação - CORRETO
1 void main ( )
2 {
3 int op , soma , d i f , n1 , n2 ;
4
5 c l r s c r ( ) ;
6
7 do{
8 cout << "Menu de opç~oes:" ;
9 cout << "1 - Cálculo de soma" ;
10 cout << "2 - Cálculo de subtraç~ao" ;
11 cout << "3 - Sair" ;
12 c in >> op ;
13
14 i f ( op == 1)
15 {
16 cout << "Soma de dois números:" ;
17 cout << "Entre com dois números inteiros: " ;
18 c in >> n1 >> n2 ;
19 soma = n1 + n2 ;
20 cout << "A soma é: " << soma ;
21 }
22 else i f ( op == 2)
23 {
24 cout << "Subtraç~ao de dois números:" ;
25 cout << "Entre com dois números inteiros: " ;
26 c in >> n1 >> n2 ;
27 d i f = n1 − n2 ;
28 cout << "A diferença é: " << d i f ;
29 }
30 else
31 cout << "Opç~ao inválida!" ;
32 }while ( op != 3 ) ;
33
34 getch ( ) ;
35 }
17. Alguns programadores usam letras maiúsculas nos nomes de constantes para se destacarem
no programa e não serem confundidos com variáveis. Exemplo:
const int MAX ALUNOS = 100;
ao invés de const int max alunos = 100;
18. Escolha nomes significativos para funções e parâmetros, tornando o programa mais leǵıvel e
evitando o uso excessivo de comentários.
19. Sempre inclua protótipos de funções, ainda que seja posśıvel omiti-los quando as funções são
definidas antes que sejam usadas.
20. Antes de compilar, verifique se os protótipos, as chamadas e as definições de funções estão
em acordo quanto aos nomes das funções, os tipos e seqüências dos parâmetros, bem como
seus tipos de retornos, se houver.
81
21. É aconselhável definir o tamanho do vetor como uma constante com const ao invés de cons-
tante número, ou seja,
const int TAM = 10;
int vet[TAM];
ao invés de
int vet[10];.
82
APÊNDICE
C
Revisão de conceitos matemáticos muito
utilizados
1. Adição – combina dois números (termos, somandos ou parcelas) em um único número, a
soma.
2. Subtração – indica quanto é um valor numérico (minuendo) se dele for removido outro valor
numérico (subtraendo).
a− b = c
a é o minuendo, b é o subtraendo, c é a diferença.
3. Divisão – é a operação matemática que determina a quantidade de vezes que um número
(divisor) está contido dentro de outro número (dividendo).
a/b = q
a é o dividendo, b é o divisor, q é o quociente, r é o resto
O divisor não pode ser zero, pois qual número multiplicado por zero é igual ao dividendo?
4. Multiplicação – é uma forma simples de se adicionar uma quantidade finita de números
iguais. O resultado da multiplicação de dois números é chamado produto. Esses números são
chamados de multiplicando e multiplicador.
5. Prioridades das operações – a multiplicação e a divisão possuem prioridade sobre a adição
e a subtração. Entretanto, deve-se realizar primeiramente a operação que estiver dentro de
parênteses, colchetes ou chaves.
6. Média aritmética – é a soma dos elementos dividida pela quantidade deles. Exemplo:
calcular a média aritmética (MA) de quatro notas bimestrais (N1, N2, N3 e N4).
Solução: MA = (N1 + N2 + N3 + N4)/4
7. Média ponderada – primeiro multiplica-se cada peso com seu elemento. Faz-se a soma dos
produtos, dividindo-a pela soma dos pesos. Exemplo: Calcular a média ponderada (MP ) de
2 notas em que a primeira possui peso 3 e a segunda peso 2.
Solução: MP = (3 ∗N1 + 2 ∗N2)/5
8. Regra de 3 – é um processo de resolução de problemas de quatro valores, sendo que três são
conhecidos e deve-se determinar o quarto valor. Para resolvê-lo deve-se montar uma tabela e
83
resolver a equação. Exemplo: um atleta percorre 30 km em 3h. Em quanto tempo percorrerá
50km mantendo o mesmo ritmo?
Solução: monta-se uma tabela:
Percurso (km) Tempo (h)
30 3
50 x
Assim, temos:
30
50
=
3
x
(C.1)
30.x = 150 (C.2)
x = 5 (C.3)
Portanto, o atleta percorrerá 50 km em 5h.
Outro exemplo: um produto de valor R$P sofrerá aumento de X%. Calcule o valor em reais
do aumento (A) e o novo valor (NP) em reais do produto.
Solução:
Valor (R$) Porcentagem (%)
P 100
A X
Assim, temos:
P
A
=
100
X
(C.4)
100.A = P.X (C.5)
A =
P.X
100
(C.6)
Portanto, o aumento é calculado pela equação C.6.
E o novo preço é: NP = P + A.
9. Divisibilidade – um número inteiro A é diviśıvel por um inteiro (não nulo) B se, e somente
se, existir k inteiro tal que:
A = kB
ou seja, se o resto da divisão de A por B for zero.
10. Número par – é todo número inteiro que ao ser dividido pelo número dois resulta em um
número inteiro, ou seja, o resto é zero.
11. Número ı́mpar – é todo número inteiro que ao ser dividido pelo número dois resulta em
um número racional não inteiro.
12. Números inteiros – são somente constitúıdos dos números naturais 0, 1, 2, ... e dos seus
opostos -1, -2, -3, .... Dois números são opostos se, e somente se, sua soma é zero.
84
13. Números naturais – é um inteiro não-negativo 0, 1, 2, 3, ....
14. Número racional – é todo número que pode ser representado por uma razão (ou fração)
entre dois números inteiros.
85