Estrutura de Dados - Linguagem em C++

UNIVERSIDADE ESTADUAL PAULISTA
JLIO DE MESQUITA FILHO

Campus de Ilha solteira
Trabalho de Formatura
Apostila da Linguagem de Programao C++
Autor: Enrique Camargo Trevelin

Orientador: Carlos Antnio Alves
Ilha Solteira Julho de 2007
Sumrio
Mdulo 1 A Linguagem C++....................................................................... 4
1.1 Histria da Linguagem C/C++.............................................................................. 4
1.2 Caractersticas da Linguagem C++....................................................................... 4
1.3 Exemplos de Aplicaes Escritas em C++ ........................................................... 5
1.4 Comparao de C++ com outras linguagens ........................................................ 5
1.5 Paradigmas de Programao: Programao Estruturada e Orientada a Objetos .. 6
Mdulo 2 Compiladores .............................................................................. 8

2.1 O que um Compilador........................................................................................ 8
2.2 Compiladores de C++ ........................................................................................... 8
2.3 DevC++................................................................................................................. 8
2.3.1 - Instalao............................................................................................................ 9
2.3.2 - Interface............................................................................................................ 10
2.3.3 - Utilizao.......................................................................................................... 12
2.3.4 Erros................................................................................................................. 13
2.4 Estrutura Bsica de um Programa em C++......................................................... 15
Mdulo 3 Caractersticas e Definies Gerais da Linguagem C++....... 17

3.1 Nomes e Identificadores Usados na Linguagem C++ ........................................ 17
3.2 Palavras Reservadas na Linguagem C++............................................................ 17
3.3 Tipos e Dados ..................................................................................................... 18
3.4 Definio de Variveis........................................................................................ 19
3.5 Definio de Constantes ..................................................................................... 20
3.6 Nmeros Hexadecimais e Octais ........................................................................ 20
3.7 Valores Strings.................................................................................................... 21
3.8 Cdigos de Barra Invertida ................................................................................. 21
3.9 Operadores .......................................................................................................... 22
3.10 Tabela de Operadores da Linguagem C............................................................ 25
3.11 Expresses ........................................................................................................ 26
3.12 Precedncia e Associatividade de Operadores.................................................. 26
3.13 Converses de Tipos......................................................................................... 28
3.14 Modeladores de Tipos....................................................................................... 29
Mdulo 4 Funes na Linguagem C......................................................... 30

4.1 Funes ............................................................................................................... 30
UNESP Campus de Ilha Solteira 2007
Pgina 1
4.2 Declarando uma Funo ..................................................................................... 31

4.3 Main como uma Funo ..................................................................................... 33
4.4 Variveis dentro das Funes ............................................................................. 34
4.4.1 Variveis Locais .............................................................................................. 34
4.4.2 Variveis Globais.............................................................................................. 35
4.5.1 Chamada por Valor.......................................................................................... 36
4.5.2 - Chamada por Referncia .................................................................................. 37
4.6 Biblioteca de Execuo....................................................................................... 37
4.7 Funes Recursivas............................................................................................. 38
4.8 - Sobrecarga da Funo.......................................................................................... 39
4.9 Funes Inline..................................................................................................... 39
4.10 Parmetros Padro ............................................................................................ 40
Mdulo 5 Estudo dos comandos cout e cin .............................................. 42

5.1 Utilizao de cout ............................................................................................... 42
5.2 Overload do operador de insero ...................................................................... 43
5.3 Formatao de exibio com cout ...................................................................... 44
5.4 Utilizao de cin ................................................................................................. 46
5.5 Mtodo de cin: cin.getline .................................................................................. 46
Mdulo 6 - Estruturas de Controle de Fluxo.............................................. 48

6.1 - Estruturas de Controle de Fluxo .......................................................................... 48
6.2 A declarao if .................................................................................................... 48
6.3 O Encadeamento If Else if ............................................................................... 50
6.4 A Declarao Switch .......................................................................................... 51
6.5 A declarao for.................................................................................................. 53
6.6 A declarao while.............................................................................................. 55
6.7 A Declarao Do While...................................................................................... 56
6.8 Laos Aninhados................................................................................................. 57
6.9 Break e Continue ................................................................................................ 58
Mdulo 7 Matrizes ..................................................................................... 60

7.1 Matrizes .............................................................................................................. 60
7.2 Declarao de uma matriz................................................................................... 60
7.3 Acessando Valores de uma Matriz ..................................................................... 61
7.4 Utilizando Laos para Percorrer Matrizes .......................................................... 61
7.5 Matrizes Multidimensionais ............................................................................... 63
7.6 Matrizes em Funes .......................................................................................... 64
7.7 Criando Matrizes Dinamicamente ...................................................................... 66
Pgina 2
Mdulo 8 Strings ........................................................................................ 68

8.1 Cabealho de um programa com strings............................................................. 68
8.2 Declarando e Inicializando uma String............................................................... 68
8.3 Leitura e Escrita de Strings na Tela .................................................................... 69
8.4 Operaes com Strings ....................................................................................... 71
8.5 Biblioteca cctype: operaes com caracteres...................................................... 73
Mdulo 9 Ponteiros .................................................................................... 75

9.1 - Endereos de Memria ........................................................................................ 75
9.2 Ponteiros ............................................................................................................. 76
9.3 Declarando Ponteiros.......................................................................................... 76
9.4 Desreferenciando um Ponteiro............................................................................ 77
9.5 Ponteiros em Funes: Chamada por Referncia ................................................ 78
9.6 Ponteiros para Matrizes ...................................................................................... 80
9.7 Funes que Retornam Ponteiros ....................................................................... 82
9.8 Ponteiros para Funes ....................................................................................... 82
9.9 Ponteiros para Ponteiros ..................................................................................... 83
9.10 Operadores new e delete ................................................................................... 84
Mdulo 10 - Entrada e Sada de Dados....................................................... 86

10.1 A biblioteca fstream.......................................................................................... 86
10.2 Os objetos de fstream........................................................................................ 86
10.3 Escrevendo em um arquivo............................................................................... 87
10.4 Checando se o arquivo abriu sem problemas.................................................... 88
10.5 Fechando um Arquivo ...................................................................................... 89
10.6 Lendo os dados de um arquivo ......................................................................... 89
10.7 Modos de Arquivo ............................................................................................ 92
Mdulo 11 Programao Orientada Objetos ....................................... 94

11.1 Paradigmas de Programao............................................................................. 94
11.1 Programao Orientada Objetos .................................................................... 94
11.2 Conceitos Bsicos ............................................................................................. 95
11.2 Herana e Polimorfismo ................................................................................... 96
Referncias Bibliogrficas ............................................................................ 98
Pgina 3
Mdulo 1 A Linguagem C++

