1.
Programação Orientada para Objetos com C++ José Luiz de Souza Pio UFMG Belo Horizonte – Minas Gerais Abril de 2002

2.
Programa <ul><li>Conceitos Básicos (4 horas) </li></ul><ul><li>Projeto de Programas OO (12 horas) </li></ul><ul><li>Linguagem C++ (12 horas) </li></ul><ul><li>Aplicação (12 horas) </li></ul>

3.
Introdução <ul><li>Projeto de Programas </li></ul><ul><ul><li>Técnicas que visam garantir: </li></ul></ul><ul><ul><ul><li>Qualidade </li></ul></ul></ul><ul><ul><ul><li>Confiabilidade </li></ul></ul></ul><ul><ul><ul><li>Clareza </li></ul></ul></ul><ul><ul><ul><li>Facilidade de manutenção </li></ul></ul></ul><ul><ul><li>Conceito Fundamental: TAD (Tipo abstrato de Dados) </li></ul></ul>

4.
Introdução <ul><li>Abstração de Dados </li></ul><ul><ul><li>Programa = modelo para a solução de um problema </li></ul></ul><ul><ul><li>Abstração de dados </li></ul></ul><ul><ul><ul><li>Representação abstrata dos dados da aplicação </li></ul></ul></ul><ul><ul><li>TAD </li></ul></ul><ul><ul><ul><li>Definição de dados associados as suas operações </li></ul></ul></ul>

5.
Introdução <ul><li>Técnicas </li></ul><ul><ul><li>Programação não estruturada </li></ul></ul><ul><ul><li>Programação estruturada </li></ul></ul><ul><ul><li>Programação modular </li></ul></ul>

6.
Introdução <ul><li>Programação não estruturada (espaguete) </li></ul>

7.
Introdução <ul><li>Programação Estruturada </li></ul>

8.
Introdução <ul><li>Programação Estruturada </li></ul><ul><ul><li>Objetivos </li></ul></ul><ul><ul><ul><li>Gerar programas altamente legíveis (clareza) </li></ul></ul></ul><ul><ul><ul><li>Hierarquia funcional descrita através de estruturas de controle </li></ul></ul></ul><ul><ul><ul><ul><li>(If - then – else) – (while) – (for) – (do) </li></ul></ul></ul></ul><ul><ul><ul><li>O código produzido deve ser lido seqüencialmente em pequenos segmentos de código </li></ul></ul></ul>

9.
Introdução <ul><li>Vantagens: </li></ul><ul><ul><li>Programa correto desde a sua concepção (!?) </li></ul></ul><ul><ul><li>Clareza no código </li></ul></ul><ul><ul><li>Menor tempo de depuração </li></ul></ul><ul><ul><li>Teste mais fácil </li></ul></ul><ul><ul><li>Interessados na metodologia  Método de Jackson </li></ul></ul>

10.
Introdução <ul><li>Programação Modular </li></ul><ul><ul><li>Organização do programa em módulos </li></ul></ul><ul><ul><li>Utilização de módulos executáveis </li></ul></ul>

11.
Introdução <ul><li>Como modularizar? </li></ul><ul><ul><li>1. Desmembrar o programa, ou módulo, em um módulo raiz e um ou mais submódulos, cujo o conjunto satisfaça à especificação do programa ou módulo; </li></ul></ul><ul><ul><li>2. Definir as interfaces entre o módulo raiz e os submódulos. Estas interfaces determinam os dados passados ao ativar, os resultados retornados e as assertivas de entrada e a saída dos diversos módulos; </li></ul></ul><ul><ul><li>3. Repetir os passos 1 e 2 até obter uma organização modular satisfatória; </li></ul></ul><ul><ul><li>4. Empacotar a organização modular lógica completa, produzindo uma organização modular física, onde cada módulo físico corresponda a um subprograma bem definido e identificável. </li></ul></ul>

12.
Introdução <ul><li>Vantagens da Programação Modular </li></ul><ul><ul><li>A possibilidade de desenvolver programas complexos em equipe </li></ul></ul><ul><ul><li>Aumento do grau de paralelismo na produção </li></ul></ul><ul><ul><li>Redução da depuração </li></ul></ul><ul><ul><li>Redução da manutenção </li></ul></ul><ul><ul><li>Reutilização do modulo </li></ul></ul>

13.
Introdução <ul><li>Problema: </li></ul><ul><ul><li>Separação entre dados e procedimentos </li></ul></ul><ul><li>Solução: </li></ul><ul><ul><li>Dependência mútua entre dados e procedimentos </li></ul></ul><ul><li>Este é o principal aspecto das linguagens que suportam OO </li></ul>

14.
POO <ul><li>Orientação para Objetos </li></ul><ul><ul><li>A dependência mútua entre as estruturas de dados utilizadas em um programa e as operações que as acessam. Essa associação é inevitável, por dois motivos: </li></ul></ul><ul><ul><li>- Só é possível exercer operações diretas sobre uma estrutura de dados se conhecermos a forma como ela está implementada; </li></ul></ul><ul><ul><li>- As estruturas de dados são organizadas para que as operações realizadas sobre elas sejam implementadas de forma eficiente. </li></ul></ul>

15.
POO Operações Estrutura de dados Dependência Mútua Como ficam as estruturas de dados globais?

16.
POO Decisões de Projeto Estruturas Operações Decomposição Coloque juntas todas as decisões de projeto relacionadas

17.
POO <ul><li>Elemento capaz de: </li></ul><ul><ul><li>Agrupar várias operações; </li></ul></ul><ul><ul><li>Suportar a declaração de ED que não é global nem volátil como uma variável local. </li></ul></ul><ul><li>Objeto = Resultado da união inseparável entre uma ED e todas as operações associadas. </li></ul>

18.
POO <ul><li>O programa é decomposto em características que são implementadas de acordo com as mesmas decisões de projeto, não mais em funções desempenhadas. </li></ul>

19.
Objetos e Métodos <ul><li>Um objeto é composto por um conjunto de dados privados é um conjunto de métodos que atuam sobre estes dados. </li></ul>

20.
Objetos e Métodos OBJETO Dados Privados Métodos Métodos são formados por sua interface e implementação Variáveis locais a cada objeto Todos os elementos do sistema são representados por objetos que podem ser gerados um número arbitrário de vezes durante a execução do programa.

21.
Métodos e Objetos <ul><li>Em um programa, a declaração de um novo objeto deve ser constituída dos seus dados privados e de seus métodos; </li></ul><ul><li>Métodos: </li></ul><ul><ul><li>Interface: interface descreve a parte visível do método, seu nome, tipos de parâmetros, e valor de retorno . </li></ul></ul><ul><ul><li>Implementação: implementação contém o código efetivo para operação, inclusive chamadas a outros métodos do objeto. </li></ul></ul>

22.
Métodos e Objetos <ul><li>Exemplo </li></ul>Círculo X, Y, Raio CalculaArea CalculaPerimetro DesenhaCirculo

23.
Métodos e Objetos <ul><li>Como seria a interface do método CalculaArea? </li></ul><ul><li>Como seria sua implementação? </li></ul>

24.
Métodos e Objetos <ul><li>Questões </li></ul><ul><ul><li>Explique por que existe dependência mútua entre ED e operações. </li></ul></ul><ul><ul><li>Que são as decisões de projetos? </li></ul></ul><ul><ul><li>Qual a necessidade dos dados privados a um objeto? </li></ul></ul><ul><ul><li>É necessário conhecer a implementação de um objeto para utiliza-lo? </li></ul></ul><ul><ul><li>Qual a vantagem que diferentes objetos terem métodos com nomes iguais? </li></ul></ul>

25.
Métodos e Objetos <ul><li>Exercícios </li></ul><ul><ul><li>Esboce um objeto para calcular propriedade geométricas de retângulos. </li></ul></ul><ul><ul><li>Esboce um objeto chamado Médias, cujo o objetivo é calcular diferentes tipos de médias (aritmética, ponderada, geométrica, etc). </li></ul></ul><ul><ul><li>Projete um objeto chamado dispersão, cujo o objetivo e calcular diferentes tipos de medidas de dispersão. </li></ul></ul>

26.
Classes, Instâncias e Mensagens <ul><li>Classe: Modelo a partir do qual os objetos são criados; </li></ul><ul><li>Exemplo: </li></ul><ul><li>Tom, Garfield, Frajola, Manda-chuva e Batatinha. São todos da mesma classe: Gatos </li></ul>

27.
Classes, Instâncias e Mensagens <ul><li>Uma melhor definição: </li></ul><ul><li>“ Classe é um agrupamento de objetos que revelam profundas semelhanças entre si, tanto no aspecto estrutural quanto no funcional”. </li></ul>

28.
Classes, Instâncias e Mensagens <ul><li>Uma classe é um tipo definido pelo usuário que contém o molde, a especificação para os objetos, assim como o tipo inteiro contém o molde para as variáveis declaradas como inteiros. A classe envolve, associa, métodos e dados, controlando o acesso a estes, defini-la implica em especificar os seus ATRIBUTOS (dados) e seus SERVIÇOS (código). </li></ul>

29.
Classes, Instâncias e Mensagens <ul><li>Uma representação gráfica para as classes </li></ul>Nome da Classe Atributos Serviços Característica comum aos objetos descritos pela classe Alguma operação que pode ser solicitada pelo objeto Coad & Yourdon

30.
Classes, Instâncias e Mensagens <ul><li>TODO OBJETO É UMA INSTÂNCIA DE UMA CLASSE </li></ul><ul><li>OBJETOS SÃO CRIADOS DURANTE A EXECUÇÃO DO PROGRAMA, E OCUPAM ESPAÇO NA MEMÓRIA </li></ul><ul><li>TODAS AS INSTÂNCIAS DE UMA CLASSE OBEDECEM AO MESMO PROTOCOLO </li></ul>

31.
Classes, Instâncias e Mensagens Motor Cabo elétrico Disco de serra Correia Serra Elétrica Serra E létrica Martelete Furadeira Prensa

32.
Classes, Instâncias e Mensagens <ul><li>PROTOCOLO: É o conjunto de métodos implementados para uma classe </li></ul><ul><li>VARIÁVEIS DE INSTÂNCIA: Elementos que compõe a coleção de dados privados de uma classe </li></ul><ul><li>ESTADO INTERNO: Conjunto de valores assumidos pelas variáveis de instância </li></ul>

33.
Classes, Instâncias e Mensagens Protocolo Parte visível Parte privada Variáveis de Instância e métodos Classe

34.
Classes, Instâncias e Mensagens <ul><li>Exemplo </li></ul>CanetaGráfica Coordenadas MoveTo LineTo

35.
Classes, Instâncias e Mensagens Bic Paker Y X 4 20 Y X 200 10 Instâncias da classe CanetaGráfica Estado interno Variáveis de instância

36.
Classes, Instâncias e Mensagens <ul><li>Um estado interno de um objeto muda cada vez que se modifica o valor de uma de suas variáveis de instância. </li></ul><ul><li>É interessante que os objetos possuam um estado inicial conhecido (construtores). </li></ul><ul><li>Métodos destrutores são utilizados para liberar a memória. </li></ul>

37.
Classes, Instâncias e Mensagens <ul><li>Mensagem: Ativa um método de um objeto </li></ul>t = 50 Lig = TRUE Mensagem Composta por um seletor e um conjunto de parâmetros Resposta Resultado da execução do método máquina A t = 0 Lig = FALSE t = 50 Lig = TRUE máquina A Mensagem Resposta Máquina(50, TRUE)

38.
Classes, Instâncias e Mensagens <ul><li>Questões </li></ul><ul><ul><li>É vantajoso definir um protocolo extenso para uma classe? </li></ul></ul><ul><ul><li>Por que um objeto deve ter um estado inicial bem definido? </li></ul></ul><ul><ul><li>Chamada a procedimento = envio de mensagem? </li></ul></ul><ul><ul><li>Qual a relação existente entre a resposta a uma mensagem e o estado interno de um objeto receptor? </li></ul></ul><ul><ul><li>Ao projetar uma classe deve-se pensar primeiro nos dados ou nos métodos? </li></ul></ul>

39.
Classes, Instâncias e Mensagens Objeto 1 Dados Objeto n Dados Objeto 2 Dados Objeto 6 Dados Objeto 5 Dados Objeto 3 Dados Objeto 4 Dados

40.
Encapsulamento <ul><li>Impede ao cliente enxergar os detalhes da implementação do objeto </li></ul>Interface Sistema Interface Parte Privada O que o cliente vê O que o projetista vê

41.
Encapsulamento <ul><li>O Encapsulamento favorece o ocultamento da informação ( information hiding ), possibilitando que os dados de cada objeto só sejam acessíveis e modificados através de seus métodos. </li></ul>

42.
Encapsulamento <ul><li>REGRAS DO ENCAPSULAMENTO </li></ul><ul><ul><li>Regra 1 </li></ul></ul><ul><ul><ul><li>Apenas os métodos devem ser capazes de alterar o estado interno de um objeto </li></ul></ul></ul><ul><ul><li>Regra 2 </li></ul></ul><ul><ul><ul><li>A resposta a uma mensagem deve ser completamente determinada pelo estado interno do objeto </li></ul></ul></ul>

