Programação C++ Completa

Programação C++
22 de Setembro de 2008

Conteúdo
I Sobre essa apostila 4
II Informações Básicas 6
III GNU Free Documentation License 11
IV Programação C++ 20
1 O que é o C++ 21
2 Plano de ensino 22
2.1 Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2 Público Alvo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3 Pré-requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4 Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.6 Cronograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.7 Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.8 Avaliação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.9 Bibliograﬁa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3 Introdução e Breve História 26
3.1 Introdução ao C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.1 Breve História do C e do C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.2 Algumas novidades... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2 Características do C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.3 Alguns conceitos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.4 Ambientes de Desenvolvimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.5 Incompatibilidades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4 Iniciando 30
4.1 Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.2 Conceitos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.3 Símbolos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.4 Os Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.5 Precedência de Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1

CDTC Centro de Difusão de Tecnologia e Conhecimento Brasília/DF
4.6 Outros Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5 Constantes 37
5.1 Tipos de Dados Fundamentais de C++ . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3 Literais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6 I/O com Arquivos 40
6.1 Entrada/Saída de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6.2 Stringstream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
7 Estruturas de Iteração e Desvios Condicionais 44
7.1 Estruturas de Iteração . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7.1.1 Estruturas de Iteração . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7.1.2 Desvios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
7.2 Escopo de Variáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
7.3 Funções sem tipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.4 Valores Padrões nos Parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
7.5 Especificador Inline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7.6 Recursividade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.7 Declarações de Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
8 Vetores e Seqüência de Caracteres 60
8.1 Vetores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
8.2 Arrays multidimensionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
8.3 Passando Vetores Como Parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.4 Seqüencia de Caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9 Ponteiros e Memória Dinâmica 67
9.1 Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
9.1.1 Ponteiros Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
9.1.2 Ponteiros para Ponteiros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
9.1.3 Ponteiros sem tipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
9.1.4 Ponteiro Nulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
9.1.5 Ponteiros para Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
9.2 Memória Dinâmica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
10 Estruturas de Dados 78
10.1 Tipos de Dados Definidos (typedef) . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
10.2 Uniões (Unions) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
10.3 Uniões Anônimas (Anonymous unions) . . . . . . . . . . . . . . . . . . . . . . . . . 85
10.4 Enumerações (enum) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
11 Programação Orientada a Objeto - POO 88
11.1 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
11.2 Construtores e Destrutores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
11.3 Construtores Sobrecarregados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
11.4 Construtor Padrão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
11.5 Classes definidas com struct e union . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
2

11.6 Sobrecarregando Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
11.7 Friendship e Herança . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
11.7.1 Funções Friend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
11.8 Herança Múltipla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
11.9 Polimorﬁsmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
12 Templates, Namespaces 115
12.1 Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
12.2 Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
13 Exceptions e Diretivas 127
13.1 Diretivas Pré-Processamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
14 Entrada/Saída com Arquivos 137
3

Conteúdo
O conteúdo dessa apostila é fruto da compilação de diversos materiais livres publicados na in-
ternet, disponíveis em diversos sites ou originalmente produzido no CDTC em http://www.cdtc.org.br.
O formato original deste material bem como sua atualização está disponível dentro da licença
GNU Free Documentation License, cujo teor integral encontra-se aqui reproduzido na seção de
mesmo nome, tendo inclusive uma versão traduzida (não oﬁcial).
A revisão e alteração vem sendo realizada pelo CDTC (suporte@cdtc.org.br), desde outubro
de 2006. Criticas e sugestões construtivas são bem-vindas a qualquer tempo.
Autores
A autoria deste conteúdo, atividades e avaliações é de responsabilidade de Júlio Cesar Júnior
(julio@cdtc.org.br) .
O texto original faz parte do projeto Centro de Difusão de Tecnolgia e Conhecimento, que vem
sendo realizado pelo ITI em conjunto com outros parceiros institucionais, atuando em conjunto
com as universidades federais brasileiras que tem produzido e utilizado Software Livre, apoiando
inclusive a comunidade Free Software junto a outras entidades no país.
Informações adicionais podem ser obtidas atréves do email ouvidoria@cdtc.org.br, ou da
home page da entidade, através da URL http://www.cdtc.org.br.
Garantias
O material contido nesta apostila é isento de garantias e o seu uso é de inteira responsabi-
lidade do usuário/leitor. Os autores, bem como o ITI e seus parceiros, não se responsabilizam
direta ou indiretamente por qualquer prejuízo oriundo da utilização do material aqui contido.
Licença
Copyright ©2006,Júlio Cesar Júnior (julio@cdtc.org.br) .
Permission is granted to copy, distribute and/or modify this document under the terms
of the GNU Free Documentation License, Version 1.1 or any later version published by
the Free Software Foundation; with the Invariant Chapter being SOBRE ESSA APOS-
TILA. A copy of the license is included in the section entitled GNU Free Documentation
License.
5

Parte II
Informações Básicas
6

Sobre o CDTC
Objetivo Geral
O Projeto CDTC visa a promoção e o desenvolvimento de ações que incentivem a dissemina-
ção de soluções que utilizem padrões abertos e não proprietários de tecnologia, em proveito do
desenvolvimento social, cultural, político, tecnológico e econômico da sociedade brasileira.
Objetivo Específico
Auxiliar o Governo Federal na implantação do plano nacional de software não-proprietário e
de código fonte aberto, identificando e mobilizando grupos de formadores de opinião dentre os
servidores públicos e agentes políticos da União Federal, estimulando e incentivando o mercado
nacional a adotar novos modelos de negócio da tecnologia da informação e de novos negócios
de comunicação com base em software não-proprietário e de código fonte aberto, oferecendo
treinamento específico para técnicos, profissionais de suporte e funcionários públicos usuários,
criando grupos de funcionários públicos que irão treinar outros funcionários públicos e atuar como
incentivadores e defensores de produtos de software não proprietários e código fonte aberto, ofe-
recendo conteúdo técnico on-line para serviços de suporte, ferramentas para desenvolvimento de
produtos de software não proprietários e de seu código fonte livre, articulando redes de terceiros
(dentro e fora do governo) fornecedoras de educação, pesquisa, desenvolvimento e teste de pro-
dutos de software livre.
Guia do aluno
Neste guia, você terá reunidas uma série de informações importantes para que você comece
seu curso. São elas:
• Licenças para cópia de material disponível
• Os 10 mandamentos do aluno de Educação a Distância
• Como participar dos fóruns e da wikipédia
• Primeiros passos
É muito importante que você entre em contato com TODAS estas informações, seguindo o
roteiro acima.
Licença
Copyright ©2006, Júlio Cesar Júnior (julio@cdtc.org.br) .
7

É dada permissão para copiar, distribuir e/ou modiﬁcar este documento sob os termos
da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior
publicada pela Free Software Foundation; com o Capítulo Invariante SOBRE ESSA
APOSTILA. Uma cópia da licença está inclusa na seção entitulada "Licença de Docu-
mentação Livre GNU".
Os 10 mandamentos do aluno de educação online
• 1. Acesso a Internet: ter endereço eletrônico, um provedor e um equipamento adequado é
pré-requisito para a participação nos cursos a distância.
• 2. Habilidade e disposição para operar programas: ter conhecimentos básicos de Informá-
tica é necessário para poder executar as tarefas.
• 3. Vontade para aprender colaborativamente: interagir, ser participativo no ensino a distân-
cia conta muitos pontos, pois irá colaborar para o processo ensino-aprendizagem pessoal,
dos colegas e dos professores.
• 4. Comportamentos compatíveis com a etiqueta: mostrar-se interessado em conhecer seus
colegas de turma respeitando-os e fazendo ser respeitado pelo mesmo.
• 5. Organização pessoal: planejar e organizar tudo é fundamental para facilitar a sua revisão
e a sua recuperação de materiais.
• 6. Vontade para realizar as atividades no tempo correto: anotar todas as suas obrigações e
realizá-las em tempo real.
• 7. Curiosidade e abertura para inovações: aceitar novas idéias e inovar sempre.
• 8. Flexibilidade e adaptação: requisitos necessário a mudança tecnológica, aprendizagens
e descobertas.
• 9. Objetividade em sua comunicação: comunicar-se de forma clara, breve e transparente é
ponto-chave na comunicação pela Internet.
• 10. Responsabilidade: ser responsável por seu próprio aprendizado. O ambiente virtual não
controla a sua dedicação, mas reﬂete os resultados do seu esforço e da sua colaboração.
Como participar dos fóruns e Wikipédia
Você tem um problema e precisa de ajuda?
Podemos te ajudar de 2 formas:
A primeira é o uso dos fóruns de notícias e de dúvidas gerais que se distinguem pelo uso:
O fórum de notícias tem por objetivo disponibilizar um meio de acesso rápido a informações
que sejam pertinentes ao curso (avisos, notícias). As mensagens postadas nele são enviadas a
8

todos participantes. Assim, se o monitor ou algum outro participante tiver uma informação que
interesse ao grupo, favor postá-la aqui.
Porém, se o que você deseja é resolver alguma dúvida ou discutir algum tópico específico do
curso, é recomendado que você faça uso do Fórum de dúvidas gerais que lhe dá recursos mais
efetivos para esta prática.
. O fórum de dúvidas gerais tem por objetivo disponibilizar um meio fácil, rápido e interativo
para solucionar suas dúvidas e trocar experiências. As mensagens postadas nele são enviadas
a todos participantes do curso. Assim, fica muito mais fácil obter respostas, já que todos podem
ajudar.
Se você receber uma mensagem com algum tópico que saiba responder, não se preocupe com a
formalização ou a gramática. Responda! E não se esqueça de que antes de abrir um novo tópico
é recomendável ver se a sua pergunta já foi feita por outro participante.
A segunda forma se dá pelas Wikis:
Uma wiki é uma página web que pode ser editada colaborativamente, ou seja, qualquer par-
ticipante pode inserir, editar, apagar textos. As versões antigas vão sendo arquivadas e podem
ser recuperadas a qualquer momento que um dos participantes o desejar. Assim, ela oferece um
ótimo suporte a processos de aprendizagem colaborativa. A maior wiki na web é o site "Wikipé-
dia", uma experiência grandiosa de construção de uma enciclopédia de forma colaborativa, por
pessoas de todas as partes do mundo. Acesse-a em português pelos links:
• Página principal da Wiki - http://pt.wikipedia.org/wiki/
Agradecemos antecipadamente a sua colaboração com a aprendizagem do grupo!
Primeiros Passos
Para uma melhor aprendizagem é recomendável que você siga os seguintes passos:
• Ler o Plano de Ensino e entender a que seu curso se dispõe a ensinar;
• Ler a Ambientação do Moodle para aprender a navegar neste ambiente e se utilizar das
ferramentas básicas do mesmo;
• Entrar nas lições seguindo a seqüência descrita no Plano de Ensino;
• Qualquer dúvida, reporte ao Fórum de Dúvidas Gerais.
Perfil do Tutor
Segue-se uma descrição do tutor ideal, baseada no feedback de alunos e de tutores.
O tutor ideal é um modelo de excelência: é consistente, justo e profissional nos respectivos
valores e atitudes, incentiva mas é honesto, imparcial, amável, positivo, respeitador, aceita as
idéias dos estudantes, é paciente, pessoal, tolerante, apreciativo, compreensivo e pronto a ajudar.
9

A classificação por um tutor desta natureza proporciona o melhor feedback possível, é crucial, e,
para a maior parte dos alunos, constitui o ponto central do processo de aprendizagem.’ Este tutor
ou instrutor:
• fornece explicações claras acerca do que ele espera, e do estilo de classificação que irá
utilizar;
• gosta que lhe façam perguntas adicionais;
• identifica as nossas falhas, mas corrige-as amavelmente’, diz um estudante, ’e explica por-
que motivo a classificação foi ou não foi atribuída’;
• tece comentários completos e construtivos, mas de forma agradável (em contraste com um
reparo de um estudante: ’os comentários deixam-nos com uma sensação de crítica, de
ameaça e de nervosismo’)
• dá uma ajuda complementar para encorajar um estudante em dificuldade;
• esclarece pontos que não foram entendidos, ou corretamente aprendidos anteriormente;
• ajuda o estudante a alcançar os seus objetivos;
• é flexível quando necessário;
• mostra um interesse genuíno em motivar os alunos (mesmo os principiantes e, por isso,
talvez numa fase menos interessante para o tutor);
• escreve todas as correções de forma legível e com um nível de pormenorização adequado;
• acima de tudo, devolve os trabalhos rapidamente;
10

Parte III
GNU Free Documentation License
11