1.1 Histria da Linguagem C/C++
O C++ foi inicialmente desenvolvido por Bjarne Stroustrup durante a dcada de
1980 com o objetivo de melhorar a linguagem de programao C, mantendo a
compatibilidade com esta linguagem. Stroustrup percebeu que a linguagem Simula possua
caractersticas bastante teis para o desenvolvimento de software, mas era muito lenta para
uso prtico. Por outro lado o BCPL era rpido, mas possua baixo nvel, dificultando sua
utilizao em desenvolvimento de aplicaes. Durante seu perodo na Bell Labs, ele
enfrentou o problema de analisar o kernel UNIX com respeito computao distribuda. A
partir de sua experincia de doutorado, comeou a acrescentar elementos do Simula no C.
C foi escolhido pois possua uma proposta de uso genrico, era rpido e tambm
portvel para diversas plataformas. Algumas outras linguagens que tambm serviram de
inspirao para o informtico foram ALGOL 68, Ada, CLU e ML. Novas caractersticas
foram adicionadas, como funes virtuais, sobrecarga de operadores e funes, referncias,
constantes, controle de memria pelo usurio, melhorias na checagem de tipo e estilo de
comentrio de uma linha (//). A primeira verso comercial da linguagem C++ foi lanada
em outubro de 1985.
1.2 Caractersticas da Linguagem C++

O principal desenvolvedor da linguagem C++, Bjarne Stroustrup, descreve no livro
In The Design and Evolution of C++ quais seus principais objetivos ao desenvolver e
expandir esta linguagem:
Em proposta geral, C++ deve ser to eficiente e portvel quanto C, sendo

desenvolvida para ser uma linguagem com tipos de dados estticos.
C++ desenvolvido para ser o quanto mais compatvel com C possvel, fornecendo
transies simples para cdigo C.
C++ desenvolvido para suportar mltiplos paradigmas de programao,

principalmente a programao estruturada e a programao orientada a objetos,
possibilitando mltiplas maneiras de resolver um mesmo problema.
C++ desenvolvido para fornecer ao programador mltiplas escolhas, mesmo que

seja possvel ao programador escolher a opo errada.
Pgina 4
1.3 Exemplos de Aplicaes Escritas em C++

Abaixo temos alguns exemplos de aplicaes e programas comerciais
desenvolvidos totalmente ou parcialmente em C++.
Grande parte dos programas da Microsoft, incluindo Windows XP, Windows NT,
Windows 9x, Pacote Office, Internet Explorer, Visual Studio e outros.
Sistemas Operacionais como o j citado Windows, Apple OS X, BeOS, Solaris e

Symbian (sistema operacional para celulares).
Bancos de dados como SQL e MySQL.
Aplicaes Web, como a mquina de busca Google e o sistema de comrcio virtual

da Amazon.
Aplicaes grficas como os programas da Adobe (Photoshop, Illustrator), Maya e

AutoCAD.
Jogos em geral, como o Doom III.
A lista enorme e poderia se estender por muitas e muitas pginas. Atualmente C++ ,
juntamente com Java, a linguagem de programao comercial mais difundida no mundo.
1.4 Comparao de C++ com outras linguagens

Podemos dividir as linguagens de programao conforme o dialeto utilizado por
elas. Quanto mais prximo da linguagem humana for a maneira com que passamos
instrues para a mquina, mais alto ser seu nvel: por exemplo, Fortran e Basic so
consideradas linguagens de alto nvel pois seus comandos parecem-se com frases humanas
(em ingls, claro): Se x = y ento faa x = x+1 e imprima y. De maneira anloga, quanto
mais prximo da linguagem da mquina for a linguagem de programao, mais baixo ser
seu nvel: por exemplo, o Assembly considerada uma linguagem de nvel baixo, pois seus
comandos so escritos em hexadecimal. Ambos os tipos possuem vantagens e
desvantagens, mas de maneira geral podemos dizer que a vantagem das linguagens de nvel
alto a simplicidade de programao, enquanto que a vantagem das linguagens de nvel
baixo a alta velocidade que seus programas podem ter.
Tanto C como C++ podem ser consideradas linguagens de nvel intermedirio, pois
utilizam-se de um dialeto de nvel alto mas possibilita ao programador facilidades para se
trabalhar em nvel baixo, como manipulao de bits, bytes e endereos de memria de
maneira direta, sem recorrer a abstraes apresentadas por outras linguagens de alto nvel.
A filosofia que existe por trs da linguagens C e C++ que o programador sabe
realmente o que est fazendo. Estas linguagens quase nunca colocam-se no caminho do
programador, deixando-o livre para us-la de qualquer forma que queira, mas arcando com
Pgina 5
as consequncias de seu mau ou incorreto uso. O motivo para essa liberdade na

programao permitir ao compilador criar cdigos muito rpidos e eficientes, deixando
a responsabilidade da verificao de erros para o programador. O prprio criador de C++,
Bjorne Stroustrup afirma que C faz com que dar um tiro no p seja fcil; C++ torna isso
mais difcil, mas quando ns o fazemos arrebenta com a perna toda. A citao de
Stroutrup trata com humor o fato de o C++, ao possibilitar a programao de alto nvel, ter
facilitado a codificao de algoritmos e organizao de projetos em relao ao C, uma
linguagem que requer constante ateno contra erros lgicos de programao devido sua
alta flexibidade. Por outro lado, o C++ possui nuances da sintaxe e semntica da
linguagem muito sutis, difceis de serem identificados, e que quando no percebidos
podem levar a comportamentos indesejados no cdigo.
As principais vantagens e desvantagens do C++ so listadas a seguir:
Vantagens
Possibilidade em programao de alto e baixo nvel.

Alta flexibilidade, portabilidade e consistncia.
Compatilidade com C, resultando em vasta base de cdigos.
Adequado para grandes projetos.
Ampla disponibilidade e suporte, devido principalmente grande base de
desenvolvedores.
No est sob o domnio de uma empresa (em contraste do Java - Sun ou Visual Basic
Microsoft).
Padronizao pela ISO.
Grandes possibilidades para a metaprogramao e programao genrica.
Desvantagens
Compatilidade com o C herdou os problemas de entendimento de sintaxe do mesmo.

Os compiladores atuais nem sempre produzem o cdigo mais otimizado, tanto em
velocidade quando tamanho do cdigo.
Grande perodo para o aprendizado.
A biblioteca padro ainda no cobre reas importantes da programao, como threads,
conexes TCP/IP e manipulao de sistemas de arquivos, o que implica na necessidade
de criao de bibliotecas prprias para tal, que pecam em portabilidade.
Devido grande flexibilidade no desenvolvimento, recomendado o uso de padres de
programao mais amplamente que em outras linguagens.
1.5 Paradigmas de Programao: Programao

Estruturada e Orientada a Objetos
Um paradigma de programao um conjunto de idias que fornecem ao
programador uma viso sobre a estruturao e execuo de um programa. Assim como ao
resolver um problema podemos adotar uma entre variadas metodologias para resolv-lo, ao
criar um programa podemos adotar um determinado paradigma de programao para
desenvolv-lo. Certas linguagens de programao so escritas especificamente para
trabalhar com um tipo de paradigma: este o caso de Smalltalk e Java que suportam a
Pgina 6
programao orientada a objetos. Outras linguagens suportam vrios paradigmas, ou seja, o

programador pode escolher qual paradigma se adapta melhor ao problema que ele precisa
resolver e trabalhar com ele, e at mesmo alternar entre paradigmas (desde que ele saiba o
que est fazendo).
A linguagem C utiliza o paradigma da programao estruturada. A base da
programao estruturada trabalhar a lgica do programa como uma estrutura composta de
similares sub-estruturas, reduzindo a compreenso do programa compreenso de cada
sub-estrutura individualmente. Na prtica, este mtodo envolve a criao de vrias funes
dentro de um programa, pequenas e simples o suficiente para serem entendidas
individualmente, sendo o programa a sequncia de todas estas funes trabalhando em
conjunto. A programao estruturada se ope ao uso de comandos de pulo como GOTO,
preferindo a criao de estruturas e condies lgicas que substituam ou mesmo eliminem
a necessidade de um comando de pulo. Este paradigma o mais utilizado no ensino e
aprendizado de linguagens de programao, por ser mais facilmente entendido por
estudantes e por criar hbitos de programao saudveis e teis mesmo em outros
paradigmas.
A linguagem C++ uma das linguagens que suportam vrios paradigmas.
Inicialmente, sendo uma evoluo de C, ela suporta inteiramente o paradigma da
programao estruturada. Alm disso, ela suporta outros paradigmas como a programao
procedural, a programao genrica, abstrao de dados e a programao orientada a
objetos. Dentre estes paradigmas, o mais utilizado atualmente a Programao Orientada a
Objetos, ou mais comumente chamado de OOP (Object-Oriented Programming). Apesar
de ter sido criada nos anos 60, este paradigma s comeou a ganhar aceitao maior aps
os anos 90,com a exploso das linguagens C++, Java e Visual Basic. A idia bsica por
trs da OOP criar um conjunto de objetos (unidades de software) para modelar um
sistema. Estes objetos so independentes entre si, possuindo responsabilidades e funes
distintas no programa como um todo, mas que se comunicam entre si atravs do envio e
recebimento de mensagens. A OOP especialmente til para grandes programas que se
beneficiam mais com a modularidade oferecida por este paradigma: dividindo o programa
em vrios mdulos independentes, aumenta-se a flexibilidade e a facilidade para
manuteno do programa como um todo.
Nesta apostila, enfocaremos os aspectos de linguagem de programao estruturada
da linguagem C++, deixando os aspectos de linguagem orientada a objetos para os ltimos
captulos a ttulo de introduo ao assunto. Isto se deve a maior dificuldade de aprendizado
e entendimento do paradigma da programao orientada a objetos, principalmente
tratando-se de estudantes com pouco contato com linguagens de programao. Por isso,
prefervel estabelecer uma base para o estudante com os conceitos da programao
estruturada, que so mais facilmente compreendidos e trabalhados, para que depois este
estudante possa progredir para o paradigma da OOP com maior facilidade.
Pgina 7
Mdulo 2 Compiladores
2.1 O que um Compilador
Toda linguagem de programao possui um tradutor de cdigo. Este tradutor pode
ser um compilador ou um interpretador, dependendo da linguagem. Interpretadores so
programas que lem o cdigo-fonte e executam ele diretamente, sem a criao de um
arquivo executvel. Chamamos de compilador o programa que traduz um arquivo escrito
em cdigo de linguagem de programao (arquivo-fonte) para a linguagem do
microprocessador, criando um arquivo capaz de executar as instrues pedidas (arquivo
executvel).
O primeiro passo de um compilador analisar o cdigo presente no arquivo-fonte,
verificando se existem erros de sintaxe. Caso algum erro de sintaxe seja encontrado, a
compilao interrompida para que o programador possa corrijir estes erros. Caso o
cdigo no possua erros o prximo passo do compilador criar um arquivo de cdigoobjeto, que possui as instrues do programa j traduzidas para a linguagem da mquina e
informaes sobre alocao de memria, smbolos do programa (variveis e funes) e
informaes de debug. A partir deste arquivo de cdigo-objeto, o compilador finalmente
cria um arquivo executvel com o programa compilado, que funciona independente do
compilador e realiza as instrues criadas pelo programador.
2.2 Compiladores de C++

Existem muitos compiladores de C++ no mercado. Os mais famosos so os
softwares da Borland e da Microsoft, que so realmente muito bons e oferecem muitos
recursos. O problema que estes compiladores so caros e voltados principalmente para
programadores experientes, que podem fazer uso dos recursos avanados destes
programas. Para quem no est ainda aprendendo a linguagem e no quer ainda gastar
dinheiro com compiladores, existem vrias opes de compiladores freeware (software
livre, de graa). Nesta seo descreveremos a instalao e o uso do DevC++, um
compilador freeware muito utilizado.
2.3 DevC++
O Dev-C++ um compilador freeware das linguagens C, C++ e C#. uma opo
muito interessante, pois de fcil utilizao e aprendizado para usurios novos e possui
muitos recursos avanados para usurios experientes. Alm de, claro, seu download ser
gratuito.
Pgina 8
2.3.1 - Instalao
A verso mais recente do DevC++ pode ser baixada atravs da pgina
http://www.bloodshed.net/dev/devcpp.html, no link Download. Utilizou-se, na
elaborao desta apostila, a verso do DevC++ beta 9.2, disponvel diretamente atravs do
link http://prdownloads.sourceforge.net/dev-cpp/devcpp-4.9.9.2_setup.exe. O arquivo de
instalao possui aproximadamente 9 megas. Aps o fim do download, preciso clicar
duas vezes neste arquivo para comear a instalao.
A instalao do DevC++ bem simples. Utilizaremos nesta apostila a instalao
completa, escolhendo o item full durante a etapa da instalao mostrada na figura 2.1.
Figura 2.1 Escolha o tipo de instalao Full

O prximo passo escolher o diretrio onde o programa ser instalado. Neste
diretrio estaro todos os arquivos relacionados ao compilador, como bibliotecas,
executveis, arquivos de ajuda e muitos outros. Alm disso, neste diretrio que o
compilador salvar os cdigos e programas que fizermos. Normalmente os programas so
instalados por definio em sua pasta prpria, geralmente c:/arquivos de programas/devcpp, mas podemos escolher outro diretrio qualquer que satisfaa nossas necessidades.
Escolhemos para esta apostila instalar o compilador em C:/dev-cpp , como mostra a
figura 1.b, por maior facilidade de acesso e referncia. So necessrios aproximadamente
60 megas de espao livre em disco.
Pgina 9
Figura 2.2 Escolha o local onde sero instalados os arquivos do compilador.

Aps isto, a instalao ser concluda com sucesso. Para acessar o programa, basta
encontrar o atalho ao programa no menu iniciar sob o nome Bloodsheed Dev-C++ e
clicar para execut-lo.
2.3.2 - Interface
Importante: Na primeira vez que iniciamos o Dev-C++, todos os seus menus esto
em ingls. Porm, o programa traduzido para vrias lnguas, inclusive portugus. Para
mudar os menus do programa para a nossa lngua (ou qualquer outra lngua que desejar),
basta acessar o menu Tools -> Enviroment Options. Uma janela se abrir, com vrias
opes referentes ao funcionamento do ambiente de trabalho. Na aba Interface encontrase a opo Language com as vrias linguas em que o programa est disponvel. Basta
procurar a opo portuguese (Brazil) e clicar OK, e o programa j estar traduzido para
nossa lngua.
A tela principal do programa mostrada na figura abaixo.
Pgina 10
Figura 2.3 Interface do DevC++
Os menus principais do programa so muito parecidos com os programas windows

padro. Temos os menus:
Arquivo: possui as funes bsicas de manuseio de arquivos (criar novo arquivo,

abrir arquivo, fechar, imprimir, ver propriedades)
Editar: aonde esto localizadas as funes de edio bsicas de edio (copiar,
recortar, colar) e algumas funes teis para programao (como comentar e
descomentar trechos do programa, e criar e acessar bookmarks, que so marcas
de acesso rpido para partes do programa, especialmente teis para programas
extensos)
Localizar: possui os comandos de procurar e substituir partes do cdigo; o menu
Exibir permite o controle de quais componentes da tela so exibidos
Projeto: refere-se a projetos de programas que possuem vrios componentes e
arquivos de cdigos separados e utilizado para adicionar e retirar componentes do
projeto
Executa: talvez o mais importante para ns, e nele esto localizadas as funes
bsicas do compilador (como os comandos Compilar, Executar ) e algumas funes
Pgina 11
teis como procurar por erros de sintaxe

Debug: serve para controlar o debug de um programa, que a sua execuo passoa-passo para melhor anlise e busca por erros
Ferramentas: refere-se a vrias opes do compilador, do ambiente de trabalho e de
edio, alm de configuraes diversas
CVS: uma funo extra do compilador, e no nos tem serventia
Janela: possui comandos teis para os casos em que temos vrios arquivos ou
projetos abertos ao mesmo tempo e precisamos alternar entre eles.
Ajuda: d acesso ajuda do programa, que possui uma listagem dos principais
comandos do compilador e um breve tutorial da linguagem C.
Logo abaixo dos menus, temos as barras de ferramenta com as principais funes e
comandos do programa representados por cones para acesso rpido. Basta posicionar o
mouse sobre qualquer um dos cones para saber sua funo.
Abaixo das barras de ferramentas, esto as duas principais janelas do programa. A
janela da esquerda chamada de Navegador de Classes e Projetos, e serve para acessar
rapidamente os vrios arquivos de cdigo pertencentes um projeto ou ento acessar
rapidamente as vrias classes existentes em um programa. A janela da direita nossa tela
de trabalho, onde digitamos nossos cdigos. Note que caso exista mais de um arquivo
sendo trabalhado ao mesmo tempo, podemos alternar entre eles atravs das pequenas abas
que existem diretamente acima da tela de trabalho, cada uma identificada pelo nome de seu
arquivo.
Finalmente, a janela inferior do programa possui vrias informaes sobre o
processo de compilao e debugagem de um programa. Ela particularmente til para
encontrar erros de compilao, como veremos mais adiante.
2.3.3 - Utilizao
Para iniciarmos um novo arquivo de cdigo, preciso acessar o menu Arquivo ->
Novo -> Arquivo Fonte (como mostra a figura 2.4) ou ento utilizar o atalho CTRL + N.
O novo arquivo ser criado imediatamente e poderemos comear a trabalhar nele.
Figura 2.4 Utilize o comando Arquivo Fonte para criar um novo arquivo em branco.
As funes bsicas do compilador podem ser encontradas no menu Executar, como
mostra a figura 2.5. Os comandos que utilizaremos so: Compilar (atalho: CTRL + F9),
Executar ( CTRL + F10) e Compilar & Executar ( atalho: F9). Utilizamos o comando
Compilar para compilar o arquivo cdigo do programa em que estamos trabalhando e gerar
Pgina 12
um arquivo executvel deste programa. Em seguida, utilizamos o comando Executar para

automaticamente executar o arquivo criado pela compilao. O comando Compilar &
Executar a unio dos dois comandos: compila e executa o programa logo em seguida.
Como j indicado antes, estes trs comandos possuem cones de acesso rpido na barra de
ferramentas (veja a figura 2.6).
Figura 2.5 O menu Executar possui todas os comandos necessrios para compilar e
executar os programas que criaremos.
Figura 2.6 Localizao dos comandos bsicos na barra de tarefas. Coloque o mouse
sobre qualquer um dos cones para saber qual sua funo.
2.3.4 Erros
Quando compilamos um arquivo de cdigo no Dev-C++, a janela indicadora do
progresso da compilao automaticamente aberta. Caso o arquivo de cdigo no
contenha nenhum erro, a compilao terminar e a janela de progresso permanecer aberta
para indicar que tudo correu bem (verifique o quadrado da janela chamado status: ele
dever indicar Done aps o fim da compilao). Desta maneira, aps o fim da compilao
Pgina 13
basta fechar a janela e executar o programa executvel que foi gerado.
Figura 2.7 Janela que indica o progresso da compilao do arquivo de cdigo.

Caso nosso arquivo de cdigo contenha uma ou mais linhas de cdigos com erro, a
compilao interrompida para que estes erros (ou advertncias) sejam verificados pelo
programador. A janela de progresso da compilao fechada, e a janela inferior do
programa maximizada mostrando todos os erros que foram encontrados durante a
compilao do programa.
Figura 2.8 A janela que indica a posio e o tipo de erros encontrados durante a
compilao do programa.
A figura acima mostra que a janela possui trs colunas: linha, unidade e mensagem.
A coluna linha indica a linha de cdigo onde o erro foi encontrado; a coluna unidade indica
o arquivo onde foi encontrado o erro e a coluna mensagem relata o tipo de erro encontrado.
Um duplo clique em qualquer uma das indicaes de erro nesta janela faz com que a linha
de cdigo onde o erro foi encontrado seja sublinhada em vermelho na janela de edio de
cdigo.
Geralmente, os erros encontrados so erros de digitao do cdigo. Quando
erramos o nome de uma varivel ou mesmo um comando, o Dev-C++ indica que o nome
errado no foi declarado anteriormente (varivel_x undeclared(first use in this
function)), pois ele age como se este nome desconhecido fosse uma varivel no
declaradada e tenta continuar a compilao.
Outro erro bastante comum a falta de ponto-e-vrgula no fim de uma linha de
comando. Neste caso, a mensagem de erro geralmente ; expected before
algum_comando, indicando que o compilador esperava o ponto-e-vrgula antes do
prximo comando ou varivel. A mensagem de erro indica a prxima linha de cdigo, mas
o ponto-e-vrgula ausente est na linha anterior. O compilador tambm indica quando
utiliza-se o ponto-e-vrgula antes da hora, ou seja, quando o compilador espera por uma
Pgina 14
expresso ou comando e encontra somente o ponto-e-vrgula. Por exemplo, uma

declarao de varivel sem declarao de valor: varivel = ;. Neste caso, a mensagem de
erro dada pelo programa expected primary-expression before ; token.
2.4 Estrutura Bsica de um Programa em C++

Temos abaixo a estrutura de um programa escrito na linguagem C++:
#include <iostream>
using namespace std;
int main()
{
//comandos do programa
system(PAUSE > null);
return 0;
}
As duas primeiras linhas so o cabealho do programa. Todo programa deve ter um
cabealho desse tipo para definir quais as bibliotecas ele utilizar. Bibliotecas so
arquivos que normalmente so instalados juntos com o compilador e que possuem os
comandos e funes pertencentes linguagem.
O cabealho #include<> serve para indicar ao compilador todas as bibliotecas que
este programa utilizar. Na maioria dos programas que escreveremos durante esta apostila,
s utilizaremos o #include <iostream>, que serve para incluir a biblioteca iostream em
nossos programas. Esta biblioteca contm as principais funes, comandos e classes de
entrada e sada de C++, necessrias para realizar programas que, por exemplo, recebam
dados via teclado e enviem dados via monitor.
A segundal linha do cabealho, using namespace std; , um aviso ao compilador
que estaremos utilizando os comandos e funes padro de C++. Ele necessrio porque
em C++ podemos criar vrias bibliotecas para serem utilizveis em vrios programas. Cada
uma dessas bibliotecas contm comandos, classes e funes prprias, e para evitar
confuses e problemas com os nomes destes comandos, utilizamos o cabealho using
namespace ...; para definir qual o campo de nomes que estamos utilizando. Num
programa normal, que no utiliza outras bibliotecas alm da padro de C++, utilizamos o
namespace std como nosso campo de nomes de comandos e funes. Assim, sempre que
utilizamos um comando prprio de C++, o compilador reconhecer automaticamente este
comando como sendo pertencente biblioteca padro de C++.
Assim como em C, tudo o que acontece durante a execuo do programa est
contido dentro de uma funo principal, chamada main. Declaramos a funo main com:
int main ( )
Todos os comandos executados pelo programa esto contidos entre as chaves { }
da funo main. No mdulo 4 estudaremos as funes fundo e veremos que um programa
pode ter mais de uma funo, mas indispensvel que todos os programas possuam a
Pgina 15
funo main.
Cada programa ter seus prprios comandos, logicamente. Entretanto, o
encerramento de um programa geralmente feito da mesma maneira para todos eles. As
duas ltimas linhas antes do fecha-chaves so dois comandos normalmente utilizados ao
fim de um programa.
A linha system(PAUSE > null) uma chamada de funo prpria de C++. A
funo system( ) recebe argumentos como o PAUSE que na verdade so comandos para o
sistema operacional. Neste caso, ela recebe o comando PAUSE > null para pausar a
execuo do programa at que o usurio aperte uma tecla qualquer. Utilizamos este recurso
para que a tela do programa no seja terminada automaticamente pelo sistema, impedindo
que vejamos os resultados do programa.
Finalmente, o comando return 0 a resposta da funo main para o sistema.
Quase toda funo retorna um valor para o sistema ou programa que a chamou, por
exemplo, uma funo pode retornar o resultado de uma operao matemtica executada
por ela. No caso da funo main, ela retorna um valor para o sistema operacional que
executou o programa. Esse valor interpretado pelo sistema como uma mensagem
indicando se o programa foi executado corretamente ou no. Um valor de retorno 0 indica
que o programa foi executado sem problemas; qualquer outro valor de retorno indica
problemas. Quando o programa executado at o fim, ele retorna 0 ao sistema operacional,
indicando que ele foi executado e terminado corretamente. Quando o programa encontra
algum erro ou terminado antes da hora, ele retorna um valor qualquer ao sistema,
indicando erro durante a execuo.
Pgina 16
Mdulo 3 Caractersticas e Definies Gerais da

Linguagem C++
3.1 Nomes e Identificadores Usados na Linguagem C++

Existem algumas regras para a escolha dos nomes (ou identificadores) de
variveis em C++:
Nomes de variveis s podem conter letras do alfabeto, nmeros e o

caracter underscore _.
No podem comear com um nmero.
Nomes que comecem com um ou dois caracteres underscore (_ e __)

so reservados para a implementao interna do programa e seu uso
extremamente desaconselhado. O compilador no acusa erro quando
criamos variveis desse jeito, mas o programa criado se comportar de
forma inesperada.
No possvel utilizar palavras reservadas da linguagem C++ (para mais

detalhes, veja o item 2.2). Tambm no possvel criar uma varivel que
tenha o mesmo nome de um funo, mesmo que essa funo tenha sido
criada pelo programador ou seja uma funo de biblioteca.
C++ diferencia letras maisculas e minsculas em nomes de variveis. Ou

seja, count, Count e COUNT so trs nomes de variveis distintos.
C++ no estabelece limites para o nmero de caracteres em um nome de

varivel, e todos os caracteres so significantes.
3.2 Palavras Reservadas na Linguagem C++

Na linguagem C++ existem palavras que so de uso reservado, ou seja, que
possuem funes especficas na linguagem de programao e no podem ser utilizadas
para outro fim, como por exemplo, ser usada como nome de varivel. Por exemplo, a
palavra reservada for serve para chamar um lao de repetio, e no pode ser
utilizada como nome de uma varivel.
A lista abaixo relaciona as palavras reservadas da linguagem C++:
asm
catch
Continue
Dynamic_cast
auto
char
default
else
bool
class
delete
enum
break
const
do
explicit
case
const_cast
double
export
Pgina 17
extern
goto
mutable
protected
short
struct
true
union
Volatile
false
if
namespace
public
signed
switch
try
unsigned
wchar_t
float
inline
new
register
sizeof
template
typedef
using
while
for
int
operator
reinterpret_cast
static
this
typeid
virtual
friend
long
private
return
static_cast
throw
typename
void
importante notar que a linguagem C++ diferencia letras maisculas e

minsculas, ou seja, char uma palavra reservada de C++ mas CHAR ou ChAr no
(entretanto, normalmente desaconselha-se o uso dessa diferenciao por atrapalhar a
legibilidade do cdigo). Reforando o que j foi mencionado, as palavras reservadas s
iro executar os comandos que lhes foram designados.
3.3 Tipos e Dados

Quando um programa escrito em qualquer linguagem de programao necessrio
a definio de algumas variveis. Variveis so instncias em que sero armazenados
valores utilizados durante a execuo de programas. Estas variveis podem ser modificadas
para suportar diferentes tipos de dados. Os principais tipos de dados utilizados em C++
podem ser divididos em variveis inteiras e reais.
Variveis inteiras servem para armazenar nmeros inteiros, sem partes fracionrias.
O principal tipo de varivel inteira em C++ o int. Alm dele, existem os tipos char,
short e long, cada um deles caracterizado por um tamanho em bits diferente. Estes tipos
podem ser modificados pelo prefixo unsigned, que determina que a varivel em questo
s ter valores positivos, liberando o bit de sinal e aumentando a capacidade de
armazenamento da varivel (por default, todas as variveis inteiras e reais declaradas em
C++ so signed, ou seja, possuem um bit de sinal e podem ser tanto positivas como
negativas). A tabela abaixo mostra os principais tipos de inteiros, seus tamanhos em bits e
seu intervalo de armazenamento.
Tipo
Char
unsigned char
Int
unsigned int
Short
unsigned short
Long
unsigned long
Tabela 3.1 Tipos de variveis inteiras em C++

Tamanho (em bits)
Intervalo
8
-128 a 127
0 a 255
8
16
-32768 a 32767
0 a 65535
16
-32768 a 32767
16
0 a 65535
16
-2147483648 a 2147483647
32
0 a 4294967295
32
Variveis reais servem para armazenar nmeros que possuem partes fracionrias.
Pgina 18
Existem duas maneiras de representar nmeros fracionrios em C++. A primeira, a mais

simples, utilizar o ponto para separar as partes inteiras e fracionrias. Por exemplo:
0.00098
1.2145
3.1461
8.0
(Mesmo no caso de um nmero com parte fracionria igual a zero, a utilizao do
ponto assegura que este nmero seja considerado um nmero de ponto flutuante por C++).
A segunda maneira utilizar a notao cientfica E. Por exemplo : 3.45E7 significa
3.45 multiplicado por 10 elevado stima potncia (10.000.000). Essa notao
bastante til para representar nmeros realmente grandes ou realmente pequenos. A
notao E assegura que o nmero seja armazenado em formato de ponto flutuante. Alguns
exemplos:
2.52E8 = 2.52 x 100.000.000 = 252.000.000
-3.2E3 = -3.2 x 1000 = -3200
23E-4 = 23 x 0.0001 = 0.0023
Assim como os inteiros, os nmeros reais em C++ podem ser representados por 3
tipos de variveis com diferentes intervalos. So elas: float, double e long double. Float
o tipo de varivel real natural, aquela com a qual o sistema trabalha com maior
naturalidade. Double e long double so teis quando queremos trabalhar com intervalos
de nmeros reais realmente grandes. Utilizamos nmeros reais geralmente para expressar
preciso atravs do nmero de casas decimais, ento podemos dizer que uma varivel float
menos precisa que uma varivel double, assim como uma varivel double menos
precisa que long double. A tabela abaixo mostra os tipos de variveis reais, seu tamanho
em bits e o intervalo de armazenagem.
Tipo
Float
Double
long double
Tabela 3.2 Tipos de variveis reais em C++

Tamanho (em bits)
Intervalo
32
3,4E-38 a 3,4E+38
64
1,7E-308 a 1,7E+308
80
3,4E-4932 a 1,1E+4932
3.4 Definio de Variveis

As variveis devem ser declaradas, ou seja, devem ser definidos nome, tipo e
algumas vezes seu valor inicial. As variveis so classificadas em variveis locais e
globais.
Variveis globais so aquelas declaradas fora do escopo das funes.
Variveis locais so aquelas declaradas no incio de um bloco e seus escopos esto
restritos aos blocos em que foram declaradas. A declarao de variveis locais deve
obrigatoriamente ser a primeira parte de um bloco, ou seja, deve vir logo aps um caractere
de abre chaves, '{'; e no deve ser intercalada com instrues ou comandos.
Pgina 19
Para declarar uma varivel somente obrigatrio declarar seu tipo e nome:
<tipo> <nome>;
Por exemplo:
int exemplo;
Alm disso, caso seja necessrio, podemos declarar um valor a esta varivel no
momento de sua declarao, e tambm adicionar um prefixo a ela, da seguinte forma:
<prefixo> <tipo> <nome> = <valor>;
Por exemplo:
unsigned int exemplo = 12;
3.5 Definio de Constantes

O conceito de constantes em linguagens de programao atribuir um certo valor
constante a um nome, e quando este nome for referenciado dentro do cdigo do programa,
ser utilizado nas operaes o valor atribudo a este nome. Ou seja, se for definida a
constante PI com o valor 3,1415926536, quando for encontrado no cdigo o nome PI,
ser utilizado em seu lugar o valor 3,1415926536.
Em C++ , utilizamos o prefixo const associado a um tipo, um nome e um valor para
definir uma constante. Assim:
const <tipo> <nome> = <valor>;
Por exemplo:
const int eterna = 256;
No exemplo acima, definimos uma constante inteira de nome eterna que possui o
valor numrico 256. importante notar que devemos declarar a constante e lhe atribuir um
valor na mesma linha de comando. No podemos criar uma constante e lhe atribuir um
valor posteriormente, ou seja, as seguintes linhas de comando so invlidas:
const int eterna;
eterna = 256;
A partir da primeira linha, eterna passa a ser uma constante e seu valor no pode
ser mais mudado durante a execuo do programa. Como seu valor no foi declarado, esta
constante pode ter qualquer valor que esteja na memria do computador naquele momento
da declarao da varivel.
3.6 Nmeros Hexadecimais e Octais

Em programao algumas vezes comum usar um sistema de numerao baseado
em 8 ou 16 em vez de 10. O sistema numrico baseado em 8 chamado octal e usa os
dgitos de 0 a 7. Em octal, o nmero 10 o mesmo que 8 em decimal. O sistema numrico
de base 16 chamado hexadecimal e usa os dgitos de 0 a 9 mais as letras de A at F, que
equivalem a 10, 11, 12, 13, 14 e 15. Por exemplo, o nmero hexadecimal 10 16 em
decimal. Por causa da freqncia com que estes dois sistemas numricos so usados, a
linguagem C++ permite que se especifique valores inteiros em hexadecimal ou octal para
uma varivel ou constante em vez de decimal. Um valor hexadecimal deve comear com
Pgina 20
0x (um zero seguido de um x), seguido pelo valor em formato hexadecimal. Um valor
octal comea com um zero. Aqui esto alguns exemplos:
hex = 0xFF; /* 255 em decimal */
oct = 011; /* 9 em decimal */
Outra base numrica muito utilizada na programao a base binria. Apesar de
C++ no possuir uma forma especfica de se expressar valores de base binria, podemos
utilizar a notao hexadecimal para esta funo. A tabela abaixo mostra como pode ser
feita a converso de um valor binrio para um valor hexadecimal.
Tabela 3.3 Converso de valor binrio para hexadecimal
Dgito Hexadecimal Equivalente Binrio Dgito Hexadecimal Equivalente Binrio
0
0000
8
1000
1
0001
9
1001
2
0010
A
1010
3
0011
B
1011
4
0100
C
1100
5
0101
D
1101
6
0110
E
1110
7
0111
F
1111
3.7 Valores Strings

Outro tipo de valor suportado pela Linguagem C++ o tipo string. Uma string
um conjunto de caracteres entre aspas. Por exemplo, voc um vencedor uma string,
composta pelas vrias letras que formam a frase. No confunda strings com caractere. Uma
constante caractere simples fica entre dois apstrofos, por exemplo a. Entretanto a
uma string que contm somente uma letra.
3.8 Cdigos de Barra Invertida

A linguagem C++ fornece constantes caractere mais barra invertida especiais,
teis para caracteres que no so facilmente inseridos atravs do teclado ou de strings
(como por exemplo, o retorno de carro). Estes cdigos so mostrados na tabela a
seguir:
Cdigo
\b
\n
\t
\
\\
\a
\xN
Tabela 3.4 Cdigos de barra invertida em C++

Significado
Cdigo
Significado
Retrocesso
\f
Alimentao de formulrio
Nova linha
\r
Retorno de carro
Tabulao horizontal
\
Aspas
Apstrofo
\0
Nulo
Barra invertida
\v
Tabulao vertical
Sinal sonoro
\N
Constante octal
Constante hexadecimal
Pgina 21
Usa-se um cdigo de barra invertida exatamente da mesma maneira como usa qualquer
outro caractere. Por exemplo:
ch = \t;
printf(Este um teste\n);
Esse fragmento de cdigo primeiro atribui uma tabulao a ch e, ento, imprime
este um teste na tela, seguido de uma nova linha.
3.9 Operadores
Um operador um smbolo que diz ao compilador para realizar manipulaes
matemticas e lgicas especficas. A linguagem C++ possui trs classes gerais de
operadores: aritmticos, relacionais e lgicos e bit-a-bit.
3.9.1 Operador de atribuio

O operador = atribui um valor ou resultado de uma expresso contida a sua
direita para a varivel especificada a sua esquerda. Exemplos:
a = 10;
b = c * valor + getval(x);
a = b = c = 1;
O ltimo exemplo interessante por mostrar que possvel associar vrios
operadores de atribuio em sequncia, fazendo com que todas as variveis envolvidas
tenham o mesmo valor especificado.
3.9.2 Operadores Aritmticos

So aqueles que operam sobre nmeros e expresses, resultando valores
numricos. So eles:
Tabela 3.5 Operadores Aritmticos em C++
Operador
Ao
+
Soma
subtrao
*
multiplicao
/
diviso
%
mdulo da diviso (resto da diviso inteira)
sinal negativo (operador unrio)
Pgina 22
3.9.3 Operadores Relacionais

Operam sobre expresses, resultando valores lgicos de TRUE (verdadeiro) ou
FALSE (falso). so eles:
Tabela 3.6 Operadores Relacionais em C++
Operador
Ao
>
>=
<
<=
==
!=
Maior
maior ou igual
Menor
menor ou igual
Igual
no igual (diferente)
Ateno!
No existem os operadores relacionais: =<, => e <>.
No confunda a atribuio (=) com a comparao (==).
3.9.4 Operadores Lgicos

Operam sobre expresses, resultando valores lgicos de TRUE (verdadeiro) ou
FALSE (falso). Possuem a caracterstica de short circuit, ou seja, sua execuo curta e
s executada at o ponto necessrio. So eles:
Tabela 3.7 Operadores Lgicos em C++
Operador
Ao
&&
operao AND
||
operao OR
!
operador de negao NOT (operador
unrio)
Exemplos de short circuit:
(a == b) && (b == c) /* Se a != b no avalia o resto da expresso */
(a == b) || (b == c) /* Se a == b no avalia o resto da expresso */
3.9.5 Manipulao de bits

A manipulao feita em todos os bits da varivel. importante notar que a
varivel manipulada no pode ser do tipo float ou double. Os operadores que manipulam
bits esto relacionados abaixo:
Pgina 23
Tabela 3.8 Operadores para manipulao de bits em C++

Operador
Ao
&
bit and
|
bit or
^
bit xor - exclusive or
<<
Rotao a esquerda
>>
Rotao a direita
~
bit not (complemento)
Observao: x << n ir rotacionar n vezes a varivel x esquerda.
3.9.6 Operadores de assinalamento

expresso da seguinte forma: (operadores combinados)
var = var op expr
->
var op = expr
Onde tempos op como um dos seguintes operadores:

Tabela 3.9 Operadores de Assinalamento em C++
Operador
Ao
+
Soma
Subtrao
*
Multiplicao
/
Diviso
%
mdulo (resto da diviso)
>>
Rotao a direita
<<
Rotao a esquerda
&
And
^
xor - exclusive or
|
Or
Exemplo de aplicao:
i+= 2; /* equivalente a: i = i + 2 */
j-= 3; /* equivalente a: j = j 3 */
k >>= 3; /* equivalente a: k = k >> 3;*/
z &= flag; /* equivalente a: z = z & flag;*/
3.9.7 Operadores de Pr e Ps-Incremento

Operadores de pr e ps-incremento so aqueles usados quando necessrio
incrementar ou decrementar um determinado valor.
Pgina 24
As operaes abaixo podem ser representadas assim:

i = i + 1;
i = ++i;
i = i 1;
i = --i;
z = a; a = a + 1;
z = a++;
z = a;
z = a--;
a = a + 1; z = a;
z = ++a;
a = a - 1; z = a;
z = --a;
a = a 1;

++i;
--i;
3.9.8 - Operadores de Endereo

So operadores usados com ponteiros, para acesso a endereos de memria.
Tabela 3.10 Operadores de endereamento em C++
Operador
Significado
&
endereo de uma varivel
*
contedo do endereo especificado
Exemplos:
int var, *x;
x = &var;
var = *x;
3.10 Tabela de Operadores da Linguagem C

A tabela abaixo mostra todos os operadores apresentados anteriormente:
+
!
~
&
*
sizeof
++
-*
/
/
Tabela 3.11 Resumo dos operadores em C++

Operador
Funo
Exemplo C
menos unrio
a = -b;
mais unrio
a = +b ;
negao lgica
! flag
bitwise not
a = ~b ;
endereo de
a = &b ;
referncia a ptr
a = *ptr ;
tamanho de var
a = sizeof(b) ;
incremento
++a; ou a++;
decremento
--a; ou a--;
multiplicao
a = b * c;
diviso inteira
a = b / c;
diviso real
a = b / c;
Pgina 25
%
+
>>
<<
>
>=
<
<=
==
!=
&
|
^
&&
||
=
OP=
resto da diviso
soma
subtrao
shift right
shift left
maior que
maior ou igual a
menor que
menor ou igual a
igual a
diferente de
bitwise AND
bitwise OR
bitwise XOR
logical AND
logical OR
assinalamento
assinalamento
a = b % c;
a = b + c;
a = b c;
a = b >> n;
a = b << n;
a>b
a >= b
a<b
a <= b
a == b
a != b
a = b & c;
a = b | c;
a = b ^ c;
flag1 && flag2
flag1 || flag2
a = b;
a OP= b;
3.11 Expresses
Operadores, constantes e variveis constituem expresses. Uma expresso em C++
qualquer combinao vlida dessas partes. Uma vez que muitas expresses tendem a
seguir as regras gerais da lgebra, estas regras so freqentemente consideradas.
Entretanto, existem alguns aspectos das expresses que esto especificamente relacionadas
com a linguagem C e sero discutidas agora.
3.12 Precedncia e Associatividade de Operadores

C++ possui uma srie de regras de precedncia de operadores, para que o
compilador saiba decidir corretamente qual operador ser executado primeiro, em uma
expresso com vrios operadores. Essas regras seguem basicamente as regras algbricas.
Alm disso, possvel o uso de parnteses para forar o compilador a executar uma parte
de uma expresso antes das outras.
Alm das regras de precedncia, existem tambm certas regras de associatividade
para determinados operadores que possuem o mesmo nvel de precedncia, como por
exemplo os operadores de diviso e multiplicao. Quando C++ encontra dois operadores
com o mesmo nvel de precedncia em uma expresso, ele verifica se estes operadores
possuem associatividade esquerda-para-direita ou direita-para-esquerda. Associatividade
esquerda-para-direita significa que se estes dois operadores agirem sobre um mesmo
operando, o operador da esquerda ser aplicado primeiro. Da mesma forma,
associatividade direita-para-esquerda significa que na mesma situao, o operador da
direita ser aplicado primeiro. Por exemplo, os operadores diviso e multiplicao
possuem associatividade esquerda-para-direita.
A tabela abaixo mostra as regras de precedncia e associativade para os operadores
Pgina 26
de C++. O nmero na coluna de precedncia indica qual o nvel de precedncia dos

operadores em questo, sendo 1 o nvel mais alto (operador a ser executado primeiro). Na
coluna de precedncia, feito o uso dos termos unrio (para operadores que usam um s
operando) e binrio (para operadores que necessitam de dois operandos) serve para
diferenciar operadores que possuem smbolos iguais. Na coluna de associatividade, as
siglas E-D e D-E indicam o tipo de associatividade dos operadores daquele nvel de
precedncia: E-D significa associatividade esquerda-para-direita, e D-E significa
associatividade direita-para-esquerda.
Tabela 3.10 Precedncia e Associatividade de operadores em C++
Precedncia
Operador
Associatividade Explicao
(expresso)
1
Agrupamento
()
2
E-D
Chamada de funo
++
Operador de incremento, psfixado
-Operador de decremento, psfixado
3 (todos unrios) !
D-E
Negao lgica
~
Negao Bitwise
+
Mais unrio (sinal positivo)
Menos unrio (sinal negativo)
++
Operador de incremento, pr-fixado
-Operador de decremento, pr-fixado
&
Endereo
*
Contedo de endereo
()
Modelador de tipo (tipo) nome
sizeof
Tamanho em bytes
new
Dynamically allocate storage
new []
Dynamically allocate array
delete
Dynamically free storage
delete []
Dynamically free array
4 (todos binrios) *
E-D
Multiplicao
/
Diviso
%
Resto de diviso
+
5 (todos binrios)
E-D
Adio
Subtrao
<<
6
E-D
Shift para esquerda
>>
Shift para direita
<
7
E-D
Menor que
<=
Menor que ou igual a
>=
Maior que ou igual a
>
Maior que
==
8
E-D
Igual a
!=
No igual a
&
9 (binrio)
E-D
Bitwise AND
Pgina 27
10
11
12
13
14
^
|
&&
||
=
E-D
E-D
E-D
E-D
D-E
*=
/=
%=
+=
-=
&=
^=
|=
<<=
>>=
15
16
:?
,
D-E
E-D
Bitwise XOR (OR exclusivo)

Bitwise OR
AND Lgico
OR Lgico
Atribuio simples
Multiplicao e atribuio
Dividir e atribuio
Achar resto da diviso e atribuio
Adio e atribuio
Subtrao e atribuio
Bitwise AND e atribuio
Bitwise XOR e atribuio
Bitwise OR e atribuio
Shift para esquerda e atribuio
Shift para direita e atribuio
Condicional
Combine two expressions into one
3.13 Converses de Tipos

3.13.1 - Converses durante a Atribuio
C++ permite que o programador atribua um valor de um certo tipo para uma
varivel designada para armazenar outro tipo de valor, mas quando isto feito o valor
automaticamente convertido para o tipo da varivel.
Quando atribumos um certo valor para uma varivel cujo tamanho maior do que
o valor atribudo, no h problemas. Porm, quando o tamanho da varivel menor do que
o valor a ser atribudo ela, haver truncamento deste valor e consequente perda de
informao e/ou preciso.
Outro caso complicado a atribuio de valores reais em variveis inteiras. Quando
armazenamos valores reais em variveis inteiras, a parte fracionria do valor descartada,
resultando em truncamento do valor. Pode ocorrer tambm incompatibilidades de tamanho,
por exemplo, um valor de tamanho float (64 bits) tentando ser armazenado em uma
varivel int (16 bits), causando invariavelmente perda de informaes.
Por isso, preciso tomar cuidado com os tipos e tamanhos de variveis envolvidos
durante uma atribuio de valores, para termos certeza que o valor inserido pode ser
armazenado por aquela varivel.
Pgina 28
3.13.2 Converses durante Expresses

Quando constantes e variveis de tipos diferentes so misturadas em uma
expresso, elas so convertidas para o mesmo tipo. O compilador C++ converter todos os
operandos para o tipo do operando maior. Isso feito na base de operao a operao,
como descrito nestas regras de converso de tipos:
1. Se algum dos operandos for do tipo long double, o outro operando convertido
para long double tambm.
2. Seno, se algum dos operando for double, o outro operando sera convertido para
double.
3. Seno, se algum dos operandos for float, o outro operando ser convertido para
float.
4. Seno, os operandos so inteiros e promoes inteiras sero feitas.
5. Nesse caso, se algum dos operandos for do tipo unsigned long, o outro operando
sera convertido para unsigned long.
6. Seno, caso um dos operandos seja long int e o outro seja um unsigned int, a
converso depender do tamanho relative entre os dois tipos. Se long conseguir
expressar valores possveis de unsigned int, a varivel unsigne int ser convertida
para long.
7. Seno, ambos os operadores so convertidos para unsigned long.
8. Seno, se algum dos operadores for long, o outro ser convertido para long.
9. Seno, se algum dos operadores for um unsigned int, o outro ser convertido para
unsigned int.
10. Caso o compilador chegue a este ponto na lista, ambos operadores sero int.
3.14 Modeladores de Tipos

possvel tambm forar a converso de uma varivel ou expresso para um
determinado tipo, usando o mecanismo dos modeladores de tipos, tambm chamado de
type cast. possvel utilizar duas sintaxes diferentes para obter o mesmo resultado de
modelamento. So elas:
(tipo) varivel_ou_expresso; por exemplo:
(int) modelos; (int) 19.99;
e
tipo (varivel_ou_expresso); por exemplo:
int (modelos); int (19.99);
Ambos os comandos produzem o mesmo resultado: forar o valor presente na
varivel (ou expresso) ser convertido no tipo desejado. Note que o valor da varivel no
alterado; somente feita uma converso momentnea, cujo valor resultante deve ser
armazenada em outra varivel ou trabalhado imediatamente em uma expresso.
Pgina 29
Mdulo 4 Funes na Linguagem C

4.1 Funes
Funes so os blocos de construo da linguagem C++, com os quais podemos
construir programas melhores e mais facilmente compreensveis. Quando os programas
tornam-se maiores e mais complexos, pode-se melhorar a clareza e compreenso do
trabalho dividindo-o em partes menores, que chamamos de funes. Todo programa possui
ao menos uma funo: a funo main, a qual podemos chamar de corpo do programa,
onde esto localizados todos os comandos e chamadas de outras funes que so
executadas pelo programa. Alm da funo main, podemos utilizar e tambm criar vrias
outras funes dentro do mesmo programa. Por exemplo, imagine um programa que
organize o funcionamento de uma loja. Poderia haver uma funo para organizar o
estoque, outra para relacionar os preos dos produtos, outra para acessar um banco de
dados com os cadastros dos clientes, entre outras. Se fossem colocados todos os comandos
do programa dentro da funo main, o programa ficaria muito grande e provavelmente
incompreensvel. Dividindo o programa em funes separadas, deixando para a funo
main somente a tarefa de organizar as chamadas das demais funes, podemos trabalhar
mais facilmente com o programa, modificando e corrigindo funes individualmente.
medida que o tamanho e a complexidade do programa aumentam, aumenta tambm a
possibilidade de erros, j se o mesmo for dividido em blocos menores e organizados, fica
mais fcil encontrar e evitar erros. Basicamente, uma funo funciona da seguinte forma:
feita uma chamada para esta funo durante a execuo do programa; o programa
interrompido temporariamente, e pula para esta funo executando seus comandos;
quando a funo termina, ou seja, quando seus comandos acabam (ou quando o comando
return encontrado), o programa volta ao ponto onde foi interrompido para continuar sua
execuo normal. Uma funo pode receber dados do programa para executar seus
comandos (estes dados so chamados de parmetros ou argumentos), e pode tambm
retornar dados para o programa (o que chamamos de retorno de funo).
Por exemplo, vamos observar a funo sqrt( ), que retorna o valor da raiz quadrada
de um nmero. Esta funo foi criada e definida na biblioteca padro da linguagem C/C++,
de modo que podemos nos preocupar somente com sua execuo neste momento. Voc
pode usar a seguinte linha de comando em um programa qualquer:
x = sqrt(6.25);
A expresso sqrt(6.25) chama a funo sqrt( ). O nmero entre parnteses o valor
que estamos enviando para a funo sqrt( ), e o chamamos de parmetro ou argumento. A
funo calcular a raiz quadrada de 6.25, e enviar o valor calculado para o programa, o
chamado retorno da funo. Nesta linha de comando, especificamos que o retorno da
funo, ou seja, seu resultado, ser armazenado na varivel x. Resumindo, um valor
enviado para a funo, e a funo retorna o valor resultante para o programa.
Entretanto, antes de podermos utilizar a funo sqrt( ) ou qualquer outra funo em
um programa preciso declar-la. Veremos isso em detalhes no prximo item.
Pgina 30
4.2 Declarando uma Funo

Antes de utilizar uma funo em um programa preciso declar-la, ou seja,
especificar para o compilador exatamente o que faz esta funo e que tipo de dados ela
recebe e retorna. Podemos dividir o processo de declarar uma funo em duas etapas
distintas: o prottipo da funo e a definio da funo.
4.2.1 Prottipo de uma Funo

O prottipo de uma funo tem a mesma funo de uma declarao de variveis:
dizer ao compilador quais tipos de variveis estaro envolvidos na funo. Isso permite que
o compilador saiba trabalhar corretamente com os valores que entram e saem da funo,
fazendo converses de tipos sempre que necessrio. A sintaxe da declarao de um
prottipo de funo a seguinte:
<tipo_da_funo> <nome> ( <tipo_de_parmetro> <nome_da_varivel>);
O tipo da funo denominar qual ser o tipo de valor que esta funo retorna. Uma
funo pode retornar qualquer tipo de valor, seja inteiro, fracionrio ou nenhum valor.
Quando uma funo no retorna nenhum valor para o programa, seu tipo void. Esse tipo
de funo executar seus comandos normalmente, mas no retornar nenhum valor para o
programa quando terminar.
J o tipo de parmetro serve para determinar o tipo de variveis que a funo
receber como parmetros. Assim como o tipo da funo, qualquer tipo de varivel pode
ser utilizado como parmetro. Uma funo que no recebe parmetros de entrada deve ter a
palavra chave void entre parnteses. possvel ter vrios parmetros na mesma funo,
separando-os com vrgulas. Alguns exemplos de prottipo de funo:
int livro (unsigned int paginas);
float divide (float dividendo, float divisor);
void imprime ( void );
float divide (float, float);
O ltimo exemplo mostra que a escolha do nome do parmetro no prottipo
opcional: basta inserir o tipo de parmetros que sero utilizados pela funo e o compilador
alocar a memria necessria para eles. Porm a atribuio de nomes para parmetros
aconselhvel, pois melhora a legibilidade do programa.
Quando declaramos e definimos uma funo no incio do programa, isto , antes da
funo main, podemos omitir o prottipo da funo, fazendo somente a definio da
funo como veremos abaixo.
Pgina 31
4.2.2 Definio de uma Funo

O prottipo de uma funo diz para o compilador quais os tipos de variveis ela
usar. J a definio de uma funo diz ao compilador exatamente o que a funo faz. A
sintaxe da definio de uma funo a seguinte:
<tipo da funo> <nome> ( <tipo do parmetro> <nome do parmetro>)
{
comandos da funo;
}
A primeira linha da definio de uma funo idntica ao prottipo, com a exceo
de que somos obrigados a declarar nomes para as variveis de parmetro e que a linha no
termina em um ponto-e-vrgula, e sim em uma abre-chaves. Dentro das chaves estaro
todos os comandos pertencentes a funo, inclusive declarao de variveis locais,
chamadas para outras funes e chamadas de retorno. Por exemplo:
int cubo ( int valor) {
resultado = valor*valor*valor;
return resultado;
}
A funo acima calcula o cubo de um valor inteiro. Note que podemos declarar
variveis dentro de uma funo; entretanto, estas variveis s podero ser utilizadas dentro
desta mesma funo. O comando return termina a funo e retorna um valor para o
programa.
4.2.3 Retorno de uma funo

O comando return utilizado para terminar a execuo de uma funo e retornar
um valor para o programa. Sua sintaxe a seguinte:
return <varivel ou expresso>;
O comando return aceita qualquer constante, varivel ou expresso geral que o
programador precise retornar para o programa principal, desde que este valor seja igual ou
convertvel para o tipo da funo (j estabelecido no prottipo da funo). importante
notar que o valor retornado no pode ser uma matriz; porm, possvel retornar uma
matriz indiretamente, desde que ela faa parte de uma estrutura ou objeto (tipos de dados
que sero estudados mais adiante).
possvel tambm criar funes que contnham mltiplos comandos return, cada
um dos quais retornando um valor para uma condio especfica. Por exemplo, considere a
funo compara_valores, mostrada a seguir:
Pgina 32
int compara_valores(int primeiro, int segundo)

{
if (primeiro == segundo)
return (0);
else if (primeiro > segundo)
return (1);
else if (primeiro < segundo)
return (2);
}
A funo compara_valores examina dois valores listados na tabela abaixo:
Resultado
0
1
2
Significado
Os valores so iguais
O primeiro valor maior que o segundo
O segundo valor maior que o primeiro
Como regra, deve-se tentar limitar as funes a usar somente um comando return.
medida que as funes se tornarem maiores e mais complexas, ter muitos comandos
return normalmente tornar as funes mais difceis de compreender. Na maioria dos
casos, pode-se reescrever a funo para que ela use somente um comando return
4.3 Main como uma Funo

Como j dissemos anteriormente, todo programa possui uma funo
principal que contm todos os comandos e chamadas para outras funes presentes no
programa. A funo main funciona como uma funo normal: possui um prottipo e uma
definio. Geralmente omitimos o prottipo, fazendo apenas a definio da funo main da
seguinte forma:
int main (void) {
//corpo do programa
return 0;
}
Note que a funo main do tipo int, e retorna 0. Entretanto, no existe outra
funo acima de main que a tenha chamado, para que ela possa retornar um valor de
resposta. Para que serve este retorno ento? Simples: consideramos que a funo
chamadora de main o prprio sistema operacional. Assim, utilizamos o retorno para
indicar o funcionamento do programa. Caso o programa termine e retorne o valor 0 para o
sistema operacional, sabemos que tudo correu bem e que o programa terminou
normalmente. Um valor retornado diferente de 0 indica que o programa no rodou at o
final (ou seja, at o ponto return 0;) e que aconteceu algum erro. Muitos sistemas
operacionais e programas utilizam esse sistema simples para detectar erros durante a
execuo de seus aplicativos.
Pgina 33
4.4 Variveis dentro das Funes

medida que as funes vo se tornando mais teis nos programas, muitas delas
requerem que as variveis gerem resultados valiosos. Para usar uma varivel dentro de uma
funo, precisa-se primeiro declarar a varivel, exatamente como feito na funo principal
main. Quando se declara variveis dentro de uma funo, os nomes usados para essas
variveis so exclusivos para a funo.
Portanto, se o programa usa dez funes diferentes e cada funo usa uma varivel
chamada contador, o compilador considerar a varivel de cada funo como distinta. Se
uma funo requer muitas variveis, elas devero ser declaradas no incio da funo,
exatamente como se faria dentro de main.
4.4.1 Variveis Locais

A Linguagem C++ permite declarar variveis dentro de suas funes. Essas
variveis so chamadas de variveis locais, pois seus nomes e valores somente tm
significado dentro da funo que contm a declarao da varivel.
O programa a seguir ilustra o conceito de uma varivel local. A funo
valores_locais declara 3 variveis a, b e c, e atribui s variveis os valores 1, 2 e 3,
respectivamente. A funo main tenta imprimir o valor de cada varivel. No entanto, como
os nomes dos valores so locais funo, o compilador gera erros, dizendo que os
smbolos a, b, e c esto indefinidos.
#include <iostream>
void valores_locais(void);
void valores_locais(void)
{
int a=1, b=2, c=3;
}
int main (void)
{
cout<<A vale << a <<. B vale << b <<. C vale << c
<<.\n;
system("PAUSE > null");
return 0;
}
O programa abaixo a verso corrigida do programa acima. Veja que a funo
main chama a funo valores_locais, que por sua vez declara as variveis junto com seus
valores e as imprime na tela corretamente.
#include <iostream>
void valores_locais(void);
Pgina 34
void valores_locais(void)
{
int a=1, b=2, c=3;
cout<<"A vale "<< a <<". B vale "<< b <<". C vale "<< c
<<".\n";
}
int main (void)
{
valores_locais();
return 0;
}
4.4.2 Variveis Globais

Alm das variveis locais, a Linguagem C permite que os programas usem
variveis globais, cujos nomes, valores e existncia so conhecidos em todo o
programa. Em outras palavras, todos os programas em Linguagem C podem usar
variveis globais. O programa a seguir ilustra o uso de trs variveis globais a, b e c:
#include <iostream>
int a = 1, b = 2, c = 3; // Variaveis globais
void valores_globais(void)
{
<<".\n";
}
int main(void)
{
valores_globais();
<<".\n";
return 0;
}
Quando este programa compilado e executado, as funes variaveis_globais e

main exibem os valores das variveis globais. Observe que as variveis globais so
declaradas fora de todas as funes. Declarando variveis globais deste modo, todas as
funes do programa podem usar e alterar os valores da varivel global simplesmente
referenciando o nome dela.
Embora as variveis globais possam parecer convenientes, o uso incorreto delas
podem causar erros que so difceis de depurar. Se um programa usa variveis globais,
algumas vezes o nome de uma varivel global o mesmo que aquele de uma varivel local
que seu programa declara dentro de uma funo. Por isso, preciso estar atento com o uso
de variveis globais e sua nomeao. Quando nomes de variveis globais e locais
Pgina 35
estiverem em conflito, a linguagem C++ usar sempre a varivel local.
4.5.1 Chamada por Valor

Os programas passam informaes para funes usando parmetros. Quando um
parmetro passado a uma funo, a Linguagem C++ usa uma tcnica conhecida como
chamada por valor para fornecer funo uma cpia dos valores dos parmetros. Usando
a chamada por valor, quaisquer modificaes que a funo fizer nos parmetros existem
apenas dentro da prpria funo. Quando a funo termina, o valor das variveis que a
funo chamadora passou para a funo no modificada dentro da funo chamadora.
Por exemplo, o programa a seguir passa trs parmetros (as variveis a, b e c) para
a funo exibe_e_altera. A funo, por sua vez, exibir os valores, somar 100 aos valores
e depois exibir o resultado. Quando a funo terminar, o programa exibir os valores das
variveis. Como a Linguagem C usa chamada por valor, a funo no altera os valores das
variveis dentro do chamador, como mostrado a seguir:
#include <iostream>
void exibe_e_altera(int primeiro, int segundo, int terceiro)
{
cout<<"Valores originais da funcao: "<<primeiro<<"
"<<segundo<<" "<<terceiro<<"\n";
primeiro = primeiro +100;
segundo = segundo + 100;
terceiro = terceiro + 100;
cout<<"Valores originais da funcao: "<<primeiro<<"
"<<segundo<<" "<<terceiro<<"\n";
}
int main(void)
{
int a = 1, b = 2, c = 3;
exibe_e_altera(a, b, c);
cout<<"Valores finais em main: "<<a<<" "<<b<<"
"<<c<<"\n";
}
Como pode ser visto, as alteraes que a funo faz nas variveis somente so
visveis dentro da prpria funo. Quando a funo termina, as variveis dentro de main
esto inalteradas.
Pgina 36
4.5.2 - Chamada por Referncia

Usando a chamada por valor, as funes no podem modificar o valor de uma
varivel passada para uma funo. No entanto, na maioria dos programas, as funes
modificaro as variveis de um modo ou de outro. Por exemplo, uma funo que l
informaes de um arquivo precisa colocar as informaes em uma matriz de string de
caracteres. Da mesma forma, uma funo tal como strupr precisa converter as letras em
uma string de caractere para maisculas. Quando as funes alteram o valor de um
parmetro, os programas precisam passar o parmetro para a funo usando chamada por
referncia.
A diferena entre chamada por valor e chamada por referncia que, usando a
chamada por valor, as funes recebem uma cpia do valor de um parmetro. Por outro
lado, com a chamada por referncia, as funes recebem o endereo de memria da
varivel. Portanto, as funes podem alterar o valor armazenado na posio de memria
especfica (em outras palavras, o valor da varivel); alteraes essas que permanecem aps
a funo terminar.
Para usar a chamada por referncia, seu programa precisar usar ponteiros. Por ora
tudo o que precisamos saber que um ponteiro armazena um endereo de memria, assim
como uma varivel armazena um valor. O mdulo 8 dedicado totalmente explicao de
ponteiros e suas aplicaes em C++, incluindo o funcionamento de uma chamada de
funo por referncia.
4.6 Biblioteca de Execuo

Muitas vezes, uma funo criada para um determinado programa atende as
necessidades de um segundo programa. A capacidade de reutilizar as funes em mais de
um programa pode poupar um tempo considervel de programao e teste. Para isto s
copiar a funo de um para outro programa.
A linguagem C++ possui uma biblioteca padro com muitas funes teis
previamente implementadas para uso do programador, inclusive incluindo todas as funes
da biblioteca padro de C. A biblioteca padro se divide em vrias bibliotecas ou arquivos
menores, divididos pelos tipos de funo que cada um contm. Por exemplo, a biblioteca
cmath contm as funes matemticas padro da linguagem C e a biblioteca string
contm funes da biblioteca padro de C++ que tratam de strings. Para utilizar uma destas
bibliotecas, preciso avisar ao compilador atravs da diretiva
#include <nome_da_biblioteca>
O comando #include copia o contedo da biblioteca para o programa que
estamos compilando, para que as funes pertencentes ela possam ser utilizadas.
Algumas das bibliotecas padro de C e seus cabealhos so mostrados abaixo:
Pgina 37
Funes matemticas:
#include <cmath>
Funes de string:
#include <cstring>
Funes de string do C++: #include <string>

Funes de I/O:
Funes de tempo:
#include <cstdio>
#include <ctime>
Uma descrio detalhada das funes presentes na biblioteca padro de C++ no

cabe nesta apostila. Entretanto, muitos livros e websites contm listagens e explicaes das
funes padres. Um bom exemplo o website http://www.cppreference.com/index.html ,
que contm uma vasta referncia sobre vrios aspectos da linguagem C++.
No deixe de examinar as funes que seu compilador fornece. Muitos
compiladores referenciam essas funes internas como biblioteca de execuo. A maioria
dos compiladores fornece centenas de funes de biblioteca de execuo com propsito
que vo de abertura e trabalho com arquivos para acessar informaes do disco ou de
diretrio para determinar o tamanho de uma string de caracteres. As duas ou trs horas que
sero gastas para ler a documentao da biblioteca de execuo pouparo muitas horas de
programao.
4.7 Funes Recursivas

Em C++, as funes podem chamar a si prprias, com exceo da funo principal
main. Uma funo recursiva se um comando no corpo da funo chama ela mesma.
Algumas vezes chamada de definio circular, a recursividade o processo de definio
de algo em termos de si mesmo.
Exemplos de recursividade existem em grande nmero. Uma maneira de definir um
nmero inteiro sem sinal por meio de recursividade utilizando-se os dgitos 0, 1, 2, 3, 4,
5, 6, 7, 8, 9 mais ou menos outro nmero inteiro. Por exemplo, o nmero 15 o nmero 7
mais o nmero 8; 21 9 mais 12 e 12 9 mais 3.
Para uma linguagem ser recursiva, uma funo deve estar apta a chamar a si
prpria. O exemplo clssico de recursividade mostrado na funo fatorial_recursivo(),
que calcula o fatorial de um nmero inteiro. O fatorial de um nmero N o produto de
todos os nmeros inteiros entre 1 e N. Por exemplo, o fatorial de 3 1 x 2 x 3, ou 6.
#include <iostream>
#include <cstdio>
unsigned long fatorial_recursivo (int n){
unsigned long resposta;
if ((n == 1) || (n == 0))return(1);
resposta = n * fatorial_recursivo(n - 1);
return(resposta);
Pgina 38
}
int main()
{
unsigned long f;
int n;
cout<<"Digite um nmero: \n";
cin >> n;
f = fatorial_recursivo(n);
cout<<"O fatorial de "<<n<<" e "<<f<<" \n";
return 0;
}
Quando uma funo chama a si prpria, as novas variveis locais e os argumentos
so alocados na pilha, e o cdigo da funo executado com esses novos valores a partir
do incio. Uma chamada recursiva no faz uma nova cpia da funo. Somente os
argumentos e as variveis so novos. Quando cada chamada recursiva retorna, as antigas
variveis locais e os parmetros so removidos da pilha e a execuo recomea no ponto
de chamada da funo dentro da funo.
Tendo em vista que o local para os argumentos de funes e para as variveis locais
a pilha e que a cada nova chamada criado uma cpia destas variveis na pilha,
possvel ocorrer overflow da pilha (stack overflow) e o programa terminar com um erro.
4.8 - Sobrecarga da Funo

Quando um programa usa uma funo, a Linguagem C armazena o endereo de
retorno, os parmetros e as variveis locais na pilha. Quando a funo termina, a
Linguagem C descarta o espao da pilha que continha as variveis locais e parmetros, e,
depois, usa o valor de retorno para retornar a execuo do programa para a posio correta.
Embora o uso da pilha seja poderoso porque permite que o programa chame e passe as
informaes para as funes, tambm consome tempo de processamento. Os
programadores chamam a quantidade de tempo que o computador requer para colocar e
retirar informaes da pilha de sobrecarga da funo. Na maioria dos sistemas, os clculos
baseados em funes podem requerer quase o dobro do tempo de processamento.
Entretanto, C++ introduz um conceito que pode reduzir bastante a sobrecarga da
funo: so as funes inline.
4.9 Funes Inline

As funes inline so funes que so compiladas na sequncia (in line) do
cdigo. Isso quer dizer que quando chamamos uma funo inline em um programa, o
compilador substitui a chamada de funo pelo prprio cdigo da funo, adaptando
automaticamente os parmetros e retorno da funo. Assim, elimina-se a necessidade do
Pgina 39
programa pular para outro ponto na memria do computador, executar a funo e depois
retornar ao ponto onde parou.
Criamos funes inline do mesmo jeito que criamos funes normais: declarando
seu prottipo e sua definio, com parmetros e retorno. S preciso adicionar o prefixo
inline antes do prottipo ou da definio da funo, como mostrado na funo abaixo:
inline int quadrado (long x)
{
x = x * x;
return x;
}
No podemos criar funes inline recursivas, pois logicamente uma funo

recursiva tem um tamanho varivel de acordo com seu nmero de iteraes, que muitas
vezes muda durante a execuo do programa.
Ganha-se velocidade com as funes inline, mas perde-se em memria utilizada. Se
um programa chama uma funo inline 10 vezes, criam-se 10 cpias da funo dentro do
cdigo, aumentando seu tamanho durante a compilao. preciso escolher com cuidado
quando utilizar funes normais e funes inline, tendo em mente o compromisso rapidez
de execuo memria utilizada.
4.10 Parmetros Padro

Outra novidade introduzida por C++ no manuseio de funes a possibilidade de
definir-se um valor padro para parmetros de uma funo. Isto , podemos definir um
parmetro para uma funo e estabelecer um valor padro para ele, da seguinte forma:
void mensagem (int x = 1);
Quando chamamos a funo e enviamos um valor como parmetro para ela, a
funo executada normalmente, utilizando o valor de x que enviamos. Porm, caso no
envissemos um valor x como parmetro para esta funo, isto , fizssemos a seguinte
declarao no programa:
mensagem( );
Automaticamente a funo substituiria x por 1, como especificamos no prottipo da
funo. Caso no tivssemos definido um valor padro para o parmetro x, o compilador
nos retornaria um erro de parmetros insuficientes para que a funo seja executada.
Abaixo temos um exemplo de programa utilizando um parmetro padro.
#include <iostream>
#include <cstdio>
void mensagem (int x = 1) {
Pgina 40
if (x != 1)
parametro X
if (x == 1)
O parametro
}
cout<<"Voce enviou um parametro para a funo! O

igual a "<<x<<"\n";
cout<<"Voce NAO enviou um parametro para funo!
X igual a "<<x<<"\n";
int main()
{
int valor;
cout<<"Entre com um valor. Este valor ser repassado para a
funo mensagem automaticamente!\n";
cin>>valor;
mensagem(valor);
cout<<"Agora chamaremos a funo mensagem sem lhe dar um
parametro. Veja o que acontece: \n";
mensagem();
return 0;
}
Pgina 41
Mdulo 5 Estudo dos comandos cout e cin

A linguagem C++ possui uma tima biblioteca de classes relacionadas ao controle
de entrada e sadas de dados. Desde o incio da apostila temos feito uso de algumas
facilidades fornecidas por esta biblioteca, especificamente, os comandos cout e cin. Como
voc deve ter percebido, a classe cout serve para exibir valores - seja o valor de uma
varivel ou uma frase enquanto que cin serve para armazenar valores recebidos atravs
do teclado em variveis. Tnhamos na linguagem C as funes printf e scanf para executar
estas mesmas funes. Na verdade, printf e scanf tambm esto presentes em C++ (assim
como todas as funes padres de C), e podemos utiliz-las caso desejemos. Porm, os
comandos ou, utilizando um termo mais tecnicamente apropriado, classes cin e cout
facilitam muito a vida do programador, por serem mais inteligentes que printf e scanf.
5.1 Utilizao de cout

Como j dissemos, cout exibe valores na tela. A sintaxe utilizada :
cout << <valor, string, varivel, ponteiro, etc>;
Utilizamos cout em conjunto com o operador de insero <<. Note que smbolo <<
tambm utilizado pelo operador de bitwise shift para a esquerda (move bits de uma
varivel para a direo esquerda), entretanto no precisamos nos preocupar com isto: C++
sabe diferenciar quando estamos utilizando um operador ou o outro, atravs do contexto.
O operador << indica ao comando cout que um dado deve ser exibido na tela, alm
de identificar automaticamente qual o tipo deste dado e como ele deve ser formatado para
exibio na tela. Assim, no precisamos informar cout que estamos enviando um inteiro,
um real ou uma string, como fazamos em C: o operador << se encarrega desta
identificao, bastando para o operador indicar o nome da varivel. Abaixo temos a lista de
todos os tipos bsicos de C++ reconhecidos pelo operador de insero:
unsigned char
signed char
char
short
unsigned short
int
unsigned int
long
unsigned long
float
Pgina 42
double
long double
O operador de insero tambm fornece facilidades para a exibio de strings.

Alm dos tipos bsicos mostrados acima, o operador de insero tambm reconhece os
seguintes tipos de ponteiros:
const signed char *

const unsigned char *
const char *
void *
Ponteiros sero explicados com maior propriedade no mdulo 8, mas precisamos

saber que C e C++ representam strings utilizando ponteiros para o endereo de memria da
string. Este ponteiro pode ser o nome de uma varivel matriz de tipo char, um ponteiro de
tipo char ou ento uma frase entre aspas. O operador de insero reconhece cada um destes
casos e exibe na tela a string de texto. Por exemplo:
char nome[20] = Jose das Couves;
char * nome2 = Jose das Galinhas;
cout << Jose das Dores;
cout << nome;
cout << nome2;
Estas 3 utilizaes de cout exibem as strings de texto na tela. Veremos mais adiante
que toda string possui um caractere de trmino, \0, que indica para o compilador que a
string terminou. Nestes trs casos, o operador de insero orienta-se por este \0 para
terminar a exibio das strings.
importante ressaltar que o operador de insero no reconhece automaticamente
matrizes numricas e no as exibe automaticamente na tela. Para fazer isso, precisaremos
utilizar os mtodos tradicionais envolvendo loops para mostrar cada membro da matriz de
uma vez. Este assunto ser discutido no mdulo 7, dedicado para matrizes.
5.2 Overload do operador de insero

Overload do operador de insero nada mais do que utilizar o operador de
insero vrias vezes na mesma chamada de cout. Por exemplo:
cout << O valor da varivel X : << X;
A linha de comando acima exibe dois valores: a string O valor da varivel X : e
a varivel X. Note que utilizamos duas vezes o operador de insero, sempre antes do valor
a ser exibido. Podemos repetir o operador de insero quantas vezes precisarmos na mesma
linha de cout.
Pgina 43
5.3 Formatao de exibio com cout

A funo printf fornecia aos usurios de C mltiplas maneiras de formatar a
exibio dos dados na tela do computador. A classe cout tambm fornece as mesmas
facilidades para os usurios de C++. Nas subsees abaixo descreveremos como fazer
vrios tipos de formatao de dados utilizando cout e o operador de insero.
5.3.1 Escolhendo a Base Numrica

Podemos escolher a base numrica que utilizaremos para representar nmeros
inteiros. Para isto, devemos utilizar os comandos:
cout << hex;
cout<< oct;
cout<< dec;
Aps utilizar qualquer um destes comandos, sempre que pedirmos para cout exibir
um nmero inteiro na tela, o comando automaticamente converter o nmero para a base
definida previamente. Por exemplo:
int numero = 10;
cout << hex;
cout << numero;
Dessa forma, cout exibir na tela no o nmero 10 como estamos acostumados, mas
a letra a, que representa 10 na base hexadecimal. Note que podemos utilizar o operador de
insero duas vezes para deixar o cdigo mais compacto e obter o mesmo resultado:
int numero = 10;
cout << hex << numero;
No se esquea de retornar para a base decimal com cout << dec; aps exibir
valores na base hexadecimal ou octal!
5.3.2 Formatao de nmeros reais

Podemos escolher tambm a notao utilizada para exibio de nmeros reais. Com
o comando:
cout << fixed;
Instrumos o programa a exibir valores reais usando a notao de ponto fixo ( por
exemplo, 3.1214). Da mesma forma, com o comando:
cout << scientific;
Instrumos o programa a utilizar a notao cientfica (por exemplo, 3.21E-2).
5.3.3 Espaamento de Texto

Pgina 44
O comando cout permite tambm escolher um nmero mnimo de caracteres para

ser exibido na tela. Isto feito utilizando o mtodo:
cout.width ( x );;
Onde substitumos x pelo nmero mnino de caracteres a ser exibido na tela. Aps a
utilizao deste mtodo, utilizamos o comando cout para exibir o valor desejado, como no
exemplo abaixo:
int variavel = 10;
cout.width ( 5 );
cout << variavel;
Neste exemplo, foi especificado cout.width (5); e o valor a ser exibido 10.
Assim, cout predecer o valor 10 com trs espaos em branco.
Observe que o valor especifica o nmero mnimo de caracteres que a sada
consumir. Se o valor a ser exibido requer mais caracteres do que o especificado, ser
usado o nmero de caracteres necessrios para exibir o valor corretamente.
importante observar tambm que o mtodo cout.width s vlido para a prxima
utilizao de cout: aps isto, o nmero mnimo de caracteres volta a ser zero.
Podemos tambm determinar o caractere a ser utilizado para preencher os espaos
em branco de um campo de exibio. Isto feito com o seguinte mtodo:
cout.fill ( caractere);
Onde substitumos caractere pelo caractere que ser exibido. necessrio utilizar
aspas entre o caractere, para indicar para o compilador que no se trata de uma varivel.
O exemplo abaixo mostra a utilizao conjunta destes dois mtodos:
int variavel = 10;
cout.width ( 8 );
cout.fill(0);
cout << variavel;
Este exemplo far a seguinte exibio na tela, preenchendo os espaos em branco
determinados por cout.width com o caractere 0, determinado por cout.fill:
00000010
5.3.4 Preciso de Variveis Reais

O seguinte mtodo utilizado para fixar a preciso de variveis reais, ou seja, o
nmero mnimo de casas decimais serem exibidas aps a vrgula em um valor real:
cout.precision ( valor );
Por default, C++ utiliza 6 casas decimais aps a vrgula. Quando alteramos o valor
Pgina 45
da preciso, este novo valor vale para todas as utilizaes futuras de cout.
5.3.5 Alinhamento de Texto

A escolha da direo de alinhamento de texto feita da seguinte forma utilizando
cout:
Alinhamento direita:
cout << right << <valor a ser exibido>;
Alinhamento esquerda: cout << left << <valor a ser exibido>;
Por default, todos os valores exibidos em um programa so automaticamente
alinhados direita. Quando mudamos o modo do alinhamento de texto, ele permanecer
dessa forma at que o alteremos novamente.
5.4 Utilizao de cin

Utilizamos o comando cin para obter valores do usurio atravs do teclado. A
sintaxe utilizada a seguinte:
cin >> variavel_destino;
Assim como cout, cin utiliza um operador (nesse caso, o operador de extrao >> )
para identificar o tipo de varivel onde o valor ser armazenado e encontrar o endereo de
memria correto. Ao contrrio da funo scanf, utilizada na linguagem C, no preciso
especificar qual o tipo de valor ser enviado pelo teclado pois o operador de extrao faz as
converses necessrias. Podemos utilizar cin para ler valores inteiros, reais e strings de
caracteres.
Na maioria dos casos, o comando cin cobre nossas necessidades de entrada de
dados via teclado. Entretanto, quando precisamos ler strings com mais de uma palavra,
como por exemplo frases ou nomes, cin apresenta certos problemas. Isto acontece por
causa da maneira que C++ trata os espaos em branco em uma entrada via teclado.
Espaos em branco so considerados fim de entrada pelo comando cin; ao invs de
descartar os caracteres que vierem aps o espao em branco, C++ os guarda em um buffer
(uma espcie de reserva ou pilha de dados). Quando cin for chamado novamente, antes
de ler a nova entrada do teclado, o programa primeiro utiliza os dados que esto nesse
buffer. Assim, temos a impresso que a nova entrada de dados foi descartada pelo
programa, mas na verdade ela foi jogada no buffer, esperando uma nova chamada de cin.
Para solucionar este problema, utilizamos o mtdo de cin cin.getline.
5.5 Mtodo de cin: cin.getline

O mtodo cin.getline muito til para receber strings de caracteres com espaos,
como frases. Este mtodo l uma linha inteira, marcando o fim da entrada de dados pelo
uso da tecla <ENTER> indicando a entrada de uma nova linha. Abaixo temos a sintaxe do
mtodo:
Pgina 46
cin.getline ( <matriz_destino>, <limite de caracteres>);

O primeiro argumento a matriz de caracteres para onde sero enviados os dados
recebidos. necessrio declarar uma matriz de caracteres previamente ao uso deste
mtodo. O segundo argumento o nmero mximo de caracteres que ser lido pelo
mtodo, menos o caractere \0 indicando o fim da string. Assim, se especificarmos um
nmero mximo igual a 20, este comando ler 19 caracteres e descartar os prximos
caracteres entrados pelo usurio, at que a tecla <ENTER> seja pressionada. Um espao
ser sempre utilizado para marcar o fim da string atravs do caractere \0.
Um exemplo da utilizao de cin.getline:
char matriz[60];
cin.getline ( matriz, 50 );
cout >> matriz;
Nesse caso, o mtodo cin.getline ler os prximos 49 caracteres (lembre-se do
espao reservado para o caractere fim_de_string \0) que o usurio entrar atravs do teclado.
A leitura ser feita at que ele aperte a tecla <ENTER> interrompendo o comando. Caso o
usurio entre mais do que 50 caracteres , os prximos sero descartados pelo programa.
Pgina 47
Mdulo 6 - Estruturas de Controle de Fluxo

6.1 - Estruturas de Controle de Fluxo
Estruturas de controle de fluxo so comandos utilizados em uma linguagem de
programao para determinar qual a ordem e quais comandos devem ser executados pelo
programa em uma dada condio. C++ oferece vrias opes de estrutura de controle de
fluxo, todas elas herdadas da linguagem C. Neste mdulo iremos ver como funcionam cada
uma destas estruturas em detalhe.
Geralmente, as estruturas de controle utilizam expresses condicionais. Caso a
expresso retorne 0, dizemos que ela falsa. Caso ela retorne qualquer outro valor,
dizemos que ela verdadeira. Nesse contexto, qualquer expresso pode ser utilizada desde
que retorne um valor zero ou no zero. Podemos utilizar operadores aritmticos,
relacionais, lgicos, desde que no final a expresso nos retorne um valor que possa ser
testado. Tambm possvel testar vrias condies ao mesmo tempo, unindo as expresses
com o auxlio dos operadores AND e OR.
6.2 A declarao if
Utilizamos a declarao if quando desejamos que o programa teste uma ou mais
condies e execute um ou outro comando de acordo com o resultado deste teste. A sintaxe
de if a seguinte:
if (condio)
{
comandos;
}
else
{
comandos;
}
A declarao if testar a condio expressa entre parnteses. Caso a condio seja
verdadeira, os comandos declarados entre as chaves sero executados.
A declarao else opcional: podemos utiliz-la para determinar um conjunto de
comandos que sero executados caso a condio testada seja falsa. Note que somente um
dos conjuntos de comandos ser executado, nunca os dois: caso a condio seja verdadeira,
o bloco pertencente a if ser executado; caso a condio falhe, o bloco pertencente a else
ser executado.
O programa abaixo ilustra de maneira simples o uso da declarao if-else, obtendo
um nmero do usurio e verificando se este valor maior ou igual a 50.
#include <iostream>
Pgina 48

int main()
{
int teste;
cout<<"Digite um numero qualquer:\n";
cin>> teste;
if (teste > 50)
{
cout<<"O numero que voce digitou maior que 50";
}
else
{
cout<<"O numero que voce digitou menor que
50";
}
return 0;
}
possvel tambm aninhar ifs, ou seja, fazer uma declarao if dentro de outra
declarao if anterior. Este um mtodo muito til em programao, mas preciso tomar
cuidado ao utiliz-lo para saber qual bloco else pertence qual if. Em C++, o else ligado
ao if mais prximo dentro do mesmo bloco de cdigo que j no tenha uma declarao else
associada a ele. Para se certificar de que estamos aninhando os ifs e elses corretamente,
utilizamos chaves para delimitar os diferentes blocos, como pode ser visto no cdigo
abaixo:
if ( x > 10)
{
if ( x == 17)
{
cout<< x maior que 10 e igual a 17;
}
else
{
cout<< x maior que 10 mas no igual a 17;
}
}
else
{
cout << x menor do que 10;
}
Note que a segunda declarao if est totalmente contida pelas chaves da primeira
declarao if. Utilizou-se chaves em todas os blocos de comando, para melhor separar as
condies dos blocos de comandos. Alm disso, note o uso da tabulao para separar
visualmente os diferentes blocos e declaraes: poderamos escrever todo o cdigo sem
usar tabulao, alinhando todas as linhas esquerda, mas isto dificultaria a identificao
das diferentes declaraes.
Pgina 49
6.3 O Encadeamento If Else if

Utilizamos a variao If Else If quando desejamos que o programa teste vrias
condies em sequncia, at encontrar uma que seja verdadeira. Sua sintaxe muito
parecida com a declarao if simples:
if (condio)
{
comandos;
}
else if (condio)
{
comandos;
}
else if (condio)
{
comandos;
}
else
{
comandos;
}
Cada bloco else if dever testar uma condio diferente. O programa testar todas
as condies na sequncia, de cima para baixo, at encontrar uma condio verdadeira.
Quando isto acontece, os comandos pertencentes ao bloco verdadeiro sero executados
enquanto todos os outros blocos do encadeamento so ignorados. Caso nenhuma condio
else if seja verdadeira, executa-se o bloco de comandos pertencente ao else final. Note
que o else opcional: Se o else final no estiver presente e todas as outras condies forem
falsas, ento nenhuma ao ser realizada.
Utilizando este encadeamento, ampliaremos o programa anterior para que ele teste
vrias condies sobre um nmero enviado pelo usurio, at encontrar uma condio
verdadeira.
#include <iostream>
int main()
{
int teste;
cout<<"Digite um numero qualquer:\n";
cin>> teste;
if (teste <= 50)
{
Pgina 50
cout<<"O nmero que voc digitou menor que 50\n";

}
else if (teste > 50 && teste <= 100)
{
cout<<"O nmero digitado maior que 50 e menor ou
igual a 100\n";
}
else if (teste > 100 && teste <= 200)
{
cout<<"O nmero digitado maior que 100 e menor ou
igual a 200\n";
}
else
{
cout<<"O numero digitado maior que 200\n";
}
return 0;
}
6.4 A Declarao Switch

A declarao switch uma maneira fcil e elegante de se fazer uma tomada de
deciso com mltiplas escolhas. Na declarao switch, a varivel sucessivamente testada
contra uma lista de inteiros ou constantes caractere. Quando uma associao encontrada,
o conjunto de comandos associado com a constante executado. Veja a sintaxe de switch
abaixo:
switch ( varivel )
{
case valor1:
comandos;
break;
case valor2:
comandos;
break;
...
case valorx;
comandos;
break;
default:
comandos;
}
A declarao switch testa o valor de uma nica varivel. Note que existem vrios
Pgina 51
case, cada um associado a um determinado valor. A declarao comparar o valor da

varivel com o valor de cada um dos case: quando uma associao encontrada, os
comandos pertencentes ao case relacionado so executados. Se nenhuma associao for
encontrada, a declarao switch executar os comandos pertencentes ao bloco default (note
que o bloco default opcional: caso ele no exista, caso nenhuma associao seja
encontrada a declarao switch termina sem que nenhum comando seja executado). O
exemplo abaixo demonstra uma utilizao da declarao switch.
#include <iostream>
int main()
{
int option;
cout<<"Digite a opo desejada:\n";
cout<<"1. Opo 1\n";
cout<<"2. Opo 2\n";
cout<<"3. Opo 3\n";
option = 0;
cin>> option;
switch(option)
{
case 1:
cout<<"Voc escolheu a primeira opo\n";
break;
case 2:
cout<<"Voc escolheu a segunda opo\n";
break;
case 3:
cout<<"Voc escolheu a terceira opo\n";
break;
default:
cout<<"Voc escolheu uma opo invlida!\n";
}
return 0;
}
Aps o fim de cada bloco de comandos case, comum utilizar o comando
break;. Este comando interrompe a execuo do lao em que o programa se encontra,
fazendo com que o programa prossiga para o prximo comando imediatamente aps o
lao. No caso de switch, o comando break assegura que a execuo da declarao switch
termine, forando o programa voltar para sua execuo normal. Caso omitssemos os
comandos break; no fim de cada bloco, a declarao switch executaria os comandos
presentes no case em que a associao foi encontrada, e continuaria a executar todos os
comandos presentes em todos os case na sequncia (incluindo o bloco default) at o
trmino da declarao switch. Note que este comportamento pode ser til em alguns
programas, como por exemplo uma sequncia de operaes matemticas onde utilizamos a
declarao switch para escolher o ponto de partida da sequncia.
Pgina 52
6.5 A declarao for

Utiliza-se a declarao for para realizar tarefas repetitivas dentro de um programa,
como somar todos os elementos de uma matriz ou exibir na tela uma sequncia grande de
valores. A declarao for tem o seguinte formato:
for ( valor_inicial; condio_testada; valor_incremento)
{
comandos;
}
A declarao for o que chamamos de lao ou loop em programao: um conjunto
de comandos que sero executados repetidamente at que uma determinada condio falhe
e termine o lao. Em for, determinamos o nmero de repeties desejadas atravs de uma
varivel de controle que ser modificada pelos argumentos da declarao for.
valor_inicial refere-se atribuio de um valor inicial para a varivel de

controle, por exemplo: controle = 0;
condio_testada uma expresso qualquer contendo a varivel de controle,
que ser testada continuamente. Enquanto a condio for verdadeira, os
comandos dentro do lao for sero executados. Quando a condio falhar, o
lao termina e o programa continua seu fluxo normal. Por exemplo,
controle < 30; uma expresso vlida, que testa se a varivel controle
menor do que 30.
valor_incremento uma expresso que incrementar a varivel de controle
sempre que a condio testada anteriormente for verdadeira. Por exemplo,
controle = controle + 1 ou mais simplesmente controle++
Como j dissemos, os comandos entre as chaves sero executados sempre
que a condio testada for verdadeira, e se repetiro at que a condio se
torne falsa e o lao termine.
O exemplo de cdigo abaixo mostra uma declarao de lao for utilizando o

exemplo dado anteriormente:
#include <iostream>
int main()
{
int controle;
for ( controle = 0; controle <= 30; controle++)
{
cout << "Esta frase se repetir at que
controle seja maior do que 30\n";
cout<< "controle = "<<controle<<"\n";
}
return 0;
}
varivel
Pgina 53
A varivel controle comea com valor 0. O lao for testa o valor da varivel
continuamente, sempre determinando se ele menor do que 30. Sempre que o valor da
varivel for menor que 30 (condio verdadeira), a varivel de controle incrementada de
1 e os comandos entre as chaves so executados. Quando a varivel controle for maior do
que 30 (condio falsa), o lao termina e o programa volta a ser executado normalmente.
O comando for extremamente flexvel. Podemos atribuir qualquer valor que
quisermos varivel de controle, e tambm podemos increment-la (ou decrement-la da
forma que desejarmos). No exemplo abaixo, utilizamos o lao for de forma inversa ao
exemplo anterior: a varivel de controle comea em 60 e vai sendo decrementada de 2 a
cada repetio.
#include <iostream>
int main()
{
int controle;
for ( controle = 60; controle >= 0; controle = controle - 2)
{
cout << "Esta frase se repetir at que a varivel
controle seja igual a 0\n";
cout<< "controle = "<<controle<<"\n";
}
return 0;
}
Os trs argumentos do lao for so opcionais: podemos omitir qualquer um dos
argumentos, mas precisamos estar atentos s consequncias que isto traz ao programa. Por
exemplo, o cdigo abaixo omite o argumento de incremento da varivel de controle. No
entando, fazemos o incremento da varivel dentro do bloco de comandos do lao for:
for (x = 0; x <= 50; )
{
cout<<x;
x++;
}
Caso no fizssemos o incremento dentro do bloco de comandos, a condio
testada seria sempre verdadeira, e o lao for nunca terminaria. o chamado lao infinito:
for (x = 0; x <= 50; )
{
cout<<x;
}
Laos infinitos geralmente surgem por algum erro de programao. Quando o
programa entra em um lao infinito, pode-se pressionar Ctrl+C no modo MS-DOS para
Pgina 54
finalizar o programa.
importante saber que mesmo omitindo um argumento, necessrio incluir o
ponto-e-vrgula correspondente. Podemos omitir tambm a inicializao da varivel de
controle, caso ela tenha sido declarada e inicializada anteriormente no programa.
Tambm podemos criar um lao for nulo, sem um bloco de comandos:
for (x = 0; x == 50; x++)
{
}
Nesse caso, o programa ainda interrompido para a execuo do lao for, e no faz
nada durante este intervalo. Esta tcnica pode ser utilizada para forar uma pausa na
execuo de um programa, porm ela pouco precisa e desperdia recursos do
microprocessador.
Finalmente, podemos utilizar vrias variveis de controle para controlar um mesmo
lao for. Para isto, utilizamos vrgulas para separar as expresses relacionadas a cada
varivel dentro de um mesmo argumento. O cdigo abaixo abaixo ilustra como isto feito:
for (i=0, j=100; i <= 100; i++, j++)
{
cout << i << j;
}
A utilizao de vrias variveis dentro de um mesmo lao for particularmente til
em programas que trabalham com matrizes e vetores.
6.6 A declarao while

Uma outra forma de lao a declarao while. Seu funcionamento muito parecido
com a declarao for que estudamos anteriormente. Ao encontrar um lao while, o
programa testa a condio especificada. Se a condio for verdadeira, efetuar os
comandos contidos no lao. Quando a condio se torna falsa, o lao termina e o programa
passa para o prximo comando. A sintaxe da declarao while a seguinte:
while (condio)
{
comandos;
}
A declarao while diferente diferente da declarao for em alguns aspectos.
Em primeiro lugar, while no utiliza variveis de controle automaticamente. O nico
argumento entre os parnteses a condio a ser testada: caso a condio nunca mude e
seja sempre verdadeira, estaremos criando um lao infinito. Assim, cabe ao programador
inserir uma varivel de controle no lao while para evitar que isso ocorra. Isso pode ser
feito declarando-se e inicializando-se uma varivel antes do lao while, testando esta
Pgina 55
varivel de controle no lao while e finalmente modificando esta varivel (incrementandoa ou decrementando-a) aps a execuo dos comandos necessrios. O programa abaixo
demonstra como inserir uma varivel de controle no lao while.
#include <iostream>
int main()
{
int controle = 0;
while (controle < 20)
{
cout<<"A variavel de controle funcionar se esta frase
se repetir somente 20 vezes: ";
controle++;
cout<<controle<<" \n";
}
return 0;
}
6.7 A Declarao Do While

A declarao do while muitssimo parecida com a declarao while, com uma
nica diferena fundamental: o teste condicional feito aps a execuo dos comandos
pertencentes ao lao. Veja a sintaxe do lao do while:
do
{
comandos;
}
while ( condio);
Note a inverso da ordem: primeiro temos a declarao do seguida do corpo do
lao, contendo os comandos serem executados entre as chaves. Aps o smbolo fechachaves, temos a declarao while e a expresso que ser testada. Os comandos entre as
chaves sero executados at que a condio torne-se falsa. Porm, lembre-se que a
condio s ser testada aps a execuo dos comandos dentro do lao, ao contrrio dos
laos que vimos anteriormente que antes testavam uma condio para depois executar
qualquer comando. O exemplo abaixo ilustra uma utilizao simples do lao do while.
#include <iostream>
int main()
{
int controle = 1;
do
{
Pgina 56
cout<<"Esta frase foi escrita "<<controle<<" vezes!\n";

controle++;
}
while (controle <= 20);
return 0;
}
6.8 Laos Aninhados

Qualquer um dos laos estudados acima pode ser aninhados, ou seja, colocados um
dentro do outro. Esta tcnica pode ser muito til para trabalhar com matrizes
multidimensionais, programas que trabalhem com menus e vrias outras situaes.
Entretanto, preciso ateno para no confundir quais blocos fazem parte de qual lao ou
declarao. Como j dissemos anteriormente, fundamental a utilizao de chaves para
separar corretamente os blocos e laos, e tambm a utilizao de tabulao na escrita do
cdigo para melhor visualizao de cada uma das partes do programa. Tambm
interessante a utilizao de comentrios no cdigo, para melhor identificao.
O programa exemplo abaixo demonstra a utilizao de vrios laos e declaraes
aninhadas, assim como a aplicao de tabulao e comentrios para melhor entendimento
do programa.
#include <iostream>
int main()
{
int mult1, mult2;
for (mult1 = 1; mult1 <= 10; mult1++)
{
cout<<"Tabuada do numero "<<mult1<<":\n";
for (mult2 = 1; mult2 <= 10; mult2++)
{
cout.width(2);
cout<<mult1<<" X ";
cout.width(2);
cout<<mult2<<" = ";
cout.width(3);
cout<<mult1*mult2<<"\n";
}
}
return 0;
}
Pgina 57
6.9 Break e Continue

Utilizamos os comandos break e continue para pular partes de um cdigo. J vimos
a utilizao do comando break quando falamos sobre a declarao switch: ele utilizado
para interromper a execuo de um lao, pulando imediatamente para o prximo comando
aps o fim do lao. O comando break quebra qualquer teste de condio que esteja sendo
feito, forando o lao a terminar abruptamente.
O comando continue utilizado em um lao de repetio para pular todos os
comandos que seriam executados na sequncia do comando continue e forar o lao a pular
para a prxima repetio. O comando break fora o lao a terminar; j o comando continue
pula os prximos comandos que seriam feitos mas continua a executar o lao. O exemplo
abaixo mostra a utilizao de um comando continue em um programa que simula um menu
de opes.
#include <iostream>
int main()
{
int opcao;
while (opcao!= 5)
{
cout<<"Escolha uma opo entre 1 e 4. Escolha 5
para sair do programa\n";
cin>>opcao;
if ((opcao> 5) || (opcao< 1))
{
continue;
//opo invalida: volta ao inicio
do loop
}
switch (opcao)
{ //incio do switch
case 1:
cout<<"Opo 1 foi escolhida\n";
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
cout<<"Voc saiu do programa\n";
break;
} //fim do switch
} //fim do lao while
Pgina 58

}
Em primeiro lugar, o lao while far com que o programa rode repetidamente at
que a varivel opcao, cujo valor atribudo pelo usurio a cada repetio do programa,
tenha valor igual a 5. A declarao if checa se o valor entrado pelo usurio maior que
cinco ou menor que 1. Caso isto seja verdade, o comando continue interrompe a execuo
de todos os comandos seguintes, fazendo o lao while ser repetido mais uma vez. Caso o
usurio entre um valor entre 1 e 5, o comando continue no executado e o lao while
continua para o prximo bloco de comandos, no caso, a declarao switch. A declarao
switch utilizada para mostrar qual opo o usurio escolheu e, no caso do usurio ter
escolhido o valor 5, indicar que o programa terminou. Quando o valor 5 escolhido, a
condio do lao while torna-se falsa, terminando o programa.
Pgina 59
Mdulo 7 Matrizes
7.1 Matrizes
Matrizes so variveis que contm vrios valores de um mesmo tipo. Por exemplo,
podemos criar a matriz notas para armazenar as notas obtidas por 100 alunos em um
exame, ou ento utilizar uma matriz chamada gastos_mensais para anotar nossos gastos
mensais ao longo do ano. Uma matriz armazena vrios valores de um mesmo tipo:
podemos criar matrizes para armazenar qualquer um dos tipos bsicos de variveis, como
int, float e char. Cada valor armazenado separadamente em um elemento da matriz, e
pode ser acessado e modificado a qualquer momento.
7.2 Declarao de uma matriz

Para criar uma matriz, precisamos declarar trs atributos dela:
O tipo de valor que vai ser armazenado na matriz

O nome da matriz, para que possamos acess-la
O nmero de elementos da matriz
A declarao de uma matriz muito parecida com a declarao de uma varivel,

bastando adicionar o nmero de elementos que desejamos que ela tenha. A sintaxe a
seguinte:
<tipo> <nome> [<numero de elementos>];
Por exemplo, caso quisssemos criar uma matriz chamada catlogo para armazenar
156 inteiros, a declarao seria assim:
int catalogo [156];
Podemos utilizar qualquer tipo de variveis j estudadas anteriormente para criar
uma matriz, como float, int, char. Uma vez criada uma matriz de um determinado tipo, ela
s pode receber valores deste tipo. Note que precisamos definir um tipo para uma matriz:
no possvel criar uma matriz genrica que aceite um tipo qualquer, ou vrios tipos.
Isso acontece porque ao declarar uma matriz, o compilador aloca memria suficiente para
conter o nmero de valores especificado de acordo com o tipo da matriz. Por exemplo,
uma matriz de 100 elementos do tipo int normalmente ir requerer 100*2 ou 200 bytes de
memria. Por outro lado, uma matriz de 100 elementos do tipo float ir requerer 100*4
bytes ou 400 bytes.
Assim como uma varivel normal, podemos atribuir valores para uma matriz no
momento de sua declarao. Isto feito utilizando o operador de atribuio = seguido
dos valores contidos entre chaves e separados por vrgulas. Por exemplo, considere a
matriz de inteiros teste abaixo:
int teste[5] = { 1, 2, 3, 4 , 5};
Tambm podemos atribuir apenas parte dos valores de uma matriz, por exemplo,
Pgina 60
podemos criar uma matriz que comporte 50 valores do tipo float e atribuir apenas 5 valores
ela, deixando para atribuir o restante dos valores no decorrer do programa.
float notas[50] = { 7.65, 8.48, 4.27, 6.78, 9.10 };
A linguagem C++ faz com que toda matriz parcialmente inicializada tenha seus
valores restantes automaticamente transformados em zero. Assim, caso precisemos de uma
matriz que s contenha zeros, podemos atribuir o primeiro elemento da matriz como zero e
deixar que o compilador transforme os elementos restantes em zero, como vemos abaixo:
int zeros[75] = {0};
7.3 Acessando Valores de uma Matriz

Aps criar uma matriz, podemos acessar qualquer valor dentro dela. Cada valor, ou
elemento de uma matriz, possui um nmero prprio. Toda matriz comea no elemento 0.
Precisamos ter isso em mente quando acessamos valores dentro de uma matriz, pois o
primeiro elemento ser o elemento 0, o segundo elemento ser o elemento 1.
Cada elemento de uma matriz tratado como uma varivel separada. Assim,
podemos atribuir valor para um elemento, exib-lo na tela, utiliz-lo em operaes
matemticas e em laos condicionais. O programa abaixo ilustra estas vrias aes:
#include <iostream>
int main() {
int matriz[5] = {1,2,3,4,5};
cout<<"o primeiro valor da matriz : "<<matriz[0]<<endl;
cout<<"o ltimo valor da matriz : "<<matriz[4]<<endl;
cout<<"Somando o segundo e o quarto elementos da matriz
temos: "<< matriz[1] + matriz[3]<<endl;
matriz[2] = 27;
cout<<"Mudamos o valor do terceiro elemento da matriz para:
"<<matriz[2]<<endl;
return 0;
}
7.4 Utilizando Laos para Percorrer Matrizes

Uma das utilizaes mais teis dos laos condicionais o acesso vrios (ou todos)
elementos de uma matriz rapidamente. Podemos utilizar qualquer um dos laos que
estudamos, mas sem dvida o lao for o mais prtico para trabalhar-se com matrizes.
Utilizamos a varivel de controle do lao para acessar cada um dos elementos desejados
(lembre-se que a matriz sempre comea no elemento 0), como vemos no programa abaixo
que percorre os elementos de uma matriz, primeiro preenchendo a matriz com os dados
entrados pelo usurio, depois exibindo estes dados na tela.
Pgina 61
#include <iostream>
int main()
{
int sequencia[4];
for (int i = 0; i < 4; i++) {
cout << "Entre com o elemento numero "<<(i+1)<<" da
sequencia: ";
cin >> sequencia[i];
cout << endl;
}
cout << "A sequencia entrada pelo usuario foi: ";
for (int i = 0; i < 4; i++) {
cout << sequencia[i]<<" ";
}
return 0;
}
Importante: como vimos no exemplo anterior, podemos utilizar variveis para
acessar os elementos de uma matriz. Da mesma forma, podemos definir constantes para
indicar o nmero de elementos de uma matriz. Essa tcnica muito til, pois caso
precisemos alterar o nmero de elementos da matriz ao invs de caarmos no cdigo todas
as referncias este nmero, tudo que precisamos fazer alterar o valor da constante.
Assim, veja o mesmo programa anterior reescrito utilizando uma definio de constante.
#include <iostream>
int main()
{
const int TAMANHO = 4;
int sequencia[TAMANHO];
for (int i = 0; i < 4; i++) {
sequencia: ";
cout << endl;
}
cout << "A sequencia entrada pelo usuario foi: ";
for (int i = 0; i < 4; i++) {
}
return 0;
}
Pgina 62
7.5 Matrizes Multidimensionais

Alm das matrizes simples de uma nica dimenso, C++ permite a criao de
matrizes de mltiplas dimenses. As matrizes bidimensionais so sem dvida as mais
utilizadas e as mais teis, pois comportam-se como tabelas com linhas e colunas. Ao
declarar uma matriz multidimensional, adicionamos um conjunto de colchetes para cada
dimenso extra. Entre os colchetes de cada dimenso, colocamos o nmero de elementos
que aquela dimenso ter (ou uma varivel que represente o nmero de elementos). Assim:
int tabela [10] [5]; //matriz bidimensional
int horas [12] [30] [24]; //matriz de trs dimenses
int minutos [12] [30] [24] [60]; //matriz de quatro dimenses
Normalmente trabalhamos no mximo com matrizes bidimensionais, mas podem
surgir ocasies onde matrizes de mais de duas dimenses sejam necessrias. Matrizes
multidimensionais funcionam como matrizes dentro de matrizes. Por exemplo, uma matriz
bidimensional pode ser vista como uma matriz de uma dimenso cujos elementos so outra
matrizes. Esta analogia til para entender como feita a inicializao dos valores de
matrizes multidimensionais: inicializamos a matriz separando seus elementos por vrgulas,
onde cada elemento uma matriz individual e inicializada da mesma forma que a matriz
principal. Por exemplo, seja a matriz bidimensional tabela:
int tabela [2] [3] = { { 1, 2, 3} , { 4, 5, 6}};
Veja que cada elemento fechado por chaves e separado por vrgulas. A mesma
coisa acontece com matrizes de trs dimenses, e assim por diante. O exemplo abaixo
mostra a declarao de uma matriz tridimensional. Preste ateno na presena das chaves e
das vrgulas separando cada elemento diferente:
int tritabela [2] [2] [2] = { {{ 9, 8}, {7,6}} , {{5, 4},{3, 2}} };
Cada elemento de uma matriz multidimensional pode ser acessado individualmente,
indicando a posio exata do valor dentro da matriz. Como vimos anteriormente no caso
das matrizes simples, a utilizao dos laos condicionais facilita o acesso aos vrios
elementos de uma matriz. No caso das matrizes multidimensionais, utilizamos laos
aninhados para acessar cada dimenso de uma vez. O programa abaixo declara a matriz
tridimensional que vimos anteriormente e utiliza uma sucesso de laos for aninhados para
exibir a matriz na tela.
Pgina 63
#include <iostream>
int main()
{
int tritabela [2] [2] [2] = {{{ 9, 8}, {7,6}},{{5, 4},{3,
2}}};
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
cout << tritabela[i][j][k]<<" ";
}
cout<<endl;
}
cout<<endl;
}
return 0;
}
7.6 Matrizes em Funes

