antonio mendes da silva filho - s3.amazonaws.com livro é um relato de recente trabalho na área de...

Introdução à Programação Orientada a Objetos com C++

Antonio Mendes da Silva Filho

introd_00.indd 1 12/4/2010 10:30:04

Preencha a ficha de cadastro no final deste livroe receba gratuitamente informações

sobre os lançamentos e as promoções da Elsevier.

Consulte também nosso catálogo completo, últimos lançamentos e serviços exclusivos no site

www.elsevier.com.br

introd_00.indd 2 12/4/2010 10:30:06

Introdução à Programação Orientada a Objetos com C++


introd_00.indd 3 12/4/2010 10:30:06

CIP-Brasil. Catalogação-na-fonte.Sindicato Nacional dos Editores de Livros, RJ

_________________________________________________________________________

_________________________________________________________________________

S58i Silva Filho, Antonio Mendes da Introdução à programação orientada a objetos com C++ / Antonio Mendes da Silva Filho. – Rio de Janeiro: Elsevier, 2010.

ISBN 978-85-352-3702-3

1. Programação orientada a objetos (Computação). 2. C++ (Linguagem de programação de computador) I. Título.

10-0446.CDD: 005.117

CDU: 004.21

© 2010, Elsevier Editora Ltda.

Todos os direitos reservados e protegidos pela Lei no 9.610, de 19/02/1998.Nenhuma parte deste livro, sem autorização prévia por escrito da editora, poderá ser reproduzida ou transmitida sejam quais forem os meios empregados: eletrônicos, mecânicos, fotográficos, gravação ou quaisquer outros.

Copidesque: Ivone TeixeiraRevisão: Marco Antônio CorrêaEditoração Eletrônica: SBNigri Artes e Textos Ltda.

Elsevier Editora Ltda.Conhecimento sem FronteirasRua Sete de Setembro, 111 – 16o andar20050-006 – Centro – Rio de Janeiro – RJ – Brasil

Rua Quintana, 753 – 8o andar04569-011 – Brooklin – São Paulo – SP – Brasil

Serviço de Atendimento ao [email protected]

ISBN 978-85-352-3702-3

Nota: Muito zelo e técnica foram empregados na edição desta obra. No entanto, podem ocorrer erros de digitação, impressão ou dúvida conceitual. Em qualquer das hipóteses, solicitamos a comunicação ao nosso Serviço de Atendimento ao Cliente, para que possamos esclarecer ou encaminhar a questão.

Nem a editora nem o autor assumem qualquer responsabilidade por eventuais danos ou perdas a pessoas ou bens, originados do uso desta publicação.

introd_00.indd 4 12/4/2010 10:30:06

Dedicatória

À minha esposa Viviane e aos filhos Vivian e Anthony, em reconhecimento aos muitos momentos de convívio cedidos e constante apoio dado durante a realização deste livro. Ao meu pai Antonio e à minha mãe Eunide (in memoriam) pelo ininterrupto afeto e simplicidade dos ensinamentos.

introd_00.indd 5 12/4/2010 10:30:06

introd_00.indd 6 12/4/2010 10:30:06

Sobre o Autor

Professor e consultor em área de Tecnologia da Informação e Comunicação, com mais de 20 anos de experiência profissional, é autor do livro Arquitetura de Software, pela Editora Campus/Elsevier, possui diversos artigos publicados em eventos nacio-nais e internacionais, é colunista de Ciência e Tecnologia na revista Espaço Acadêmico, com mais de cem artigos publicados, tendo feito palestras em eventos nacionais e no exterior. Foi professor visitante da University of Texas, em Dallas, e da University of Ottawa. Formado em Engenharia Elétrica pela Universidade de Pernambuco, com mestrado em Engenharia Elétrica pela Universidade Federal da Paraíba (Campina Grande), mestrado em Engenharia da Computação pela University of Waterloo e doutorado em Ciência da Computação pela Univesidade Federal de Pernambuco.

introd_00.indd 7 12/4/2010 10:30:06

introd_00.indd 8 12/4/2010 10:30:06

Agradecimentos

Este livro é um relato de recente trabalho na área de introdução à programação em cursos de computação e engenharias. Ao longo de minha jornada como docente, tive a oportunidade de trocar ideias e interagir com alunos e outros interessados e pude perceber que o aprendizado é um processo que se constrói passo a passo. Nes-se processo, utilizar exemplos e levantar questionamentos sobre possíveis soluções ajuda o aluno (aprendiz) a assimilar de maneira mais efetiva o conteúdo. Agradeço a cada um dos alunos que ao longo de anos de ensino contribuíram com perguntas e curiosidades para a formação desse conteúdo. Também gostaria de agradecer aos colegas por serem pacientes com minha falta de atenção e afastamento enquanto escrevia este livro. Por fim, gostaria também de agradecer à Editora Campus/Elsevier e a toda equipe pelo empenho e dedicação na realização deste livro.