(Traduzido pelo João S. O. Bueno através do CIPSGA em 2001)
Esta é uma tradução não oficial da Licençaa de Documentação Livre GNU em Português
Brasileiro. Ela não é publicada pela Free Software Foundation, e não se aplica legalmente a dis-
tribuição de textos que usem a GFDL - apenas o texto original em Inglês da GNU FDL faz isso.
Entretanto, nós esperamos que esta tradução ajude falantes de português a entenderem melhor
a GFDL.
This is an unofficial translation of the GNU General Documentation License into Brazilian Por-
tuguese. It was not published by the Free Software Foundation, and does not legally state the
distribution terms for software that uses the GFDL–only the original English text of the GFDL does
that. However, we hope that this translation will help Portuguese speakers understand the GFDL
better.
Licença de Documentação Livre GNU Versão 1.1, Março de 2000
Copyright (C) 2000 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
É permitido a qualquer um copiar e distribuir cópias exatas deste documento de licença, mas
não é permitido alterá-lo.
INTRODUÇÃO
O propósito desta Licença é deixar um manual, livro-texto ou outro documento escrito "livre"no
sentido de liberdade: assegurar a qualquer um a efetiva liberdade de copiá-lo ou redistribui-lo,
com ou sem modificações, comercialmente ou não. Secundariamente, esta Licença mantém
para o autor e editor uma forma de ter crédito por seu trabalho, sem ser considerado responsável
pelas modificações feitas por terceiros.
Esta Licença é um tipo de "copyleft"("direitos revertidos"), o que significa que derivações do
documento precisam ser livres no mesmo sentido. Ela complementa a GNU Licença Pública Ge-
ral (GNU GPL), que é um copyleft para software livre.
Nós fizemos esta Licença para que seja usada em manuais de software livre, por que software
livre precisa de documentação livre: um programa livre deve ser acompanhado de manuais que
provenham as mesmas liberdades que o software possui. Mas esta Licença não está restrita a
manuais de software; ela pode ser usada para qualquer trabalho em texto, independentemente
do assunto ou se ele é publicado como um livro impresso. Nós recomendamos esta Licença prin-
cipalmente para trabalhos cujo propósito seja de introdução ou referência.
APLICABILIDADE E DEFINIÇÕES
Esta Licença se aplica a qualquer manual ou outro texto que contenha uma nota colocada pelo
detentor dos direitos autorais dizendo que ele pode ser distribuído sob os termos desta Licença.
12

O "Documento"abaixo se refere a qualquer manual ou texto. Qualquer pessoa do público é um
licenciado e é referida como "você".
Uma "Versão Modificada"do Documento se refere a qualquer trabalho contendo o documento
ou uma parte dele, quer copiada exatamente, quer com modificações e/ou traduzida em outra
língua.
Uma "Seção Secundária"é um apêndice ou uma seção inicial do Documento que trata ex-
clusivamente da relação dos editores ou dos autores do Documento com o assunto geral do
Documento (ou assuntos relacionados) e não contém nada que poderia ser incluído diretamente
nesse assunto geral (Por exemplo, se o Documento é em parte um livro texto de matemática, a
Seção Secundária pode não explicar nada de matemática).
Essa relação poderia ser uma questão de ligação histórica com o assunto, ou matérias relaci-
onadas, ou de posições legais, comerciais, filosóficas, éticas ou políticas relacionadas ao mesmo.
As "Seções Invariantes"são certas Seções Secundárias cujos títulos são designados, como
sendo de Seções Invariantes, na nota que diz que o Documento é publicado sob esta Licença.
Os "Textos de Capa"são certos trechos curtos de texto que são listados, como Textos de Capa
Frontal ou Textos da Quarta Capa, na nota que diz que o texto é publicado sob esta Licença.
Uma cópia "Transparente"do Documento significa uma cópia que pode ser lida automatica-
mente, representada num formato cuja especificação esteja disponível ao público geral, cujos
conteúdos possam ser vistos e editados diretamente e sem mecanismos especiais com editores
de texto genéricos ou (para imagens compostas de pixels) programas de pintura genéricos ou
(para desenhos) por algum editor de desenhos grandemente difundido, e que seja passível de
servir como entrada a formatadores de texto ou para tradução automática para uma variedade
de formatos que sirvam de entrada para formatadores de texto. Uma cópia feita em um formato
de arquivo outrossim Transparente cuja constituição tenha sido projetada para atrapalhar ou de-
sencorajar modificações subsequentes pelos leitores não é Transparente. Uma cópia que não é
"Transparente"é chamada de "Opaca".
Exemplos de formatos que podem ser usados para cópias Transparentes incluem ASCII sim-
ples sem marcações, formato de entrada do Texinfo, formato de entrada do LaTex, SGML ou XML
usando uma DTD disponibilizada publicamente, e HTML simples, compatível com os padrões, e
projetado para ser modificado por pessoas. Formatos opacos incluem PostScript, PDF, formatos
proprietários que podem ser lidos e editados apenas com processadores de texto proprietários,
SGML ou XML para os quais a DTD e/ou ferramentas de processamento e edição não estejam
disponíveis para o público, e HTML gerado automaticamente por alguns editores de texto com
finalidade apenas de saída.
A "Página do Título"significa, para um livro impresso, a página do título propriamente dita,
mais quaisquer páginas subsequentes quantas forem necessárias para conter, de forma legível,
o material que esta Licença requer que apareça na página do título. Para trabalhos que não
tenham uma página do título, "Página do Título"significa o texto próximo da aparição mais proe-
minente do título do trabalho, precedendo o início do corpo do texto.
13

FAZENDO CÓPIAS EXATAS
Você pode copiar e distribuir o Documento em qualquer meio, de forma comercial ou não
comercial, desde que esta Licença, as notas de copyright, e a nota de licença dizendo que esta
Licença se aplica ao documento estejam reproduzidas em todas as cópias, e que você não acres-
cente nenhuma outra condição, quaisquer que sejam, às desta Licença.
Você não pode usar medidas técnicas para obstruir ou controlar a leitura ou confecção de
cópias subsequentes das cópias que você fizer ou distribuir. Entretanto, você pode aceitar com-
pensação em troca de cópias. Se você distribuir uma quantidade grande o suficiente de cópias,
você também precisa respeitar as condições da seção 3.
Você também pode emprestar cópias, sob as mesmas condições colocadas acima, e também
pode exibir cópias publicamente.
FAZENDO CÓPIAS EM QUANTIDADE
Se você publicar cópias do Documento em número maior que 100, e a nota de licença do
Documento obrigar Textos de Capa, você precisará incluir as cópias em capas que tragam, clara
e legivelmente, todos esses Textos de Capa: Textos de Capa da Frente na capa da frente, e
Textos da Quarta Capa na capa de trás. Ambas as capas também precisam identificar clara e
legivelmente você como o editor dessas cópias. A capa da frente precisa apresentar o titulo com-
pleto com todas as palavras do título igualmente proeminentes e visíveis. Você pode adicionar
outros materiais às capas. Fazer cópias com modificações limitadas às capas, tanto quanto estas
preservem o título do documento e satisfaçam a essas condições, pode ser tratado como cópia
exata em outros aspectos.
Se os textos requeridos em qualquer das capas for muito volumoso para caber de forma
legível, você deve colocar os primeiros (tantos quantos couberem de forma razoável) na capa
verdadeira, e continuar os outros nas páginas adjacentes.
Se você publicar ou distribuir cópias Opacas do Documento em número maior que 100, você
precisa ou incluir uma cópia Transparente que possa ser lida automaticamente com cada cópia
Opaca, ou informar, em ou com, cada cópia Opaca a localização de uma cópia Transparente
completa do Documento acessível publicamente em uma rede de computadores, a qual o público
usuário de redes tenha acesso a download gratuito e anônimo utilizando padrões públicos de
protocolos de rede. Se você utilizar o segundo método, você precisará tomar cuidados razoavel-
mente prudentes, quando iniciar a distribuição de cópias Opacas em quantidade, para assegurar
que esta cópia Transparente vai permanecer acessível desta forma na localização especificada
por pelo menos um ano depois da última vez em que você distribuir uma cópia Opaca (direta-
mente ou através de seus agentes ou distribuidores) daquela edição para o público.
É pedido, mas não é obrigatório, que você contate os autores do Documento bem antes de
redistribuir qualquer grande número de cópias, para lhes dar uma oportunidade de prover você
com uma versão atualizada do Documento.
14

MODIFICAÇÕES
Você pode copiar e distribuir uma Versão Modificada do Documento sob as condições das se-
ções 2 e 3 acima, desde que você publique a Versão Modificada estritamente sob esta Licença,
com a Versão Modificada tomando o papel do Documento, de forma a licenciar a distribuição
e modificação da Versão Modificada para quem quer que possua uma cópia da mesma. Além
disso, você precisa fazer o seguinte na versão modificada:
A. Usar na Página de Título (e nas capas, se houver alguma) um título distinto daquele do Do-
cumento, e daqueles de versões anteriores (que deveriam, se houvesse algum, estarem listados
na seção "Histórico do Documento"). Você pode usar o mesmo título de uma versão anterior se
o editor original daquela versão lhe der permissão;
B. Listar na Página de Título, como autores, uma ou mais das pessoas ou entidades responsá-
veis pela autoria das modificações na Versão Modificada, conjuntamente com pelo menos cinco
dos autores principais do Documento (todos os seus autores principais, se ele tiver menos que
cinco);
C. Colocar na Página de Título o nome do editor da Versão Modificada, como o editor;
D. Preservar todas as notas de copyright do Documento;
E. Adicionar uma nota de copyright apropriada para suas próprias modificações adjacente às
outras notas de copyright;
F. Incluir, imediatamente depois das notas de copyright, uma nota de licença dando ao público
o direito de usar a Versão Modificada sob os termos desta Licença, na forma mostrada no tópico
abaixo;
G. Preservar nessa nota de licença as listas completas das Seções Invariantes e os Textos de
Capa requeridos dados na nota de licença do Documento;
H. Incluir uma cópia inalterada desta Licença;
I. Preservar a seção entitulada "Histórico", e seu título, e adicionar à mesma um item dizendo
pelo menos o título, ano, novos autores e editor da Versão Modificada como dados na Página de
Título. Se não houver uma sessão denominada "Histórico"no Documento, criar uma dizendo o
título, ano, autores, e editor do Documento como dados em sua Página de Título, então adicionar
um item descrevendo a Versão Modificada, tal como descrito na sentença anterior;
J. Preservar o endereço de rede, se algum, dado no Documento para acesso público a uma
cópia Transparente do Documento, e da mesma forma, as localizações de rede dadas no Docu-
mento para as versões anteriores em que ele foi baseado. Elas podem ser colocadas na seção
"Histórico". Você pode omitir uma localização na rede para um trabalho que tenha sido publicado
pelo menos quatro anos antes do Documento, ou se o editor original da versão a que ela se refira
der sua permissão;
K. Em qualquer seção entitulada "Agradecimentos"ou "Dedicatórias", preservar o título da
15

seção e preservar a seção em toda substância e fim de cada um dos agradecimentos de contri-
buidores e/ou dedicatórias dados;
L. Preservar todas as Seções Invariantes do Documento, inalteradas em seus textos ou em
seus títulos. Números de seção ou equivalentes não são considerados parte dos títulos da seção;
M. Apagar qualquer seção entitulada "Endossos". Tal sessão não pode ser incluída na Versão
Modificada;
N. Não reentitular qualquer seção existente com o título "Endossos"ou com qualquer outro
título dado a uma Seção Invariante.
Se a Versão Modificada incluir novas seções iniciais ou apêndices que se qualifiquem como
Seções Secundárias e não contenham nenhum material copiado do Documento, você pode optar
por designar alguma ou todas aquelas seções como invariantes. Para fazer isso, adicione seus
títulos à lista de Seções Invariantes na nota de licença da Versão Modificada. Esses títulos preci-
sam ser diferentes de qualquer outro título de seção.
Você pode adicionar uma seção entitulada "Endossos", desde que ela não contenha qual-
quer coisa além de endossos da sua Versão Modificada por várias pessoas ou entidades - por
exemplo, declarações de revisores ou de que o texto foi aprovado por uma organização como a
definição oficial de um padrão.
Você pode adicionar uma passagem de até cinco palavras como um Texto de Capa da Frente
, e uma passagem de até 25 palavras como um Texto de Quarta Capa, ao final da lista de Textos
de Capa na Versão Modificada. Somente uma passagem de Texto da Capa da Frente e uma de
Texto da Quarta Capa podem ser adicionados por (ou por acordos feitos por) qualquer entidade.
Se o Documento já incluir um texto de capa para a mesma capa, adicionado previamente por
você ou por acordo feito com alguma entidade para a qual você esteja agindo, você não pode
adicionar um outro; mas você pode trocar o antigo, com permissão explícita do editor anterior que
adicionou a passagem antiga.
O(s) autor(es) e editor(es) do Documento não dão permissão por esta Licença para que seus
nomes sejam usados para publicidade ou para assegurar ou implicar endossamento de qualquer
Versão Modificada.
COMBINANDO DOCUMENTOS
Você pode combinar o Documento com outros documentos publicados sob esta Licença, sob
os termos definidos na seção 4 acima para versões modificadas, desde que você inclua na com-
binação todas as Seções Invariantes de todos os documentos originais, sem modificações, e liste
todas elas como Seções Invariantes de seu trabalho combinado em sua nota de licença.
O trabalho combinado precisa conter apenas uma cópia desta Licença, e Seções Invariantes
Idênticas com multiplas ocorrências podem ser substituídas por apenas uma cópia. Se houver
múltiplas Seções Invariantes com o mesmo nome mas com conteúdos distintos, faça o título de
16