Podemos utilizar matrizes como parmetros de funes com alguns cuidados
simples. Ao declarar os parmetros que sero utilizados na funo, declaramos um
parmetro para a matriz e um parmetro para seu tamanho separadamente. Fazemos isso
para que possamos utilizar matrizes de qualquer tamanho utilizando a mesma funo. Ao
criar o parmetro referente matriz, usamos um conjunto de colchetes vazios para indicar
que se trata de uma matriz e no de uma varivel simples. No entanto, quando utilizarmos
esta funo, passamos para ela somente o nome da matriz, sem os parnteses: o programa
j sabe que uma matriz ser enviada, pois j declaramos isso no prottipo da funo. O
programa abaixo mostra uma funo que soma todos os elementos de uma matriz.
#include <iostream>
int soma( int matriz[], int tamanho) {
int resultado = 0;
for (int i = 0; i < tamanho; i++){
resultado = resultado + matriz[i];
}
return resultado;
}
int main()
{
int sequencia[TAMANHO];
int result = 0;
for (int i = 0; i < 4; i++) {
Pgina 64

sequencia: ";
cout << endl;
}
result = soma(sequencia, TAMANHO);
cout << "A soma de todos os elementos da matriz e igual a
"<<result<<"."<<endl;
return 0;
}
Tambm podemos utilizar funes que trabalhem com matrizes multidimensionais.
Entretanto, ao criar o parmetro da matriz preciso declarar o tamanho de todas as
dimenses da matriz com exceo da primeira. Por exemplo:
int soma_tabela ( int matriz [ ] [3] [4], int elementos) { comandos; }
A primeira dimenso deixada em branco, para ter seu tamanho definido pelo outro
parmetro elementos. Entretanto, as outras duas dimenses tem seu tamanho definido
respectivamente em 3 e 4. Caso deixssemos estas outras duas dimenses sem um tamanho
definido, o programa no seria compilado.
muito importante notar que, ao trabalhar com matrizes dentro de funes,
estamos trabalhando com a prpria matriz, ou melhor, com o endereo dos dados desta
matriz. Normalmente, quando trabalhamos com variveis dentro de uma funo, estamos
trabalhando com cpias destes valores. Entretanto, isso no verdade para matrizes, por
razes que veremos no mdulo sobre ponteiros. Por enquanto, basta saber que quando
trabalhamos com matrizes dentro de funes, qualquer modificao feita na matriz feita
para valer. Se somarmos mais 10 a todos os valores de uma matriz em uma funo, quando
a funo terminar a matriz estar modificada. Esta caracterstica muito til para contornar
o fato que no podemos utilizar uma matriz como retorno de uma funo: no precisamos
que a funo retorne uma matriz, s precisamos fazer com que a funo altere a matriz. Por
exemplo, o programa abaixo usa uma funo para ordenar os nmeros dentro de uma
matriz.
#include <iostream>
int ordena( int matriz[], int tamanho) {
int temp = 0;
for (int j = i; j < tamanho; j++){
if (matriz[j] < matriz [i]) {
temp = matriz[i];
matriz[i] = matriz[j];
matriz[j] = temp;
}
}
}
}
Pgina 65
int main()
{
int sequencia[TAMANHO] = {27, 12, 42, -8};
cout <<"Sequencia original: ";
for (int i = 0; i < 4; i++) {
}
cout<<endl;
ordena(sequencia, TAMANHO);
cout <<"Sequencia ordenada: ";
for (int i = 0; i < 4; i++) {
}
cout<<endl;
return 0;
}
7.7 Criando Matrizes Dinamicamente