43.
Encapsulamento <ul><li>Conseqüências </li></ul><ul><ul><li>Regra 1: Não é possível acessar o valor de uma variável de instância externamente. </li></ul></ul><ul><ul><li>Regra 2: Se duas instâncias de uma mesma classe possuem o mesmo estado interno, então devem responder a mensagens iguais de forma idêntica (o comportamento de uma classe deve ser muito bem estabelecido). </li></ul></ul>

44.
Encapsulamento <ul><li>Se um valor for utilizado por um método ele pode ser: </li></ul><ul><ul><ul><li>Uma variável de instância do objeto; </li></ul></ul></ul><ul><ul><ul><li>Um parâmetro formal; </li></ul></ul></ul><ul><ul><ul><li>Uma variável local; </li></ul></ul></ul><ul><ul><ul><li>Uma constante local; </li></ul></ul></ul><ul><ul><ul><li>Uma constante global. </li></ul></ul></ul><ul><ul><li>Não se deve acessar variáveis globais da aplicação no interior de um método </li></ul></ul>

45.
Encapsulamento <ul><li>Reusabilidade: reaproveitamento dos componentes. Com o encapsulamento os objetos se tornam mais reutilizável. </li></ul><ul><li>Aumenta a produtividade. </li></ul>

46.
Encapsulamento <ul><li>Manutenabilidade: Impacto que as modificações causam no funcionamento de um sistema. </li></ul><ul><li>O encapsulamento favorece mudanças com efeitos mínimos e bem localizados </li></ul>

47.
Encapsulamento <ul><li>Questões </li></ul><ul><ul><li>Quais problemas ocorrem com o desrespeito a Regra 1? </li></ul></ul><ul><ul><li>E a Regra 2? </li></ul></ul><ul><ul><li>Que tipo de mudanças o projetista pode fazer em uma classe com a garantia de que seus clientes não serão afetados </li></ul></ul>

48.
Encapsulamento <ul><li>Exercícios </li></ul><ul><ul><li>Defina classes para representar figuras geométricas, como círculos e retângulos. Que características elas têm em comum? </li></ul></ul><ul><ul><li>Imagine que você está projetando um sistema de controle bancário. Defina o objeto conta corrente e as operações que ele deve ser capaz de efetuar. Quais são as semelhanças com o objeto Poupança? Quais são as diferenças? </li></ul></ul>

49.
Herança e Polimorfismo <ul><li>Herança é um mecanismo simples e poderoso que permite que uma nova classe seja descrita a partir de outra classe já existente, herdando as suas propriedades. </li></ul>

50.
Herança e Polimorfismo <ul><li>Diz-se que uma subclasse herda os métodos e as variáveis de instância de uma superclasse. </li></ul><ul><ul><li>A subclasse deve ser capaz de adicionar novos métodos e variáveis de instância as originais, além de redefinir os métodos herdados. </li></ul></ul><ul><ul><li>Uma subclasse é uma especialização de uma superclasse. </li></ul></ul><ul><ul><li>Uma instância da subclasse têm todas as propriedades de uma instância da superclasse, mais suas características particulares, e nunca menos. </li></ul></ul>

51.
Herança e Polimorfismo classe B Dados B Métodos B classe C Dados B Dados C Métodos B Métodos C

52.
Herança e Polimorfismo superclasse subclasses Representação gráfica para a Herança Especialização

53.
Herança e Polimorfismo <ul><li>Hierarquia de classes </li></ul><ul><ul><li>Classes mais genéricas ficam próximas ao topo e as mais especializadas na parte inferior. </li></ul></ul>

54.
Herança e Polimorfismo A herança múltipla classe A classe B classe C Dados A Métodos A Dados B Métodos B Dados A Dados B Dados C Métodos A Métodos B Métodos C

55.
Herança e Polimorfismo <ul><li>Polimorfismo </li></ul><ul><ul><li>É desejável que certos métodos tenham um comportamento diferente de acordo com o a instância corrente, isto é alcançado através do mecanismo chamado de polimorfismo, e os métodos envolvidos são chamados de virtuais, que podem atuar em qualquer nível da hierarquia. </li></ul></ul>

56.
Herança e Polimorfismo <ul><li>Polimorfismo </li></ul><ul><ul><li>É um conceito complementar a herança que permite enviar a mesma mensagem a objetos distintos e que cada objeto responda de maneira mais apropriada para a sua classe. A vantagem que se obtém com o polimorfismo é a possibilidade uniforme para o tratamento de objetos distintos </li></ul></ul>

57.
Herança e Polimorfismo <ul><li>Quando uma mensagem é enviada a um objeto polimórfico, não é possível determinar previamente qual o endereço do objeto. E agora? </li></ul><ul><li>O mecanismo que permite a resolução de endereços em tempo de execução chama-se ligação dinâmica. </li></ul>

58.
Herança e Polimorfismo <ul><li>Extensibilidade: Vantagem adicional obtida com o uso da herança e do polimorfismo. Permite que uma subclasse seja criada para incorporar os requisitos específicos de uma nova aplicação. </li></ul>

59.
Herança e Polimorfismo <ul><li>Conclusões </li></ul><ul><ul><li>Programação Orientada para Objetos não é a mesma coisa que programação com objetos; </li></ul></ul><ul><ul><li>Com POO se obtém: </li></ul></ul><ul><ul><ul><li>Reusabilidade </li></ul></ul></ul><ul><ul><ul><li>Manutenibilidade </li></ul></ul></ul><ul><ul><ul><li>Extensibilidade </li></ul></ul></ul>

60.
Herança e Polimorfismo <ul><li>Questões </li></ul><ul><ul><li>O que é o mecanismo de ligação dinâmica? </li></ul></ul><ul><ul><li>Em que situação a identidade de um objeto é conhecida em tempo de execução? </li></ul></ul><ul><ul><li>Sem polimorfismo e ligação dinâmica como seria feita a inclusão de um novo objeto em um programa? </li></ul></ul>

61.
Herança e Polimorfismo <ul><li>Exercícios </li></ul><ul><ul><li>Implemente novos tipos de figuras geométricas, expandindo, através da herança e do polimorfismo, a hierarquia anteriormente desenvolvida. </li></ul></ul><ul><ul><li>Como poderia ser estruturada uma hierarquia incluindo as classes ContaCorrente e Poupança? </li></ul></ul>

62.
Classes e Objetos em C++

63.
Classes e Objetos em C++ <ul><li>Uma definição de classe é basicamente uma definição de um tipo de dado. </li></ul><ul><li>Em geral, as operações são públicas e os dados internos da classe são privados - as únicas modificações possíveis nos dados são realizadas através das operações que a classe deixa disponível para que o público use. </li></ul>

64.
Classes e Objetos em C++ <ul><li>A informação que permanece escondida do usuário da classe está contida na seção privativa da classe. Os dados não podem ser acessados ou modificados diretamente. </li></ul>

65.
Classes e Objetos em C++ <ul><li>É possível que dados internos sejam acessados externamente; para tanto, deve-se colocar estes dados na seção pública da classe. </li></ul>

66.
Classes e Objetos em C++ <ul><li>Funções declaradas dentro de uma classe são chamadas de funções membros . Funções membros são definidas da mesma forma que funções normais -- a única diferença visível é que o nome da função é precedido pelo nome da classe, sendo os nomes separados por ::. </li></ul>

67.
Classes e Objetos em C++ <ul><li>Em geral, a parte privativa da classe contém apenas dados, enquanto que a parte pública contém apenas declarações de funções. Entretanto, nada impede que dados sejam declarados também na parte pública e funções na parte privativa. </li></ul>

68.
Classes e Objetos em C++ <ul><li>Exemplo </li></ul>Class Tempo{ public: Time(); void SetTime(int, int, int); void PrintPadrao(); void PrintMilitar(); private: int hora; int minuto; int segundo; }; Construtor Interface de classe Só são acessados por funções membro ou friend

69.
Classes e Objetos em C++ <ul><li>Implementação das funções membro </li></ul>Tempo::Tempo{ hora = 0; minuto = 0; segundo = 0; } void Time::SetTime(int h, int m, int s){ hora = (h>=0 && h < 24) ? h : 0; minuto = (m>=0 && m<60) ? m : 0; segundo =(s>=0 && s<60) ? S : 0; } void Time::PrintMilitar(){ cout << (hora<10 ? ‘’0’’ : ‘’ ‘’) <<hora << ‘’:’’ << (minuto < 10 ? ‘’0’’: ‘’ ‘’) << minuto; } Completar Obs: Isto é um if!

70.
Classes e Objetos em C++ <ul><li>Usando os objetos </li></ul>int main (){ Tempo t; cout<< ‘’A hora militar eh’’; t.PrintMilitar(); : : } Cria o objeto Usa a função membro

71.
Classes e Objetos em C++ <ul><li>Onde ficam as classes? </li></ul><ul><ul><ul><li>A implementação pode ser feita na própria definição da classe (inline); </li></ul></ul></ul><ul><ul><ul><li>Usual: </li></ul></ul></ul><ul><ul><ul><ul><li>Definições (protótipos das funções membro e dados) em arquivo cabeçalho; </li></ul></ul></ul></ul><ul><ul><ul><ul><li>Implementação em arquivo .cpp; </li></ul></ul></ul></ul>

72.
Classes e Objetos em C++ <ul><li>Especificadores de acesso as classes </li></ul><ul><ul><ul><ul><li>public: Qualquer membro de dados ou funções membro são acessíveis, onde quer que o programa tenha que acessar algum objeto da classe. </li></ul></ul></ul></ul><ul><ul><ul><ul><li>private: Qualquer membro de dados ou função membro são acessíveis somente pelas funções membro da classe. </li></ul></ul></ul></ul>

73.
Classes e Objetos em C++ <ul><li>Mas o que é uma função amiga? </li></ul><ul><ul><ul><li>São rotinas que pertencem a uma classe, mas podem ser usadas em outra sem qualquer vínculo de Herança o u Associativo com esta . </li></ul></ul></ul>

74.
Classes e Objetos em C++ class TPessoa { protected: char* pcNome; int nIdade; public: void Anda(void); friend; } class TAnimal { protected: char* pcNome; char* pcCientNome; public: void Anda(void); } void TPessoa::Anda(void) { ... } Apesar de estar definida nas duas classes, só teremos a implementação do método Anda de TPessoa:

75.
Classes e Objetos em C++ <ul><li>Definindo objetos </li></ul>Tempo sunset, ArraydeTempos[5], *ptToTime;

76.
Classes e Objetos em C++ <ul><li>Escopo da Classe e acesso a membros </li></ul><ul><ul><li>Membro de dados e funções membro formam o escopo da classe; </li></ul></ul><ul><ul><li>Variáveis definidas em uma função membro tem o escopo da função; </li></ul></ul><ul><ul><li>Os membros são acessados por operadores de acesso a membros. </li></ul></ul>

77.
Classes e Objetos em C++ <ul><li>Operadores de acesso a membros </li></ul><ul><ul><ul><li>Operador ponto (.) - Combina o nome do objeto com uma referência ao objeto para acessar membro; </li></ul></ul></ul><ul><ul><ul><li>Operador seta (->) - Combina um ponteiro para um objeto para acessar os membros do objeto. </li></ul></ul></ul>

78.
Classes e Objetos em C++ <ul><li>Exemplo </li></ul>Class Contador{ public: int x; void PrintX(){ cout << x;} }; int main(){ Contador conta; *ptConta = &conta; conta.x = 7; conta.PrintX(); ptConta->x = 8; ptConta->PrintX(); }

79.
Classes e Objetos em C++ <ul><li>Revisão </li></ul><ul><ul><ul><ul><ul><li>Classes habilitam a modelagem dos objetos com atributos e comportamentos; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Em C++, as classes são definidas usando a palavra reservada class (obs: struct); </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>O nome da classe é utilizado para declarar os objetos pertencentes a classe; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>As definições de classe começam com a palavra reservada class. O corpo da classe é delimitado por “{“e “ }” e termina com “;”; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Qualquer membro de dados ou função membro declarado depois de public: em uma classe é visível a qualquer função com acesso a um objeto da classe. </li></ul></ul></ul></ul></ul>

80.
Classes e Objetos em C++ <ul><ul><ul><ul><ul><li>Qualquer membro de dados ou função membro declarada depois de private: só é visível para friends e outros membros da classe; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Um construtor é uma função membro especial, usada para inicializar os membros de um objeto da classe; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>A interface da classe é definida pelas funções membro public; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Funções membro definidas fora da classe: Usar operador :: </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Funções definidas fora da classe estão dentro do escopo da classe; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Acesso aos membros: operadores . e -> </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Definições da classe colocadas em arquivos cabeçalhos </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Definições das funções membro em arquivo .cpp com mesmo nome base </li></ul></ul></ul></ul></ul>

81.
Classes e Objetos em C++ <ul><ul><ul><ul><ul><li>Dentro do escopo da classe a referência aos membros é feita através do nome do membro; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Fora do escopo da classe a referência é feita através do nome do objeto, uma referência para o objeto ou um ponteiro para o objeto; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Normalmente os membros de dados de uma classe são declarados private e as funções membro declaradas como public; </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Algumas funções membro podem ser private (funções de baixo nível); </li></ul></ul></ul></ul></ul><ul><ul><ul><ul><ul><li>Inicializadores do objeto são fornecidos pelos construtores da classe; </li></ul></ul></ul></ul></ul>