cada seção único adicionando ao final do mesmo, em parênteses, o nome do autor ou editor
origianl daquela seção, se for conhecido, ou um número que seja único. Faça o mesmo ajuste
nos títulos de seção na lista de Seções Invariantes nota de licença do trabalho combinado.
Na combinação, você precisa combinar quaisquer seções entituladas "Histórico"dos diver-
sos documentos originais, formando uma seção entitulada "Histórico"; da mesma forma combine
quaisquer seções entituladas "Agradecimentos", ou "Dedicatórias". Você precisa apagar todas as
seções entituladas como "Endosso".
COLETÂNEAS DE DOCUMENTOS
Você pode fazer uma coletânea consitindo do Documento e outros documentos publicados
sob esta Licença, e substituir as cópias individuais desta Licença nos vários documentos com
uma única cópia incluida na coletânea, desde que você siga as regras desta Licença para cópia
exata de cada um dos Documentos em todos os outros aspectos.
Você pode extrair um único documento de tal coletânea, e distribuí-lo individualmente sob
esta Licença, desde que você insira uma cópia desta Licença no documento extraído, e siga esta
Licença em todos os outros aspectos relacionados à cópia exata daquele documento.
AGREGAÇÃO COM TRABALHOS INDEPENDENTES
Uma compilação do Documento ou derivados dele com outros trabalhos ou documentos se-
parados e independentes, em um volume ou mídia de distribuição, não conta como uma Ver-
são Modificada do Documento, desde que nenhum copyright de compilação seja reclamado pela
compilação. Tal compilação é chamada um "agregado", e esta Licença não se aplica aos outros
trabalhos auto-contidos compilados junto com o Documento, só por conta de terem sido assim
compilados, e eles não são trabalhos derivados do Documento.
Se o requerido para o Texto de Capa na seção 3 for aplicável a essas cópias do Documento,
então, se o Documento constituir menos de um quarto de todo o agregado, os Textos de Capa
do Documento podem ser colocados em capas adjacentes ao Documento dentro do agregado.
Senão eles precisarão aparecer nas capas de todo o agregado.
TRADUÇÃO
Tradução é considerada como um tipo de modificação, então você pode distribuir traduções
do Documento sob os termos da seção 4. A substituição de Seções Invariantes por traduções
requer uma permissão especial dos detentores do copyright das mesmas, mas você pode incluir
traduções de algumas ou de todas as Seções Invariantes em adição às versões orignais dessas
Seções Invariantes. Você pode incluir uma tradução desta Licença desde que você também in-
clua a versão original em Inglês desta Licença. No caso de discordância entre a tradução e a
17

versão original em Inglês desta Licença, a versão original em Inglês prevalecerá.
TÉRMINO
Você não pode copiar, modificar, sublicenciar, ou distribuir o Documento exceto como expres-
samente especificado sob esta Licença. Qualquer outra tentativa de copiar, modificar, sublicen-
ciar, ou distribuir o Documento é nula, e resultará automaticamente no término de seus direitos
sob esta Licença. Entretanto, terceiros que tenham recebido cópias, ou direitos de você sob esta
Licença não terão suas licenças terminadas, tanto quanto esses terceiros permaneçam em total
acordo com esta Licença.
REVISÕES FUTURAS DESTA LICENÇA
A Free Software Foundation pode publicar novas versões revisadas da Licença de Documen-
tação Livre GNU de tempos em tempos. Tais novas versões serão similares em espirito à versão
presente, mas podem diferir em detalhes ao abordarem novos porblemas e preocupações. Veja
http://www.gnu.org/copyleft/.
A cada versão da Licença é dado um número de versão distinto. Se o Documento especificar
que uma versão particular desta Licença "ou qualquer versão posterior"se aplica ao mesmo, você
tem a opção de seguir os termos e condições daquela versão específica, ou de qualquer versão
posterior que tenha sido publicada (não como rascunho) pela Free Software Foundation. Se o
Documento não especificar um número de Versão desta Licença, você pode escolher qualquer
versão já publicada (não como rascunho) pela Free Software Foundation.
ADENDO: Como usar esta Licença para seus documentos
Para usar esta Licença num documento que você escreveu, inclua uma cópia desta Licença
no documento e ponha as seguintes notas de copyright e licenças logo após a página de título:
Copyright (c) ANO SEU NOME.
É dada permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença
de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior publicada pela Free Soft-
ware Foundation; com as Seções Invariantes sendo LISTE SEUS TÍTULOS, com os Textos da
Capa da Frente sendo LISTE, e com os Textos da Quarta-Capa sendo LISTE. Uma cópia da li-
cença está inclusa na seção entitulada "Licença de Documentação Livre GNU".
Se você não tiver nenhuma Seção Invariante, escreva "sem Seções Invariantes"ao invés de
dizer quais são invariantes. Se você não tiver Textos de Capa da Frente, escreva "sem Textos de
Capa da Frente"ao invés de "com os Textos de Capa da Frente sendo LISTE"; o mesmo para os
Textos da Quarta Capa.
Se o seu documento contiver exemplos não triviais de código de programas, nós recomenda-
mos a publicação desses exemplos em paralelo sob a sua escolha de licença de software livre,
18

tal como a GNU General Public License, para permitir o seu uso em software livre.
19

Capítulo 1
O que é o C++
O C++ é uma linguagem de programação de alto nível com facilidades para o uso em baixo
nível (herdados do C), multiparadigma e de uso geral. Desde os anos 1990 é uma das linguagens
comerciais mais populares, sendo bastante usada também na academia por seu grande desem-
penho e base de utilizadores.
21

Capítulo 2
Plano de ensino
2.1 Objetivo
Qualiﬁcar técnicos e programadores na linguagem de programação c++.
2.2 Público Alvo
Técnicos e Programadores que desejam trabalhar com C++.
2.3 Pré-requisitos
Os usuários deverão ser, necessariamente, indicados por empresas públicas e ter conheci-
mento básico acerca da lógica de programação.
2.4 Descrição
O curso de Introdução à Programação C++ será realizado na modalidade EAD e utilizará
a plataforma Moodle como ferramenta de aprendizagem. Ele é composto de um módulo de
aprendizado que será dado na primeira semana e um módulo de avaliação que será dado na
segunda semana. O material didático estará disponível on-line de acordo com as datas pré-
estabelecidas no calendário.
2.5 Metodologia
O curso está dividido da seguinte maneira:
2.6 Cronograma
• Introdução e Breve História;
• Iniciando;
22

• Operadores, Identificadores e Símbolos;
• Constantes;
• Entrada e Saída de Dados;
• Estruturas de Iteração e Desvios Condicionais;
• Funções;
• Vetores e Seqüência de Caracteres;
• Ponteiros e Memória Dinâmica;
• Estruturas de Dados;
• Programação Orientada a Objeto;
• Programação Orientada a Objeto - continuação;
• Finalizando POO;
• Templates, Namespaces;
• Exceptions, Type Casting, Diretivas;
• I/O com arquivos;
• Avaliação de aprendizagem;
• Avaliação do curso;
As lições contém o conteúdo principal. Elas poderão ser acessadas quantas vezes forem ne-
cessárias, desde que esteja dentro da semana programada. Ao final de uma lição, você receberá
uma nota de acordo com o seu desempenho. Responda com atenção às perguntas de cada lição,
pois elas serão consideradas na sua nota final. Caso sua nota numa determinada lição for menor
do que 6.0, sugerimos que você faça novamente esta lição.
Ao final do curso será disponibilizada a avaliação referente ao curso. Tanto as notas das lições
quanto a da avaliação serão consideradas para a nota final. Todos os módulos ficarão visíveis
para que possam ser consultados durante a avaliação final.
Aconselhamos a leitura da "Ambientação do Moodle"para que você conheça a plataforma de
Ensino a Distância, evitando dificuldades advindas do "desconhecimento"sobre a mesma.
Os instrutores estarão a sua disposição ao longo de todo curso. Qualquer dúvida deverá ser
enviada no fórum. Diariamente os monitores darão respostas e esclarecimentos.
2.7 Programa
O curso de Nagios oferecerá o seguinte conteúdo:
• Introdução e Breve História;
23

• Iniciando;
• Operadores, Identificadores e Símbolos;
• Constantes;
• Entrada e Saída de Dados;
• Estruturas de Iteração e Desvios Condicionais;
• Funções;
• Vetores e Seqüência de Caracteres;
• Ponteiros e Memória Dinâmica;
• Estruturas de Dados;
• Programação Orientada a Objeto;
• Programação Orientada a Objeto - continuação;
• Finalizando POO;
• Templates, Namespaces;
• Exceptions, Type Casting, Diretivas;
• I/O com arquivos;
2.8 Avaliação
Toda a avaliação será feita on-line.
Aspectos a serem considerados na avaliação:
• Iniciativa e autonomia no processo de aprendizagem e de produção de conhecimento;
• Capacidade de pesquisa e abordagem criativa na solução dos problemas apresentados.
Instrumentos de avaliação:
• Participação ativa nas atividades programadas.
• Avaliação ao final do curso.
• O participante fará várias avaliações referente ao conteúdo do curso. Para a aprovação e
obtenção do certificado o participante deverá obter nota final maior ou igual a 6.0 de acordo
com a fórmula abaixo:
• Nota Final = ((ML x 7) + (AF x 3)) / 10 = Média aritmética das lições
• AF = Avaliações
24

2.9 Bibliograﬁa
• http://www.dcc.unicamp.br/ cmrubira/aacesta/cpp/cpp15.html
• http://psantos.zi-yu.com/wiki.aspx?topic=PRE.CppTutorial
• http://pt.wikipedia.org/wiki/C
• http://www.cplusplus.com/doc/tutorial/
• http://www.lmpt.ufsc.br/ andre (André Duarte Bueno, UFSC-LPMT-NPC)
25

Capítulo 3
Introdução e Breve História
3.1 Introdução ao C++
O C++ é uma linguagem de programação de alto nível(1) com facilidades para o uso em baixo
nível(2) (herdados do C), multiparadigma e de uso geral. Desde os anos 1990 é uma das lin-
guagens comerciais mais populares, sendo bastante usada também na academia por seu grande
desempenho e base de utilizadores.
Durante sua fase inicial de desenvolvimento, a linguagem era chamada "novo C"ou ainda "C
com classes". O termo "C++"é creditado a Rick Mascitti, e foi utilizado pela primeira vez em de-
zembro de 1983. Ele é uma referência ao operador de incremento ++, signiﬁcando um acréscimo
(uma evolução) à linguagem C.
3.1.1 Breve História do C e do C++
A linguagem C foi desenvolvida por Denis Richard em 1972 e teve origem na linguagem B,
desenvolvida por Ken Thompson, em 1970. C teve sua divulgação e sucesso graças à vendagem
do livro "The C Programmign Language"e ao fato de ser independente de hardware. Vale notar
que C e o Sistema Operacional Unix foram desenvolvidos conjuntamente, o que faz que ambien-
tes Unix, Linux e MacOS X e a linguagem C tenham uma interação forte.
Figura 3.1: Bjarne Stroustrup
26

Em 1980, Bjarne Stroustrup desenvolveu o C++ no Bell Labs como um adicional à linguagem
C. Hoje em dia quase todas as grandes empresas que desenvolvem softwares usam C++. Mas a
pergunta principal é: "Devemos aprender primeiro o C e depois C++ ou ir direto ao C++? Bjarne
Stroustrup afirmou em 1999: "estou firmemente convencido de que é melhor ir direto ao C++".
3.1.2 Algumas novidades...
A linguagem C++ consegue agrupar uma funcionalidade que envolve formulações como clas-
ses, altamente abstratas, que permitem um trabalho de alto nível e formulações de baixo nível.
Com isso é uma das melhores LPs (Linguagens de Programação) que existem. As principais
novidades existentes no C++ em relação ao C são:
Uso de classes, funções, inline, conversão de tipo, verificação de argumentos de uma função,
operadores para gerenciamento de memória, referências, constantes, sobrecarga de operador,
sobrecarga de funções, polimorfismo, templates (gabaritos), tratamento de exceções e espaços
de nomes (namespace). Também podemos citar o aumento da produtividade, maior reaproveita-
mento de código, maior qualidade geral do projeto, facilidade de extensão e manutenção. Maior
compreensão geral pela equipe de desenvolvimento, já que com C++ um único programador é
apto gerenciar uma quantidade maior do código.
Pode-se dizer que C++ foi a única linguagem entre tantas outras que obteve sucesso como uma
sucessora à linguagem C, inclusive servindo de inspiração para outras linguagens como Java, a
IDL de CORBA e C#.
(1) Linguagem de programação de baixo nível, próximas a máquina, como Assembly.
(2)Linguagem de programação de alto nível, no nível da especificação de algoritmos, como Pas-
cal, Fortran, Java, C, C++.
OBS: ainda temos as Linguagem de programação de muito alto nível, no nível da especifica-
ção declarativa, como SQL.
3.2 Características do C++
Algumas regras que o próprio Bjarne Stroustrup utilizou para desenvolver a linguagem são:
• C++ é desenvolvido para ser uma linguagem tipada (forte uso de tipos dinâmicos) estatica-
mente e de proposta geral que é tão eficiente e portável quanto o C;
• C++ é desenvolvido para suportar múltiplos paradigmas de linguagem (Orientada a Objetos,
Estruturada, Funcional, lógica, etc);
• C++ é desenvolvido para fornecer ao programador escolhas, mesmo que seja possível ao
programador escolher a opção errada;
27