A linguagem C++ prima pela economia de memria durante a execuo de seus
programas. Quando declaramos uma matriz no incio de um programa, o compilador
separa um pedao da memria do computador de tamanho equivalente ao tamanho
mximo da matriz. Assim, se criarmos uma matriz de inteiros com 200 elementos, o
compilador separa na memria do computador um espao de 400 bytes (2 bytes x 200
elementos). Entretanto, quando trabalhamos com matrizes frequentemente no sabemos
qual o tamanho exato de elementos que precisamos. Ao criar uma matriz, estipulamos um
valor que seja maior do que o valor mximo de elementos que precisamos, mesmo que no
utilizemos todos os espaos disponveis na matriz. Isso causa desperdcio de memria do
computador e lentido na execuo de programas.
Para evitar este problema, a linguagem C++ introduz dois novos operadores de
controle de memria. Em primeiro lugar, temos o operador new, que utilizado para
alocar espaos na memria de computador durante a execuo de um programa. Em
segundo lugar, o operador delete, que libera a memria alocada com o operador new aps
sua utilizao. Este tipo de criao e destruio de variveis chamado de alocao
dinmica. Uma matriz criada dessa forma chamada de matriz dinmica.
A vantagem de se criar matrizes dinmicas que a memria utilizada pela matriz s
tirada do sistema aps a execuo do operador new, e pode ser liberada novamente
aps sua utilizao com o operador delete. Quando criamos uma matriz do jeito normal,
a memria utilizada por ela guardada pelo programa durante toda sua execuo,
consumindo recursos desnecessrios do computador.
A sintaxe para criar-se uma matriz utilizando o operador new a seguinte:
Pgina 66
<tipo> * <nome> = new <tipo> [ <numero de elementos> ];