introd_00.indd 9 12/4/2010 10:30:06

introd_00.indd 10 12/4/2010 10:30:06

A quem se destina o livro

Quem deve ler e beneficiar-se deste livro? Ele é recomendado a estudantes dos cursos de computação, engenharias e correlatos de universidades e outras instituições de ensino superior, uma vez que contempla o conteúdo exigido nesses cursos.

introd_00.indd 11 12/4/2010 10:30:06

introd_00.indd 12 12/4/2010 10:30:06

Apresentação

A programação orientada a objetos (POO) é uma abordagem de programa-ção que serve de elo entre os problemas existentes e as soluções computacionais apresentadas no campo da programação. Antes da POO havia um obstáculo con-ceitual para os programadores quando eles tentavam adaptar as entidades reais às restrições impostas pelas linguagens e técnicas de programação tradicionais. Em uma situação real, o ser humano tende a raciocinar em termos dos objetos ou entidades reais. Todavia, vale lembrar que, antes da POO, os programadores eram ensinados a raciocinar sobre os problemas em termos de blocos de código ou procedimentos e forma como eles atuavam sobre os dados. Observe que essas duas abordagens são distintas e constituem um problema quando existe necessidade de desenvolver um sistema complexo.

A POO apresenta-se como um paradigma de programação que permite aos programadores raciocinar e solucionar problemas em termos de objetos, os quais estão diretamente associados às entidades ou “coisas” reais. Como resultado desse mapeamento natural, utilizando a POO um programador pode concentrar-se nos objetos que compõem o sistema, em vez de tentar vislumbrar o sistema como um conjunto de procedimentos e dados. Vale salientar que a POO é uma forma natural e lógica pela qual os seres humanos, especificamente os programadores, raciocinam. Os benefícios resultantes de empregar a POO como abordagem de programação não se restringem a raciocinar e resolver problemas em termos de objetos ou entidades reais, mas implicam a reutilização de código.

Além da identificação de uma técnica de programação adequada para imple-mentação de sistemas, há a necessidade de selecionar uma linguagem de programação. Neste texto, é empregada a linguagem C++ desenvolvida nos laboratórios da Bell por Bjarne Stroustrup. Embora a C++ mantenha algumas semelhanças com a linguagem C, oferece menor possibilidade de erros. Além disso, a C++ suporta características como, por exemplo, polimorfismo, herança e ocultação de dados, entre outras. Na

introd_00.indd 13 12/4/2010 10:30:06

prática, as diferenças entre C e C++ são maiores do que se possa imaginar. Programa-dores de C++ não apenas fazem uso dos aspectos da POO de C++ como também incrementam e aperfeiçoam os recursos oferecidos pela linguagem C. Nesse sentido, o objetivo deste livro é ajudar o leitor a solucionar problemas escrevendo programas em C++ e explorando recursos da orientação a objetos no menor tempo possível.

Devido ao exposto e à grande importância que a POO tem no contexto atual entre os paradigmas de programação, um texto didático que faça a introdução de pro-gramação orientada a objetos usando a linguagem C++ tem como objetivo fornecer os conceitos necessários aos estudantes de computação, engenharias e áreas afins.

introd_00.indd 14 12/4/2010 10:30:06

Sumário

Capítulo 1 – panorâmiCa da programação orientada a objetos ...................................1Objetivos ....................................................................................................................11.1. Introdução ......................................................................................................11.2. Origem da Programação Orientada a Objetos .........................................21.3. Limitações das Linguagens Procedimentais ..............................................3

1.3.1. Linguagens Procedimentais ........................................................31.3.2. Divisão do Programa em Funções ............................................41.3.3. Programação Estruturada ...........................................................41.3.4. Dados – Componente Essencial na Modelagem de um

Sistema ...........................................................................................51.3.5. Uso de Variáveis em Linguagens de Programação

Estruturada ....................................................................................51.3.6. Problemas de Programas Procedimentais ................................7

1.4. Características das Linguagens Orientadas a Objetos .............................71.4.1. A Abordagem de Orientação a Objetos ...................................71.4.2. Encapsulamento de Dados .........................................................81.4.3. Raciocínio em Termos de Objetos ............................................91.4.4. Classe ..............................................................................................91.4.5. Herança ........................................................................................101.4.6. Reusabilidade ..............................................................................111.4.7. Criação de Novos Tipos de Dados .........................................111.4.8. Polimorfismo e Overloading (Sobrecarga) .................................12