• C++ é desenvolvido para ser o quanto mais compatível com C possível, fornecendo transi-
ções simples para código C;
• C++ evita fornecer facilidades que são específicas a certas plataformas ou a certos grupos
de desenvolvedores;
• C++ não exige overhead (tempo de processamento excessivo) para facilidades que não são
utilizadas;
• C++ é desenvolvido para ser utilizado mesmo sem um ambiente de desenvolvimento sofis-
ticado.
3.3 Alguns conceitos básicos
Debuger
Ajuda o programador a encontrar os erros de programação, famosos bugs.
Profiler
Ajuda a identificar os pontos onde o programa está sendo lento, ou que consomem mais tempo;
com isso pode-se melhorar a qualidade do programa e sua velocidade. Apenas rodamos o pro-
grama dentro do profiler e analisamos os resultados de tempo de execução de cada método ou
função.
Linker
Transforma um ou mais arquivos *.o (no Unix/Linux) em um arquivo executável. Os arquivos que
serão unidos são definidos em um arquivo de projeto ou em um arquivo makefile. No linux, depois
de linkado, um programa tem um arquivp ’a.out’. Os erros de ligação são detectados pelo linker.
Compilador
Encontra erros de sintaxe do programa e realiza a tradução do código em linguagem de máquina.
Após o processo, o programa passa a ter um arquivo ’*.o’.
3.4 Ambientes de Desenvolvimento
Antes de começarmos a teoria propriamente dita, abaixo serão listados os principais am-
bientes de desenvolvimento C++, sejam eles compiladores ou ambientes de desenvolvimento
integrado (IDE) que rodam em ambiente Linux:
28

G++ Um componente do GCC, compilador padrão do Projecto GNU.
Intel C++ Produz código otimizado para processadores Intel.
C++ Builder Ferramenta da Borland que oferece versões antigas gratuitas
sem presença de IDE. Possui integração com Delphi.
Comeau C++ Pode ser experimentado pela Internet.
Eclipse Disponível para C++ através da extensão CDT.
Code::Blocks Ambiente aberto e multi-plataforma, em sua versão para Windows utiliza
o compilador MinGW, apesar de também suportar outros compiladores
como o Visual C++, Digital Mars, Borland C++ 5.5 e Open Watcom.
Não mostrarei métodos de instalação no curso pois, além de serem extremamente triviais, são
muitos os compiladores existentes. Para dúvidas, entre em contato com os monitores no fórum
de dúvidas.
3.5 Incompatibilidades
Considerar o C++ como um superconjunto, uma linguagem que implementa completamente o
C e adiciona novas funcionalidades ao C é um erro. Grande parte do código C pode ser perfei-
tamente compilado em C++, mas existem algumas diferenças sintáticas e semânticas entre elas
que tornam alguns trechos de código C válidos em código C++ inválido, ou códigos que exibem
comportamentos diferentes em cada linguagem. A mais comum é que C permite conversão implí-
cita entre o tipo void* para ponteiros para outros tipos, algo que o C++ não permite. Seria inválido
então o seguinte código em C++:
ÒØ ¶ Ñ ÐÐÓ
´× Þ Ó ´ ÒØµ ¶ µ
, a não ser que explicitemos a conversão:
ÒØ ¶ ´ ÒØ ¶µ Ñ ÐÐÓ
´× Þ Ó ´ ÒØµ ¶ µ
Outro ponto é o fato do C++ adicionar novas palavras reservadas, como new e class, que
podem ser utilizadas como identiﬁcadores (por exemplo nomes de variáveis) em C, gerando in-
compatibilidade.
29

Capítulo 4
Iniciando
4.1 Layout
O desenvolvimento de um programa em c++ começa com a definição do arquivo de projeto.
Em seguida são criados os arquivos de cabeçalho (*.h) e os arquivos de implementação (*.cpp).
• 1) O arquivo de projeto define quais arquivos fazem parte do programa além de definir
em que seqüência devem ser compilados. Contém, então, uma lista com os nomes dods
arquivos de cabeçalho (*.h), de implementação (*.cpp) e a forma como os mesmos serão
compilados. A organização do programa separando o código em vários arquivos facilita a
manutenção e possibilita um maior entendimento da estrutura dos programas. Além disso,
o processo de compilação fica mais rápido;
• 2) Arquivos de cabeçalho armazenam a definição da classe, e têm a extensão *.h. ;
• 3) Arquivos de implementação armazenam as definições dos métodos das classes, e têm a
extensão *.cpp. ;
• 4) É necessário um arquivo com a definição da função main, um aruqivo também *.cpp, que
usa as classes definidas pelo programador.
Um exemplo de código (dividido em 3 arquivos) onde estão presentes uma breve documen-
tação da aplicação, da classe implementada e uma descrição dos atributos e métodos. Não é
necessário o entendimento do funcionamento, apenas atente à divisão dos arquivos e no formato
usado:
»»¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹Ì ÔÐ

Óº
»»»
Ð Ö ÙÑ
Ð ×× Ñ Ò Ñ Ð ×Ø

Ð ×× Ì ÔÐ

Ó
ß
ÔÙ Ð
»»»Å ØÓ Ó Ü
Ù Ó ÔÐ
Ó
ÚÓ ÊÙÒ´µ
»»¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹Ì ÔÐ

Óº
ÔÔ
Ò
ÐÙ Ó×ØÖ Ñ
30

»» Ò Ñ ØÓ Ó
Ð ×× º
Ò
ÐÙ Ì ÔÐ

Óº
»¶¶
Ç Ñ ØÓ Ó ÊÙÒ ×
Ö Ú ÙÑ Ñ× Ò Ø Ð
¶»
ÚÓ Ì ÔÐ
Ó ÊÙÒ´µ
ß
»» Ò
Ó Ó Ñ ØÓ Ó
»»×Ø
ÓÙØ ×
Ö Ú Ò Ø Ð
»»
ÓÙØ
ÓÙØ
×Ø
ÓÙØ Ñ Ú Ò Ó Ó ·· ¸¸×Ø Ò ½
4.2 Conceitos Básicos
Alguns conceitos relacionados à sintaxe e semântica da linguagem:
Atribuição: Atribuir um valor a uma determinada posição de memória, abstratamente num objeto
ou variável. Para atribuições usa-se o símbolo de igual (=).
Exemplo:
Ü
¿
·½
Declaração: Declara que existe tal objeto, mas não o cria.
Exemplo:
ÒØ Ü

Ð ×× Ø Ð
ÐÓ Ø ÙÒ
Ó´µ
×ØÖÙ
Ø ×
ÜØ ÖÒ
ÓÒ×Ø ÒØ
Inicialização: As variáveis, no ato de sua declaração podem ser inicializadas com algum valor
que terão até o ﬁm do programa ou até que este valor seja alterado.
Exemplo:
ÒØ Ü ½¼

Ö
³ ³
ÒØ ¼
Escopo: Deﬁne aonde um objeto é visível. Pode ser objeto local, de classe , de função, glo-
bal, ou de arquivo.
31

Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ ÒØ Ö

Ö
ÙÒ× Ò ÒØ Ò »»
¸ Ò × Ó Ú Ö Ú × ÐÓ ×
ÒØ Ñ Ò ´µß
ÙÒ× Ò × ÓÖØ Ñ
ÐÓ Ø Ü¸ Ý »»Ü¸Ý¸Ñ × Ó Ú Ö Ú × ÐÓ
×
ººº
Especificadores: São palavras reservadas da linguagem, usadas para atribuir determinadas
propriedades ao tipos ou definir o tipo do objeto.
Exemplo:
ÒØ Ü
ÒØÐ Ò ÚÓ ´µ
ßººº
ØÝÔ ÐÓ Ø Ö
ÓÒ Ð
»»× Ó ÒØ
ÓÖ × ÒØ¸ ÒØÐ Ò ¸ ØÝÔ º
Diretrizes pré-processamento: Informações no início do programa que são passadas ao
compilador. Iniciam-se com o símbolo #.
Lvalue: é uma expressão que se refere a um objeto ou função. Pode aparecer à esquerda do
sinal de igual (=). Objetos especificados como const não são lvalues.
4.3 Símbolos
Existem alguns símbolos que podemos usar ao programar em C++: Identificadores, opera-
dores, palavras-chave, literais e separadores.
Identificadores: Sequência de letras definidas pelo programador. Podem ser nome dos ob-
jetos, nome dos atributos, ou nome dos métodos.
Exemplo:
ÒØ Ü¸Ý¸Ü »»Ü¸ Ý Þ × Ó Ó× ÒØ
ÓÖ ×º
Operadores: Operadores são símbolos cujo uso já vem definido na linguagem. São eles:
± ² ¶ ´µ ¹ · ß ℄ ³ ¸ º »
32

Mais na frente explicarei melhor os operadores.
Palavras-chave: São palavras de uso interno da linguagem, já contêm algum significado es-
pecífico para o processo de compilação. Não podem ser usadas, portanto, para dar nome a
variáveis.
Exemplo:

Ð ××¸ ×ØÖ Ò ¸ Ð× ¸ Ø Ò¸ Ñ Òººº
Literais: Tipos previamente definidos na linguagem para serem usados representando obje-
tos de uso corrente. Exemplo:
ÒØ Ü ¿ »»Ç ÒÙÑ ÖÓ ÙÑ Ð Ø Ö Ð

Ö
³ ³ »» Ð ØÖ ³ ³ ÙÑ Ð Ø Ö Ð
ÐÓ Ø Ý º »»ÓÒ Ñ ÖÓ º¿ ÙÑ Ð Ø Ö Ð

Ö¶ ÒÓÑ ÙÐ Ó »» ÙÐ Ó ÙÑ Ð Ø Ö Ð
4.4 Os Operadores
Atribuição
Usados para atribuir um valor para a variável.
Operadores aritméticos
Operadores que correspondem às suas respectivas operações matemáticas. São elas:
+ adição
- subtração
* multiplicação
/ divisão
, ressaltando que o módulo é o resto da divisão de um valor pelo outro.
Combinados
Usados quando queremos modificar o valor da variável executando uma operação no valor atual-
mente armazenado
nela. São eles:
· ¸ ¹ ¸ ¶ ¸ » ¸ ± ¸ ¸ ¸ ² ¸ ¸ º
Exemplos:
Ü · ¿ »»Ü Ü·¿
Ü ¹ ¿ »»Ü Ü¹¿
Ü ¿ »»Ü Ü¶¿
Ü » ¿ »»Ü Ü»¿
Ü ± ¿ »»Ü Ü±¿
33

Incremento e decremento
Usados para incrementar ou decrementar em uma unidade o valor armazenado na variável. São,
portanto, equivalentes:
Ü · ½
Ü··
Ü Ü · ½
ou
Ü ¹ ½
Ü¹¹
Ü Ü ½
OBS: Note a diferença existente entre os dois exemplos seguintes, onde no primeiro é usado
como preﬁxo e no segundo é usado como suﬁxo:
1 2
A=++B; A=B++;
//A armazena 4, B armazena 4 //A armazena 3, B armazena 4
Relacionais
Usados para avaliar uma comparação entre dois valores. Retornam um booleano true ou false.
São eles:
== É igual a...
!= Não é igual a...
> É maior que...
< É menor que...
>= É maior ou igual a...
<= É menor ou igual a...
Exemplos:
´ µ »» Ö ØÓÖÒ Ð×
´ µ »» Ö ØÓÖÒ ØÖÙ
´¿ ¾µ »» Ö ØÓÖÒ ØÖÙ
´ µ »» Ö ØÓÖÒ ØÖÙ
´ µ »» Ö ØÓÖÒ Ð× º
Lógicos
Usados para expressar negação, conjunção ou disjunção.
Exemplos:
´¿ ¿µ »» Ö ØÓÖÒ Ð×Ó ÔÓ × ¿ ¿ Ú Ö º
´½¼ ¾µ »» Ö ØÓÖÒ ØÖÙ ÔÓ × Ö ØÓÖÒ Ö Ð×Óº
34

ØÖÙ Ð×
²² »»Ö ØÓÖÒ Ð×Ó
ØÖÙ Ð×
»»Ö ØÓÖÒ ØÖÙ
Condicional (?) e vírgula (,)
O condicional ’?’ é usado para avaliar uma expressão, retornando um valor (resultado1) se a
expressão for verdadeira e um outro valor (resultado2) se ela for falsa. Neste formato:

ÓÒ Ó Ö ×ÙÐØ Ó½ Ö ×ÙÐØ Ó¾
Exemplo:
¿ »» Ö ØÓÖÒ ¿¸ ÕÙ Ò Ó Ù Ð º
·¾ ¿ »» Ö ØÙÖÒ× ¸ × Ò
× ÕÙ Ð ØÓ ·¾º
Já a vírgula é usada para separar duas ou mais expressões que são incluídas onde apenas
uma expressão é esperada.
´ ¸ · µ
Primeiramente b recebe o valor 4, em seguida atribuído o valor b+6 para a variável a. No final,
a tem o valor 10 e b tem o valor 4.
Binários
Modificam variáveis considerando os padrões binários que representam os valores que eles ar-
mazenam.
São eles:
operador equivalente em assembly descrição
& AND Binário AND.
| OR Binário Inclusivo OR.
^ XOR Binário exclusivo OR.
~ NOT complemento unário (inversão de bit).
« SHL Desloca para a esquerda (shift left).
» SHR Desloca para a direita (shift right).
4.5 Precedência de Operadores
Ao escrevermos expressões complexas, às vezes fica difícil distinguir qual operador vem pri-
meiro na hierarquia. Há uma ordem de prioridade para cada operador que, da maior para a
menor, é esta:
35

Nível Operador Agrupamento
1 :: esquerda para a direita.
2 () [] . -> ++ – esquerda para a direita.
dynamic_cast static_cast reinterpret_cast
const_cast typeid
3 ++ – ! sizeof new delete direita para a esquerda.
* &
+ -
4 (type) direita para a esquerda.
5 * ->* esquerda para a direita.
6 * / % esquerda para a direita.
7 + - esquerda para a direita.
8 « » esquerda para a direita.
9 < > <= >= esquerda para a direita.
10 == != esquerda para a direita.
11 & esquerda para a direita.
12 ^ esquerda para a direita.
13 | esquerda para a direita.
14 && esquerda para a direita.
15 || esquerda para a direita.
16 ?: direita para a esquerda.
17 = *= /= %= += -= »= «= &= ^= |= direita para a esquerda.
18 , esquerda para a direita.
4.6 Outros Operadores
Existem certos operadores que são usados para converter dados de um dado tipo para outro.
A maneira mais simples de fazer isso em C++, herdada do C, é a seguinte:
ÒØ
ÐÓ Ø ¿º½
´ ÒØµ
Este código converte um ﬂoat (3.14) para um inteiro (3). Outra maneira é:
ÒØ ´ µ
O último operador a vermos é o × Þ Ó ´µ. Ele aceita 1 parâmetro, que pode ser tanto um tipo
ou uma variável e retorna o tamanho em bytes daquele tipo ou objeto.
× Þ Ó ´
Öµ
Com esse comando, atribuímos o valos 1 a a pois char é um tipo constituído de um byte.
36

Capítulo 5
Constantes
5.1 Tipos de Dados Fundamentais de C++
Ao programar, o valor das variáveis são armazenados na memória do computador, mas este
tem que saber que tipo de dados queremos salvar, já que armazenar um número simples não irá
ocupar a mesma área de memória que armazenar uma letra ou um número maior, por exemplo.
Sabemos que a memória é organizada em bytes. Um byte é a quantia mínima que podemos
gerenciar em C++. Um byte pode armazenar uma quantidade relativamente pequena de dados:
um caracter simples ou um inteiro pequeno (geralmente um inteiro entre 0 e 255). Além disso, o
computador pode manipular tipos de dados mais complexos que aparecem do agrupamento de
vários bytes, como números grandes ou números não-inteiros.
São tipos fundamentais em C++ (incluídos o intervalo de valores que cada um pode representar):
37

Nome Descrição
Tamanho
Intervalo de valores
char usualmente caracteres
1 byte
c/ sinal: -128 a 127
sem sinal: 0 a 255.
short inteiros curtos
2 byte
c/ sinal: -32768 a 32767
sem sinal: 0 a 65535.
int inteiros
4 byte
c/ sinal: -2147483648 a 2147483647
sem sinal: 0 a 4294967295.
long inteiros longos
4 byte
c/ sinal: -2147483648 a 2147483647
sem sinal: 0 a 4294967295.
bool valores booleanos true ou false
1 byte
true ou false.
float números em ponto flutuante.
4 byte
3.4e +/- 38 (7 dígitos).
double precisão double de números em ponto flutuante.
8 byte
1.7e +/- 308 (15 diítos).
long double precisão long de números em ponto flutuante.
8 byte
1.7e +/- 308 (15 dígitos).
wchar_t caracter wide
2 ou 4 byte
1 caracter wide.
Os valores das colunas tamanho e intervalo dependem do sistema para o qual o programa é
compilado. Os valores mostrados são aqueles encontrados na maioria dos sistemas 32-bit. Para
outros sistemas, entretanto, a especificação genérica é que int tem o tamanho natural sugerido
pela arquitetura do sistema (uma "palavra", 4 bytes ou 8 bytes por exemplo) e os outros tipos
inteiros (char, short, int, long) devem, cada um, ser no mínimo do tamanho do que o precede,
com char sempre sendo 1 byte de tamanho. O mesmo se aplica aos tipos de ponto flutuantes
(float, double, long double), onde cada um deve prover no mínimo a mesma precisão do que o
precede.
38

5.2 Constantes
Constantes são expressões com um valor fixo.
5.3 Literais
Constantes usadas para expressar valores particulares num programa. Podem ser divididas
em Números Inteiros, Números em Ponto-Flutuante, Caracteres, Strings, Valores Booleanos.
Inteiros:
½¼
¿
¹
São constantes numéricas que identificam valores decimais. Em C++, além dos decimais,
podemos usar literais de números octais (base 8) e hexadecimais (base 16), da seguinte maneira:
• -Se quisermos expressar um número octal, nós o precedemos com um 0 (zero).
• -Se quisermos expressar um número hexadecimal, nós o precedemos com um 0x (zero-xis).
Exemplo:
»»
Ñ Ð
¼½½¿ »»
Ñ Ð Ñ Ó
Ø Ð
¼Ü »»
Ñ Ð Ñ Ü
Ñ Ð
Por padrão, literais inteiros têm um tipo pré-definido: int.
Ponto-Flutuante
Expressam números com decimais e/ou expoentes.
Exemplo:
¿º½ ½ »» ¿º½ ½ º¼¾ ¾¿ »» º¼¾ Ü ½¼ ¾¿ ½º ¹½ »» ½º Ü ½¼ ¹½ ¿º¼ »» ¿º¼
O tipo padrão para ponto-flutuante é double.
39

Capítulo 6
I/O com Arquivos
6.1 Entrada/Saída de Dados
A partir desta parte do curso começaremos a interagir com o usuário por meio dos padrões
da biblioteca de entrada/saída. C++ usa uma abstração chamada stream para executar opera-
ções de entrada e saída em aparatos como tela ou teclado. Uma Stream é um objeto de onde o
programa pode inserir ou extrair caracteres.
Por padrão, a saída de um programa é a tela e o objeto stream deﬁnido para acessá-la é "cout".
Cout é usada em conjunto com o operador de inserção: «.
Exemplo:

ÓÙØ ÇÐ ÅÙÒ Ó »» ÇÐ ÅÙÒ Ó ÑÔÖ ××Ó Ò Ø Ð

ÓÙØ Ü »» ÑÔÖ Ñ Ò Ø Ð Ó Ú ÐÓÖ Ü

ÓÙØ Ü »» ÑÔÖ Ñ ×ØÖ Ò »
Ö
Ø Ö Ü Ò Ø Ð

ÓÙØ ÇÐ ÅÙÒ Ó¸ ×ØÓ ÙÑ Ö × »» ÑÔÖ Ñ ÇÐ ÅÙÒ Ó¸ ×ØÓ ÙÑ Ö × º

ÓÙØ ÇÐ ÅÙÒ Ó¸ ×Ø Ó ÒÙÑ Ü ÑÔÐÓ ÒÙÑÐ
Ó Ð Ó
O operador « insere o dado que o segue na stream que o precede. Nos casos anteriores, x
e a string "Olá Mundo"são inseridas em ’cout’, por exemplo. Deve-se ressaltar que o ’cout’ não
insere uma quebra de linha automática, devendo esta ser explicitada.

ÓÙØ Á×ØÓ ÙÑ Ö ×

ÓÙØ × Ñ ÕÙ Ö Ð Ò ÙØÓÑ Ø
º
O exemplo anterior será mostrado desta maneira:
Á×ØÓ ÙÑ Ö × × Ñ ÕÙ Ö Ð Ò ÙØÓÑ Ø
º
Já neste caso:

ÓÙØ Á×ØÓ ÙÑ Ö × Ò

ÓÙØ
ÓÑ ÕÙ Ö Ò

ÓÙØ Ð Ò ÙØÓÑ Ø
º
a frase será impressa desta maneira:
40

Á×ØÓ ÙÑ Ö ×

ÓÑ ÕÙ Ö
Ð Ò ÙØÓÑ Ø
º
Para imprimirmos a frase com a quebra de linha também podemos usar o manipulador endl
(endline), da seguinte maneira:

ÓÙØ Ö ×
ÓÑ Ò Ð

ÓÙØ ÕÙ Ö Ð Ò Ò Ð
que mostrará na tela:
Ö ×
ÓÑ
ÕÙ Ö Ð Ò
O padrão de entrada de dados é, usualmente, o teclado. Para manipular a entrada padrão de
dados em C++ usamos o operador de extração » na stream cin. Este operador deve ser seguido
pela variável que irá armazenar os dados que serão extraídos da stream. Desta maneira:
ÒØ ÒÙÑ ÖÓ

Ò ÒÙÑ ÖÓ
A primeira linha declara uma variável numero do tipo int e a segunda linha espera que o
usuário digite algo, alguma entrada de dados do cin (o teclado) para armazenar na variável inteira.
É interessante notar que o cin só pode processar a entrada do teclado uma vez que a tecla
de retorno tiver sido pressionada. Com isso, mesmo se ﬁzermos a requisição de um caracter
simples, a extração do cin não vai processar a entrada até que o usuário pressione a tecla de
retorno depois que o caracter for introduzido. Exemplo:
»» Ü ÑÔÐÓ ÒØÖ × ººº
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ñ Ò ´µ
ß
ÒØ

ÓÙØ ÁÒ× Ö ÙÑ Ú ÐÓÖ ÒØ ÖÓ

Ò Ü

ÓÙØ Ç Ú ÐÓÖ Ò× Ö Ó Ü

ÓÙØ × Ù ÕÙ Ö Ó Ü¶Ü º Ò
Ö ØÙÖÒ ¼
resultado:
ÁÒ× Ö ÙÑ Ú ÐÓÖ ÒØ ÖÓ ½¼
Ç Ú ÐÓÖ Ò× Ö Ó ½¼ × Ù ÕÙ Ö Ó ½¼¼º
Podemos usar cin para pedir ao usuário que insira mais de um dado: São equivalentes os
dois exemplos:
41


Ò Ü Ý
e

Ò Ü

Ò Ý
OBS: se um valor inteiro é requisitado no código e o usuário insere um nome, por exemplo,
pode resultar em mal funcionamento do programa. Ao usar entrada de dados com as extrações
cin, temos que confiar que o usuário irá inserir os dados corretamente, sem caracteres ou algo
similar quando é preciso. Mais à frente, quando formos ver a classe stringstream, veremos uma
possível solução para esses tipos de erros.
Podemos ainda usar o cin para extrair strings da mesma maneira que fizemos com os outros
tipos de váriaveis usando o mesmo operador ».

Ò Ö ×
Contudo, essa extração com o cin para de ler dados do usuário assim que encontra um espaço
em branco. Sendo desta maneira, só podemos pegar uma palavra do usuário por extração, e não
uma frase inteira. Para pegarmos as frases inteiras podemos usar a função getline, que é mais
recomendável. Teremos, por exemplo, como resultado se o nome inserido pelo usuário for "Fulano
de Tal":
Ò
ÐÙ Ó×ØÖ Ñ
Ò
ÐÙ ×ØÖ Ò
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ñ Ò ´µ
ß
×ØÖ Ò ÒÓÑ

ÓÙØ ÈÓÖ ÚÓÖ¸ Ò× Ö × Ù ÒÓÑ
ÓÑÔÐ ØÓ
ØÐ Ò ´
Ò¸ ÒÓÑ µ

ÓÙØ ÇÐ ¸ ÒÓÑ º Ò
Ö ØÙÖÒ ¼
resultado:
ÈÓÖ ÚÓÖ¸ Ò× Ö × Ù ÒÓÑ
ÓÑÔÐ ØÓ
ÇÐ ÙÐ ÒÓ Ì Ðº
6.2 Stringstream
O cabeçalho padrão stringstream define a classe stringstream que permite que um objeto ba-
seado numa string seja tratado como uma stream. Assim, podemos fazer operações de extração
ou inserção de/para strings, especialmente úteis para converter strings para valores numéricos e
vice-versa. Se quisermos extrair um inteiro de uma strings podemos fazer:
42