Por exemplo, para criar uma matriz do tipo float com 10 elementos:
float * lista = new float [10];
O acesso aos elementos da nova matriz feito de forma anloga ao de uma matriz
criada do jeito normal: utilizamos o nome da matriz seguido do nmero do elemento
acessado. Como j dito anteriormente, o primeiro elemento de uma matriz sempre o
elemento 0.
Note que no podemos inicializar automaticamente os valores de uma matriz criada
dessa forma. Cada elemento da matriz deve ter seu valor atribudo separadamente.
A outra face do operador new o operador delete. S podemos utilizar este
operador com matrizes criadas pelo operador new, ou seja, matrizes criadas por declarao
normal no podem ser apagadas durante a execuo do programa. Para utilizar o operador
delete para apagar uma matriz, a sintaxe a seguinte:
delete <nome>;
O programa abaixo pede ao usurio o nmero de elementos da matriz, cria uma
matriz e depois volta a pedir ao usurio os valores de cada um dos elementos da matriz. No
final do programa, a matriz deletada.
#include <iostream>
int main() {
int tamanho = 0;
cout<<"Entre com o tamanho da matriz: ";
cin>>tamanho;
cout<<endl;
int *sequencia = new int[tamanho];
for (int i = 0; i < tamanho; i++) {
cout << "Entre com o elemento "<<(i+1)<<" da matriz: ";
cin>>sequencia[i];
cout<<endl;
}
cout<<"A matriz entrada e: ";
for (int i = 0; i < tamanho; i++) {
}
cout<<endl;
cout<<"Programa encerrado. A matriz criada ser deletada, e a
memria ser devolvida para o processador.";
delete sequencia;
return 0;
}
Pgina 67
Mdulo 8 Strings
No falamos at agora de matrizes de caracteres, apesar de j utiliz-las vrias
vezes. Uma matriz de caracteres normalmente chamada de string em linguagem de
programao. Em C++, existem duas maneiras de se criar e trabalhar com strings. Um
deles o mtodo antigo, j utilizado pela linguagem C, de se declarar e trabalhar com uma
matriz de caracteres do mesmo modo que trabalhamos com matrizes numricas. O outro
mtodo utilizar as facilidades da biblioteca padro de C++, que define um tipo de
varivel especfico para strings, com vrias operaes e funes prprias. Nesta apostila
trabalharemos com as strings do tipo C++, por serem elas mais simples e ao mesmo tempo
apresentarem mais recursos do que as strings tipo C.
8.1 Cabealho de um programa com strings