1.5. Diferenças entre C e C++ .........................................................................12Resumo .....................................................................................................................13Questões ...................................................................................................................13Exercícios .................................................................................................................13

Capítulo 2 – Componentes da linguagem C++ .............................................................15Objetivos ..................................................................................................................15

introd_00.indd 15 12/4/2010 10:30:06

2.1. Introdução ....................................................................................................152.2. Construção de um Programa ....................................................................16

2.2.1. Criando um Projeto no Ambiente Dev-C++ ........................162.2.2. Criando um Arquivo no Dev-C++ .........................................172.2.3. Removendo ou Renomeando um Arquivo ............................182.2.4. Compilando e Executando um Programa no Dev-C++ .....192.2.5. Entendendo o Programa em C++ ..........................................202.2.6. A Função main() .........................................................................212.2.7. Comentários ................................................................................22

2.3. Uso de Cout .................................................................................................222.3.1. Entendendo o uso do Objeto cout .........................................232.3.2. Operador << ..............................................................................23

2.4. Diretivas do Pré-processador ....................................................................232.4.1. Diretivas do Pré-processador ...................................................232.4.2. Diretiva #define .........................................................................24

2.5. Uso de Variáveis ..........................................................................................252.5.1. Variáveis do Tipo Inteiro ..........................................................262.5.2. Nomes de Variáveis ...................................................................27

2.6. Entrada Usando CIN .................................................................................272.6.1. Entendendo o Uso do Objeto cin ...........................................272.6.2. Operador >> ..............................................................................27

2.7. Manipuladores .............................................................................................292.7.1. Entendendo Manipuladores .....................................................292.7.2. Operador endl .............................................................................302.7.3. Operador setw ............................................................................32

2.8. Tipos de Variáveis (Dados) ........................................................................332.8.1. Constantes do Tipo Inteiro ......................................................342.8.2. Variáveis do Tipo char ...............................................................342.8.3. Constante do Tipo char.............................................................342.8.4. Variáveis do Tipo Ponto Flutuante ou Real ...........................352.8.5. Qualificador const ......................................................................372.8.6. Tipo de Dados long ...................................................................372.8.7. Definições Múltiplas ..................................................................382.8.8. Sumário de Tipos de Variáveis .................................................382.8.9. Tipos de Dados unsigned .........................................................40

2.9. Conversão de Tipos ....................................................................................422.9.1. Conversões Automáticas ...........................................................432.9.2. Casts .............................................................................................43

2.10. Operadores Aritméticos .............................................................................45

introd_00.indd 16 12/4/2010 10:30:06

2.10.1. Operadores de Atribuição Aritmética .....................................462.10.2. Operadores de Incremento .......................................................47

2.11. Funções de Biblioteca .................................................................................48Resumo .....................................................................................................................50Questões ...................................................................................................................50Exercícios .................................................................................................................50

Capítulo 3 – laços e deCisões .......................................................................................53Objetivos ..................................................................................................................533.1. Introdução ....................................................................................................543.2. Operadores Relacionais ..............................................................................54

3.2.1. Operadores Relacionais .............................................................553.3. Laços .............................................................................................................56

3.3.1. Laço for .......................................................................................563.3.2. Instrução for ...............................................................................583.3.3. Loop while...................................................................................613.3.4. Loop do .......................................................................................64

3.4. Decisões ........................................................................................................663.4.1. if... else..........................................................................................663.4.2. Aninhamento (Nesting) de ifs (dentro de laços) ......................683.4.3. if... else..........................................................................................693.4.4. Função getche() ..........................................................................713.4.5. if... else aninhados ......................................................................723.4.6. else... if .........................................................................................753.4.7. Switch ...........................................................................................763.4.8. Operador Condicional ...............................................................79

3.5. Operadores Lógicos ....................................................................................813.5.1. Operador Lógico E (AND) ......................................................813.5.2. Operador Lógico OU (OR) ......................................................833.5.3. Operador Lógico NÃO (NOT) ...............................................84

3.6. Expressões Lógicas .....................................................................................853.7. Precedência de Operadores .......................................................................863.8. Mais Mecanismos de Controle ..................................................................87

3.8.1. Break ............................................................................................873.8.2. Continue ......................................................................................87

Resumo .....................................................................................................................89Questões ...................................................................................................................89Exercícios .................................................................................................................90