×ØÖ Ò ×ÒÙÑ ´ ½ µ
ÒØ ÒÙÑ ÖÓ
×ØÖ Ò ×ØÖ Ñ´×ÒÙÑµ ÒÙÑ ÖÓ
Após isto, a variável numero deve conter o numérico 1997.
»» ×ØÖ Ò ×ØÖ Ñ×
Ò
ÐÙ Ó×ØÖ Ñ
Ò
ÐÙ ×ØÖ Ò
Ò
ÐÙ ××ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ñ Ò ´µ
ß
×ØÖ Ò Ö
ÒØ ÒÓÒÙÑ ¼
ÒØ Ñ ×ÒÙÑ ¼
ÒØ ÒÙÑ ¼

ÓÙØ ÒØÖ
ÓÑ Ó ÒÓ Ó × Ù Ò ×
Ñ ÒØÓ
ØÐ Ò ´
Ò¸Ö
µ
×ØÖ Ò ×ØÖ Ñ´Ö
µ ÒÓÒÙÑ

ÓÙØ ÒØÖ
ÓÑ Ó Ñ × Ó × Ù Ò ×
Ñ ÒØÓ
ØÐ Ò ´
Ò¸Ö
µ
µ Ñ ×ÒÙÑ

ÓÙØ ÒØÖ
ÓÑ Ó Ó × Ù Ò ×
Ñ ÒØÓ
ØÐ Ò ´
Ò¸Ö
µ
µ ÒÙÑ

ÓÙØ Ø Ò ×
Ñ ÒØÓ ÒÙÑ Ñ ×ÒÙÑ ÒÓÒÙÑ Ò Ð
Ö ØÙÖÒ ¼
que resulta em:
ÒØÖ
ÓÑ Ó ÒÓ Ó × Ù Ò ×
Ñ ÒØÓ ½ ¾
ÒØÖ
ÓÑ Ó Ñ × Ó × Ù Ò ×
Ñ ÒØÓ ¼½
ÒØÖ
ÓÑ Ó Ó × Ù Ò ×
Ñ ÒØÓ ½
Ø Ò ×
Ñ ÒØÓ ½ ¼½ ½ ¾
43

Capítulo 7
Estruturas de Iteração e Desvios
Condicionais
7.1 Estruturas de Iteração
A maioria das linguagens de programação têm certas estruturas que servem para desviar o
controle das instruções, repetir certos trechos de códigos, tomar cedisões, etc. As principais es-
truturas de controle em C++ serão mostradas nesta parte do curso.
If e Else
A palavra-chave IF é usada quando queremos executar certo trecho do código somente se al-
guma condição(ões) for(em) satisfeita(s).
Exemplo:
´Ü ½¾¿µ

ÓÙØ Ç Ú ÐÓÖ Ü ½¾¿
Aqui, o programa imprime a string "O valor de x é 123"somente se o valor de x for igual (=)
a 123. Para inserir mais de uma instrução quando a condição é verdadeira, basta usarmos as
linhas de código entre chaves , assim:
´Ü ½¾¿µ
ß

ÓÙØ Ç Ú ÐÓÖ Ü ½¾¿

ÓÙØ Ç Ú ÐÓÖ Ü Ò Ó ½¼¼
Se a condição tiver sido falsa e quisermos executar algum trecho de código neste caso, usa-
mos o Else:
´Ü ½¾¿µ

ÓÙØ Ç Ú ÐÓÖ Ü ×ÙÔ Ö ÓÖ ½¾¿
Ð× ´Ü ½¾¿µ

ÓÙØ Ç Ú ÐÓÖ Ü Ò Ö ÓÖ ½¾¿
Ð×

ÓÙØ Ç Ú ÐÓÖ Ü Þ ÖÓ
44

Aqui, se o valor de x for superior a 123, ele imprime: Ç Ú ÐÓÖ Ü ×ÙÔ Ö ÓÖ ½¾¿ já se
o valor de x for inferior a 123, ele imprime: Ç Ú ÐÓÖ Ü Ò Ö ÓÖ ½¾¿ ou se for 0, ele
imprime: Ç Ú ÐÓÖ Ü Þ ÖÓº
7.1.1 Estruturas de Iteração
Os Loops têm como propósito repetir um trecho de código um certo número de vezes en-
quanto/até que a condição seja satisfeita.
While
Uma destas estruturas é o loop while. Ele repete certo trecho enquanto a condição não for
satisfeita.
Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ñ Ò ´µ
ß
ÒØ Ò

ÓÙØ ÁÒ× Ö ÙÑ Ú ÐÓÖ Ò
Ó

Ò Ò
Û Ð ´Ò ¼µ ß

ÓÙØ Ò ¸
¹¹Ò

ÓÙØ ÇÇÅ Ò
Ö ØÙÖÒ ¼
O que resulta em:
ÁÒ× Ö ÙÑ Ú ÐÓÖ Ò
Ó
¸ ¸ ¸ ¸ ¿¸ ¾¸ ½¸ ÇÇÅ
O programa anterior faz o que está descrito nos seguintes passos:
• 1- Quando é iniciado, pede ao usuário que insira um valor de entrada e ele acaba atribuindo
um valor para n.
• 2- Quando o loop inicia, se o valor inserido atende à condição n>0: verdadeira - a sentença
é executada e vai para o passo 3 falsa - ignora a sentença e vai para o passo 5
• 3- Imprime o valor de n na tela e decrementa o valor de n em 1 unidade.
• 4- Fim do bloco e o programa retorna à parte descrita no passo 2.
• 5- Continua o programa logo após o bloco. Imprime BOOM e ﬁnaliza o programa.
45

OBS: ao criarmos a estrutura while, devemos levar em conta que ela deve terminar a algum
ponto. Para isso, devemos fornecer algum método para forçar a condição a se tornar falsa em
algum lugar. Caso contrário, o while se tornará um "loop inﬁnito".
Do-While
Loop que funciona de maneira praticamente igual ao loop while, com a diferença que, neste,
a condição do do-while será avaliada após a execução do bloco, ao invés de antes. Com isto,
mesmo que a condição não seja atendida, o programa vai garantir que o código dentro do bloco
seja executado ao menos 1 vez. Por exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ñ Ò ´µ
ß
ÙÒ× Ò ÐÓÒ Ò
Ó ß

ÓÙØ ÁÒ× Ö ÙÑ Ú ÐÓÖ ´ÁÒ× Ö ¼ Ô Ö × Öµ

Ò Ò

ÓÙØ ÎÓ
Ò× Ö Ù Ò Ò
Û Ð ´Ò ¼µ
Ö ØÙÖÒ ¼
que retorna na tela:
ÁÒ× Ö ÙÑ Ú ÐÓÖ ´ÁÒ× Ö ¼ Ô Ö × Öµ ½¿¾
ÎÓ
Ò× Ö Ù ½¾¿
ÁÒ× Ö ÙÑ Ú ÐÓÖ ´ÁÒ× Ö ¼ Ô Ö × Öµ ¿¾½
ÎÓ
Ò× Ö Ù ¿¾½
ÁÒ× Ö ÙÑ Ú ÐÓÖ ´ÁÒ× Ö ¼ Ô Ö × Öµ ¼
ÎÓ
Ò× Ö Ù ¼
No programa anterior, se não inserirmos o valor 0, o programa pedirá um novo número para
sempre.
For
A função do loop for é, além de repetir certo trecho de código enquanto a condição permanece
verdadeira, como o while, fornecer uma inicialização e incremento de alguma variável especíﬁca
(um contador) usada no trecho de código no seu escopo*.
Sua sintaxe é
ÓÖ ´ Ò
Ð Þ Ó
ÓÒ Ó Ò
Ö Ñ ÒØÓµß
Exemplo:
46

Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ñ Ò ´µ
ß
ÓÖ ´ ÒØ Ò ½¼ Ò ¼ Ò¹¹µ ß

ÓÙØ Ò ¸

ÓÙØ ÇÇÅ Ò
Ö ØÙÖÒ ¼
que mostra na tela:
½¼¸ ¸ ¸ ¸ ¸ ¸ ¸ ¿¸ ¾¸ ½¸ ÇÇÅ
OBS: ponto-e-vírgulas são obrigatórios, apesar do incremento e inicialização serem opcionais.
Com isso, se não forem usados teríamos, por exemplo:
ÓÖ ´ Ò ½¼ µß
já as vírgulas podem ser usadas para especificar mais de uma expressão em um dos campos,
assim:
ÓÖ ´ Ò ¼¸ ½¼¼ Ò Ò··¸ ¹¹ µß
7.1.2 Desvios
Break
Com o break, podemos deixar um loop mesmo que a condição não seja satisfeita. Útil em lo-
ops infinitos, ou para forçar um final antes do fim normal do bloco.
Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ñ Ò ´µ
ß
ÒØ Ü
ÓÖ ´Ü ½¼ Ü ¼ Ü¹¹µ
ß

ÓÙØ Ü ¸
´Ü ¿µ
ß

ÓÙØ ÓÒØ Ñ Ò Ð Þ
Ö
Ö ØÙÖÒ ¼
47

que retorna:
½¼¸ ¸ ¸ ¸ ¸ ¸ ¸ ¿¸ ÓÒØ Ñ Ò Ð Þ
Continue
Com o continue, o programa pula o resto do loop na iteração atual como se o fi do bloco ti-
vesse sido atingido e pula ao começo da iteração seguinte.
Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ñ Ò ´µ
ß
ÓÖ ´ ÒØ Ü ½¼ Ü ¼ Ü¹¹µ ß
´Ü µ
ÓÒØ ÒÙ

ÓÙØ Ü ¸

ÓÙØ Ò Ð Ò
Ö ØÙÖÒ ¼
que mostra na tela:
½¼¸ ¸ ¸ ¸ ¸ ¸ ¿¸ ¾¸ ½¸ Ò Ð
Goto
O goto permite desviarmos para um ponto qualquer no programa. Por este motivo, deve ser
usado com cautela, já que sua execução causa um desvio incondicional que ignora qualquer tipo
de limite de escopo. O destino é definido com um label, que é usado como um argumento para o
goto. Este label é feito de um identificador válido seguido de dois-pontos (sorriso.
Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ñ Ò ´µ
ß
ÒØ Ü ½¼
ÐÓÓÔ

ÓÙØ Ü ¸
Ü¹¹
´Ü ¼µ ÓØÓ ÐÓÓÔ

ÓÙØ Ò Ð Ò
Ö ØÙÖÒ ¼
que mostra na tela:
48

½¼¸ ¸ ¸ ¸ ¸ ¸ ¸ ¿¸ ¾¸ ½¸ Ò Ð
Exit
O exit é uma função definida na biblioteca cstdlib cuja função é terminar o programa atual com
um código específico. Seu protótipo é:
ÚÓ Ü Ø ´ ÒØ Ü Ø
Ó µ
O exitcode é usado por alguns sistemas operacionais e pode ser usado por programas que o
chamem. por convenção, um exitcode 0 significa que o programa terminou normalmente. Outros
valores indicam que algum erro ou resultados inesperados aconteceram.
Switch
O switch é uma estrutura que checa várias possibilidades de valores constantes para uma ex-
pressão. Acompanhe o formato padrão do switch junto à sua explicação, a seguir:
×Û Ø
´ ÜÔÖ ×× Óµ
ß

×
ÓÒ×Ø ÒØ ½
ß ÐÓ
Ó
Ó ½
Ö

×
ÓÒ×Ø ÒØ ¾
ß ÐÓ
Ó
Ó ¾
Ö
º
º
º
ÙÐØ
ß ÐÓ
Ó
Ó Ô Ö Ó
Primeiramente ele avalia a expressão e verifica se o resultado dela é equivalente à cons-
tante_1. Se for, executa o bloco_de_código_1 até que encontre um break. Ao encontrá-lo, o
programa desvia ao fim do switch.
Se o valor da expressão não for igual à constante_1, o switch checa a constante_2, seguindo o
mesmo procedimento anterior. Note que os três-pontos mostram que podem ser usadas quantas
constantes e blocos de códigos sejam necessáris. Se por ventura nenhuma dessas constantes
for igual ao valor da expressão, o switch executará o bloco_de_código_padrao, do default. Por
este motivo, um switch exige sempre que haja um label default.
OBS:
• 1) é importante ressaltar que se o break entre os labels e blocos de código não forem
usados, o switch poderá entrar na primeira clausula, por exemplo, e continuar executando
as outras sem interrução do loop. Esta é a importância do break dentro do switch. Apesar
disso, como o default deve ser o último label a ser inserido, ele não exige o desvio break.
49

• 2) O switch só pode ser usado para comparar expressões com constantes. Assim, não
podemos colocar variáveis como labels.
Ambos os seguintes trechos de código têm o mesmo funcionamento:
×Û Ø
´Üµ ß

× ½

ÓÙØ Ü ½
Ö

× ¾

ÓÙØ Ü ¾
Ö
ÙÐØ

ÓÙØ Î ÐÓÖ ×
ÓÒ
Ó Ü
Funciona da mesma maneira que:
´Ü ½µ ß