Todo programa escrito em C++ deve conter a seguinte linha de incluso em seu
cabealho:
#include <string>
Isso faz com que o compilador inclua no programa a biblioteca padro de strings de
C++, que contm todas as definies do tipo string, assim como as funes e facilidades
relacionados este tipo. Assim, o cabealho de um programa tpico envolvendo strings fica
assim:
#include <iostream>
#include <string>
8.2 Declarando e Inicializando uma String

Declaramos strings da mesma maneira que declaramos variveis: explicitando o
tipo da varivel (no caso, string) e seu nome. Veja a sintaxe e o exemplo abaixo:
string <nome da string>;
string nacionalidade;
string sobrenome;
Uma string declarada desta forma estar vazia at que um valor seja atribudo ela,
Pgina 68
das maneiras j estudadas: atravs de uma atribuio, ou de uma entrada de dados do

usurio, por exemplo.
C++ possui uma srie de facilidades para a inicializao de strings. Cada um desses
diferentes mtodos chamado de inicializador de uma string. A tabela abaixo rene os
quatro principais inicializadores de string:
string s1;
Cria uma string vazia, chamada s1. Esta a

inicializao default de uma string: toda
string criada dessa forma est vazia.
string s2 (s1);
Cria a string s2 como uma cpia de outra

string (nesse caso, s1).
string s2 (Esta uma string literal);
Cria a string s2 como uma cpia da string

literal entre os parnteses.
string s2 (x, c);
Cria a string s2, que contm x cpias do

caractere entre aspas (no caso, c).
O programa abaixo exemplifica os mtodos descritos acima:

#include <iostream>
#include <string>
int main()
{
string vazia;
string ditado("Casa de ferreiro, espeto de pau");
string copia_ditado(ditado);
string letra_z( 42, 'z');
cout <<"Mostrando o contedo da string 'vazia':"<< endl;
cout << vazia;
cout <<"Mostrando o contedo da string 'ditado':"<<
endl;
cout << ditado;
cout
<<"Mostrando
o
contedo
da
string
'copia_ditado':"<< endl;
cout << copia_ditado;
cout <<"Mostrando o contedo da string 'letra_z':"<<
endl;
cout << letra_z;
return 0;
}
8.3 Leitura e Escrita de Strings na Tela

Utilizamos cin e cout para ler e escrever strings, assim como fazemos com variveis
Pgina 69
simples. Basicamente, cin e cout tratam strings como se fossem variveis simples,
facilitando sua manipulao e seu uso em programas.
J vimos no programa exemplo anterior que utilizamos cout para exibir strings
inteiras na tela. cout exibe todos os caracteres da string, e detecta automaticamente o fim
dela.
Utiliza-se o comando cin para ler strings atravs do teclado. A sintaxe a seguinte:
cin >> <nome da strin>;
Como j vimos, cin ler os caracteres inseridos atravs do teclado at encontrar um
espao em branco (tecla barra de espao) ou o fim da entrada (tecla Enter). Quando cin
encontra um espao em branco, todos os caracteres aps este espao so ignorados. O
programa abaixo l entradas do teclado para armazenar o nome e sobrenome do usurio
dentro de strings.
#include <iostream>
#include <string>
int main()
{
string nome;
string sobrenome;
cout<<"Digite seu nome: ";
cin >> nome;
cout<<"Digite seu sobrenome: ";
cin >> sobrenome;
cout << "Seu nome "<<nome<<"
<<sobrenome<<"."<<endl;
return 0;
seu
sobrenome
}
Esse programa apresenta alguns problemas quando o usurio possui mais de um
nome ou sobrenome. Por exemplo, caso o nome Jos Ricardo seja inserido, a leitura do
sobrenome ser ignorada e o programa exibir Jos como o nome e Ricardo como
sobrenome. Da mesma forma, no caso da entrada de um sobrenome duplo, somente o
primeiro sobrenome guardado na string sobrenome, sendo o segundo ignorado. Isto
acontece por causa da maneira que C++ trata os espaos em branco em uma entrada via
teclado.
Espaos em branco so considerados fim de entrada pelo comando cin; ao invs de
descartar os caracteres que vierem aps o espao em branco, C++ os guarda em um buffer
(uma espcie de reserva ou pilha de dados). Quando cin for chamado novamente, antes
de ler a nova entrada do teclado, o programa primeiro utiliza os dados que esto nesse
Pgina 70
buffer. Assim, temos a impresso que a nova entrada de dados foi descartada pelo
programa, mas na verdade ela foi jogada no buffer, esperando uma nova chamada de cin.
Dessa forma, cin no o mtodo recomendado para ler frases inteiras, com palavras
separadas por espaos. Para este objetivo, utilizamos o mtodo cin.getline, que j
estudamos no mdulo 5, com algumas alteraes.
O mtodo cin.getline l linhas inteiras de entrada atravs do teclado, sem se
importar com os espaos em branco. Mas a sintaxe do mtodo cin.getline um pouco
diferente, quando trabalhamos com strings:
getline ( cin, <nome da string>);
Assim, este mtodo recebe todos os caracteres (incluindo os espaos em branco)
entrados pelo usurio, at que ele aperte a tecla Enter. O programa abaixo uma verso
melhorada do programa anterior, utilizando o mtodo cin.getline para receber os dados
desejados.
#include <iostream>
#include <string>
int main()
{
string nome;
string sobrenome;
getline(cin, nome);
getline(cin, sobrenome);
cout <<"Seu nome "<<nome<<"
"<<sobrenome<<"."<<endl;
return 0;
}
seu
sobrenome
8.4 Operaes com Strings

C++ possui uma srie de funes e operaes prprias para strings. A tabela abaixo
resume as operaes mais utilizadas (s uma string qualquer):
s.empty( )
Funo que retorna verdadeiro se a string est vazia, e

falso caso contrrio.
s.size ( )
Funo que retorna o tamanho em caracteres da string
s [n]
Acessa um elemento da string. Funciona exatamente