introd_00.indd 17 12/4/2010 10:30:06

Capítulo 4 – estruturas ................................................................................................91Objetivos ..................................................................................................................914.1. Introdução ....................................................................................................92

4.1.1. Estrutura ......................................................................................924.2. Estruturas Simples ......................................................................................92

4.1.1. Estrutura ......................................................................................924.3. Especificação de Estrutura ........................................................................94

4.3.1. Definição de Estrutura ..............................................................944.3.2. Definição de uma Variável do Tipo Estrutura ......................95

4.4. Acesso a Membros de Estrutura ..............................................................954.4.1. Acesso a Membros de Estrutura .............................................954.4.2. Definição de Estruturas sem Rótulo (tag) ..............................954.4.3. Inicialização de Membros da Estrutura ..................................964.4.4. Estruturas Dentro de Estruturas ...........................................1004.4.5. Tipos de Dados Enumerados (Enumerated Data Types).......1004.4.6. Especificador enum .................................................................102

4.5. Estruturas e Classes ..................................................................................1054.5.1. Estruturas ..................................................................................1054.5.2. Classes ........................................................................................1054.5.3. Diferenças entre Estruturas e Classes ...................................105

Resumo ...................................................................................................................106Questões .................................................................................................................106Exercícios ...............................................................................................................106

Capítulo 5 – Funções ................................................................................................... 107Objetivos ................................................................................................................1075.1. Introdução ..................................................................................................108

5.1.1. Função .......................................................................................1085.1.2. Sintaxe de Função ....................................................................108

5.2. Passagem de Argumentos em Funções .................................................1115.2.1. Passagem de Argumentos .......................................................111

5.3. Retorno de Valores de Funções ..............................................................1165.3.1. Definição de Tipo de Retorno ...............................................118

5.4. Argumentos de Referência.......................................................................1185.4.1. Variável de Referência .............................................................1185.4.2. Passagem de Argumento por Referência ..............................1195.4.3. Usando Referência para Retornar Valores ...........................121

5.5. Funções Sobrecarregadas .........................................................................1225.6. Funções Inline ...........................................................................................124

5.6.1. Problema com Inserção Repetida de Função ......................1245.6.2. Função inline .............................................................................125

introd_00.indd 18 12/4/2010 10:30:07

5.7. Retorno por Referência ............................................................................1285.7.1. Referência ..................................................................................1285.7.2. Função Retornando Referência .............................................128

5.8. Tópicos Complementares ........................................................................1295.8.1. Argumentos Default ................................................................1295.8.2. Categorias de Variáveis e Armazenamento

(ou Memória) ............................................................................1325.8.3. Variável automatic ....................................................................1325.8.4. Tempo de Vida de Variável .....................................................1335.8.5. Visibilidade de Variável ...........................................................1335.8.6. Variáveis Locais ........................................................................1335.8.7. Variável External ......................................................................1345.8.8. Variáveis Globais ......................................................................134


Capítulo 6 – objetos e Classes .................................................................................... 139Objetivos ................................................................................................................1396.1. Introdução ..................................................................................................139

6.1.1. Objetos e Classes ......................................................................1406.1.2. Atributos e Operações em Classes ........................................1406.1.3. Mensagens (Funções-membros) ............................................1406.1.4. Herança ......................................................................................1406.1.5. Polimorfismo ............................................................................1406.1.6. Encapsulamento .......................................................................1416.1.7. Abstração (de Dados) ..............................................................1416.1.8. Exemplificando uma Classe ....................................................1416.1.9. Ocultação de Dados ................................................................1426.1.10. Dado private..............................................................................1436.1.11. Função public ...........................................................................1436.1.12. Função-membro .......................................................................143

6.2. Objetos C++ .............................................................................................1446.3. Classes e Objetos.......................................................................................146

6.3.1. Classes, Objetos e Memória ....................................................1466.3.2. Objetos C++ como Tipos de Dados ....................................147

6.4. Construtores e Destrutores .....................................................................1496.4.1. Construtor .................................................................................1496.4.2. Inicialização com Construtor .................................................1516.4.3. Destrutor ...................................................................................152

introd_00.indd 19 12/4/2010 10:30:07

6.5. Objetos como Argumentos e Retorno de Função ...............................1526.5.1. Objetos como Argumentos de Função ................................152

6.6. Retorno de Objetos de Funções .............................................................1566.7. Abstração e Encapsulamento ..................................................................157

6.7.1. Abstração ...................................................................................1576.7.2. Encapsulamento .......................................................................157

6.8. Dados de Classe static ..............................................................................1606.8.1. Dado-membro static ................................................................160