ÓÙØ Ü ½
Ð× ´Ü ¾µ ß

ÓÙØ Ü ¾
Ð× ß

ÓÙØ Î ÐÓÖ ×
ÓÒ
Ó Ü
Veja um outro exemplo de switch:
×Û Ø
´Ü¶¾µ
ß

× ¾
ß

ÓÙØ Ç Ú ÐÓÖ ÜÔÖ ×× Ó ¾º
Ö

×
ß

ÓÙØ Ç Ú ÐÓÖ ÜÔÖ ×× Ó º
Ö

×
ß

ÓÙØ Ç Ú ÐÓÖ ÜÔÖ ×× Ó º
Ö
ÙÐØ
ß
50


ÓÙØ Ç Ú ÐÓÖ ÜÔÖ ×× Ó ×
ÓÒ
Ó
que, no caso em que x é 3 resulta:
Ç Ú ÐÓÖ ÜÔÖ ×× Ó º
Funções Uma função é um bloco de instruções que é executado apenas quando é chamado
em algum ponto do programa. Ao usar funções, podemos estruturar os programas de uma ma-
neira mais modular, acessando todo o potencial que a programação estruturada em C++ pode
oferecer.
O formato padrão de funções é:
Ì ÔÓ Ó ÒÓÑ ÙÒ
Ó ´Ô Ö Ñ ØÖÓ½¸ Ô Ö Ñ ØÖÓ¾¸ ºººµß
ÐÓ
Ó
Ó ÙÒ
Ó
O Tipo é o tipo (int, ﬂoat, etc...) do dado que será retornado pela função ao lugar que a
chamou. O nome da função é o nome que será usado para caracterizar a função e chamá-la
quando for necessário. Os parâmetros podem ser quantos forem necessários. São tipos de
dados seguidos pelo identiﬁcador, como uma declaração de variável comum (int x, por exemplo),
e que agem na função como variáveis locais comuns. Eles permitem passar argumentos para a
função quando é chamada. Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ ×ÓÑ ´ ÒØ ¸ ÒØ µ
ß
ÒØ Ü
Ü ·
Ö ØÙÖÒ ´Üµ
ÒØ Ñ Ò ´µ
ß
ÒØ Ý
Ý ×ÓÑ ´¾¼¼¸½¼¼µ

ÓÙØ Ç Ö ×ÙÐØ Ó Ý
Ö ØÙÖÒ ¼
Que mostra na tela:
Ç Ö ×ÙÐØ Ó ¿¼¼º
Um programa em C++ sempre inicia sua execução no método main. Logo, neste exemplo,
começamos declarando y, e dizendo que seu valor é igual ao valor que a função soma com os
parâmetros 200 e 100 retornará. Ao chamar a função soma, o controle é desviado para esta
função, que soma os dois numeros recebidos como parâmetros e retornam o resultado para onde
ela foi chamada. o valor de y resultante na função main então se altera para 300 e é impresso na
tela com o cout.
51

7.2 Escopo de Variáveis
O escopo de variáveis (ou local do programa onde as variáveis são válidas) declaradas numa
função é a própria função e por isso, elas não podem ser utilizadas fora delas. No exemplo an-
terior, o escopo de x é a função soma. Se tentássemos usá-la fora da função, teríamos um erro
indicando que a variável não pode ser reconhecida pelo compilador. Da mesma maneira, z não
poderia ser utilizada na função soma.
Resumidamente, o escopo das variáveis segue o seguinte:
Variávels Locais
Seu escopo é limitado ao mesmo nível de bloco em que são declaradas.
Variáveis Globais
Variáveis que são visíveis em qualquer ponto do código, dentro e fora de todas as funções. De-
vem, para isso, ser declaradas fora das funções diretamente no corpo do programa.
Exemplos:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ ×Ù ØÖ
Ó ´ ÒØ ¸ ÒØ µ
ß
ÒØ Ö ×
Ö × ¹
Ö ØÙÖÒ ´Ö ×µ
ÒØ Ñ Ò ´µ
ß
ÒØ Ü ¸ Ý ¿¸ Þ
Þ ×Ù ØÖ
Ó´ ¸¾µ

ÓÙØ Ç ÔÖ Ñ ÖÓ Ö ×ÙÐØ Ó Þ ³ Ò³

ÓÙØ Ç × ÙÒ Ó Ö ×ÙÐØ Ó ×Ù ØÖ
Ó´ ¸¾µ ³ Ò³

ÓÙØ Ç Ø Ö
ÖÓ Ö ×ÙÐØ Ó ×Ù ØÖ
Ó´Ü¸Ýµ ³ Ò³
Þ · ×Ù ØÖ
Ó´Ü¸Ýµ

ÓÙØ Ç ÕÙ ÖØÓ Ö ×ÙÐØ Ó Þ ³ Ò³
Ö ØÙÖÒ ¼
,o que mostra na tela:
Ç ÔÖ Ñ ÖÓ Ö ×ÙÐØ Ó
Ç × ÙÒ Ó Ö ×ÙÐØ Ó
Ç Ø Ö
ÖÓ Ö ×ÙÐØ Ó ¾
Ç ÕÙ ÖØÓ Ö ×ÙÐØ Ó
52

7.3 Funções sem tipo
Se verificarmos o formato geral de funções, verificamos que elas se iniciam com um tipo, que
é o tipo da função por si mesma, o tipo do valor que ela retorna ao ponto que a chamou. Mas
devemos saber que podemos não querer retornar valor algum. Imagine que somente queremos
que uma função retorne algo na tela. Não queremos, então, que ela retorne valor algum e usamos
o void para demonstrar isto ao compilador.
Exemplo de uso do void:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÚÓ Ñ Ò× Ñ´µ
ß

ÓÙØ Å Ò× Ñ ØÓ
ÒØ Ñ Ò ´µ
ß
Ñ Ò× Ñ´µ
Ö ØÙÖÒ ¼
, que retorna na tela:
Å Ò× Ñ ØÓ
OBS: 1) O void pode ainda ser utilizado para explicitar que não queremos que a função receba
parâmetros quando é chamada. A função anterior poderia ser declarada assim:
ÚÓ Ñ Ò× Ñ ´ÚÓ µ
ß

ÓÙØ Å Ò× Ñ ØÓ
2) Mesmo que a função não contenha parâmetros, é imprescindível o uso dos parênteses na
sua declaração:
ÚÓ Ñ Ò× Ñ ´µ
ß

ÓÙØ Ð Ð Ð
Parâmetros passados por Valor e por Referência
Argumentos passados por valor significa que, ao serem passados para a função, são "cópias"de
seus valores, e não as variáveis propriamente ditas. Na prática, o que acontece é que são pas-
sados para a função apenas os VALORES das variáveis. Com isso, não importa se estes valores
forem alterados ao longo da função, as variáveis originais continuarão tendo o mesmo valor fora
dela.
Parte do Exemplo anterior:
53

ÒØ Ü ¿¸ Ý
ÒØ Þ
Þ
Ó´Ü¸Ýµ
Aqui, quando a função é chamada, o valor de a e b se tornam 3 e 4 respectivamente, mas
qualquer modificação a a ou b dentro da função não alterará o valor de x e y fora dela, já que não
foram passadas à função e sim apenas seus valores (ou cópias deles).
Já no caso dos argumentos passados por referência a função não recebe apenas um valor, mas
sim o ENDEREÇO de uma variável global. Portanto, qualquer modificação que for realizada no
conteúdo deste parâmetro afetará também a variável global que está associada a ele. Durante a
execução do subprograma, ou função, os parâmetros passados por referência são análogos às
variáveis globais.
Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÚÓ Ó ÖÓ´ ÒØ² ¸ ÒØ² ¸ ÒØ²
µ
ß
¶ ¾
¶ ¾

¶ ¾
ÒØ Ñ Ò ´µ
ß
ÒØ Ü ½¸ Ý ¿¸ Þ
Ó ÖÓ´Ü¸ Ý¸ Þµ

ÓÙØ Ü Ü ¸ Ý Ý ¸ Þ Þ
Ö ØÙÖÒ ¼
,o que retorna na tela:
Ü ¾¸ Ý ¸ Þ ½
Note que na declaração de cada parâmetro da função é usado o símbolo &. Ele é quem
especifica que os parâmetros serão passados por referência. Perceba também que depois de o
programa ter chamado a função, os parâmetros x, y e z têm seus valores alterados, situação esta
que foi criada dentro da função por terem sido passados como por referência.
Existe um exemplo interessante que mostra que, ao passarmos os valores por referência, per-
mitimos que a função retorne mais de um valor. neste caso o valor original (passado por valor), o
valor anterior a ele e o valor posterior a ele. Veja:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
54

ÚÓ ÒØ ÔÓ×Ø´ ÒØ Ü¸ ÒØ² ÒØ¸ ÒØ² ÔÓ×Øµ
ß
ÒØ Ü¹½
ÔÓ×Ø Ü·½
ÒØ Ñ Ò ´µ
ß
ÒØ Ü ½¼¼¸ Ý¸ Þ
ÒØ ÔÓ×Ø´Ü¸ Ý¸ Þµ

ÓÙØ Î ÐÓÖ ÒØ Ö ÓÖ Ý ¸ Î ÐÓÖ ÈÓ×Ø Ö ÓÖ Þ
Ö ØÙÖÒ ¼
que, como o valor de x é 100, retorna na tela:
Î ÐÓÖ ÒØ Ö ÓÖ ¸ Î ÐÓÖ ÈÓ×Ø Ö ÓÖ ½¼½
7.4 Valores Padrões nos Parâmetros
Ao declararmos uma função podemos especiﬁcar um valor padrão para cada parâmetro. Este
valor será usado se o argumento correspondente for deixado em branco na hora de chamar a
função. Para isto, simplesmente usamos o operador de atribuição e um valor para os argumentos
na declaração da função. Se um valor para aquele parâmetro não for passado quando a função
é chamada, o valor padrão é usado. Contudo, se um valor para o parâmetro for especiﬁcado na
chamada da função, este valor padrão é ignorado e o valor passado à função é usado.
Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ Ú × Ó´ ÒØ ¸ ÒØ ¾µ
ß
ÒØ Ü
Ü »
Ö ØÙÖÒ ´Üµ
ÒØ Ñ Ò ´µ
ß

ÓÙØ Ú × Ó´½¾µ

ÓÙØ Ò Ð

ÓÙØ Ú × Ó´¾¼¸ µ
Ö ØÙÖÒ ¼
que resulta em:
55

No caso anterior, o valor padrão b=2 só é utilizado no caso de divisao(12), pois não existe um
segundo argumento especificado.
Em C++, podemos usar mesmo nome para mais de uma função desde que tenham um número
de parâmetros diferentes ou tipos diferentes nos parâmetros.
Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ
Ð
ÙÐ Ö´ ÒØ ¸ ÒØ µ
ß
Ö ØÙÖÒ ´ ¶ µ
ÐÓ Ø
Ð
ÙÐ Ö´ ÐÓ Ø ¸ ÐÓ Ø µ
ß
Ö ØÙÖÒ ´ » µ
ÒØ Ñ Ò ´µ
ß
ÒØ Ü ¸Ý ¾
ÐÓ Ø Ò º¼¸Ñ ¾º¼

ÓÙØ
Ð
ÙÐ Ö´Ü¸Ýµ

ÓÙØ Ò

ÓÙØ
Ð
ÙÐ Ö´Ò¸Ñµ

ÓÙØ Ò
Ö ØÙÖÒ ¼
que retorna como resultado na tela:
½¼
¾º
Neste caso, declaramos 2 funções com o mesmo nome (calcular) mas com tipos diferentes
(int e float).
7.5 Especificador Inline
Usado para dizer ao compilador que a substituição inline deve ser usada, ao invés do meca-
nismo de chamada da função usual. Não muda o comportamento da função, mas é usado para
sugerir ao compilador que o código gerado pelo corpo da função seja inserido em cada ponto de
chamada da função, ao invés de ser inserido apenas uma vez e ser feita uma chamada normal a
56

ela, o que geralmente envolve um tempo de execução adicional.
Seu formato:
ÒÐ Ò Ø ÔÓ ÒÓÑ ÙÒ
Ó ´ Ö ÙÑ ÒØÓ× ººº µ
ß ÐÓ
Ó Ò×ØÖÙ
Ó ×
A única diferença é o uso do especiﬁcador inline no início da DECLARAÇÃO da função, não
sendo necessário nenhuma mudança na chamada da função. A maioria dos compiladores já
otimiza o código incluíndo funções inline quando é mais conveniente. O especiﬁcador só indica
que para determinada função o inline é preferido.
7.6 Recursividade
É a propriedade que as funções têm de chamarem a si mesmas. Suas utilidades são inúme-
ras, como calcular fatoriais de números, ordenações, etc.
Exemplo
Como o fatorial de um número é calculado usando:
Ò Ò ¶ ´Ò¹½µ ¶ ´Ò¹¾µ ¶ ´Ò¹¿µ ººº ¶ ½
em um programa teríamos:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÐÓÒ ØÓÖ Ð ´ÐÓÒ Üµ
ß
´Ü ½µ
Ö ØÙÖÒ ´Ü ¶ ØÓÖ Ð ´Ü¹½µµ
Ð×
Ö ØÙÖÒ ´½µ
ÒØ Ñ Ò ´µ
ß
ÐÓÒ ÒÙÑ