com um elemento de uma matriz.
Pgina 71
s1 + s2
Concatena duas strings.
s1 = s2
Atribui o contedo de s2 na string s1.
s1 == s2
Testa a igualdade entre s1 e s2 (retorna verdadeiro se

as duas strings forem iguais). Duas strings so
consideradas iguais se elas tiverem o mesmo nmero
de caracteres e seus caracteres forem iguais.
A primeira funo, <string>.empty indica se uma string est vazia ou no. Esta
funo retorna um valor booleano verdadeiro ( true ou 1 ) caso a string esteja vazia, caso
contrrio ela retorna falso (false ou 0).
A funo <string>.size bastante til para trabalhar com strings entradas pelo
usurio. Como no podemos saber exatamente o nmero de caracteres entrados pelo
usurio, til ter uma funo que nos retorne o tamanho de uma string.
Como vemos acima, possvel acessar um elemento individual de uma string do
mesmo modo que fazemos com matrizes. Esse tipo de acesso til quando precisamos
manipular os vrios caracteres de uma string, como por exemplo, identificar as letras
maisculas de uma string e transform-las em minsculas. Para esse tipo de manipulao
caractere caractere, contamos com as diversas funes da biblioteca cctype, que veremos
no item 8.5.
A concatenao de strings particularmente til. Quando utilizamos o sinal de
soma entre duas strings, estamos concatenando elas, ou seja, juntando o comeo da
segunda matriz com o final da primeira. Tambm possvel concatenar strings literais (
frases entre aspas) junto com as variveis string dessa forma. O programa abaixo ilustra a
concatenao de strings.
#include <iostream>
#include <string>
int main()
{
string nome;
string sobrenome;
getline(cin, nome);
getline(cin, sobrenome);
string concatena;
concatena = nome + sobrenome;
cout << "O seu nome completo : " + nome + " " +
sobrenome << endl;
Pgina 72
return 0;
8.5 Biblioteca cctype: operaes com caracteres

A biblioteca cctype uma verso da biblioteca ctype da linguagem C, convertida
para C++. Ela contm diversas funes que permitem processar os caracteres de uma
string, um por um. Por exemplo, podemos precisar saber se um determinado caracter uma
letra ou um nmero, se est acentuado ou no, se minsculo ou maisculo, e transformar
este caractere. Para utilizar esta biblioteca, precisamos declar-la no cabealho do
programa, assim como fizemos com a biblioteca de strings. Para declar-la, a sintaxe a
seguinte:
#include <cctype>
Assim, o cabealho de um programa que utiliza strings e a biblioteca cctype ficaria
assim:
#include <iostream>
#include <string>
#include <cctype>
A tabela abaixo resume algumas das funes mais teis desta biblioteca (x um
elemento de uma string, por exemplo, sobrenome[4]) :
isalnum (x)
Retorna verdadeiro (1) caso x for uma letra ou um nmero.
isalpha (x)
Retorna verdadeiro (1) caso x for uma letra.
iscntrl (x)
Retorna verdadeiro (1) caso x for um dgito de controle.
isdigit (x)
Retorna verdadeiro (1) caso x for um nmero.
isgraph (x)
Retorna verdadeiro (1) caso x no for um espao.
islower (x)
Retorna verdadeiro (1) caso x for uma letra minscula.
isprint (x)
Retorna verdadeiro (1) caso x for um caractere imprimvel.
ispunct (x)
Retorna verdadeiro (1) caso x for um caractere acentuado.
isspace (x)
Retorna verdadeiro (1) caso x for um esao em branco.
isupper (x)
Retorna verdadeiro (1) caso x for uma letra maiscula
isxdigit (x)
Retorna verdadeiro (1) caso x for um nmero hexadecimal.
tolower (x)
Transforma um caractere maisculo em minsculo.
toupper (x)
Transforma um caractere minsculo em maisculo.
Pgina 73
Com exceo das duas ltimas funes que transformam caracteres, todas as outras
testam os caracteres de uma string, retornando valores booleanos ( true ou false, 1 ou 0 ). O
programa abaixo mostra o uso de algumas dessas funes, atravs da leitura de uma string
entrada pelo usurio. Note que tambm feito o uso da funo <string>.size para
determinar o tamanho da string.
#include <iostream>
#include <string>
int main()
{
string frase;
int letras = 0, maiusculas = 0, minusculas = 0, numeros
= 0;
cout<<"Entre com uma frase qualquer, composta de letras
maiusculas, minusculas e numeros: "<< endl;
getline(cin, frase);
letras = frase.size();
cout<<"Sua frase tem "<< letras<< " letras."<<endl;
for (int i = 0; i < letras; i++)
{
if (isdigit(frase[i])) numeros++;
if (islower(frase[i])) minusculas++;
if (isupper(frase[i])) maiusculas++;
}
cout<<"Sua frase tem "<< numeros<< " numeros."<<endl;
cout<<"Sua
frase
tem
"<<
minusculas<<
"
letras
minusculas."<<endl;
cout<<"Sua
frase
tem
"<<
maiusculas<<
"
letras
maiusculas."<<endl;
return 0;
}
Pgina 74
Mdulo 9 Ponteiros
9.1 - Endereos de Memria
J dissemos vrias vezes que as variveis ficam armazenadas em determinados
espaos na memria do computador. Ao trabalhar com uma varivel, geralmente no
precisamos nos preocupar com o endereo desta varivel, pois o compilador cuida destes
detalhes tcnicos. Entretanto, pode ser bastante til saber o endereo de uma varivel.
Em C++, utilizamos o operador de endereo & para acessar o endereo de uma varivel.
Sua sintaxe muito simples, bastando inserir o operador & na frente do nome de uma
varivel:
&<varivel>
O programa abaixo cria uma varivel inteira e utiliza cout para exibir o valor da
varivel e depois seu endereo, utilizando o operador &.
#include <iostream>
int main( )
{
int valor = 124;
cout << "A variavel armazena o seguinte valor: ";
cout << valor <<endl;
cout << "A variavel esta armazenada no seguinte endereo: ";
cout << &valor <<endl;
return 0;
}
O operador de endereo utilizvel tambm em matrizes. Quando utilizamos este
operador em uma matriz, temos o endereo inicial da matriz, que nada mais do que o
endereo do primeiro elemento da matriz. Tambm podemos utilizar o operador & para
acessar os endereos de cada elemento de uma matriz, como vemos no exemplo abaixo:
#include <iostream>
int main( )
{
int matriz[3] = { 42, 37, 28 };
cout << &matriz[0] << " : " << matriz[0] << endl;
return 0;
}
Pgina 75
9.2 Ponteiros
Em linguagem de programao, chamamos de ponteiros as variveis especiais que
armazenam endereos de memria. Como j vimos, as variveis possuem trs atributos
bsicos: seu nome, o valor armazenado por ela e o endereo de memria onde ela est
armazenada. Os ponteiros, ao invs de armazenar valores, armazenam endereos de
memria. Ao utilizar um ponteiro, podemos acessar este endereo e manipular o valor que
est armazenado l dentro.
Ponteiros so utilizados constantemente em C++. Por exemplo, quando trabalhamos
com matrizes sem saber estamos trabalhando com ponteiros: a linguagem C++ ( e a
linguagem C tambm) utiliza ponteiros para acessar as diversas posies de uma matriz.
9.3 Declarando Ponteiros

A declarao de ponteiros bem parecido com a declarao de variveis. Assim
como uma varivel comum, ponteiros precisam ter tipos (como int, float, long) para indicar
ao compilador qual o tipo de valor para o qual o ponteiro aponta. Alm disso, utilizamos o
asterisco * antes do nome do ponteiro, para indicar ao compilador que estamos declarando
um ponteiro e no uma varivel simples. A sintaxe da declarao de um ponteiro vista
abaixo:
<tipo> * <nome do ponteiro>;
Ponteiros podem ser de qualquer tipo, como int, float, long e at mesmo sem tipo
(void). Abaixo temos alguns exemplos de declarao de ponteiro:
int *referencia;
float *media;
Aps declarar um ponteiro, importante atribuir o endereo que ser armazenado
por ele. Isto feito utilizando o operador & para obter o endereo de uma varivel. A
atribuio feita da mesma forma que atribuimos valores para uma varivel. Suponha que
tenhamos em um programa qualquer um ponteiro chamado referencia e uma varivel
chamada valor. Caso desejssemos que o ponteiro referencia armazenasse o endereo da
varivel valor, faramos a seguinte atribuio:
referencia = &valor;
O programa abaixo simplesmente o primeiro programa-exemplo deste mdulo,
reescrito utilizando-se um ponteiro para armazenar o endereo da varivel. Note que cout
exibe corretamente o endereo armazenado pelo ponteiro, da mesma maneira que exibiria
uma varivel:
#include <iostream>
Pgina 76
int main( )
{
int valor = 124;
int *referencia;
cout << "A variavel armazena o seguinte valor: ";
cout << valor <<endl;
cout << "A variavel esta armazenada no seguinte endereo: ";
referencia = &valor;
cout << referencia <<endl;
return 0;
}
9.4 Desreferenciando um Ponteiro

Desferenciar um ponteiro nada mais do que acessar o valor que est
armazenado no endereo de memria armazenado pelo ponteiro. Esta operao feita pelo
operador * (que chamamos formalmente de asterisco de indireo). Assim como
utilizamos o operador de endereo & para acessar o endereo de uma varivel, utilizamos o
asterisco de indireo para obter o valor que est dentro da posio de memria guardada
pela ponteiro. Para utiliz-lo basta adicionar o asterisco antes do nome de um ponteiro em
qualquer operao ou comando dentro um programa:
*<nome do ponteiro>;
O programa abaixo bastante parecido com os anteriores, mas utiliza o asterisco de
indireo para obter o valor da posio de memria indicada pelo ponteiro. Alm disso,
este valor modificado utilizando este mesmo operador:
#include <iostream>
int main( )
{
int valor = 42;
int * ponteiro;
ponteiro = &valor;
cout << "Endereo apontado pelo ponteiro: ";
cout << ponteiro <<endl;
cout << "Valor guardado por este endereo: ";
cout << *ponteiro <<endl;
cout << Valor atualizado!;
*ponteiro = 12458;
cout << "Novo valor guardado por este endereo: ";
cout << *ponteiro <<endl;
return 0;
}
Pgina 77
Esta operao til para acessar e modificar valores dentro de posies de

memria. Um ponteiro com o asterisco de indireo se comporta como uma varivel
comum. Podemos utiliz-lo em comandos, expresses, atribuies e onde mais for
necessrio.
9.5 Ponteiros em Funes: Chamada por Referncia

Como vimos no mdulo 4, podemos criar funes que utilizam dois tipos de
chamada de parmetros: a chamada por valor, onde a funo recebe uma cpia do valor de
uma varivel e a varivel em si no alterada pela funo, e a chamada por referncia,
onde a funo recebe o endereo da varivel, que tem seu valor alterado durante a
execuo da funo. Nesta seo explicaremos como feita a chamada de por referncia.
A chamada por referncia acontece quando passamos um ponteiro como parmetro
de uma funo. J sabemos que o ponteiro armazena um endereo de uma varivel: assim,
a funo recebe o endereo de uma varivel, e pode alterar o valor armazenado neste
endereo da maneira que precisar.
preciso uma srie de cuidados quando criamos funes que usam chamada por
referncia. A primeira delas declarar os ponteiros que sero utilizados como parmetros
no prottipo da funo. Por exemplo:
void soma ( int * parcela1, int * parcela2) {
//corpo da funo
}
A declarao de ponteiros como parmetros feita da mesma forma que
declararamos ponteiros em um programa, declarando o tipo e utilizando o asterisco para
indicar que se trata de um ponteiro.
Ao escrever o corpo da funo, tambm preciso ateno. Como estamos
trabalhando com um ponteiro, preciso lembrar que um ponteiro indica um endereo.
Quando precisamos do valor guardado neste endereo, preciso usar o asterisco antes do
ponteiro. Assim, qualquer operao envolvendo o valor indicado pelo ponteiro deve conter
o ponteiro acompanhado do asterisco. Caso utilizemos o prprio ponteiro, no estamos
alterando o valor, e sim o endereo. De forma resumida:
ponteiro endereo
*ponteiro valor
muito importante ter isso em mente ao criar funes que utilizem ponteiros. A
confuso entre o uso de um ponteiro como endereo ou como valor a principal fonte de
erros nestas situaes. O cdigo abaixo o corpo de uma funo que utiliza ponteiros.
Note que utilizamos um ponteiro e uma varivel normal como parmetros. Alm disso,
sempre que utilizamos o valor referenciado pelo ponteiro durante a funo, utilizamos o
asterisco de dereferenciao antes do nome do ponteiro.
Pgina 78
void potencia( int *variavel,int elevado) {

int original = 2;
if (elevado == 0) {
*variavel = 1;
return;
}
if (elevado == 1) return;
for (int i = 2; i <= elevado; i++) {
*variavel = *variavel*original;
}
Quando utilizamos uma funo deste tipo, preciso que o programa passe um
ponteiro como parmetro desta funo. Isto pode ser feito de duas maneiras: indicando um
ponteiro que contenha um endereo, ou indicando simplesmente o endereo de uma
varivel. Como j vimos, utilizamos o operador & antes do nome de uma varivel para
obter seu endereo. Assim, uma funo que utiliza ponteiros aceita em seu parmetro um
ponteiro ou o endereo de uma varivel ( &varivel ).
O programa abaixo mostra a utilizao de uma funo com chamada por referncia,
tendo em mente os cuidados descritos anteriormente.
#include <iostream>
void potencia( int *variavel,int elevado) {
int original = 2;
if (elevado == 0) {
*variavel = 1;
return;
}
if (elevado == 1) return;
for (int i = 2; i <= elevado; i++) {
*variavel = *variavel*original;
}
}
int main()
{
int dois = 2;
int j = 5;
potencia( &dois, j);
cout << "dois elevado a "<< j <<" : "<< dois << endl;
return 0;
}
A utilizao da chamada por referncia parece no ter muita utilidade quando
Pgina 79
trabalhamos com variveis simples. Porm, este cenrio muda quando trabalhamos com
matrizes: a utilizao da chamada por referncia a melhor forma de se criar funes que
trabalham com matrizes.
9.6 Ponteiros para Matrizes

J vimos que podemos utilizar matrizes como parmetros de funes e que no
podemos utilizar matrizes como retorno de funes. Tambm j vimos que essa limitao
pode ser superada graas ao fato das funes poderem alterar as matrizes que recebem
como parmetros. Assim, caso precisemos de uma funo que some 20 todos os
elementos de uma matriz, no podemos criar uma funo que retorne uma cpia da matriz
alterada, mas podemos criar facilmente uma funo que altere a prpria matriz, utilizando
a chamada por referncia.
Isto acontece porque quando trabalhamos com funes, C++ trata o nome de uma
matriz como o endereo de seu primeiro elemento. Assim:
matriz = = &matriz [0]
Assim, quando utilizamos uma matriz como parmetro de um funo, estamos na
verdade enviando o endereo de seu primeiro elemento para a funo, como numa
chamada por referncia. A partir deste endereo, a funo tem acesso a todos os elementos
da matriz, e pode fazer todas as alteraes que precisar nesta matriz. Podemos utilizar o
nome da matriz como se fosse um ponteiro: utilizando o asterisco para obter seu valor, e
realizar operaes de aritmtica de ponteiros para acessar seus elementos. Entretanto,
mais fcil utilizar a matriz do modo que j conhecemos: utilizando o nome da matriz e o
nmero do elemento entre chaves para acessar e alterar qualquer um de seus elementos.
Abaixo explicaremos como funciona a aritmtica dos ponteiros.
J sabemos que um ponteiro um valor que aponta para uma posio de memria
especfica. Se somar-se o valor 1 a um ponteiro, o ponteiro apontar para a prxima
posio de memria. Se somar-se 5 ao valor de um ponteiro, o ponteiro apontar para a
posio de memria de cinco posies adiante do endereo atual. No entanto, a aritmtica
de ponteiro no to simples quanto parece. Por exemplo, assuma que um ponteiro
contenha o endereo 1000. Se fosse somado 1 ao ponteiro, poderia se esperar que o
resultado fosse 1001. No entanto, o endereo resultante depende do tipo de ponteiro. Por
exemplo, se fosse somado 1 a um ponteiro do tipo char (que contm 1000), o endereo
resultante ser 1001. Se fosse somado 1 a um ponteiro do tipo int (que requer dois bytes na
memria), o endereo resultante ser 1002. Quando incrementamos um ponteiro de um
determinado tipo, o prprio compilador j faz a converso de tipo para ns. Assim,
podemos utilizar o incremento de um ponteiro para acessar os vrios elementos de uma
matriz de qualquer tipo. O programa abaixo utiliza a aritmtica de ponteiros para acessar
uma matriz. Cria-se um ponteiro que aponta para o endereo do primeiro elemento da
matriz (lembre-se sempre que o nome de uma matriz indica o mesmo endereo de seu
primeiro elemento), e a partir da vamos incrementando este ponteiro para exibir todos os
elementos da matriz. Inicialmente, incrementamos o ponteiro manualmente para ilustrar
melhor o que estamos fazendo, mas podemos facilmente utilizar um lao for para
incrementar o ponteiro e percorrer a matriz toda.
Pgina 80
#include <iostream>
int main()
{
int tabela[5] = { 20, 34, 58, 70, 125 };
int *ponteiro = tabela;
cout << *ponteiro << endl;
ponteiro++;
for (int i = 2; i < 5; i++){
ponteiro++;
}
return 0;
}
O programa abaixo ilustra a criao de duas funes que utilizam matrizes. As duas
funes fazem a mesma coisa (organizar uma matriz em ordem crescente), mas a primeira
funo trata a matriz como um ponteiro, enquanto que a segunda trabalha com a matriz do
modo j conhecido. Os dois mtodos so vlidos e tem sua utilidade, mas de modo geral
mais simples e recomendvel utilizar matrizes do modo j estudado.
#include <iostream>
int ordenamatriz( int matriz[], int tamanho) {
int temp = 0;
if (matriz[j] < matriz [i]) {
temp = matriz[i];
matriz[i] = matriz[j];
matriz[j] = temp;
}
}
}
}
int ordenaponteiro (int *matriz, int tamanho)
{
int temp = 0;
for (int i =0; i < tamanho; i++) {
if ( *(matriz + j) < *(matriz + i ) ) {
temp = *( matriz + i );
Pgina 81
*(matriz + i) = *(matriz + j);

*(matriz + j) = temp;
}
int main()
{
int sequencia[TAMANHO] = {27, 12, 42, -8};
int sequencia2[TAMANHO] = {21, -27, 1024, 42};
cout<<endl;
ordenamatriz(sequencia, TAMANHO);
ordenaponteiro(sequencia2, TAMANHO);
cout <<"Sequencia ordenada 1: ";
for (int i = 0; i < 4; i++) {
}
cout<<endl;
cout <<"Sequencia ordenada 2: ";
for (int i = 0; i < 4; i++) {
cout << sequencia2[i]<<" ";
}
cout<<endl;
return 0;
}
9.7 Funes que Retornam Ponteiros

Podemos criar funes que retornam ponteiros para o programa que as chamou.
Estas funes so teis, por exemplo, para trabalhar com matrizes e strings, retornando o
endereo da matriz ou string modificada para o programa. Para declarar uma funo que
retorne um ponteiro, preciso declarar o tipo de retorno no prottipo da funo, no se
esquecendo do asterisco. Por exemplo, veja o prottipo de funo abaixo:
int *calculaseno ( );
char *maisculas( );
9.8 Ponteiros para Funes

Pgina 82
Encerrando os tpicos relacionados com ponteiros e funes, temos os ponteiros

para funes. Um ponteiro para uma funo armazena o endereo de uma funo. Este tipo
de ponteiro til para ser usado como parmetro de outra funo. Sua declarao
parecida com a declarao de funes que retornam ponteiros, mas no deve ser
confundida. Sua sintaxe a seguinte:
<tipo do ponteiro/funo> (*<nome da funo>) ( );
Basicamente, coloca-se o asterisco antes do nome da funo, junto dos parnteses,
Alguns exemplos:
int (*seno) ( );
int (*integral) ( );
9.9 Ponteiros para Ponteiros

Ponteiros, assim como variveis, ocupam um endereo na memria do computador.
Podemos ento criar ponteiros que apontam para o endereo de outro ponteiro, como
vemos no cdigo exemplo abaixo:
int inteiro = 1024;
int *pontinteiro = &inteiro;
int *pontponteiro = &pontinteiro;
Declaramos um ponteiro para um ponteiro utilizando dois asteriscos antes de
declarar seu nome. No programa acima temos a seguinte sequncia:
pontponteiro pontinteiro inteiro
Utilizando o operador de desreferncia * no ponteiro pontpvalor, recebemos o
valro armazenado pela varivel inteiro, como j era de se esperar. Quando utilizamos o
operador de desreferncia * no ponteiro pontppont, o que recebemos o ponteiro
pontpinteiro, ou melhor, o valor armazenado por ele: o endereo da varivel inteiro. Para
acessar o valor da varivel inteiro utilizando o ponteiro pontppont, precisamos utilizar
o operador de desreferncia * duas vezes. O programa abaixo mostra trs maneiras
diferentes de se acessar o valor de inteiro: acessando a prpria varivel, utilizando um
ponteiro e o operador de desreferncia, ou utilizando um ponteiro para ponteiro e o
operador de desreferncia duas vezes.
#include <iostream>
int main()
{
int inteiro = 1024;
int *pontinteiro = &inteiro;
int **pontponteiro = &pontinteiro;
cout << "Acessando o valor da variavel inteiro: "<<endl;
Pgina 83
cout << "De forma direta (pela propria variavel): "<< inteiro
<< endl;
cout << "De forma indireta (pelo ponteiro
pontinteiro): "<< *pontinteiro << endl;
para
variavel
cout << "De forma duplamente indireta (pelo ponteiro para

ponteiro pontponteiro): "<< **pontponteiro << endl;
return 0;
}
Na verdade, C++ nos permites criar infinitas indirees (ponteiros para ponteiros
para ponteiros...e assim por diante). Mas na prtica, a utilizao de ponteiros para ponteiros
geralmente evitada por causar grande confuso e dificultar a compreenso dos
programas.
9.10 Operadores new e delete

J falamos no mdulo sobre matrizes da importncia dos operadores new e delete.
A linguagem C++ prima pela economia de memria, para possibilitar a construo de
programas maiores e/ou mais rpidos. Assim, temos dois operadores que gerenciam a
alocao e a liberao de memria dinamicamente, possibilitando a criao e destruio de
variveis durante a execuo de um programa para evitar o desperdcio de memria. Este
tipo de criao e destruio de variveis chamado de alocao dinmica.
A vantagem de se criar variveis dinmicas que a memria utilizada por esta
varivel s tirada do sistema aps a execuo do operador new, e pode ser liberada
novamente aps sua utilizao com o operador delete. Quando declaramos uma varivel
do jeito normal, a memria utilizada por ela guardada pelo programa durante toda sua
execuo, consumindo recursos desnecessrios do computador.
A sintaxe para se criar uma varivel com o operador new a seguinte:
<tipo> * <nome> = new <tipo>;
Como voc deve ter percebido, estamos criando um ponteiro. A novidade est do
lado direito do operador de atribuio: o uso do operador new faz com que o sistema
separe um espao na memria para armazenar uma varivel do tipo declarado (ou ainda
uma matriz, como vimos anteriormente). Para acessar este espao, utilizamos o ponteiro
que acabamos de criar, utilizando o operador de desreferncia * para acessar o valor que
est armazenado ali.
A outra face do operador new o operador delete. S podemos utilizar este
operador com variveis criadas pelo operador new, ou melhor, com os ponteiros que
usamos para acessar a memria alocada com o operador new. O uso do operador delete
bastante simples:
delete <nome>;
Aps o uso do operador delete, o espao alocado por new totalmente liberado
Pgina 84
para o sistema.
Apesar da vantagem da economia de memria apresentada pelos operadores new e
delete, preciso saber aonde utiliz-los. Eles so especialmente teis para matrizes cujo
tamanho exato no conhecemos, ocasionando grande economia de memria. Entretanto,
para variveis que sero utilizadas o tempo todo pelo programa, a economia de memria
obtida no to grande, e a alocao/liberao constante de memria pode deixar o
programa at mais lento. Assim, recomenda-se a utilizao da declarao normal de
variveis na maioria dos programas que criamos.
Pgina 85
Mdulo 10 - Entrada e Sada de Dados

A maioria dos programas de computador trabalham com arquivos. Processadores de
texto criam e editar arquivos de texto; navegadores de internet interpretam e exibem
arquivos HTML; compiladores lem arquivos-fonte e geram arquivos executveis. Um
arquivo nada mais do que uma sequncia de bytes armazenada em um dispositivo, seja
esse dispositivo ,por exemplo, um disco rgido, um CD ou um disquete. Tipicamente, o
sistema operacional gerencia os arquivos presentes em um computador, mantendo registro
de onde esto armazenados, quais os seus tamanhos, quando foram criados, etc.
Quando trabalhamos com arquivos em programao, precisamos de meios para
conectar um programa um arquivo, de modo que o programa possa ler e escrever dados
dentro deste arquivo, e tambm meios para criar novos arquivos e salv-los em um
dispositivo. A linguagem C++ possui um pacote de classes e funes que trabalham com
arquivos de forma bastante semelhante s classes cout e cin j estudadas.
10.1 A biblioteca fstream

O primeiro passo para manipular um arquivo em C++ adicionar a biblioteca
especfica para a manipulao de dados em arquivos ao cabealho de nosso programa. Esta
biblioteca chamada de fstream, de file stream (fluxo de arquivos). Para adicion-la
ao cabealho, fazemos:
#include <iostream>
#include <fstream>
Note que os nomes das duas bibliotecas so parecidos: ambas contm classes que
trabalham com entrada e sada de dados. No entanto, a biblioteca iostream trabalha apenas
com o fluxo de dados via monitor/teclado/perifricos, enquanto que a biblioteca fstream
trabalha com o fluxo de dados de arquivos. (Na verdade, atualmente a biblioteca fstream
engloba todas as classes contidas em iostream, mas nem todos os compiladores j adotaram
essa modificao).
10.2 Os objetos de fstream

Uma vez adicionada a biblioteca, podemos criar objetos em nossos programas que
serviro de intermedirios entre o programa e os arquivos manipulados. A biblioteca
fstream define trs tipos de objeto para esta funo, cada um com objetivo definido:
ofstream: objetos que escrevem dados em um arquivo.
ifstream: objetos que lem dados em um arquivo.
fstream: objetos que podem tanto ler como escrever em um arquivo.
Explicaremos o uso de cada um deles, cada vez nos aprofundando mais no assunto.
Por enquanto, veremos como criar um arquivo e escrever algumas strings nele utilizando
um objeto ofstream.
Pgina 86
10.3 Escrevendo em um arquivo

Podemos resumir assim as etapas necessrias para escrever em um arquivo atravs
de um programa em C++:
- Cria-se um objeto do tipo ofstream.
- Associa-se este objeto com um arquivo em particular (seja criando ou abrindo um arquivo
j existente).
- Usa-se o objeto para enviar dados para este arquivo, de forma bem parecida como usamos
o comando cout. A diferena que os dados vo para o arquivo, ao invs de serem
exibidos na tela.
Para criar um objeto ofstream, declaramos seu nome de maneira parecida com a
declarao de uma varivel:
ofstream <nome do objeto>
Por exemplo:
ofstream escreve;
A linha acima cria o objeto escreve, do tipo ofstream, capaz de escrever em
arquivos. O prxima passo associar este objeto a um arquivo. Para isto, utilizamos a
funo open( ), que abre o arquivo desejado ou cria um arquivo no disco rgido. A sintaxe
de open( ) a seguinte:
<objeto>.open(nome do arquivo);
Por exemplo, vamos utilizar o objeto escreve para criar um arquivo chamado
strings.txt. Para fazer isso, utilizamos a funo open da seguinte maneira:
escreve.open(strings.txt);
Dessa forma, estamos associando o objeto escreve ao arquivo strings.txt. Agora
podemos enviar dados atravs do objeto escreve, e estes dados sero escritos no arquivo
strings.txt. Para fazer isso, utilizamos o objeto que criamos da mesma forma que
utilizamos o comando cout. Da mesma forma como escreveramos na tela do computador
com o comando cout utilizando variveis, strings, strings literais, formatao, etc, podemos
utilizar estes recursos todos tambm com os objeto do tipo ofstream, com a diferena que
estas informaes sero gravadas em um arquivo. O exemplo abaixo rene todos os passos
anteriores e utiliza o objeto escreve para escrever diversos dados em um arquivo, para
dar uma idia melhor de suas possibilidades.
#include <iostream>
#include <fstream>
#include <string>
Pgina 87
int main(){
string frase;
cout<<"Escreva uma frase para ser escrita no arquivo
string.txt:";
getline(cin, frase);
cout<<"Obrigado. Escrevendo dados no arquivo
strings.txt...\n";
ofstream escreve;
escreve.open("strings.txt");
escreve << "Utilizamos os objetos ofstream para escrever em
arquivos\n";
escreve<< "Note que podemos utilizar os caracteres \\n pra
quebrar a linha, como fazamos em cout\n";
int numero = 100;
escreve<<"Podemos escrever o valor de variaveis numericas: "
<<numero <<"\n";
int matriz[3] = {42, 19, 99};
escreve<<"Podemos tambm escrever matrizes!";
for (int i=0; i < 3; i++){
escreve.width(6);
escreve<<matriz[i]<<" ";
}
escreve<<"\n";
escreve<<"Finalmente, podemos receber dados via cin e
escrever estes dados no arquivo!\n";
escreve<<"A frase que voc digitou durante a execuo do
programa: "<<frase<<"\n";
escreve.close();
cout<<"Dados escritos no arquivo. Fim do Programa!";
system("PAUSE");
return 0;
}
Procure o arquivo strings.txt em seu sistema, e abra ele (ele provavelmente est no
mesmo diretrio onde est o arquivo executvel do programa que compilamos. Por
definio, estes arquivos ficam no diretrio onde est o compilador, a menos que tenhamos
configurado o compilador para salv-los em outro lugar.). Percebeu a semelhana entre a
utilizao do objeto ofstream com o comando cout? Todos os mtodos que vimos com cout
para exibir um dado na tela podem ser utilizado para gravar um dado em um arquivo.
10.4 Checando se o arquivo abriu sem problemas

Sempre existe a possibilidade de erros quando trabalhamos com arquivos. Talvez o
arquivo que desejamos ler tenha sido apagado, ou renomeado, ou esteja sendo usado por
outro programa. A biblioteca de C++ possui uma funo que checa se um objeto
ofstream/ifstream conseguiu abrir um determinado arquivo, e se continua conectado
corretamente este arquivo: a funo is_open( ). Esta funo checa o estado do objeto, e
retorna 0 para o programa caso tudo esteja certo. Caso um valor diferente de 0 seja enviado
ao programa, isso indica que o arquivo no pode ser aberto pelo objeto.
Pgina 88
O cdigo abaixo pode ser utilizado em qualquer programa que utilize leitura e
escrita de arquivos (basta, logicamente, substituir os nomes do objeto e do arquivo) para
checar o estado do objeto. Caso um erro seja encontrado, o programa indica que o arquivo
no pode ser aberto e a execuo terminada. Caso contrrio, o programa continua sua
execuo normalmente.
if(!leitura.is_open( ))
{
cout<<No foi possvel abrir arquivo! Programa ser terminado!\n;
leitura.clear( ); //reseta o objeto leitura, para limpar memria do sistema
return 0;
}
10.5 Fechando um Arquivo

Utilizamos a funo close( ) no programa acima aps escrever todos os dados
desejados no arquivo. Como voc deve ter adivinhado, a funo close simplesmente fecha
o arquivo a que o objeto estava associado, liberando o objeto e a memria do arquivo.
Aps fecharmos o arquivo antigo, podemos associar o objeto outro arquivo no mesmo
programa. Dessa forma, um objeto ofstream (na verdade, qualquer um dos objetos
derivados de fstream) pode trabalhar com mltiplos arquivos dentro de um mesmo
programa, porm no simultaneamente (caso precisemos trabalhar com mltiplos arquivos
simultaneamente, preciso criar mais de um objeto fstream). A sintaxe da funo close( )
a seguinte:
<objeto>.close( );
Note que no necessrio especificar o arquivo ser fechado, pois cada objeto s
consegue estar conectado um nico arquivo por vez. No programa acima, por exemplo,
utilizamos o seguinte comando para fechar o arquivo string.txt:
escreve.close( );
10.6 Lendo os dados de um arquivo