Capítulo 7 – arrays ...................................................................................................... 165Objetivos ................................................................................................................1657.1. Introdução ..................................................................................................165

7.1.1. Arrays .........................................................................................1657.1.2. Definição de Arrays .................................................................1667.1.3. Diferença entre Arrays e Estruturas......................................166

7.2. Princípios de Uso de Arrays ....................................................................1667.2.1. Regras para Declaração de Array ...........................................167

7.3. Declaração, Inicialização e Acesso De Arrays ......................................1707.3.1. Declaração de Array ................................................................1707.3.2. Inicialização de Array ..............................................................1707.3.3. Arrays de Múltiplas Dimensões .............................................1727.3.4. Formatação de Números Decimais .......................................174

7.4. Arrays como Dado de Classe ..................................................................1767.4.1. Pilha – Estrutura de Dado ......................................................1777.4.2. Operação da Pilha ....................................................................179

7.5. Arrays de Objetos .....................................................................................1797.6. Strings e Arrays ..........................................................................................181

7.6.1. Função cin::get() .......................................................................1867.6.2. Usando get() para Ler Múltiplas Linhas ...............................1877.6.3. Função strcpy ............................................................................1877.6.4. Função strlen() ..........................................................................1887.6.5. Array de strings .........................................................................1917.6.6. Strings como Membros de Classes ........................................192


introd_00.indd 20 12/4/2010 10:30:07

Capítulo 8 – sobreCarga de operadores ..................................................................... 195Objetivos ................................................................................................................1958.1. Introdução ..................................................................................................195

8.1.1. Sobrecarga de Operadores ......................................................1968.2. Sobrecarga de Operadores Unários........................................................1968.3. Sobrecarga de Operadores Binários .......................................................2058.4. Sobrecarga de Operadores Associados a Funções ...............................213

8.4.1. Sobrecarga do Operador [ ] ....................................................2138.5. Conversão de Dados .................................................................................2158.6. Funções Friend ..........................................................................................2198.7. Aplicações e Restrições de Uso ...............................................................222

8.7.1. Conversão entre Objetos de Classes Diferentes .................222Resumo ...................................................................................................................225Questões .................................................................................................................225Exercícios ...............................................................................................................226

Capítulo 9 – Herança ..................................................................................................227Objetivos ................................................................................................................2279.1. Introdução ..................................................................................................228

9.1.1. Herança ......................................................................................2289.1.2. Classe Derivada ........................................................................2289.1.3. Importância da Herança ..........................................................2289.1.4. Reusabilidade ............................................................................228

9.2. Classes Base e Derivada ...........................................................................2289.3. Construtores de Classe .............................................................................232

9.3.1. Construtores de Classes Derivadas .......................................2329.4. Herança em Classe ....................................................................................235

9.4.1. Ignorando Funções-membros ................................................2359.5. Hierarquia e Níveis de Classe ..................................................................238

9.5.1. Classe Abstrata .........................................................................2429.6. Herança com public e private ..................................................................242

9.6.1. Herança usando public e private ............................................2429.6.2. Níveis de Herança ....................................................................245

9.7. Herança Múltipla .......................................................................................2499.7.1. Ambiguidade em Herança Múltipla .......................................253


introd_00.indd 21 12/4/2010 10:30:07

Capítulo 10 – ponteiros e apliCações .........................................................................255Objetivos ................................................................................................................25510.1. Introdução a Ponteiros .............................................................................256

10.1.1. Ponteiros ....................................................................................25610.1.2. Entendendo Ponteiros .............................................................256

10.2. Operadores Endereço e Ponteiro ...........................................................25710.2.1. Operador de Endereço ............................................................257

10.3. Operações com Ponteiros ........................................................................26010.4. Objetos Dinâmicos com Ponteiros ........................................................263

10.4.1. Alocação Dinâmica de Memória ............................................26410.5. Ponteiros como Argumentos ..................................................................26810.6. Classes Lista, Pilha e Fila..........................................................................270

10.6.1. Lista ............................................................................................27010.6.2. Pilha ............................................................................................27110.6.3. Fila ..............................................................................................273


Capítulo 11 – eduCação Continuada ...........................................................................277Objetivos ................................................................................................................27711.1. Retrospecto ................................................................................................27711.2. Prospecto ....................................................................................................28011.3. Aplicações na Engenharia ........................................................................28211.4. Sugestões de Leitura .................................................................................283

introd_00.indd 22 12/4/2010 10:30:07

antonio mendes da silva filho - s3.amazonaws.com livro é um relato de recente trabalho na área de...

Documents