ÓÙØ ÁÒ× Ö ÙÑ Ú ÐÓÖ

Ò ÒÙÑ

ÓÙØ ÒÙÑ ØÓÖ Ð ´ÒÙÑµ
Ö ØÙÖÒ ¼
que mostra na tela:
ÁÒ× Ö ÙÑ Ú ÐÓÖ ½¼
½¼ ¿ ¾ ¼¼
57

Percebemos que no código anterior a função chama a si mesma, mas apenas se o valor
passado como argumento for maior que 1. Caso contrário, a função executa um loop infinito
recursivo em que, assim que atingir o valor 0, continuaria multiplicando por todos os números
negativos (o que provavelmente geraria um erro de overflow na execução). Neste exemplo, por
termos usado long, os resultados não seriam válidos para valores muito maiores que 10! ou 15!,
dependendo do sistema em que forem compilados.
7.7 Declarações de Funções
Até aqui, definimos todas as funções antes da primeira aparição de chamadas a elas no
código. Acontece que se fizermos o teste de inverter o main e declararmos as funções após
ele, teríamos erros de compilação, já que elas devem já ter sido declaradas para poderem ser
chamadas no main. No entanto, existe uma maneira de evitar termos que escrever o código
inteiro da função antes de chamá-la. Basta declararmos sua existência, ao invés da definição
completa. Esta declaração tem a forma:
Ø ÔÓ ÒÓÑ ÙÒ
Ó ´Ø ÔÓ Ö ÙÑ ÒØÓ½¸ Ø ÔÓ Ö ÙÑ ÒØÓ¾¸ ºººµ
que é idêntica à definição de uma função excluíndo o corpo dela. Apesar de deixar o có-
digo mais legível os nomes dos parâmetros não são obrigatórios. As seguintes declarações dos
protótipos de uma função são válidas:
ÒØ ÙÒ
Ó½ ´ ÒØ ¸ ÒØ µ
ÒØ ÙÒ
Ó½ ´ ÒØ¸ ÒØµ
Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÚÓ ÑÔ Ö´ ÒØ Üµ
ÚÓ Ô Ö´ ÒØ Üµ
ÒØ Ñ Ò ´µ
ß
ÒØ
Ó ß

ÓÙØ ÙÑ Ú ÐÓÖ ´ Ø ¼ Ô Ö × Öµ

Ò
ÑÔ Ö´ µ
Û Ð ´ ¼µ
Ö ØÙÖÒ ¼
ÚÓ ÑÔ Ö´ ÒØ Üµ
ß
´´Ü±¾µ ¼µ
ÓÙØ Æ Ñ ÖÓ ÑÔ Öº Ò
Ð× Ô Ö´Üµ
58

ÚÓ Ô Ö´ ÒØ Üµ
ß
´´Ü±¾µ ¼µ
ÓÙØ Æ Ñ ÖÓ Ô Öº Ò
Ð× ÑÔ Ö´Üµ
o que mostra na tela:
ÙÑ Ú ÐÓÖ ´ Ø ¼ Ô Ö × Öµ ¿
Æ Ñ ÖÓ ÑÔ Öº
ÙÑ Ú ÐÓÖ ´ Ø ¼ Ô Ö × Öµ ½¼¼¼
Æ Ñ ÖÓ Ô Öº
ÙÑ Ú ÐÓÖ ´ Ø ¼ Ô Ö × Öµ ½
Æ Ñ ÖÓ ÑÔ Öº
ÙÑ Ú ÐÓÖ ´ Ø ¼ Ô Ö × Öµ ¼
Æ Ñ ÖÓ Ô Öº
Percebemos neste exemplo que as funções par e impar só são deﬁnidas com seu corpo
inteiro após o método main, mas foram declaradas inicialmente com seus protótipos. Esta prática
mostrou-se eﬁciente para a limpeza do código, já que isso acaba facilitando a localização das
funções existentes no programa.
59

Capítulo 8
Vetores e Seqüência de Caracteres
8.1 Vetores
Um vetor ou array é uma série de elementos do mesmo tipo colocados em seqüencia em
locais de memória que podem ser acessados ou referenciados individualmente usando índices.
Podemos abstrair os vetores pensando neles como se fossem dessa forma:
Figura 8.1: Exemplo de Vetor
Significa que, por exemplo, podemos armazenar 6 valores do tipo int em um vetor sem ter que
declarar 6 diferentes variáveis, cada uma com um identificador. Para fazer isso, criamos um vetor
com um identificador único (por exemplo vet) e referenciamos as posições usando índices (por
exemplo vet[0], vet[1], vet[2], vet[3],... etc). Também abstraindo isto, teríamos:
Figura 8.2: Outro exemplo de Vetor
Lembrando que os índices nos vetores se iniciam de 0, necessitamos declarar um vetor antes
de usá-lo, como fizemos com as variáveis. Fazemos assim:
Ø ÔÓ ÒÓÑ Ó Ú ØÓÖ ÒÙÑ ÖÓ Ð Ñ ÒØÓ×℄
onde tipo é qualquer tipo válido ja conhecido (int, float, etc...), nome_do_vetor deve ser um
identificador válido (como sempre) e numero_de_elementos deve ser uma constante inteira, já
que vetores são valores são blocos de memória não-dinâmica cujo tamanho deve ser determinado
antes da execução. Exemplo:
ÒØ ÒÓØ × ¿¼℄
60

,significa que armazenaremos um vetor com 30 números inteiros.
Inicializando os Vetores
Ao declararmos um vetor localmente, se não especificarmos, seus elementos não serão inici-
alizados com valor algum por padrão e seu conteúdo será indeterminado até que algum valor
seja atribuído a eles. Localmente e globalmente, ao declararmos um vetor, podemos atribuir
valores iniciais às posições do vetor colocando-os entre chaves e separados por vírgulas (,).
Assim:
ÒØ ÒÓØ × ℄ ß ½¼¸ ¸ ¸ ¿¸
que criaria um vetor assim:
Figura 8.3: Criação de vetor
Note que o número de elementos nas chaves deve sempre ser igual ao declarado dentro dos
colchetes [ ];
Acessando os valores
Para acessarmos os valores do vetor individualmente, como se fossem variáveis, podemos usar
índices, como já foi falado. Desta maneira:
ÒÓÑ Ó Ú ØÓÖ Ò
℄
,para armazenarmos um valor do vetor em uma variável separada fazemos por exemplo:
ÒØ Ü ÒÓØ × ¿℄
que atribuir o valor inserido na quarta posição do vetor notas para a variável x. Podemos
também fazer o contrário, inserindo algum valor em uma determinada posição do vetor desta
meneira:
ÒÓØ × ¾℄
São também operações válidas de vetores:
ÒÓØ × ¼℄
ÒÓØ × ℄
Ü ÒÓØ × ·¾℄
ÒÓØ × ÒÓØ × ℄℄ ÒÓØ × ¾℄ · ¾
OBS: é importante notar que os colchetes desempenham 2 funções nos vetores. São usados
na declaração de um novo vetor, especificando seu numero de elementos, e são também usados
para isolar os índices, na hora de acessar as posições do vetor. Exemplo:
61

ÒØ ÒÓØ × ℄
ÒÓØ × ¾℄
Exemplo de código com vetores:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÒØ ÒÓØ × ℄ ß½¸ ¾¸ ¿¸ ¸
ÒØ Ò¸ Ö ×ÙÐØ Ó ¼
ÒØ Ñ Ò ´µ
ß
ÓÖ ´ Ò ¼ Ò Ò·· µ
ß
Ö ×ÙÐØ Ó · ÒÓØ × Ò℄

ÓÙØ Ö ×ÙÐØ Ó
Ö ØÙÖÒ ¼
, que mostra na tela o valor 15.
8.2 Arrays multidimensionais
São basicamente "vetores de vetores". Vetores multidimensionais podem conter quantos índi-
ces quanto forem necessários. Só devemos ter cuidado com o tamanho de memória necessária,
já que num vetor deste tipo ela cresce rapidamente com cada dimensão.
Podemos abstrair um array bidimensional assim:
Figura 8.4: Array Multidimensional
Ñ Ø, por exemplo, representa um vetor bidimensional de 4 por 5 do tipo inteiro. Declaramos
desta maneira:
ÒØ ÒÓÑ Ó ÖÖ Ý ÒÙÑ ÖÓ Ð Ò ×℄ ÒÙÑ ÖÓ
ÓÐÙÒ ×℄
Exemplo:
ÒØ Ñ Ø ℄ ℄
62

Lembrando que os índices começam sempre em 0, referenciamos o 2º elemento verticalmente
e 3º horizontalmente, por exemplo (marcado em vermelho na figura), desta maneira:
Ñ Ø ½℄ ¾℄
8.3 Passando Vetores Como Parâmetros
Podemos querer, em algum momento, passar vetores como parâmetros de funções. Como
não é possível passar um bloco completo de memória por valor como um parâmetro, passamos
apenas os endereços. Na prática, tem quase o mesmo efeito e é mais eficiente e rápido. A única
coisa que necessitamos é especificar na declaração da função o tipo do vetor, um identificador e
os colchetes [ ]. Desta maneira:
ÚÓ ÙÒ
Ó ´ ÒØ Ú Ø ℄µ
ß ÐÓ
Ó Ò×ØÖÙ ×
A declaração de função anterior aceita um parâmetro do tipo "vetor de inteiros", neste caso o
vet. Para passar a esta função um vetor declarado como:
ÒØ Ú ØÓÖ ¿¼℄
,podemos chamar a funcao desta maneira:
ÙÒ
Ó´Ú Øµ
Exemplo:
Ò
ÐÙ Ó×ØÖ Ñ
Ù× Ò Ò Ñ ×Ô
×Ø
ÚÓ ÑÓ×ØÖ Ú ØÓÖ´ ÒØ Ú Ø ℄¸ ÒØ Ð Ò Ø µ ß
ÓÖ ´ ÒØ Ò ¼ Ò Ð Ò Ø Ò··µ

ÓÙØ Ú Ø Ò℄

ÓÙØ Ò
ÒØ Ñ Ò ´µ
ß
ÒØ Ú ØÓÖ½ ℄ ß ¸ ½¼¸ ½
ÒØ Ú ØÓÖ¾ ℄ ß¾¸ ¸ ¸ ¸ ½¼
ÑÓ×ØÖ Ú ØÓÖ´Ú ØÓÖ½¸¿µ
ÑÓ×ØÖ Ú ØÓÖ´Ú ØÓÖ¾¸ µ
Ö ØÙÖÒ ¼
,que mostra na tela:
½¼ ½
¾ ½¼
63

Também podemos passar vetores multidimensionais como parâmetros de funções. Eles te-
riam o seguinte formato:
Ø ÔÓ ÒÓÑ ÙÒ
Ó ´Ø ÔÓ ÒÓÑ ℄ ÔÖÓ ÙÒ ℄ ÔÖÓ ÙÒ ℄µ
ß ÐÓ
Ó Ò×ØÖÙ ×
Exemplo:
ÚÓ ÙÒ
Ó ´ ÒØ ÑÙÐØ ℄ ¿℄ ℄µ
Note que os primeiros colchetes são deixados em branco enquanto os seguintes não. Funci-
ona assim pois o compilador deve ser capaz de determinar numa função qual é a profundidade
de cada dimensão adicional.
8.4 Seqüencia de Caracteres
Assim como em várias linguagens, podemos representar em C++ as strings como vetores de
caracteres, já que elas são, na verdade, seqüências de caracteres. Desta maneira, a seguinte
expressão:

Ö Ö × ¿¼℄
,é um vetor que pode armazenar até 30 elementos do tipo caractere. Podemos, entretanto, ar-
mazenar seqüências menores. Por exemplo, frase poderia armazenar "Olá"ou "Como vai você?",
ambas com menos de 30 caracteres. Para designar o ﬁm de uma seqüência válida, usa-se o
caracter null:
³ ¼³
Podemos representar graﬁcamente como:
Figura 8.5: Seqüência de caracteres
Inicialização de seqüências de caracteres terminadas com null
Como podem ser considerados simples vetores, as seqüências de caracteres seguem as mesmas
regras. Se quisermos inicializar um vetor de caracteres com alguma seqüência pré-determinada,
por exemplo, fazemos igual a qualquer outro vetor:

Ö Ö × ℄ ß ³ ³¸ ³ ³¸ ³Ñ³¸ ³ ³¸ ³Î³¸ ³ ³¸ ³Ò³¸ ³ ³¸ ³Ó³¸ ³×³¸ ³ ¼³
64

Programação C++ Completa

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (14)

Semelhante a Programação C++ Completa

Semelhante a Programação C++ Completa (20)

Mais de Tiago

Mais de Tiago (20)

Último

Último (20)

Programação C++ Completa