Para ler os dados de um arquivo em um programa, preciso antes de mais nada
criar um objeto do tipo ifstream, capaz de ser o intermedirio entre o arquivo ser lido e o
programa. A criao do objeto ifstream muito semelhante criao de um objeto
ofstream: no exemplo de cdigo abaixo, cria-se um objeto ifstream chamado leitura e
conecta-se ele ao arquivo string.txt criado previamente.
ifstream leitura;
leitura.open(string.txt);
Aps criarmos o objeto e conectarmos ele um arquivo, podemos comear a ler
atravs deste arquivo. A leitura de dados de um arquivo parecida com a leitura de dados
enviados atravs do teclado: criamos uma varivel para armazenar os dados recebidos, e
utilizamos o objeto ifstream para ler e enviar os dados do arquivo para o programa (no caso
da leitura via teclado, o objeto cin receberia os dados enviados pelo usurio e os repassaria
Pgina 89
para o programa). Assim, podemos utilizar qualquer um dos mtodos de leitura que
estudamos para cin, seja para ler caracteres, palavras ou frases inteiras.
Para lermos somente um caractere de um arquivo, por exemplo, nossa melhor
opo utilizar o mtodo .get, que serve justamente para esta funo. Criamos uma
varivel do tipo char para armazenar este caractere, e utilizamos o objeto ifstream da forma
mostrada no exemplo abaixo:
char armazena;
leitura.get( armazena);
O exemplo de cdigo acima utiliza o objeto leitura e o mtodo .get para ler um
caractere de um arquivo, e armazena este caractere na varivel armazena. Poderamos
criar um lao de repetio para obter todos os caracteres do arquivo, como vemos no
exemplo abaixo. O lao while continuar a executar o mtodo .get para ler o arquivo, at
que seja encontrado o fim do arquivo. Quando o fim do arquivo encontrado, o comando
leitura.get(armazena) retorna falso para o lao while, terminando a repetio. Lembrese que o arquivo strings.txt deve estar no mesmo diretrio onde estamos executando o
programa, caso contrrio erros ocorrero!
#include <iostream>
#include <fstream>
#include <string>
int main(){
char letra;
ifstream leitura;
leitura.open("strings.txt");
{
cout<<"No foi possvel abrir arquivo! Programa ser
terminado!\n";
leitura.clear( ); //reseta o objeto leitura, para limpar
memria do sistema}
}
while (leitura.get(letra)) {cout << letra;}
leitura.close();
system("PAUSE");
return 0;
}
Para lermos uma palavra inteira de um arquivo, ao invs de utilizarmos uma
simples varivel de tipo char, utilizamos uma matriz do tipo char. Da mesma maneira que
o comando cin, o objeto ler todos os caracteres em seu caminho, at que a matriz atinja
seu tamanho mximo especificado OU encontre um espao em branco, uma quebra de
linha ou o fim do arquivo.
Pgina 90
char matriz_chars[80];
leitura >> matriz_chars;
Finalmente, para lermos uma linha inteira de um arquivo, utilizamos o mtodo
.getline, que j havamos estudado no mdulo 5. O mtodo getline l uma linha inteira de
entrada, at que o tamanho mximo especificado seja atinjido ou at encontrar uma quebra
de linha ou o fim de arquivo. Relembrando sua sintaxe:
<nome do objeto>.getline ( <matriz_destino>, <limite de caracteres>);
Por exemplo
char matriz_chars[80];
leitura.getline( matriz_chars, 80);
O comando acima leria todos os caracteres de uma linha, at encontrar a quebra da
linha. Como vimos com o mtodo .get, podemos utilizar um lao de repetio para lermos
todas as linhas de um arquivo utilizando o mtodo getline. No exemplo abaixo, cada
repetio uma linha do arquivo ser escrita na tela.
#include <iostream>
#include <fstream>
#include <string>
int main(){
char depot[300];
ifstream leitura;
leitura.open("strings.txt");
{
cout<<"No
foi possvel
abrir
arquivo!
Programa
ser
terminado!\n";
leitura.clear( ); //reseta o objeto leitura, para limpar
memria do sistema}
}
while (leitura.getline(depot, 300)) {cout << depot <<"\n";}
leitura.close();
system("PAUSE");
return 0;
}
Uma pequena diferena que vemos entre esses dois mtodos de ler um arquivo
inteiro, que o mtodo .get l todos os caracteres at o fim de arquivo, incluindo quebras
de linha. O mtodo getline utiliza as quebras de linha para determinar o fim de sua leitura,
e descarta elas. Assim, no exemplo logo acima, tivemos que instruir o programa
Pgina 91
adicionar uma quebra de linha aps exibir na tela cada uma das linhas lidas. (Entretanto,
lembre-se que para arquivos grandes, o mtodo getline mais eficiente e mais rpido.
Tenha em mente que cada acesso de um objeto fstream um arquivo demanda um certo
processamento: em um arquivo grande, se temos centenas de linhas, ento temos milhares
de caracteres, o que significa que o mtodo get acessar muito mais vezes o mesmo
arquivo do que o mtodo getline).
10.7 Modos de Arquivo

Quando abrimos um arquivo, podemos querer fazer diferentes coisas com o
contedo deste arquivo. Podemos querer continuar escrever no fim do arquivo, dando
continuidade aos dados j escritos nele. Podemos querer apagar todos os dados j escritos e
comear do zero novamente. Os modos de arquivo servem justamente para isto: para
definir como deve ser o comportamento de um arquivo quando acessado pelo programa.
Podemos definir que o arquivo ser utilizado somente para leitura ou somente escrita, se
ser utilizado para anexar dados ou se ser reescrito totalmente. Definimos o modo do
arquivo quando abrimos ele com um objeto, adicionando um parmetro novo ao mtodo
open. Veja a sintaxe abaixo:
<objeto ofstream>.open(nome do arquivo, ofstream::<modo de arquivo>);
ou
<objeto ifstream>.open(nome do arquivo, ofstream::<modo de arquivo>);
A tabela abaixo resume os modos de arquivo disponveis em C++.
ios_base::in
ios_base::out
ios_base::ate
ios_base::app
ios_base::trunc
ios_base::binary
Abre arquivo para leitura.

Abre arquivo para escrita.
Procura o final do arquivo ao abrir ele.
Anexa os dados serem escritos ao final do arquivo.
Trunca os dados existentes no arquivo.
Abre e trabalha com arquivos em modo binrio.
Note que um arquivo aberto por um objeto ofstream no necessita que definamos o
modo de arquivo ofstream::out, pois este modo j definido para este tipo de objeto por
definio. O mesmo ocorre com o modo ifstream::in e os objetos ifstream.
Alm disso, por definio, um arquivo aberto por um objeto ofstream ir truncar os
dados j existentes no arquivo, escrevendo os dados novos por cima dos antigos. Porm,
o modo ofstream::app nos permite anexar dados ao final de um arquivo. O exemplo abaixo
utliza o modo ofstream::app para criar uma espcie de agenda simplificada em um
arquivo de texto.
Pgina 92
#include <iostream>
#include <fstream>
#include <string>
int main(){
int dia, mes;
char letra[1000];
cout<<"PROGRAMA AGENDA Verso 0.00042\n";
ofstream agenda;
agenda.open("agenda.txt", ofstream::app);
cout<<"Digite o compromisso no espao abaixo (): \n";
cin.getline(letra, 1000);
cout << "Digite o dia do compromisso:\n";
cin >> dia;
cout << "Digite o ms do compromisso:\n";
cin >> mes;
agenda << "Compromisso marcado para dia "<<dia<<" de
"<<mes<<": ";
agenda << letra;
agenda<<"\n";
cout<<"Obrigado! Sua agenda foi atualizada com sucesso!";
agenda.close();
system("PAUSE");
return 0;
}
Pgina 93
Mdulo 11 Programao Orientada Objetos

Nos mdulos anteriores, cobrimos todos os aspectos essenciais da programao
estruturada em C++. Entretanto, a linguagem C++ possui muito mais aspectos do que os
tratados at agora. Pode-se dizer que tocamos apenas na ponta do iceberg: o verdadeiro
poder de C++ est na sua versatilidade e capacidade de ser programada em vrios
paradigmas diferentes, seja programao estruturada, orientada objetos ou orientada
templates. O mdulo seguir tenta fazer uma explicao bsica sobre o que a
programao orientada objetos, dando aos leitores uma breve introduo aos conceitos
essenciais deste paradigma, sem adentrar em exemplos de cdigo.
11.1 Paradigmas de Programao

Como dissemos no primeiro mdulo desta apostila, paradigmas de programao so
conjuntos de idias que fornecem ao programador uma viso sobre a estruturao e
execuo de um programa. Assim como ao resolver um problema podemos adotar uma
entre variadas metodologias para resolv-lo, ao criar um programa podemos adotar um
determinado paradigma de programao para desenvolv-lo.
O primeiro paradigma que aprendemos quando comeamos estudar programao,
qualquer que seja a linguagem, o paradigma da programao estruturada. A programao
estruturada tem como objetivo escrever programas que sigam uma lgica linear, ou seja,
tenham comeo, meio e fim. grosso modo, um programa escrito dessa forma comea
com a declarao das variveis que sero utilizadas, seguindo para a execuo de
comandos, funes e tomadas de deciso numa sequncia linear, at que todas as linhas de
cdigo tenham sido executadas e o programa atinja seu final. a maneira mais simples de
se escrever um programa, principalmente porque utilizamos essa mesma lgica linear no
dia-a-dia: faa tal tarefa, depois caso tal condio seja verdadeira realize outra tarefa, e
assim por diante. Porm, quando precisamos escrever programas realmente grandes ou
realmente complexos, a programao estruturada torna-se ineficiente. Imagine um editor
de textos, onde se pode escrever em um documento, criar um novo documento, alterar
fontes, tamanhos, pargrafos, tabulaes, executar correes ortogrficas...agora imagine
como acomodar todas as diferentes aes que um usurio pode executar em um programa
de estrutura linear.
11.1 Programao Orientada Objetos

O paradigma da programao orientada objetos nasceu no comeo da dcada de
1970, e tinha por objetivo propor uma nova maneira de se olhar para a elaborao de
programas. Para a programao orientada objetos, um programa deve ser visto como uma
coleo de objetos que trabalham cooperando entre si, ao contrrio de uma lista de
instrues que deve ser seguida pelo computador. Desse modo, cada objeto dentro de um
programa deve ser visto como uma mquina independente com um determinado papel ou
objetivo na execuo do programa. Estes objetos devem se comunicar entre si, recebendo,
processando e enviando dados para os outros objetos do programa.
Pgina 94
11.2 Conceitos Bsicos

A unidade principal da programao orientada objetos a Classe. Uma classe
uma representao de um objeto ou idia real em forma de cdigo, separando as
caractersticas operacionais dos detalhes concretos de sua implementao. Simplificando,
definimos uma Classe para representar algo: por exemplo, um relgio. Para o usurio, no
importante como o relgio funciona, tanto na vida real como na programao:
importante apenas que o usurio possa interajir com o relgio, seja olhando as horas, seja
ajustando o alarme ou configurando o horrio correto. As engrenagens ou funes que
fazem o relgio funcionar ficam escondidas do usurio: isso que queremos dizer com
separar as caractersticas operacionais dos detalhes da implementao.
Em termos de programao, uma classe uma estrutura que contm variveis e
funes com o objetivo de representar uma idia. Dentro de uma classe, as variveis e
funes so chamadas de membros da classe. Ainda pensando no exemplo do relgio,
dentro desta classe teramos variveis (ou membros) para as horas, minutos, segundos e
tambm para armazenar o horrio do alarme, assim como funes-membro para ver o
horrio atual, ajust-lo ou ajustar o alarme. Porm, o usurio no precisa ter acesso todas
estas variveis: eles s precisa interajir com as caractersticas operacionais do relgio.
Assim, criamos funes-membro para fazer esta interao: uma funo para ver as horas,
outra para ajustar o horrio e outra para ajustar o alarme. Dessa forma, simplificamos a
utilizao da classe e tambm evitamos que o usurio acesse e altere dados que possam
atrapalhar o funcionamento do programa.
Dizemos que os membros da classe que o usurio pode acessar so pblicos,
enquanto que os membros internos so privados. Um membro privado no pode ser
acessado ou alterado pelo usurio: no queremos o usurio cutucando as engrenagens do
relgio. Os membros privados so acessados somente pelos membros pblicos, que fazem
a interao entre as engrenagens do programa e o usurio. Assim, mesmo que tenhamos
funes como membros privados, elas s podem ser executadas por outras funes que
sejam membros pblicos da funo. A funo pblica ver horrio de nossa classe
Relgio provavelmente precisa acessar uma funo privada que atualiza o horrio do
relgio, assim como a funo ajusta alarme altera uma varivel privada que contm o
horrio do alarme.
Formalizando, um membro pblico, seja ele uma varivel ou uma funo pode ser
acessado a qualquer momento durante a execuo de um programa (lido ou alterado no
caso das variveis, executado no caso das funes). Quando tentamos acessar diretamente
um membro privado, geramos um erro pois seu acesso proibido para o
usurio/programador! Assim, a nica forma de acessar um membro privado atravs dos
membros pblicos. Esta separao entre membros pblicos e privados feita na declarao
da classe.
O prximo conceito essencial da programao orientada objetos o prprio
objeto. Um objeto uma instncia especfica de uma classe. Podemos pensar na classe
como um tipo de varivel, enquanto que o objeto a prpria varivel. Em C++, definimos
classes para depois criar objetos que tenham as caractersticas definidas nestas classes. No
exemplo acima, definimos a classe Relgio, e agora podemos criar quantos relgios forem
necessrios: cada relgio ser um objeto diferente, com funcionamento idntico e
Pgina 95
caractersticas diferentes. Por exemplo, criamos os objetos relgio de pulso e relgiocuco. Os dois so relgios, mas podemos ajust-los em horrios diferentes, com alarmes
diferentes. Cada objeto possui todos os membros pblicos e privados que definimos na
declarao da classe. Assim, utilizamos os membros pblicos para interajir com os objetos,
enquanto que os membros privados so as engrenagens do objeto. Aqui temos um novo
nome para os membros pblicos: chamamos eles de mtodos do objeto. Um mtodo
nada mais do que uma funo que interaja com o objeto, ou seja, so prprios os
membros pblicos que definimos na declarao da classe.
Para termos um exemplo mais concreto, podemos pensar em um programa qualquer
do ambiente Windows. Nas ferramentas de programao Windows, temos vrias classes
que representam os vrios itens que vemos na tela: janelas, menus, cursores, cones.
Quando um programador precisa criar uma janela, ele no precisa ter todo o trabalho para
programar uma janela do zero: ele cria um novo objeto da classe Janela, e define suas
caractersticas atravs das funes pblicas (ou mtodos) da classe. Ele no precisa saber
como a janela desenhada na tela: basta saber quais mtodos definem as caractersticas
que ele necessita para que seu objeto funcione da maneira desejada.
11.2 Herana e Polimorfismo

O conceito de herana muito importante para a reutilizao de cdigo em C++.
Quando escrevemos uma classe, assim como quando escrevamos funes, temos em
mente o objetivo de no reescrever um cdigo que j foi desenvolvido. Alm das classes,
temos em C++ o conceito de sub-classes: classes que herdam seus membros e mtodos de
outras classes. Por exemplo, suponha que tenhamos criado a classe Cachorro. Com base
nesta classe, podemos criar subclasses representando as diversas raas de cachorro, como
Pastor_Alemo, Doberman e Vira_Lata. No precisamos reescrever todos os membros e
mtodos que j havamos escrito ao desenvolver a classe base: basta indicar ao compilador
que as novas subclasses sero herdeiras da classe-base. Feito isso, podemos modificar estas
subclasses, modificando seus membros pblicos e privados. Assim, podemos alterar a
interface da subclasse, afetando a maneira do usurio interajir com ela, ou o prprio
funcionamento da classe, alterando seus membros privados.
Note que poderamos simplesmente copiar a classe-base e modificar seu cdigo,
alterando seu nome. Mas o conceito de herana permite alterar s os membros que
necessitam ser alterados. No precisamos nem mesmo ter acesso ao cdigo fonte da classebase, o que muito til quando trabalhamos com bibliotecas comerciais que geralmente
no disponibilizam seu cdigos.
Quando alteramos uma subclasse, podemos alterar qualquer um de seus mtodos,
ou seja, podemos alterar a maneira como esta subclasse interaje com seus usurios. Por
exemplo, quando definimos as subclasses Pastor_Alemo e Vira_Lata, alteramos tambm
seu mtodo Latido. Uma subclasse far uma determinada tarefa quando for chamado o
mtodo Latido, enquanto que a outra subclasse far outra tarefa totalmente diferente,
mesmo sendo as duas subclasses derivadas da mesma classe-base. Podemos at criar uma
subclasse sem o mtodo Latido: um cachorro mudo. Essa possibilidade de se fazer
alteraes nas subclasses de uma classe base chamada de Polimorfismo. Basicamente, o
Polimorfismo afirma que mesmo que a classe B seja herdeira da classe A, ela no precisa
Pgina 96
herdar todos os mtodos de A: a classe B pode ter caractersticas diferentes, ou seja,

mtodos diferentes da classe-base. Dessa forma, o mesmo comando pode gerar
resultados diferentes dependendo da subclasse qual o objeto pertence.
A idia por trs dos conceitos de classes, objetos, herana e polimorfismo
possibilitar a elaborao de cdigo mais simples para programas mais complexos,
quebrando os diversos aspectos de um programa em blocos independentes entre si. Assim,
no precisamos atacar todo o problema de uma vez, podemos divid-lo e trabalhar com
cada uma dessas divises individualmente. Outro ponto importante por trs da
programao orientada objetos a reutilizao de cdigo: porque reinventar a roda
sempre que escrevemos um programa novo? Nesse aspecto, podemos pensar nas classes
como grupos de funes: no precisamos saber como elas funcionam, apenas precisamos
saber como utilizar seus mtodos para obter os resultados desejados. Atualmente existe um
nmero muito grande de bibliotecas de classes para C++, tanto comercial como em cdigo
aberto, com as aplicaes mais diversas, desde bibliotecas matemticas at bibliotecas
grficas para a elaborao de jogos 3D.
Pgina 97
Referncias Bibliogrficas
[1] TORRES, Jair Gustavo M. Curso de Linguagem C Ilha Solteira: Faculdade de
Engenharia de Ilha Solteira FEIS UNESP Departamento de Engenharia Eltrica,
2006.
[2] PRATA, Stephen C++ Primer Plus, 4 edio Nova York: Sams Publishing. 2001.
[3] STROUSTRUP , Bjarne - The C++ Programming Language, 3 edio New Jersey:
Addison Wesley. 1997.
[4] LIPPMAN, Stanley B.; LAJOIE, Jose Lajoie; MOO, Barbara E. C++ Primer, 4
edio New Jersey: Addison-Wesley. 2005.
Pgina 98

Estrutura de Dados - Linguagem em C++

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Estrutura de Dados - Linguagem em C++

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDADE ESTADUAL PAULISTA

JLIO DE MESQUITA FILHO

Autor: Enrique Camargo Trevelin

Ilha Solteira Julho de 2007

Mdulo 2 Compiladores .............................................................................. 8

Mdulo 3 Caractersticas e Definies Gerais da Linguagem C++....... 17

Mdulo 4 Funes na Linguagem C......................................................... 30

4.2 Declarando uma Funo ..................................................................................... 31

Mdulo 5 Estudo dos comandos cout e cin .............................................. 42

Mdulo 6 - Estruturas de Controle de Fluxo.............................................. 48

Mdulo 7 Matrizes ..................................................................................... 60

Mdulo 8 Strings ........................................................................................ 68

Mdulo 9 Ponteiros .................................................................................... 75

Mdulo 10 - Entrada e Sada de Dados....................................................... 86

Mdulo 11 Programao Orientada Objetos ....................................... 94

Referncias Bibliogrficas ............................................................................ 98

UNESP Campus de Ilha Solteira 2007

Mdulo 1 A Linguagem C++

1.2 Caractersticas da Linguagem C++

Em proposta geral, C++ deve ser to eficiente e portvel quanto C, sendo

C++ desenvolvido para suportar mltiplos paradigmas de programao,

C++ desenvolvido para fornecer ao programador mltiplas escolhas, mesmo que

UNESP Campus de Ilha Solteira 2007

1.3 Exemplos de Aplicaes Escritas em C++

Sistemas Operacionais como o j citado Windows, Apple OS X, BeOS, Solaris e

Bancos de dados como SQL e MySQL.

Aplicaes Web, como a mquina de busca Google e o sistema de comrcio virtual

Aplicaes grficas como os programas da Adobe (Photoshop, Illustrator), Maya e

Jogos em geral, como o Doom III.

1.4 Comparao de C++ com outras linguagens

as consequncias de seu mau ou incorreto uso. O motivo para essa liberdade na

Possibilidade em programao de alto e baixo nvel.

Compatilidade com o C herdou os problemas de entendimento de sintaxe do mesmo.

1.5 Paradigmas de Programao: Programao

programao orientada a objetos. Outras linguagens suportam vrios paradigmas, ou seja, o

UNESP Campus de Ilha Solteira 2007

2.2 Compiladores de C++

UNESP Campus de Ilha Solteira 2007

Figura 2.1 Escolha o tipo de instalao Full

UNESP Campus de Ilha Solteira 2007

Figura 2.2 Escolha o local onde sero instalados os arquivos do compilador.

UNESP Campus de Ilha Solteira 2007

Figura 2.3 Interface do DevC++

Os menus principais do programa so muito parecidos com os programas windows

Arquivo: possui as funes bsicas de manuseio de arquivos (criar novo arquivo,

UNESP Campus de Ilha Solteira 2007

teis como procurar por erros de sintaxe

um arquivo executvel deste programa. Em seguida, utilizamos o comando Executar para

basta fechar a janela e executar o programa executvel que foi gerado.

Figura 2.7 Janela que indica o progresso da compilao do arquivo de cdigo.

expresso ou comando e encontra somente o ponto-e-vrgula. Por exemplo, uma

2.4 Estrutura Bsica de um Programa em C++

UNESP Campus de Ilha Solteira 2007

Mdulo 3 Caractersticas e Definies Gerais da

3.1 Nomes e Identificadores Usados na Linguagem C++

Nomes de variveis s podem conter letras do alfabeto, nmeros e o

No podem comear com um nmero.

Nomes que comecem com um ou dois caracteres underscore (_ e __)

No possvel utilizar palavras reservadas da linguagem C++ (para mais

C++ diferencia letras maisculas e minsculas em nomes de variveis. Ou

C++ no estabelece limites para o nmero de caracteres em um nome de

3.2 Palavras Reservadas na Linguagem C++

UNESP Campus de Ilha Solteira 2007