82.
Classes e Objetos em C++ <ul><li>Aponte os erros </li></ul>void ~Tempo(int) Class Tempo{ public: Time(); void SetTime(int, int, int); void PrintPadrao(); void PrintMilitar(); private: int hora = 0; int minuto = 0; int segundo = 0; }; int Tempo(int, *int) (prototipo declarado na classe Tempo)

83.
Classes e Objetos em C++ Exercícios de Implementação 1. Partidos políticos necessitam, principalmente neste período, de pesquisas que mostrem as intenções de voto do eleitor. A cidade é dividida em zonas eleitorais e você deve montar um programa que emita as estatísticas e as intenções de voto em cada zona eleitoral. Quais são as classes mais importantes que você vê para desenvolver o seu programa? Detalhe e implemente a definição de uma das classes que você idealizou em C++. 2. Crie uma classe chamada Complexos para fazer aritmética de números complexos. Escreva o programa e teste sua classe. Lembre-se que um número complexo tem a forma a+bi, onde i = sqrt(-1). Use variáveis float para representar os dados private da classe. Forneça uma função construtora para os objetos dessa classe. As funções membro devem ser as seguintes: a) Adição de dois complexos; b) Subtração de complexos; c) Impressão de complexos na forma (a, b), onde a é a parte real e b é a parte complexa. 3. Crie uma classe Retangulo. A classe tem atributos comprimento e largura, com valor default igual a 1. Forneça as funções get e set, tanto para o comprimento quanto para a altura.

84.
Classes e Objetos em C++

85.
Classes e Objetos em C++ //Arquivo 1 ponto.h, definicao para a classe ponto. class ponto { public: //daqui em diante tudo e acessivel. void inicializa(float a,float b); void mostra(void); private: float x; //sao ocultos por default float y; //sao ocultos por default };

86.
Classes e Objetos em C++ //Arquivo 2 , ponto.cpp , implementacao para a classe ponto. #include <iostream.h> #include &quot;ponto.h&quot; void ponto::inicializa(float a,float b) { x=a; y=b; } //as funcoes de uma classe podem acessar os atributos private dela mesma. void ponto::mostra(void) {cout << &quot;X:&quot; << x << &quot; , Y:&quot; << y << endl;}

87.
Classes e Objetos em C++ //Arquivo 3 . Programa principal: princ.cpp #include &quot;ponto.h&quot; void main() { ponto ap; //instanciacao ap.inicializa(0.0,0.0); //metodos public ap.mostra(); //metodos public

88.
Classes e Objetos em C++ <ul><li>Tipo abstrato de dados fração. Baseado no conceito de número racional. Algumas operações não foram implementadas por serem semelhantes às existentes. </li></ul><ul><li>Resumo das operações matemáticas envolvidas: </li></ul><ul><li>Simplificação de fração: (a/b)=( (a/mdc(a,b)) / (b/mdc(a,b)) ) </li></ul><ul><li>Onde mdc(a,b) retorna o máximo divisor comum de ab. </li></ul><ul><li>Soma de fração: (a/b)+(c/d)=( (a.d+c.b) / b.d ) simplificada. </li></ul><ul><li>Multiplicação de fração: (a/b) * (c/d)= ( (a*c) / (b*d) ) simplificada. </li></ul><ul><li>Igualdade: (a/b)== (c/d) se a*d == b*c. </li></ul><ul><li>Não igualdade: (a/b) != (c/d) se a*d  b*c </li></ul><ul><li>Maior ou igual que: (a/b)  (c/d) se a*d  b*c </li></ul>

89.
Classes e Objetos em C++ //File easyfra.h long mdc(long n,long d); //maximo divisor comum metodo de Euclides. class fracao { private: long num; //numerador long den; //denominador public: fracao(long t,long m); //construtor comum void simplifica(void); //divisao pelo mdc ~fracao() { /* nao faz nada*/ } //operacoes matematicas basicas fracao soma (fracao j); fracao multiplicacao(fracao j); //operacoes de comparacao int igual(fracao t); int diferente(fracao t); int maiorouigual(fracao t); //operacoes de input output void mostra(void); //exibe fracao no video void cria(void); //pergunta ao usuario o valor da fracao //operacoes de conversao de tipos double convertedbl(void); //converte para double long convertelng(void); //converte para long };

90.
Classes e Objetos em C++ //implementacao para a classe fracao. #include <iostream.h> #include &quot;easyfra.h&quot; long mdc(long n,long d) //maximo divisor comum //metodo de Euclides . { if (n<0) n=-n; if (d<0) d=-d; while (d!=0) { long r=n % d; //%=MOD=Resto da divisao inteira. n=d; d=r; } return n; } void fracao::simplifica(void) { long commd; commd=mdc(num,den); //divisor comum num=num/commd; den=den/commd; if (den<0) { den=-den; num=-num;}; //move sinal para cima } fracao::fracao(long t,long m) { num=(t); den=(m); simplifica(); //chamada para o mesmo objeto. }

91.
Classes e Objetos em C++ fracao fracao::soma(fracao j) { fracao g((num*j.den)+(j.num*den),den*j.den); return g; } fracao fracao::multiplicacao(fracao j) { fracao g(num*j.num,den*j.den); return g; } int fracao::igual(fracao t) { return ((num*t.den)==(den*t.num)); //funciona bem mesmo para nao simplificada } int fracao::diferente(fracao t) { return ((num*t.den)!=(den*t.num)); } int fracao::maiorouigual(fracao t) { return ((num*t.den)>=(t.num*den)); } void fracao::mostra(void) { cout << &quot;(&quot; << num << &quot;/&quot; << den << &quot;)&quot;; } void fracao::cria(void) { cout << &quot;Numerador:&quot;; cin >> num; cout << &quot;Denominador:&quot;; cin >> den; simplifica(); }

92.
Classes e Objetos em C++ double fracao::convertedbl(void) { double dbl; dbl=(double(num)/double(den)); return dbl; } //conversao para long long fracao::convertelng(void) { long lng; lng=num/den; return lng; }

93.
Classes e Objetos em C++ #include <iostream.h> #include &quot;easyfra.h&quot; //nossa definicao da classe #include <stdio.h> main() { fracao a(0,1),b(0,1); cout << &quot; Entre com fracao a: &quot;; a.cria(); a.mostra(); cout << &quot; Entre com fracao b: &quot;; b.cria(); b.mostra(); fracao c(a.soma(b)); //c(a+b) cout << endl << &quot;c de a+b:&quot;; c.mostra(); cout << endl << &quot;a*b&quot;; c=a.multiplicacao(b); c.mostra(); cout << endl << &quot;a+b&quot;; c=a.soma(b); c.mostra(); cout << endl << &quot;a>=b&quot;; cout << a.maiorouigual(b); cout << endl << &quot;a==b&quot;; cout << a.igual(b); cout << endl << &quot;a!=b&quot;; cout << a.diferente(b); cout << endl << &quot;long(a) &quot;; cout << a.convertelng(); cout << endl << &quot;double(a) &quot;; cout << a.convertedbl(); return 0; }

94.
Classes e Objetos em C++ #include <iostream.h> #include <math.h> //double sqrt(double x); de math.h retorna raiz quadrada do numero //double pow(double x, double y); de math.h calcula x a potencia de y const float ZERO=0.0; class ponto{ private: float x; //sao ocultos por default nao precisaria private mas e' bom float y; //sao ocultos por default public: //daqui em diante tudo e acessivel em main. ponto(float a,float b) { x=a; y=b; } void mostra(void) const {cout << &quot;X:&quot; << x << &quot; , Y:&quot; << y << endl;} float distancia(const ponto hi) const{ return float( sqrt( ( pow(double(hi.x-x),2.0) + pow(double(hi.y-y),2.0) ) )); //teorema de Pitagoras } };

95.
Classes e Objetos em C++ void main() { ponto ap(3.0,4.0); //instanciacao ap.mostra(); //funcoes membro public const ponto origem(ZERO,ZERO); //defino objeto constante origem.mostra(); cout << &quot;Distancia da origem:&quot; << origem.distancia(ap); }

96.
Classes e Objetos em C++ <ul><li>Uso do const </li></ul>Const pode qualificar um parâmetro de função (assegurando que este não será modificado), uma função membro (assegurando que esta não modifica os dados membro de sua classe), ou uma instância de objeto/tipo (assegurando que este não será modificado.) Os modos de qualificação descritos atuam em conjunto, para assegurar que um objeto const não será modificado, C++ só permite que sejam chamados para este objeto funções membro qualificadas como const

97.
Classes e Objetos em C++ #include <iostream.h> void main() { int* a; //declara um ponteiro para endereco de variavel inteira a=new int(3); //aloca memoria para o apontado por a, gravando neste o valor 3 cout << (*a) << endl ; //imprime o valor do apontado por a delete a; //desaloca memoria } Ponteiros em C++

98.
Classes e Objetos em C++ #include <iostream.h> class vetor_tres { public: int vet[3]; //vetor alocado estaticamente numa classe. vetor_tres(int a,int b,int c) { vet[0]=a; vet[1]=b; vet[2]=c; } //construtor do vetor void mostra(void) { cout << vet[0] << &quot; &quot; << vet[1] << &quot; &quot; << vet[2] << endl;} //funcao membro para mostrar o conteudo do vetor }; Alocação Estática

99.
Classes e Objetos em C++ void main() { vetor_tres v1(1,2,3); //criacao de um objeto vetor. vetor_tres v2(15,16,17); //criacao de um objeto vetor. v1.mostra(); //mostrando o conteudo de v1. v2.mostra(); //mostrando o conteudo de v2. v2=v1; //atribuindo objeto v1 ao objeto v2. v2.mostra(); //mostrando v2 alterado. v1.vet[0]=44; v1.mostra(); //mostrando o conteudo de v1. v2.mostra(); //mostrando o conteudo de v2. }

100.
Classes e Objetos em C++ #include <iostream.h> //vetor alocado dinamicamente void main() { int tamanho; int* vet; cout << &quot;Entre com o tamanho do vetor a criar&quot;; cin >> tamanho; vet=new int[tamanho]; //alocando vetor de &quot;tamanho&quot; posicoes comecando em a[0] for (int i=0;i<tamanho;i++) { cout << &quot;Entre com o valor da posicao &quot; << i << &quot;:&quot;; cin >> vet[i]; cout << endl; } for (int j=0;j<tamanho;j++) { cout << &quot;Posicao &quot; << j << &quot;:&quot; << vet[j]<<endl; } } Alocação Dinâmica

101.
Classes e Objetos em C++ //file exvet1.h //header file para classe vetor const int inicio=0; class vetor{ private: int* v; //este e' o vetor int tamanho; //tamanho maximo do vetor, public: vetor (int tam); //construtor, aloca memória para o vetor. void atribui(int index,int valor); //altera uma posicao do vetor int conteudo(int index); //retorna conteudo de posicao do vetor int maximo(void); //retorna o maior elemento do vetor int primeiro(void); //primeiro indice do vetor int ultimo(void); //ultimo indice do vetor ~vetor() {delete v;} //inline function ou use delete v[]; }; TAD Vetor

102.
Classes e Objetos em C++ //codigo, implementacao, para o header file #include <iostream.h> #include <stdlib.h> #include &quot;exvet1.h&quot; vetor::vetor (int tam) {v=new int[tam]; tamanho=tam;} void vetor::atribui(int index,int valor) { if (index<tamanho && index>=inicio) v[index]=valor; } int vetor::conteudo(int index) { if (index>=tamanho || index<inicio) { cerr << &quot;Fora dos limites&quot;; exit(1);} return v[index]; } int vetor::primeiro(void) { return inicio;} int vetor::ultimo(void) { return tamanho-1;} int vetor:: maximo(void) {int candidato=inicio; //candidato ao maximo for (int i=inicio;i<tamanho;i++) if (v[i]>v[candidato]) candidato=i; return v[candidato];}

103.
Classes e Objetos em C++ //programa pricipal #include <iostream.h> #include &quot;exvet1.h&quot; main() { int aux; //para ler valor a atribuir vetor meu(5); for (int i=meu.primeiro();i<=meu.ultimo();i++) { cout << &quot;Entre com valor da posicao:&quot; << i << &quot;&quot;; cin >> aux; meu.atribui(i,aux); } for (int j=meu.primeiro();j<=meu.ultimo();j++) cout<< meu.conteudo(j)<< &quot; &quot;; cout <<endl << &quot;Maximo:&quot; << meu.maximo(); return 0; }

104.
Projeto de Programas OO <ul><li>É a forma pela qual o programador cria o modelo em forma de programa. É o processo onde se coloca as partes importantes de um programa em ordem. </li></ul><ul><li>Estabelecer quais as classes, objetos e métodos são necessários para um programa, e definir quais classes e objetos devem se interrelacionar. </li></ul>

105.
Projeto de Programas OO <ul><li>3 Etapas </li></ul><ul><ul><li>Planejamento da Interface Abstrata </li></ul></ul><ul><ul><ul><li>Requer tempo adicional ao projeto </li></ul></ul></ul><ul><ul><ul><li>Entretanto, aproveita-se a mesma classe em diferentes aplicações </li></ul></ul></ul>

106.
Projeto de Programas OO <ul><ul><li>Refinamento do Protocolo </li></ul></ul><ul><ul><ul><li>Estender a definição original dos objetos através da incorporação de novos métodos a seu protocolo </li></ul></ul></ul><ul><ul><ul><ul><li>Definir o protocolo mínimo da classe </li></ul></ul></ul></ul><ul><ul><ul><ul><li>Refinar: A partir do protocolo mínimo antecipar os métodos que seriam mais úteis para torná-lo mais reusável em diversas situações ou possibilitando o aumento da funcionalidade; </li></ul></ul></ul></ul>

107.
Projeto de Programas OO <ul><ul><li>Aspectos importantes para identificação de novos métodos: </li></ul></ul><ul><ul><li>Para cada método, identificar se deve existir outro com efeito inverso; </li></ul></ul><ul><ul><li>Necessidade de métodos complementares; </li></ul></ul><ul><ul><li>Métodos distintos (identificar métodos que utilizem como parâmetros apenas poucos valores aceitáveis, substituí-lo por vários métodos individuais; </li></ul></ul><ul><ul><li>Verificar que métodos devem ser adicionados para tornar a classe conceitualmente completa; </li></ul></ul>

108.
Projeto de Programas OO <ul><ul><li>Planejamento da Hierarquia de Classes </li></ul></ul><ul><ul><li>Enfoque: </li></ul></ul><ul><ul><ul><li>Top-down </li></ul></ul></ul><ul><ul><ul><ul><li>As subclasses são obtidas a partir da especialização das classes já existentes, incorporando novos métodos e variáveis de instância ou redefinindo a superclasse, se necessário. </li></ul></ul></ul></ul><ul><ul><ul><li>Bottom-Up </li></ul></ul></ul><ul><ul><ul><ul><li>Novas superclasses são conseqüências da generalização das propriedades das classes existentes; </li></ul></ul></ul></ul>

109.
Projeto de Programas OO <ul><li>Uma quarta etapa pode ser a construção das tabelas CRC (Classe, Responsabilidade, Correspondência). </li></ul>

110.
Projeto de Programas OO <ul><li>É sempre bom lembrar: </li></ul><ul><li>Variáveis da classe </li></ul><ul><li>Só existe uma cópia de cada variável </li></ul><ul><li>Todos as instâncias acessam a mesma cópia das variáveis </li></ul><ul><li>São criadas apenas uma vez assim que o sistema reconhece a classe </li></ul><ul><li>Variáveis da Instância </li></ul><ul><li>Existe uma cópia para cada instância criada </li></ul><ul><li>Cada instância acessa a sua cópia </li></ul><ul><li>São criadas sempre quando uma nova instância é gerada </li></ul>

111.
Projeto de Programas OO <ul><li>Métodos de Classe </li></ul><ul><li>Podem acessar apenas variáveis da classe </li></ul><ul><li>Podem ser acessados pela classe ou pela instância </li></ul><ul><li>Métodos de Instância </li></ul><ul><li>Podem acessar variáveis da classe e da instância </li></ul><ul><li>Só podem ser acessados por instâncias </li></ul>

112.
Projeto de Programas OO <ul><li>Para que objetos se comuniquem eles precisam se relacionar </li></ul><ul><li>Associação: conexão entre classes </li></ul><ul><li>Agregação: especialização de uma associação onde um todo é relacionado com suas partes (relacionamento “parte-de” ou “contenção” </li></ul><ul><li>Herança: um dos princípios da OO, permite a reutilização, uma nova classe pode ser definida a partir de outra já existente </li></ul>

113.
Projeto de Programas OO <ul><li>Associação: </li></ul><ul><ul><li>descreve uma relação entre duas classes </li></ul></ul><ul><ul><ul><li>Usuário possui bicicleta </li></ul></ul></ul><ul><li>Agregação: </li></ul><ul><ul><li>descreve o relacionamento entre um todo e sua parte </li></ul></ul><ul><ul><li>são indicadas por frases do tipo “tem um”, “é parte de” </li></ul></ul><ul><ul><ul><li>Uma teclado é parte de um notebook </li></ul></ul></ul>

114.
Projeto de Programas OO <ul><li>Generalização / Herança </li></ul><ul><ul><li>descreve o relacionamento entre classes definidas a partir de outras classes. </li></ul></ul><ul><ul><li>toda a subclasse herda os estados e os comportamentos definidos na superclasse </li></ul></ul><ul><ul><li>as subclasses não estão limitadas a estes estados e comportamentos. </li></ul></ul><ul><ul><ul><li>Uma mountain bike é uma bicicleta </li></ul></ul></ul>

115.
Projeto de Programas OO <ul><li>Uma associação é usualmente um relacionamento bidirecional </li></ul><ul><ul><li>Dado uma instância de Aluno , há um objeto Disciplina associado </li></ul></ul><ul><ul><li>Dado uma instância de Disciplina , há um objeto Aluno associado </li></ul></ul>Aluno Disciplina

116.
Projeto de Programas OO <ul><li>Tipos de associações </li></ul><ul><ul><li>Unidirecional </li></ul></ul><ul><ul><li>Bidirecional </li></ul></ul><ul><ul><li>Indeterminada </li></ul></ul>

117.
Projeto de Programas OO Classe A Classe B Classe A Classe B ou unidirecional bidirecional Classe A Classe B bidirecional ou não determinada

118.
Projeto de Programas OO Para facilitar seu entendimento, uma associação precisa ser nomeada - O nome é representado como um “rótulo” colocado ao longo da linha de associação - Um nome de associação é usualmente um verbo ou uma frase verbal Aluno Dsiciplina Cursa

119.
Projeto de Programas OO Aluno Disciplina cursa tem matriculado Aluno Disciplina Cursa   Tem matriculado

120.
Projeto de Programas OO <ul><li>Multiplicidade para Associações </li></ul><ul><li>Multiplicidade é o número de instâncias de uma classe relacionada com UMA instância de outra classe </li></ul><ul><li>Para cada associação, há duas decisões a fazer: uma para cada lado da associação </li></ul><ul><li>Por exemplo, na conexão entre Aluno e Disciplina: </li></ul><ul><ul><li>Para cada instância de Aluno, podem ocorrer muitas (zero ou mais) Disciplinas </li></ul></ul><ul><ul><li>Para cada instância de Disciplina, podem ocorrer uma ou várias instâncias de alunos matriculados </li></ul></ul>

121.
Projeto de Programas OO Muitos * Exatamente um 1 Zero ou mais 0.. * Um ou mais 1.. * Zero ou um 0..1 Faixa especificada 2..4 Pessoa Disciplina Aluno 1..* 1.. *

122.
Projeto de Programas OO <ul><li>Associação em C++ </li></ul><ul><ul><ul><li>E realizado através da inclusão de atributos nas classes envolvidas; </li></ul></ul></ul><ul><li>Exemplo </li></ul><ul><ul><ul><li>Sejam as classes TCliente e TProduto . Suponhamos que o relacionamento entre elas seja &quot;Um Cliente possui vários Produtos&quot; .Este tipo de associação é Unidirecional, com duas formas de implementação. </li></ul></ul></ul>

123.
Projeto de Programas OO class TCliente { protected: int nClientCod; char* pcNome; char* pcEndereco; int* nProdCod; //array de inteiros com todos os produtos que possui public: ... } class TProduto { protected: int nProdCod; char* pcDescri; public: ... } Uma instância de Cliente sabe todos os Produtos que possui

124.
Projeto de Programas OO class TCliente { protected: int nClientCod; char* pcNome; char* pcEndereco; public: ... } class TProduto { protected: int nProdCod; char* pcDescri; int nClientCod; //qual cliente o possui public: ... } Uma instância de Produto sabe qual o Cliente a possui

125.
Projeto de Programas OO <ul><li>Observemos agora a relação entre as classes TAluno e TProfessor. Neste caso temos uma associação Bidirecional, visto que &quot;Um Aluno tem vários Professores e um Professor tem vários Alunos&quot;. </li></ul>

126.
Projeto de Programas OO class TAluno { protected: char* pcDRE; char** pacMatricula; //matriculas dos professores que possui char* pcNome; int nIdade; public: ... } class TProfessor { protected: char* pcMatricula; char*pcNome; char** pacDRE; //array de strings com DRE dos alunos que possui public: ... }

127.
Projeto de Programas OO

128.
Projeto de Programas OO <ul><li>Agregação </li></ul><ul><li>Agregação é uma forma especializada de associação no qual um todo é relacionado com sua(s) parte(s) </li></ul><ul><ul><li>Agregação é conhecido como um relacionamento de contenção ou “todo-parte”. </li></ul></ul>

129.
Projeto de Programas OO <ul><li>O relacionamento é descrito com uma frase “parte de” </li></ul><ul><ul><li>Uma placa é “parte de” um computador </li></ul></ul><ul><li>Algumas operações no todo são automaticamente aplicadas a suas partes? </li></ul><ul><ul><li>Transportar o computador, Transportar a placa </li></ul></ul><ul><li>Alguns valores de atributos são propagados do todo para todos ou algumas de suas partes? </li></ul><ul><ul><li>Características do barramento </li></ul></ul><ul><li>Existe uma assimetria inerente no relacionamento onde uma classe é subordinada a outra? </li></ul><ul><ul><li>Uma placa É parte de um computador, um computador NÃO É parte de uma placa </li></ul></ul>

130.
Projeto de Programas OO Todo Parte1 Parte2

131.
Projeto de Programas OO Turma Aluno 1..* *

132.
Projeto de Programas OO <ul><li>Em uma agregação, a parte pode estar contida, ou não, em mais de um todo. </li></ul><ul><li>Quando isto ocorre, chamamos agregação compartilhada (losango branco). </li></ul><ul><li>Quando uma parte não pode estar em mais de um todo, chamamos composição (losango preto). </li></ul><ul><ul><li>Na composição, quando o objeto todo é destruído, o objeto parte é também destruído. </li></ul></ul>

133.
Projeto de Programas OO Departamento * Disciplina

134.
Projeto de Programas OO <ul><li>Associação ou Agregação? </li></ul><ul><li>Se dois objetos são altamente acoplados por um relacionamento todo-parte </li></ul><ul><ul><li>O relacionamento é uma agregação </li></ul></ul><ul><li>Se dois objetos são usualmente considerados como independentes, mesmo que eles estejam freqüentemente ligados </li></ul><ul><ul><li>O relacionamento é uma associação </li></ul></ul>

135.
Projeto de Programas OO Curso 1..* 0.. * Disciplina Aluno 3..10 Curso e disciplina são altamente acoplados (1 curso é formado por 1 ou mais disciplinas) Objetos independentes

136.
Projeto de Programas OO <ul><li>Identificando Objetos </li></ul><ul><li>Em uma sala existe um conjunto de objetos físicos que podem ser facilmente identificados, modelados e classificados como objetos OO. </li></ul><ul><li>Mas em um problema onde o espaço é uma aplicação de software, os objetos podem não ser facilmente encontrados. </li></ul><ul><li>Os objetos podem ser identificados analisando-se o problema ou fazendo um “ parser gramatical” do texto contendo a descrição do problema </li></ul><ul><li>Objetos são determinados sublinhando-se cada substantivo ou oração (parte de uma frase) </li></ul>

137.
Projeto de Programas OO <ul><li>Candidatos a objeto: </li></ul><ul><ul><li>Entidade externa que produz ou consome informação para ser usada por um sistema computacional (ex.: outros sistemas, devices , pessoas) </li></ul></ul><ul><ul><li>Coisas que são parte do domínio da informação do problema (ex.: um sinal, uma carta, um display) </li></ul></ul><ul><ul><li>Ocorrências ou eventos que acontecem no contexto da operação do sistema (ex.: a propriedade de uma transferência, a finalização de uma série de movimentos de um robô) </li></ul></ul><ul><ul><li>Papeis(roles) desempenhados por pessoas que interagem com o sistema (ex.: gerente, engenheiro, vendedor) </li></ul></ul><ul><ul><li>Unidades de organização que são relevantes a uma aplicação (ex.: divisões, grupo, time) </li></ul></ul><ul><ul><li>Lugares que estabelecem o contexto do problema (ex.: galpão, estaleiro) </li></ul></ul><ul><ul><li>Estruturas que definem a classe de um objeto (ex.: sensor, computador, veículo 4-rodas) </li></ul></ul>

138.
Projeto de Programas OO Atributos Nome do objeto Operações Unidades organizacionais Estrutura Lugar Entidades externas Papéis Eventos Coisas

139.
Projeto de Programas OO <ul><li>Escolhendo classes </li></ul><ul><ul><li>Uma classe deveria capturar uma e somente uma abstração chave </li></ul></ul><ul><ul><li>Abstração ruim: classe “Aluno” que conhece a informação do aluno e as disciplinas que aquele aluno está matriculado </li></ul></ul><ul><ul><li>Boa abstração: separar em uma classe para Aluno e uma classe para Disciplina </li></ul></ul>

140.
Projeto de Programas OO <ul><li>Nomes para classes </li></ul><ul><ul><li>Uma classe deveria ser um substantivo singular que melhor caracteriza a abstração </li></ul></ul><ul><ul><li>Dificuldades na nomeação das classes podem indicar abstrações mal definidas </li></ul></ul><ul><ul><li>Nomes deveriam surgir diretamente do domínio do problema </li></ul></ul>

141.
Projeto de Programas OO <ul><li>Um guia de estilo deveria ditar convenções de nomeação para classes </li></ul><ul><li>Uma proposta simples: </li></ul><ul><ul><li>Classes são nomeadas com um substantivo no singular </li></ul></ul><ul><ul><li>O nome de uma classe inicia com a primeira letra maiúscula </li></ul></ul><ul><ul><li>Não são utilizados símbolos de sublinhado (“_”) - nomes compostos de múltiplas palavras são organizados com todas as palavras juntas, onde a primeira letra de cada uma fica em maiúscula </li></ul></ul><ul><li>Exemplos: Aluno, Professor, ControleAcadêmico </li></ul>

142.
Projeto de Programas OO <ul><li>Uma classe deveria capturar uma e somente uma abstração chave </li></ul><ul><li>Abstração ruim: classe “Aluno” que conhece a informação do aluno e as disciplinas que aquele aluno está matriculado </li></ul><ul><li>Boa abstração: separar em uma classe para Aluno e uma classe para Disciplina </li></ul>

143.
Projeto de Programas OO <ul><li>Semântica da Classe </li></ul><ul><li>Após encontrar o nome da classe, é importante que seja feita uma breve (mas concisa) descrição da mesma </li></ul><ul><ul><li>O foco deve ser no propósito da classe e não na implementação </li></ul></ul><ul><li>O nome da classe e sua descrição formarão a base para um dicionário do modelo </li></ul><ul><li>As classes desta fase devem somente relatar o domínio do problema </li></ul>

144.
Herança e Polimorfismo em C++ <ul><li>Relações entre classes: </li></ul><ul><ul><li>Generalização(Herança); </li></ul></ul><ul><ul><li>Agregação; </li></ul></ul><ul><ul><li>Associação. </li></ul></ul>

145.
Herança e Polimorfismo em C++ <ul><li>Hierarquia </li></ul><ul><ul><li>Classificação: </li></ul></ul><ul><ul><ul><li>Classificar significa agrupar objetos com base e estrutura semelhante. </li></ul></ul></ul><ul><ul><li>Instanciação: </li></ul></ul><ul><ul><ul><li>Instanciar significa gerar novos exemplares a partir de uma descrição abstrata para gerar um objeto. </li></ul></ul></ul>

146.
Herança e Polimorfismo em C++ <ul><ul><li>Generalização </li></ul></ul><ul><ul><ul><li>Generalizar significa remover restrições para se obter abstrações mais genéricas; </li></ul></ul></ul><ul><ul><li>Especialização </li></ul></ul><ul><ul><ul><li>Especializar significa buscar características que diferenciem abstrações afins </li></ul></ul></ul>

147.
Herança e Polimorfismo em C++ <ul><ul><li>Agregação </li></ul></ul><ul><ul><ul><li>Agregar significa combinar abstrações para se obter estruturas e comportamentos mais complexos; </li></ul></ul></ul><ul><ul><li>Decomposição </li></ul></ul><ul><ul><ul><li>Decompor significa detalhar uma abstração dividindo-a em seu elementos constituintes </li></ul></ul></ul>

148.
Herança e Polimorfismo em C++ <ul><li>O mecanismo de herança possibilita: </li></ul><ul><ul><li>A derivação de um tipo mais específico a partir de tipos mais genéricos; </li></ul></ul><ul><ul><li>subclasses herdam os dados e os métodos da subclasse permitindo ainda modificações nos mesmos; </li></ul></ul><ul><ul><li>herança simples: subclasse deriva somente de uma superclasse ; </li></ul></ul><ul><ul><li>herança múltipla: subclasse deriva de várias superclasses. </li></ul></ul>

149.
Herança e Polimorfismo em C++ <ul><li>As classes podem ser organizadas em hierarquia de herança </li></ul>

150.
Herança e Polimorfismo em C++ <ul><li>Uma subclasse pode redefinir métodos herdados de uma superclasse modificando uma parte de seu comportamento </li></ul><ul><li>class ClasseHerdeira : public ClasseBase{ </li></ul><ul><li>//atributos da classe filha </li></ul><ul><li>}; </li></ul><ul><li>class ClasseHerdeira : private ClasseBase{ </li></ul><ul><li>//atributos da classe filha </li></ul><ul><li>}; </li></ul>

151.
Herança e Polimorfismo em C++ <ul><li>Regras de visibilidade </li></ul><ul><ul><li>A classe derivada pode ajustar o direito de acesso a um membro de uma classe base através de uma declaração de acesso; </li></ul></ul><ul><ul><li>A classe derivada pode reduzir ou ampliar o direito de acesso a um membro da classe base. </li></ul></ul>

152.
Herança e Polimorfismo em C++ <ul><li>Ao derivar uma classe, a classe base pode ser herdada como: </li></ul><ul><ul><ul><li>Public </li></ul></ul></ul><ul><ul><ul><li>Private </li></ul></ul></ul><ul><ul><ul><li>Protected </li></ul></ul></ul>Raramente utilizado

153.
Herança e Polimorfismo em C++ Herança Pública: Na herança pública as classes filhas passam a ter as mesmas funções membro public da classe pai, as classes filhas podem acrescentar funções membro, dados membro e até redefinir funções membro herdadas . Os atributos da classe pai não são acessíveis diretamente na classe filha a não ser que sejam qualificados como protected . Por isso é que se diz que as classes filhas garantem pelo menos o comportamento da classe pai, podendo acrescentar mais características.

154.
Herança e Polimorfismo em C++ <ul><li>Quando se deriva uma classe a partir de uma classe public, os membros public da classe base se tornam membros public na classe derivada e os membros protected da classe base se tornam protected na classe derivada. </li></ul><ul><li>Quando se deriva uma classe a partir de uma classe base protected , os membros public e protected da classe base se tornam membros protected na classe derivada. </li></ul><ul><li>Quando se deriva uma classe a partir de uma classe base private, os membros public e protected da classe base tornam-se private na classe derivada. </li></ul>

155.
Herança e Polimorfismo em C++ Construtores e herança: No construtor de uma classe filha o programador pode incluir a chamada do construtor da classe pai. Destrutores e herança: Quando um objeto da classe derivada é destruído, o destrutor da classe pai também é chamado dando a oportunidade de liberar a memória ocupada pelos atributos private da classe pai.

156.
Herança e Polimorfismo em C++ <ul><li>Diagrama de acesso </li></ul>

157.
Herança e Polimorfismo em C++ Tipo de acesso original na Classe base Tipo de acesso resultante na classe derivada Tipo de herança Não acess. Private Private Private Não acess. Protected Public Public Private Protected Public

158.
Herança e Polimorfismo em C++ Exemplo

159.
Herança e Polimorfismo em C++ //header file class ponto { private: float x; float y; public. ponto(float a,float b); void inicializa(float a,float b); float retorna_x(void); float retorna_y(void); void altera_x(float a); void altera_y(float b); void mostra(void); }; class ponto_reflete:public ponto { private: //se voce quer adicionar atributos... public: ponto_reflete(float a, float b); void reflete(void); }; class ponto_move:public ponto { public: ponto_move(float a,float b); void move(float dx,float dy); };

160.
Herança e Polimorfismo em C++ //implementation file #include <iostream.h> #include &quot;pontos.h&quot; ponto::ponto(float a,float b) { inicializa(a,b); } void ponto::inicializa(float a,float b) { x=a; y=b; } float ponto::retorna_x(void) { return x; } float ponto::retorna_y(void) { return y; } void ponto::altera_x(float a) { x=a; } void ponto::altera_y(float b) { y=b; } void ponto::mostra(void) { cout << &quot;(&quot; << x << &quot;,&quot; << y << &quot;)&quot; <<endl; }

161.
Herança e Polimorfismo em C++ ponto_reflete::ponto_reflete(float a,float b):ponto(a,b) { } void ponto_reflete::reflete(void) { altera_x(-retorna_x()); altera_y(-retorna_y()); } ponto_move::ponto_move(float a,float b):ponto(a,b) { } void ponto_move::move(float dx,float dy) { altera_x(retorna_x()+dx); altera_y(retorna_y()+dy); }

162.
Herança e Polimorfismo em C++ #include <iostream.h> #include &quot;pontos.h&quot; void main() { ponto_reflete p1(3.14,2.17); p1.reflete(); cout << &quot;P1&quot;; p1.mostra(); ponto_move p2(1.0,1.0); p2.move(.5,.5); cout << &quot;P2&quot;; p2.mostra(); } Resultado do programa: P1(-3.14,-2.17) P2(1.5,1.5)

163.
Herança e Polimorfismo em C++ Herança Private: class herdeira: private nome_classe_base; As funções membro desta classe base só são acessíveis dentro das declarações da classe filha, ou seja a classe filha não atende por essas funções membro, mas pode usá-las em seu código. Normalmente, quando se usa herança dizemos que a classe filha garante no mínimo o comportamento da classe pai (em termos de funções membro) , a herança private pode invalidar esta premissa.

164.
Herança e Polimorfismo em C++ protected deixa os atributos da classe pai visíveis, acessíveis “hierarquia abaixo”. O uso de protected serve como um nível intermediário de proteção entre o acesso public e o private. Membros protected da classe podem ser acessados por membros friends Da classe base e por membros friend das classes derivadas; Nenhuma outra função pode acessar membros protected de uma Classe base.

165.
Herança e Polimorfismo em C++ <ul><li>Exemplo – Redefinição de método herdado </li></ul><ul><ul><ul><li>Uma classe filha pode fornecer uma outra implementação para uma função membro herdada, caracterizando uma redefinição “overriding” de função membro. Importante: a função membro deve ter a mesma assinatura (nome, argumentos e valor de retorno), senão não se trata de uma redefinição e sim sobrecarga “overloading”. </li></ul></ul></ul>

166.
Herança e Polimorfismo em C++ ponto_reflete redefine a função membro mostra da classe pai, enquanto que a classe herdeira ponto_move aceita a definição da função membro mostra dada pela classe ponto que é sua classe pai.

167.
Herança e Polimorfismo em C++ //header file class ponto { private: float x; //sao ocultos por default float y; //sao ocultos por default public: //daqui em diante tudo e acessivel. ponto(float a,float b); void inicializa(float a,float b); float retorna_x(void); float retorna_y(void); void altera_x(float a); void altera_y(float b); void mostra(void); }; class ponto_reflete:public ponto { private: //se voce quer adicionar dados membro public: ponto_reflete(float a, float b); void reflete(void); void mostra(void); //redefinicao }; class ponto_move:public ponto { public: ponto_move(float a,float b); void move(float dx,float dy); //esta classe filha nao redefine mostra };

168.
Herança e Polimorfismo em C++ //implementation file #include <iostream.h> #include &quot;pontos.h&quot; ponto::ponto(float a,float b){ inicializa(a,b); } void ponto::inicializa(float a,float b){ x=a; y=b; } float ponto::retorna_x(void) { return x; } float ponto::retorna_y(void) { return y; } void ponto::altera_x(float a) { x=a; } void ponto::altera_y(float b) { y=b; } void ponto::mostra(void){ cout << &quot;(&quot; << x << &quot;,&quot; << y << &quot;)&quot; <<endl; } ponto_reflete::ponto_reflete(float a,float b):ponto(a,b) { } void ponto_reflete::reflete(void){ altera_x(-retorna_x()); altera_y(-retorna_y()); } void ponto_reflete::mostra(void) { cout << &quot;X:&quot; << retorna_x() << &quot; Y:&quot;; cout << retorna_y() << endl; } //somente altera o formato de impressao ponto_move::ponto_move(float a,float b):ponto(a,b) { } void ponto_move::move(float dx,float dy) { altera_x(retorna_x()+dx); altera_y(retorna_y()+dy); }

169.
Herança e Polimorfismo em C++ #include <iostream.h> #include &quot;pontos.h&quot; void main() { ponto_reflete p1(3.14,2.17); p1.reflete(); cout << &quot;P1&quot;; p1.mostra(); ponto_move p2(1.0,1.0); p2.move(.5,.5); cout << &quot;P2&quot;; p2.mostra(); } Resultado do programa: P1X:-3.14 Y:-2.17 P2(1.5,1.5)

170.
Herança e Polimorfismo em C++ <ul><li>Herança Múltipla </li></ul><ul><ul><li>A indicação da herança múltipla é realizada a partir de uma lista de classes base separadas por vírgulas, descritas a partir do indicador de herança (:) </li></ul></ul><ul><ul><li>Exemplo </li></ul></ul><ul><ul><li>class Derivada : public Base1, public Base2 { </li></ul></ul><ul><ul><li>//descrição da classe </li></ul></ul><ul><ul><li>}; </li></ul></ul>

171.
Herança e Polimorfismo em C++

172.
Herança e Polimorfismo em C++ <ul><li>Algumas “dicas”: </li></ul><ul><ul><ul><ul><li>Um objeto de uma classe derivada pode ser atribuído a um objeto de uma classe base; </li></ul></ul></ul></ul><ul><ul><ul><ul><li>Um ponteiro para um objeto de uma classe devida pode ser implicitamente convertido para um ponteiro para um objeto da classe base; </li></ul></ul></ul></ul><ul><ul><ul><ul><li>A classe base específica o que há de comum; </li></ul></ul></ul></ul><ul><ul><ul><ul><li>Relacionamento “é um” é herança; </li></ul></ul></ul></ul><ul><ul><ul><ul><li>Relacionamento “tem um” é composição; </li></ul></ul></ul></ul><ul><ul><ul><ul><li>Ler declarações de classes derivadas pode ser confuso! (os membros herdados não aparecem na declaração) </li></ul></ul></ul></ul><ul><ul><ul><ul><li>Construtores de objetos membros são chamados na ordem de declaração dos objetos. Na herança, os construtores da classe base são chamados na ordem da especificação, antes do construtor das classe derivadas. </li></ul></ul></ul></ul>

173.
Herança e Polimorfismo em C++ <ul><ul><ul><li>Quando o objeto da classe derivada é destruído, os destrutores são chamados na ordem inversa dos destrutores; primeiro é chamado o destrutor da classe derivada, então é chamado o destrutor da classe base; </li></ul></ul></ul><ul><ul><ul><li>Na herança múltipla, o construtor da classe derivada chama o construtor da classe base para cada uma de suas classes bases, na ordem em que as classes bases são declaradas na declaração da herança. </li></ul></ul></ul><ul><ul><ul><li>Tratar objetos da classe base como objetos da classe derivada pode causar erros! </li></ul></ul></ul><ul><ul><ul><li>Herde sempre a classe mais próxima daquilo que você necessita. </li></ul></ul></ul><ul><ul><ul><li>Use protected em último recurso. </li></ul></ul></ul><ul><ul><ul><li>Herança múltipla pode aumentar a complexidade do sistema. Muito cuidado! </li></ul></ul></ul>

174.
Herança e Polimorfismo em C++ <ul><li>Exercícios </li></ul><ul><li>Defina: Herança, Herança Múltipla, classe base e classe derivada. </li></ul><ul><li>Qual a diferença entre Herança simples e Herança Múltipla? </li></ul><ul><li>(F/V) Uma classe derivada é também chamada de subclasse por ser um subconjunto da classe base. </li></ul><ul><li>(F/V) Um objeto da classe derivada também é um objeto da classe base. </li></ul><ul><li>5) (F/V) O protected rompe o encapsulamento. </li></ul>

175.
Herança e Polimorfismo em C++ <ul><li>Polimorfismo e Funções virtual </li></ul><ul><ul><li>Polimorfismo, do grego: muitas formas. Polimorfismo é a capacidade de um operador executar a ação apropriada dependendo do tipo do operando. Aqui operando e operador estão definidos num sentido mais geral: operando pode significar argumentos atuais de um procedimento e operador o procedimento, operando pode significar um objeto e operador um método, operando pode significar um tipo e operador um objeto deste tipo. </li></ul></ul>

176.
Herança e Polimorfismo em C++ <ul><li>Funções virtuais </li></ul><ul><ul><li>Uma função virtual é uma função que é declarada como virtual em uma classe base e redefinida pela classe derivada. </li></ul></ul><ul><ul><li>A declaração da função virtual na classe base age como uma espécie de indicador que especifica uma linha geral de ação e estabelece uma interface de acesso. A redefinição da função virtual pela classe derivada especifica as operações realmente executadas pelo método. </li></ul></ul>

177.
Herança e Polimorfismo em C++ #include<iostream.h> class Base{ public: virtual void vfunc(){ cout<<“esta e vfunc() da base ”; } }; class Derivada1:public base{ public: void vfunc(){ cout<<“esta e vfunc() da derivada1 ”; } }; class Derivada2:public base{ public: void vfunc(){ cout <<“esta e vfunc() da derivada2 ”; } };

178.
Herança e Polimorfismo em C++ main(){ Base *p, b; Derivada1 d1; Derivada2 d2; p = &b; p->vfunc(); p = &d1; p->vfunc(); p = &d2; p->vfunc(); Return 0; }

179.
Herança e Polimorfismo em C++ <ul><li>Observações: </li></ul><ul><ul><li>a declaração de vfunc() deve ser precedida pela palavra chave virtual ; </li></ul></ul><ul><ul><li>a palavra chave virtual não é necessária na declaração das funções vfunc() das classes derivadas; </li></ul></ul><ul><ul><li>a definição de qual versão da função vfunc() é invocada só é obtida em tempo de execução: ela não é baseada no tipo declarado de p , mas sim para quem p aponta; </li></ul></ul><ul><ul><li>polimorfismo em tempo de execução só é atingido através do uso de apontadores para classe base. Se vfunc() for chamada da maneira ``usual,'' isto é, usando o operador ponto, como em d2.vfunc() , então a função, mesmo sendo declarada como virtual, tem o mesmo comportamento de outras funções membro. </li></ul></ul>

180.
Herança e Polimorfismo em C++ <ul><ul><li>A redefinição de uma função virtual por uma classe derivada é similar a sobrecarga de funções. Entretanto, há diversas diferenças : </li></ul></ul><ul><ul><ul><ul><li>o protótipo para uma função virtual deve combinar exatamente o protótipo especificado para a classe base </li></ul></ul></ul></ul><ul><ul><ul><ul><li>funções virtuais devem ser membros da classe das quais elas fazem parte -- não podem simplesmente ser funções amigas. </li></ul></ul></ul></ul><ul><ul><ul><li>Por estes motivos, a redefinição de funções virtuais por classes derivadas é usualmente chamada de sobreposição , e não de sobrecarga. </li></ul></ul></ul>

181.
Herança e Polimorfismo em C++ <ul><li>Deve-se observar que a ``virtualidade'' é hereditária. Isto é, quando uma função virtual é herdada, sua natureza virtual também é herdada -- mesmo quando a palavra chave virtual não é explicitamente declarada no método da classe derivada. Assim, o caráter virtual da função é mantido, não importa qual o número de níveis na hierarquia de classes. </li></ul>

182.
Herança e Polimorfismo em C++ <ul><li>O uso da palavra chave virtual indica que a função pode ser sobreposta, mas não obriga a sobreposição. Caso a classe derivada não sobreponha uma função virtual, então o método correspondente da classe base será utilizado. </li></ul>

183.
Herança e Polimorfismo em C++ <ul><li>Sobrecarga de Função </li></ul><ul><ul><li>Sobrecarga “Overloading” de função é um tipo de polimorfismo classificável como ad-hoc. C++ permite que funções de mesmo nome tenham parâmetros distintos. </li></ul></ul>

184.
Herança e Polimorfismo em C++ //header file funcover.h float abs(float a); int abs(int a); //implementation file #include &quot;funcover.h&quot; float abs(float a) { if (a>0.0) return a; else return -a; } int abs(int a) { if (a>0) return a; else return -a; } #include <iostream.h> #include &quot;funcover.h&quot; void main(){ int i1; float f1; cout << abs(int(-10))<<endl; cout << abs(float(-10.1))<<endl; f1=-9.1; i1=8.0; cout << abs(f1) << endl; cout << abs(i1) << endl; }

185.
Herança e Polimorfismo em C++ <ul><li>Outro exemplo de sobrecarga de funções </li></ul>//header file funcover.h float max(float a,float b); float max(float a,float b,float c); int max(int a,int b); #include &quot;funcover.h&quot; float max(float a,float b){ if (a>b) return a; else return b; } float max(float a,float b,float c){ if (a>b) return max(a,c); else return max(b,c); } int max(int a,int b){ if (a>b) return a; else return b; }

186.
Herança e Polimorfismo em C++ #include <iostream.h> #include &quot;funcover.h&quot; void main() { cout << max(float(1.2),float(3.4),float(2.1))<<endl; cout << max(float(1.5),float(.65)) << endl; cout << max(int(12),int(120)); }

187.
Herança e Polimorfismo em C++ <ul><li>Sobrecarga de Operadores </li></ul>//header file para classe vetor: vet.h #include <iostream.h> #include <stdlib.h> //exit(1) const int inicio=0; //inicio do vetor class vetor{ private: float* v; //pode ser qualquer tipo que atenda as operacoes < > = int tamanho; public: vetor (int tamanho) ; float& operator[] (int i); float maximo(); //acha o valor maximo do vetor int primeiro(void); int ultimo(void); };

188.
Herança e Polimorfismo em C++ vetor::vetor (int tam) {v=new float[tam]; tamanho=tam;} int vetor::primeiro (void) {return inicio;} int vetor::ultimo (void) {return tamanho-1;} float& vetor::operator[](int i){ if (i<0 || i>=tamanho) {cout << &quot;Fora dos limites! Exit program&quot;; exit(1);} return v[i]; } float vetor:: maximo(void) {int candidato=inicio; for (int i=inicio;i<tamanho;i++) if (v[i]>v[candidato]) candidato=i; return v[candidato];}

189.
Herança e Polimorfismo em C++ <ul><li>iteradorvetor(vetor & v); :Construtor, já cria o iterador de vetor inicializando-o para apontar para o começo do vetor. </li></ul><ul><li>virtual int comeca(); : Inicializa o iterador para o começo do vetor. </li></ul><ul><li>virtual int operator!(); : Verifica se a iteração não chegou no fim do vetor: 1 indica que não chegou, 0 indica que chegou no fim do vetor. </li></ul>

190.
Herança e Polimorfismo em C++ <ul><li>virtual int operator ++ (); : Faz o iterador mover adiante uma posição. </li></ul><ul><li>virtual float operator() (); :Retorna o elemento daquela posição do vetor. </li></ul><ul><li>virtual void operator= (float entra); : Atribui a posição atual do vetor. </li></ul><ul><li>int pos(); : Retorna a posição (índice) do vetor em que o iterador se encontra, não é virtual porque não faz sentido para um iterador de árvore por exemplo. </li></ul>

191.
Herança e Polimorfismo em C++ <ul><li>//it.h , arquivo com definicoes do iterador. </li></ul><ul><li> class iteradorvetor{ </li></ul><ul><li>private: </li></ul><ul><li>vetor vetorref; </li></ul><ul><li>int posicao; </li></ul><ul><li>public: </li></ul><ul><li>iteradorvetor(vetor & v); </li></ul><ul><li>int comeca(); </li></ul><ul><li>int operator!(); </li></ul><ul><li>int operator ++ (); </li></ul><ul><li>float operator() (); </li></ul><ul><li>void operator= (float entra); </li></ul><ul><li>int pos(); //retorna posicao, n~ virtual pq n~ faz sentido p/ arvore por ex. </li></ul><ul><li>}; </li></ul>

192.
Herança e Polimorfismo em C++ <ul><li>int iteradorvetor::pos(){ </li></ul><ul><li>return posicao; </li></ul><ul><li>} </li></ul><ul><li>int iteradorvetor::operator!(){ </li></ul><ul><li>return posicao<=vetorref.ultimo(); </li></ul><ul><li>} </li></ul><ul><li>iteradorvetor::iteradorvetor(vetor & vet):vetorref(vet){ </li></ul><ul><li>comeca(); </li></ul><ul><li>} </li></ul>

193.
Herança e Polimorfismo em C++ <ul><li>int iteradorvetor::comeca(){ </li></ul><ul><li>posicao=vetorref.primeiro(); </li></ul><ul><li>return operator!(); </li></ul><ul><li>} </li></ul><ul><li> </li></ul><ul><li>int iteradorvetor::operator ++(){ </li></ul><ul><li>posicao++; </li></ul><ul><li>return operator!(); </li></ul><ul><li>} </li></ul><ul><li> </li></ul>

194.
Herança e Polimorfismo em C++ <ul><li>void iteradorvetor::operator=(float entra){ </li></ul><ul><li>vetorref[posicao]=entra; </li></ul><ul><li>} </li></ul><ul><li>float iteradorvetor::operator() (){ </li></ul><ul><li>float copia; </li></ul><ul><li>copia=vetorref[posicao]; </li></ul><ul><li>return copia; </li></ul><ul><li>} </li></ul>

195.
Herança e Polimorfismo em C++ <ul><li>#include <iostream.h> </li></ul><ul><li>#include &quot;vet.h&quot; </li></ul><ul><li>#include &quot;it.h&quot; </li></ul><ul><li>main() </li></ul><ul><li>{ </li></ul><ul><li>int repete=0; </li></ul><ul><li>int ind; </li></ul><ul><li>float item; </li></ul><ul><li>vetor meu(5); </li></ul><ul><li>iteradorvetor itmeu(meu); </li></ul><ul><li> </li></ul><ul><li>for (itmeu.comeca();!itmeu;++itmeu) </li></ul><ul><li>{ </li></ul><ul><li>cout << &quot;Entre com valor da posicao:&quot; << itmeu.pos() << &quot;&quot;; </li></ul><ul><li>cin >> item; </li></ul><ul><li>itmeu=item; </li></ul><ul><li>} </li></ul><ul><li> </li></ul>

196.
Herança e Polimorfismo em C++ <ul><li>for (itmeu.comeca();!itmeu;++itmeu) cout<< itmeu()<< &quot; &quot;; </li></ul><ul><li>cout << &quot;Entre com o indice da posicao a atualizar:&quot;; </li></ul><ul><li>cin >> ind; </li></ul><ul><li>cout << &quot;Entre com o valor a incluir:&quot;; </li></ul><ul><li>cin >> item; </li></ul><ul><li>meu[ind]=item; </li></ul><ul><li> </li></ul><ul><li>for (int k=meu.primeiro();k<=meu.ultimo();k++) cout<< meu[k]<< &quot; &quot;; </li></ul><ul><li>cout <<endl << &quot;Maximo:&quot; << meu.maximo(); </li></ul><ul><li>return 0; </li></ul><ul><li>} </li></ul>

197.
Herança e Polimorfismo em C++ <ul><li>O significado do operador é você que define, mas é recomendável dar ao operador um significado próximo ao já definido na linguagem. Por exemplo: o operador + seria ótimo para representar a concatenação de dois objetos do tipo string. A sintaxe de cada operador é fixa: número de operandos, precedência... </li></ul>

198.
Herança e Polimorfismo em C++ <ul><li>Funções Virtuais Puras e Classes Abstratas </li></ul><ul><ul><li>Há situações em que a é desejável garantir que todas as classes derivadas de uma determinada classe base suportassem um dado método. Entretanto, algumas vezes a classe base não tem informação suficiente para permitir alguma definição para uma função virtual. Para estes casos, C ++ suporta o conceito de funções virtuais puras. </li></ul></ul>

199.
Herança e Polimorfismo em C++ <ul><ul><li>Uma função virtual pura não tem nenhuma definição dentro da classe base. Para declarar uma função virtual pura, usa-se a forma </li></ul></ul><ul><ul><li>virtual tipo nome_função (lista-args) = 0; </li></ul></ul>

200.
Herança e Polimorfismo em C++ <ul><ul><li>Quando uma função virtual é feita pura, qualquer classe derivada deve fornecer sua própria definição. Caso contrário, um erro de compilação será acusado. </li></ul></ul><ul><ul><li>Classes que contenham pelo menos uma função virtual pura são chamadas de classes abstratas . </li></ul></ul>

201.
Herança e Polimorfismo em C++ <ul><ul><li>Como uma classe abstrata contém um ou mais métodos para os quais não há definição (as funções virtuais puras), objetos não podem ser criados a partir de classes abstratas. Pode-se dizer que uma classe abstrata é a definição de um tipo incompleto, que serve como fundação para classes derivadas. </li></ul></ul>

202.
Herança e Polimorfismo em C++ <ul><ul><li>Vantagem? </li></ul></ul><ul><ul><ul><li>Objetos não podem ser criados para classes abstratas, mas apontadores para classes abstratas são válidos. Isto permite que classes abstratas suportem polimorfismo em tempo de execução. </li></ul></ul></ul>

203.
Herança e Polimorfismo em C++ //exvetit6 , arquivo com definicoes do iterador. class iterador{ //classe base abstrata public: int comeca(void) {cout << &quot;Erro, classe abstrata!&quot;;} float operator()() {cout << &quot;Erro, classe abstrata!&quot;; return 0;} int operator!(void) {return 0;} int operator ++() {return 0;} void operator=(float entra) {;} }; class iteradorvetor:public iterador { private: vetor vetorref; int posicao; //classe filha acrescentando dados membro public: iteradorvetor(vetor & v); int comeca(); int operator!(); int operator ++ (); float operator() (); void operator= (float entra); int pos();

204.
Herança e Polimorfismo em C++ <ul><li>Funções Amigas (Friend) </li></ul><ul><ul><li>friends permite que uma classe toda ou uma função membro acesse atributos encapsulados de outra classe. Por este motivo, friends representa uma quebra do encapsulamento e deve portanto ser usado com muita cautela. </li></ul></ul><ul><ul><li>Uma função friend é definida fora do escopo da classe, mas tem o direito de acessar membros private da classe (e protected via herança). </li></ul></ul>

205.
Herança e Polimorfismo em C++ <ul><ul><li>Uma classe inteira pode ser declarada como friend de outra classe; </li></ul></ul><ul><ul><li>Para declarar uma função friend, uma clase precede o protótipo da função na definição da classe com a palavra chave friend; </li></ul></ul><ul><ul><li>Para declarar uma classe amiga de outra </li></ul></ul><ul><ul><li>friend class ClasseDois; na definição da ClasseUm. </li></ul></ul>

206.
Herança e Polimorfismo em C++ <ul><li>#include <iostream> </li></ul><ul><li>class Count { </li></ul><ul><li>friend void setX( Count &, int ); </li></ul><ul><li>public: </li></ul><ul><li>Count() { x = 0; } // constructor </li></ul><ul><li>void print() const { cout << x << endl; } // output </li></ul><ul><li>private: </li></ul><ul><li>int x; // data member </li></ul><ul><li>}; </li></ul>

207.
Herança e Polimorfismo em C++ <ul><li>void setX( Count &c, int val ) { </li></ul><ul><li>c.x = val; // legal: setX is a friend of Count </li></ul><ul><li>} </li></ul><ul><li>int main(){ </li></ul><ul><li>Count counter; </li></ul><ul><li>cout << &quot;counter.x depois da instancicao &quot;; </li></ul><ul><li>counter.print(); </li></ul><ul><li>cout << &quot;counter.x depois da chamada da funcao amiga SetX : &quot;; </li></ul><ul><li>setX( counter, 8 ); // atribui um valor a x com SetX </li></ul><ul><li>counter.print(); </li></ul><ul><li>return 0; </li></ul><ul><li>} </li></ul>

208.
Herança e Polimorfismo em C++ <ul><ul><li>friends é muito usado em conjunto com operadores. Operadores são frequentemente usados para implementar operações entre tipos enquanto que funções membro comuns são mais usadas para passagem de mensagens alterando o estado de um único objeto, segundo alguns parâmetros, normalmente tipos simples. </li></ul></ul>

209.
Herança e Polimorfismo em C++ #include <iostream.h> class relogio { friend class caixa_de_mensagem; //permitiu acesso as definicoes private e public private: int hora; int minuto; int segundo; //atributos private, encapsulados public: relogio(int h,int m,int s) {hora=h; minuto=m; segundo=s;} } ;

210.
Herança e Polimorfismo em C++ class caixa_de_mensagem{ public: void imprime(relogio a){ cout << a.hora << &quot;:&quot; << a.minuto << &quot;:&quot; << a.segundo << endl; } } ; void main(){ relogio meurolex(11,30,10); caixa_de_mensagem ativa; ativa.imprime(meurolex); }

211.
Herança e Polimorfismo em C++ <ul><li>O uso do ponteiro this </li></ul><ul><ul><li>Todo objeto tem acesso ao seu próprio endereço através do ponteiro this. </li></ul></ul><ul><ul><li>O ponteiro this é implicitamente usado para prover referência tanto para membros de dados quanto para as funções membro do objeto </li></ul></ul>

212.
Herança e Polimorfismo em C++ <ul><li>#include <iostream> </li></ul><ul><li>class Test { </li></ul><ul><li>public: </li></ul><ul><li>Test( int = 0 ); </li></ul><ul><li>void print() const; </li></ul><ul><li>private: </li></ul><ul><li>int x; </li></ul><ul><li>}; </li></ul>

213.
Herança e Polimorfismo em C++ <ul><li>Test::Test( int a ) { x = a; } // constructor </li></ul><ul><li>void Test::print() const { </li></ul><ul><li>cout << &quot; x = &quot; << x </li></ul><ul><li><< &quot; this->x = &quot; << this->x </li></ul><ul><li><< &quot;(*this).x = &quot; << ( *this ).x << endl; </li></ul><ul><li>} </li></ul>

214.
Herança e Polimorfismo em C++ <ul><li>int main() </li></ul><ul><li>{ </li></ul><ul><li>Test testObject( 12 ); </li></ul><ul><li>testObject.print(); </li></ul><ul><li>return 0; </li></ul><ul><li>} </li></ul>

215.
Herança e Polimorfismo em C++ <ul><li>Algumas “Dicas” </li></ul><ul><ul><li>Classes abstratas não são instânciadas; </li></ul></ul><ul><ul><li>Se uma classe é derivada de uma classe com função virtual pura, então a classe derivada tb é abstrata; </li></ul></ul><ul><ul><li>Através do uso de virtual e polimorfismo, uma chamada a função membro pode produzir ações diferentes, dependendo do tipo do objeto que está recebendo a chamada; </li></ul></ul><ul><ul><li>Ponteiros declarados para classes abstratas são usados para possibilitar manipulações polimórficas de objetos de classe derivadas quando tais objetos forem instânciados de classes concretas; </li></ul></ul>

216.
Herança e Polimorfismo em C++ <ul><ul><li>Declare o destrutor da classe base como virtual se a classe possui funções virtuais; </li></ul></ul><ul><ul><li>É erro tentar instanciar um objeto de uma classe abstrata; </li></ul></ul><ul><ul><li>Construtores não podem ser virtuais (erro). </li></ul></ul><ul><ul><li>Uma classe é tornada abstrata quando se declara uma ou mais funções membro virtual; </li></ul></ul><ul><ul><li>Uma função virtual pura é uma função com um inicializador =0 em sua declaração; </li></ul></ul>

217.
Herança e Polimorfismo em C++ <ul><li>#ifndef SHAPE_H </li></ul><ul><li>#define SHAPE_H </li></ul><ul><li>class Shape { </li></ul><ul><li>public: </li></ul><ul><li>virtual double area() const { return 0.0; } </li></ul><ul><li>virtual double volume() const { return 0.0; } </li></ul><ul><li>// pure virtual functions overridden in derived classes </li></ul><ul><li>virtual void printShapeName() const = 0; </li></ul><ul><li>virtual void print() const = 0; </li></ul><ul><li>}; </li></ul><ul><li>#endif </li></ul>

218.
Herança e Polimorfismo em C++ <ul><li>#ifndef POINT1_H </li></ul><ul><li>#define POINT1_H </li></ul><ul><li>#include <iostream> </li></ul><ul><li>#include &quot;shape.h&quot; </li></ul><ul><li>class Point : public Shape { </li></ul><ul><li>public: </li></ul><ul><li>Point( int = 0, int = 0 ); // default constructor </li></ul><ul><li>void setPoint( int, int ); </li></ul><ul><li>int getX() const { return x; } </li></ul><ul><li>int getY() const { return y; } </li></ul><ul><li>virtual void printShapeName() const { cout << &quot;Point: &quot;; } </li></ul><ul><li>virtual void print() const; </li></ul><ul><li>private: </li></ul><ul><li>int x, y; // x and y coordinates of Point </li></ul><ul><li>}; </li></ul><ul><li>#endif </li></ul>

219.
Herança e Polimorfismo em C++ <ul><li>//point.cpp </li></ul><ul><li>#include &quot;point1.h&quot; </li></ul><ul><li>Point::Point( int a, int b ) { setPoint( a, b ); } </li></ul><ul><li>void Point::setPoint( int a, int b ){ </li></ul><ul><li>x = a; </li></ul><ul><li>y = b; </li></ul><ul><li>} </li></ul><ul><li>void Point::print() const </li></ul><ul><li>{ cout << '[' << x << &quot;, &quot; << y << ']'; } </li></ul>

220.
Herança e Polimorfismo em C++ <ul><li>#ifndef CIRCLE1_H </li></ul><ul><li>#define CIRCLE1_H </li></ul><ul><li>#include &quot;point1.h&quot; </li></ul><ul><li>class Circle : public Point { </li></ul><ul><li>public: </li></ul><ul><li>// default constructor </li></ul><ul><li>Circle( double r = 0.0, int x = 0, int y = 0 ); </li></ul><ul><li>void setRadius( double ); </li></ul><ul><li>double getRadius() const; </li></ul><ul><li>virtual double area() const; </li></ul><ul><li>virtual void printShapeName() const { cout << &quot;Circle: &quot;; } </li></ul><ul><li>virtual void print() const; </li></ul><ul><li>private: </li></ul><ul><li>double radius; // radius of Circle </li></ul><ul><li>}; </li></ul><ul><li>#endif </li></ul>

221.
Herança e Polimorfismo em C++ <ul><li>//circle1.cpp </li></ul><ul><li>#include <iostream> </li></ul><ul><li>#include &quot;circle1.h&quot; </li></ul><ul><li>Circle::Circle( double r, int a, int b ) </li></ul><ul><li>: Point( a, b ) // call base-class constructor </li></ul><ul><li>{ setRadius( r ); } </li></ul><ul><li>void Circle::setRadius( double r ) { radius = r > 0 ? r : 0; } </li></ul><ul><li>double Circle::getRadius() const { return radius; } </li></ul><ul><li>double Circle::area() const </li></ul><ul><li>{ return 3.14159 * radius * radius; } </li></ul><ul><li>void Circle::print() const{ </li></ul><ul><li>Point::print(); </li></ul><ul><li>cout << &quot;; Radius = &quot; << radius; </li></ul><ul><li>} </li></ul>

222.
Herança e Polimorfismo em C++ <ul><li>#ifndef CYLINDR1_H </li></ul><ul><li>#define CYLINDR1_H </li></ul><ul><li>#include &quot;circle1.h&quot; </li></ul><ul><li>class Cylinder : public Circle { </li></ul><ul><li>public: </li></ul><ul><li>// default constructor </li></ul><ul><li>Cylinder( double h = 0.0, double r = 0.0, </li></ul><ul><li>int x = 0, int y = 0 ); </li></ul><ul><li>void setHeight( double ); </li></ul><ul><li>double getHeight(); </li></ul><ul><li>virtual double area() const; </li></ul><ul><li>virtual double volume() const; </li></ul><ul><li>virtual void printShapeName() const {cout << &quot;Cylinder: &quot;;} </li></ul><ul><li>virtual void print() const; </li></ul><ul><li>private: </li></ul><ul><li>double height; // height of Cylinder </li></ul><ul><li>}; </li></ul>

223.
Herança e Polimorfismo em C++ <ul><li>#include <iostream> </li></ul><ul><li>#include &quot;cylindr1.h&quot; </li></ul><ul><li>Cylinder::Cylinder( double h, double r, int x, int y ): Circle( r, x, y ) // constructor </li></ul><ul><li>{ setHeight( h ); } </li></ul><ul><li>void Cylinder::setHeight( double h ) { height = h > 0 ? h : 0; } </li></ul><ul><li>double Cylinder::getHeight() { return height; } </li></ul><ul><li>double Cylinder::area() const{ </li></ul><ul><li>// surface area of Cylinder </li></ul><ul><li>return 2 * Circle::area() + 2 * 3.14159 * getRadius() * height; </li></ul><ul><li>} </li></ul><ul><li>double Cylinder::volume() const </li></ul><ul><li>{ return Circle::area() * height; } </li></ul><ul><li>void Cylinder::print() const{ </li></ul><ul><li>Circle::print(); </li></ul><ul><li>cout << &quot;; Height = &quot; << height; </li></ul><ul><li>} </li></ul>

224.
Herança e Polimorfismo em C++ <ul><li>Polimorfismo Paramétrico (template) </li></ul><ul><ul><li>Polimorfismo paramétrico é um recurso bastante útil para evitar redundância de código, portanto se trata de um meio de reuso deste. É importante para criar famílias de classes ou funções relacionadas. </li></ul></ul>

225.
Herança e Polimorfismo em C++ <ul><li>Este recurso permite por exemplo definir uma classe matriz uma única vez num “header file” e utilizar esta classe matriz para matrizes de tipo float , tipo int ou long ,etc. Assim, por exemplo se na sua classe matriz usa o operador %, todos os tipos a serem instanciados (susbtituídos como tipo usado na matriz) devem atender da maneira desejada a esse operador. </li></ul>

226.
Herança e Polimorfismo em C++ <ul><li>Se optar por templates, siga os seguintes passos: </li></ul><ul><ul><li>Defina os tipos que você quer parametrizar um termos de chamadas de funções membro e operadores de nomes e sintaxe iguais (uniformidade). Os tipos dos argumentos vão variar. </li></ul></ul><ul><ul><li>Construa seu programa para operar em um só destes tipos. </li></ul></ul><ul><ul><li>Termine incluindo as definições dos templates no programa e testando para os demais tipos. </li></ul></ul><ul><ul><li>Corrija as eventuais falhas de substituição </li></ul></ul>

227.
Herança e Polimorfismo em C++ <ul><li>Templates de Classe </li></ul><ul><ul><ul><li>Um gabarito de classe permite definir um padrão para definições de classes. Assim como para gabaritos de funções, a declaração de um gabarito de classe é precedida por template class < T > , onde T é apenas uma referência a tipo ou classe que será utilizada na declaração. </li></ul></ul></ul>

228.
Herança e Polimorfismo em C++ template < class T > class Vector { T * data; int size; public : Vector( int ); ~ Vector() { delete [] data; } T& operator [] ( int i) { return data[i]; } }; // observe a sintaxe para definicao fora da classe template < class T > Vector < T > ::Vector( int n) { data = new T[n]; size = n;

229.
Herança e Polimorfismo em C++ // exemplo de declaracao main () { Vector <int> ix(5); // gera um vetor de inteiros Vector <float> fx(6); // gera vetor de floats //... }

230.
Herança e Polimorfismo em C++ <ul><li>classes gabaritos (as instâncias de gabaritos de classes) devem ser explícitas sobre os parâmetros sobre os quais elas irão instanciar. </li></ul>

231.
Herança e Polimorfismo em C++ <ul><li>Templates de funções </li></ul><ul><ul><li>Considere a seguinte função que troca os valores de dois inteiros: </li></ul></ul><ul><ul><li>void swap ( int & x, int & y) { int tmp = x; x = y; y = tmp; } </li></ul></ul>

232.
Herança e Polimorfismo em C++ <ul><li>E se desejarmos trocar floats e longs? </li></ul><ul><li>E exemplo a seguir ilustra o uso do template </li></ul><ul><li>template < class T > void swap (T& x, T& y) { T tmp = x; x = y; y =tmp; } </li></ul>

233.
Herança e Polimorfismo em C++ <ul><li>Toda vez que a função swap for chamada com um dado par de tipos, o compilador C ++ irá até a definição acima e criará uma outra função gabarito como uma instância do gabarito de função acima. Funções gabaritos podem ser sobrepostas por outras definições para tipos específicos, se necessário </li></ul>

234.
E/S com streams em C++ <ul><li>Recursos de E/S </li></ul><ul><ul><li>Biblioteca<iostream.h> </li></ul></ul><ul><ul><li>Streams = sequência de bytes </li></ul></ul><ul><ul><li>Disponível E/S no estilo C <stdio.h> </li></ul></ul><ul><ul><li>Uso dos recursos do C++ facilita a portabilidade </li></ul></ul><ul><ul><li>Do código </li></ul></ul>

235.
E/S com streams em C++ <ul><li>A biblioteca iostrema </li></ul><ul><ul><li>Fornece recursos de E/S </li></ul></ul><ul><ul><li>Define objetos do tipo cin, cout, cerr, clog; </li></ul></ul><ul><ul><li><iomanip> declara processamento com arquivos controlado pelo usuário; </li></ul></ul>

236.
E/S com streams em C++ <ul><li>Exemplos </li></ul><ul><ul><li>cin >> nome </li></ul></ul><ul><ul><li>cout << nome </li></ul></ul><ul><ul><li>endl // gera um caracter de nova linha </li></ul></ul><ul><ul><li>cout << flush; //esvazia o buffer de saída </li></ul></ul>

237.
E/S com streams em C++ <ul><li>Encadeamento (c/ << sobregarregado) </li></ul><ul><ul><li>cout << “2 mais 3 é” << (2+3) << endl; </li></ul></ul><ul><li>Saída de char </li></ul><ul><ul><li>char *string = “teste”; </li></ul></ul><ul><ul><li>cout << “valor da string” << string; </li></ul></ul>

238.
E/S com streams em C++ <ul><li>Permite ainda: </li></ul><ul><ul><li>E/S formatada (classe ios) </li></ul></ul><ul><ul><ul><li>Skipws (ignora espaços em branco) </li></ul></ul></ul><ul><ul><ul><li>Left (justifica a esquerda) </li></ul></ul></ul><ul><ul><ul><li>Right (justifica a direita) </li></ul></ul></ul><ul><ul><ul><li>Dec (inteiros na base 10) </li></ul></ul></ul><ul><ul><ul><li>Oct (inteiros na base 8) </li></ul></ul></ul><ul><ul><ul><li>Hex (inteiros na base 16) </li></ul></ul></ul><ul><ul><ul><li>Showpoint (especifica o número em ponto flutuante) </li></ul></ul></ul><ul><ul><ul><li>Uppercase (letras maiúsculas) </li></ul></ul></ul><ul><ul><ul><li>etc </li></ul></ul></ul>

239.
E/S com streams em C++ <ul><ul><li>Manipulação de arquivos </li></ul></ul><ul><ul><li>Notação científica </li></ul></ul><ul><ul><li>Vínculo de E/S </li></ul></ul>

240.
<ul><li>#include <iostream> </li></ul><ul><li>using std::cout; </li></ul><ul><li>using std::endl; </li></ul><ul><li>#include <iomanip> </li></ul><ul><li>using std::ios; </li></ul><ul><li>#include <cmath> </li></ul><ul><li>int main(){ </li></ul><ul><li>cout << &quot;Before setting the ios::showpoint flag&quot; </li></ul><ul><li><< &quot;9.9900 prints as: &quot; << 9.9900 </li></ul><ul><li><< &quot;9.9000 prints as: &quot; << 9.9000 </li></ul><ul><li><< &quot;9.0000 prints as: &quot; << 9.0000 </li></ul><ul><li><< &quot;After setting the ios::showpoint flag&quot;; </li></ul><ul><li>cout.setf( ios::showpoint ); </li></ul><ul><li>cout << &quot;9.9900 prints as: &quot; << 9.9900 </li></ul><ul><li><< &quot;9.9000 prints as: &quot; << 9.9000 </li></ul><ul><li><< &quot;9.0000 prints as: &quot; << 9.0000 << endl; </li></ul><ul><li>return 0; </li></ul><ul><li>} </li></ul>

241.
Programação C++ <ul><li>Não se integra a definição da classe com arquivos cabeçalhos, por dois motivos: </li></ul><ul><ul><ul><li>desempenho de compilação: </li></ul></ul></ul><ul><ul><ul><ul><li>arquivos de cabeçalho são arquivos em código fonte, sendo portanto recompilados quando a aplicação que os incluem é modificada. Mantendo métodos em um arquivo separado, seu código pode ser pré-compilado e integrado à aplicação durante a fase de ligação; </li></ul></ul></ul></ul>

242.
Programação C++ <ul><li>segredo tecnológico: </li></ul><ul><ul><li>ao entregar a implementação de métodos em um arquivo de cabeçalho, o projetista da classe estaria entregando o código fonte de como as suas funções foram implementadas. Em alguns casos, isto seria altamente indesejável. A pré-compilação da implementação dos métodos permitiria que apenas a declaração das classes fossem abertas, com o código dos métodos sendo mantido fechado em bibliotecas de código objeto. </li></ul></ul>

243.
Programação em C++ <ul><li>Arquivos Cabeçalhos (header) </li></ul><ul><ul><li>cabeçalhos são usados para conter declarações de classes -- usualmente, um arquivo para cada classe. Em geral, definições dos métodos não são incluídas em cabeçalhos, mas sim mantidas em um arquivo à parte </li></ul></ul>

244.
Programação em C++ <ul><li>Em uma aplicação que inclua dois mais dos cabeçalhos , um erro de compilação seria gerado por estar definindo a classe base mais de uma vez. A solução para evitar este problema, é usar as diretivas de pré-processamento #define e #ifdef juntamente com uma ``variável de controle'': quando um cabeçalho é incluído pela primeira vez, a variável de controle não estará definida; assim, o segmento do arquivo de cabeçalho com a definição da classe é incluído e a variável de controle é definida. Caso contrário, a variável de controle já estará definida, e o restante do arquivo de cabeçalho (a declaração da classe) pode ser ignorado. </li></ul>

245.
Programação em C++ <ul><li>#ifndef VEHICLE_H </li></ul><ul><li>#define VEHICLE_H </li></ul><ul><li>class vehicle { </li></ul><ul><li>protected : </li></ul><ul><li>int wheels; </li></ul><ul><li>float weight; </li></ul><ul><li>public : </li></ul><ul><li>void initialize( int in_wheels, float in_weight); int get_wheels( void ); </li></ul><ul><li>float get_weight( void ); </li></ul><ul><li>float wheel_loading( void ); </li></ul><ul><li>}; </li></ul><ul><li>#endif </li></ul>

246.
Programação em C++ <ul><li>A lgumas recomendações que, sendo seguidas durante o desenvolvimento da aplicação, podem auxiliar na minimização dos erros e facilitar a manutenção de projetos de software. </li></ul>

247.
Programação em C++ <ul><li>Otimize código apenas quando você sabe que você tem um problema de desempenho . Pense duas vezes antes de fazê-lo. </li></ul><ul><li>Um arquivo de cabeçalho não deve conter mais do que uma definição de classe. </li></ul><ul><li>Se há código na sua aplicação que depende da máquina onde a aplicação será executada, coloque este código em um arquivo isolado, de forma que seja fácil localizá-lo quando transferir sua aplicação para outra máquina. </li></ul>

248.
Programação em C++ <ul><li>Todo arquivo que contém código fonte deve ser documentado com comentários introdutórios dando informação sobre o nome do arquivo e seu conteúdo </li></ul><ul><li>Todos arquivos devem incluir informação de copyright . </li></ul><ul><li>Escreva comentários descritivos antes de cada função. </li></ul><ul><li>Todo arquivo de cabeçalho deve conter o mecanismo para evitar múltiplas inclusões do mesmo arquivo. </li></ul>

249.
Programação em C++ <ul><li>Escolha nomes de variáveis que sugiram o seu uso. </li></ul><ul><li>Na definição de classes, ordene a declaração de seções na ordem: pública, protegida, privativa. </li></ul><ul><li>Não define funções membro dentro da definição da classe. </li></ul><ul><li>Sempre explicite o tipo de retorno de uma função. </li></ul><ul><li>Não especifique dados na seção pública de uma classe. </li></ul>

250.
Programação em C++ <ul><li>13. Funções pequenas (por exemplo, simplesmente retornar um valor de um membro da classe) devem ser definidas como função em linha. </li></ul><ul><li>14. Contrutores e destrutores não devem ser definidos como funções em linha. </li></ul><ul><li>15. Uma função membro que não afeta o estado de um objeto deve ser declarada como const . </li></ul><ul><li>16. Use sobrecarga de operadores com parcimônia e de maneira uniforme. </li></ul>

251.
Programação em C++ <ul><li>17. Quando dois operadores têm usualmente significados opostos (como == e != ), é apropriado definir ambos. </li></ul><ul><li>18. Evite funções com muitos argumentos. </li></ul><ul><li>19. Evite o uso de número variável de argumentos. </li></ul><ul><li>20. Quando sobrecarregando funções, todas as variações devem ter a mesma semântica, isto é, devem ser usadas para o mesmo fim. </li></ul>

252.
Programa