01 orientacao a objetos programacao

Programação Orientada para Objetos com C++

José Luiz de Souza Pio

UFMGBelo Horizonte – Minas Gerais

Abril de 2002

Programa

Conceitos Básicos (4 horas) Projeto de Programas OO (12 horas) Linguagem C++ (12 horas) Aplicação (12 horas)

Introdução

Projeto de Programas Técnicas que visam garantir:

QualidadeConfiabilidadeClarezaFacilidade de manutenção

Conceito Fundamental: TAD (Tipo abstrato de Dados)

Introdução

Abstração de Dados Programa = modelo para a solução de um

problema Abstração de dados

Representação abstrata dos dados da aplicação TAD

Definição de dados associados as suas operações

Introdução

Técnicas Programação não estruturada Programação estruturada Programação modular

Introdução

Programação não estruturada (espaguete)

Introdução

Programação Estruturada

Introdução

Programação Estruturada Objetivos

Gerar programas altamente legíveis (clareza) Hierarquia funcional descrita através de estruturas de

controle (If - then – else) – (while) – (for) – (do)

O código produzido deve ser lido seqüencialmente em pequenos segmentos de código

Introdução

Vantagens: Programa correto desde a sua concepção (!?) Clareza no código Menor tempo de depuração Teste mais fácil

Interessados na metodologia Método de Jackson

Introdução

Programação Modular Organização do programa em módulos Utilização de módulos executáveis

Introdução

Como modularizar? 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;

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;

3. Repetir os passos 1 e 2 até obter uma organização modular satisfatória;

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.

Introdução

Vantagens da Programação Modular A possibilidade de desenvolver programas

complexos em equipe Aumento do grau de paralelismo na produção Redução da depuração Redução da manutenção Reutilização do modulo

Introdução

Problema: Separação entre dados e procedimentos

Solução: Dependência mútua entre dados e procedimentos

Este é o principal aspecto das linguagens que suportam OO

POO

Orientação para Objetos 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:

- Só é possível exercer operações diretas sobre uma estrutura de dados se conhecermos a forma como ela está implementada;

- As estruturas de dados são organizadas para que as operações realizadas sobre elas sejam implementadas de forma eficiente.

POO

Operações Estrutura de dados

Dependência Mútua

Como ficam as estruturas de dados globais?

POO

Decisões de Projeto

Estruturas

Operações

DecomposiçãoColoque juntas todas as decisões de projeto relacionadas

POO

Elemento capaz de: Agrupar várias operações; Suportar a declaração de ED que não é global

nem volátil como uma variável local.

Objeto = Resultado da união inseparável entre uma ED e todas as operações associadas.

POO

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.

Objetos e Métodos

Um objeto é composto por um conjunto de dados privados é um conjunto de métodos que atuam sobre estes dados.

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.

Métodos e Objetos

Em um programa, a declaração de um novo objeto deve ser constituída dos seus dados privados e de seus métodos;

Métodos: Interface: interface descreve a parte visível do método,

seu nome, tipos de parâmetros, e valor de retorno. Implementação: implementação contém o código

efetivo para operação, inclusive chamadas a outros métodos do objeto.

Métodos e Objetos

Exemplo

Círculo

X, Y, Raio

CalculaAreaCalculaPerimetroDesenhaCirculo

Métodos e Objetos

Como seria a interface do método CalculaArea?

Como seria sua implementação?

Métodos e Objetos

Questões Explique por que existe dependência mútua entre ED e

operações. Que são as decisões de projetos? Qual a necessidade dos dados privados a um objeto? É necessário conhecer a implementação de um objeto

para utiliza-lo? Qual a vantagem que diferentes objetos terem métodos

com nomes iguais?

Métodos e Objetos

Exercícios Esboce um objeto para calcular propriedade

geométricas de retângulos. Esboce um objeto chamado Médias, cujo o

objetivo é calcular diferentes tipos de médias (aritmética, ponderada, geométrica, etc).

Projete um objeto chamado dispersão, cujo o objetivo e calcular diferentes tipos de medidas de dispersão.

Classes, Instâncias e Mensagens

Classe: Modelo a partir do qual os objetos são criados;

Exemplo:

Tom, Garfield, Frajola, Manda-chuva e Batatinha. São todos da mesma classe: Gatos


Uma melhor definição:

“Classe é um agrupamento de objetos que revelam profundas semelhanças entre si, tanto no aspecto estrutural quanto no funcional”.


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).


Uma representação gráfica para as classes

Nome da Classe

Atributos

Serviços

Característica comumaos objetos descritos pela classe

Alguma operação que podeser solicitada pelo objeto

Coad & Yourdon


TODO OBJETO É UMA INSTÂNCIA DE UMA CLASSE

OBJETOS SÃO CRIADOS DURANTE A EXECUÇÃO DO PROGRAMA, E OCUPAM ESPAÇO NA MEMÓRIA

TODAS AS INSTÂNCIAS DE UMA CLASSE OBEDECEM AO MESMO PROTOCOLO


Motor

Cabo elétrico

Disco de serra

Correia

Serra Elétrica

Serra Elétrica

Martelete

Furadeira

Prensa


PROTOCOLO: É o conjunto de métodos implementados para uma classe

VARIÁVEIS DE INSTÂNCIA: Elementos que compõe a coleção de dados privados de uma classe

ESTADO INTERNO: Conjunto de valores assumidos pelas variáveis de instância


ProtocoloParte visível

Parte privadaVariáveis de Instância e métodos

Classe


Exemplo

CanetaGráfica

Coordenadas

MoveToLineTo


Bic Paker

Y

X 4

20 Y

X 200

10

Instâncias da classe CanetaGráfica

Estado interno

Variáveis de instância


Um estado interno de um objeto muda cada vez que se modifica o valor de uma de suas variáveis de instância.

É interessante que os objetos possuam um estado inicial conhecido (construtores).

Métodos destrutores são utilizados para liberar a memória.


Mensagem: Ativa um método de um objeto

máquina A

t = 0Lig = FALSE

t = 50Lig = TRUE

máquina AMensagem Resposta

Máquina(50, TRUE)

t = 50Lig = TRUE

MensagemComposta por um seletor e um conjunto de parâmetros

RespostaResultado da execução do método


Questões É vantajoso definir um protocolo extenso para uma

classe? Por que um objeto deve ter um estado inicial bem

definido? Chamada a procedimento = envio de mensagem? Qual a relação existente entre a resposta a uma

mensagem e o estado interno de um objeto receptor? Ao projetar uma classe deve-se pensar primeiro nos

dados ou nos métodos?


Objeto 1Dados

Objeto nDados

Objeto 2Dados

Objeto 6Dados

Objeto 5Dados

Objeto 3Dados

Objeto 4Dados

Encapsulamento

Impede ao cliente enxergar os detalhes da implementação do objeto

Interface

Sistema

Interface

Parte Privada

O que o cliente vê O que o projetista vê

Encapsulamento

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.

Encapsulamento

REGRAS DO ENCAPSULAMENTO Regra 1

Apenas os métodos devem ser capazes de alterar o estado interno de um objeto

Regra 2A resposta a uma mensagem deve ser completamente

determinada pelo estado interno do objeto

Encapsulamento

Conseqüências Regra 1: Não é possível acessar o valor de uma

variável de instância externamente. 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).

Encapsulamento

Se um valor for utilizado por um método ele pode ser:

Uma variável de instância do objeto;Um parâmetro formal;Uma variável local;Uma constante local;Uma constante global.

Não se deve acessar variáveis globais da aplicação no interior de um método

Encapsulamento

Reusabilidade: reaproveitamento dos componentes. Com o encapsulamento os objetos se tornam mais reutilizável.

Aumenta a produtividade.

Encapsulamento

Manutenabilidade: Impacto que as modificações causam no funcionamento de um sistema.

O encapsulamento favorece mudanças com efeitos mínimos e bem localizados

Encapsulamento

Questões Quais problemas ocorrem com o desrespeito a

Regra 1? E a Regra 2? Que tipo de mudanças o projetista pode fazer em

uma classe com a garantia de que seus clientes não serão afetados

Encapsulamento

Exercícios Defina classes para representar figuras

geométricas, como círculos e retângulos. Que características elas têm em comum?

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?

Herança e Polimorfismo

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.


Diz-se que uma subclasse herda os métodos e as variáveis de instância de uma superclasse. 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.

Uma subclasse é uma especialização de uma superclasse. Uma instância da subclasse têm todas as propriedades de

uma instância da superclasse, mais suas características particulares, e nunca menos.


classe B

Dados BMétodos B

classe C

Dados BDados CMétodos BMétodos C


superclasse

subclasses

Representação gráficapara a Herança

Especialização


Hierarquia de classes Classes mais genéricas ficam próximas ao topo e

as mais especializadas na parte inferior.


classe A classe B

classe C

Dados AMétodos A

Dados BMétodos B

Dados ADados BDados CMétodos AMétodos BMétodos C

A herança múltipla


Polimorfismo É 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.


Polimorfismo É 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


Quando uma mensagem é enviada a um objeto polimórfico, não é possível determinar previamente qual o endereço do objeto. E agora?

O mecanismo que permite a resolução de endereços em tempo de execução chama-se ligação dinâmica.


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.


Conclusões Programação Orientada para Objetos não é a

mesma coisa que programação com objetos; Com POO se obtém:

ReusabilidadeManutenibilidadeExtensibilidade


Questões O que é o mecanismo de ligação dinâmica? Em que situação a identidade de um objeto é

conhecida em tempo de execução? Sem polimorfismo e ligação dinâmica como

seria feita a inclusão de um novo objeto em um programa?


Exercícios Implemente novos tipos de figuras geométricas,

expandindo, através da herança e do polimorfismo, a hierarquia anteriormente desenvolvida.

Como poderia ser estruturada uma hierarquia incluindo as classes ContaCorrente e Poupança?

Classes e Objetos em C++

Termo emOO

Significado em C++

Classe Em C++, a palavra reservada classrepresenta um novo tipo de dado que é umaextensão do tipo struct.

Objeto Objeto é uma variável do tipo nomeClasse,onde nomeClasse foi definida de acordo comas regras de class.

Dados deestado

São denominados campo de dados, membrode dados ou simplemente membros de classe.

Mensagem São especificadas pelos protótipos de função.

Método São definições de função.

Subclasse É chamada de classe derivada.


Uma definição de classe é basicamente uma definição de um tipo de dado.

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.


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.


É possível que dados internos sejam acessados externamente; para tanto, deve-se colocar estes dados na seção pública da classe.


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 ::.


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.


Exemplo

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çõesmembro ou friend


Implementação das funções membro

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!


Usando os objetos

int main (){Tempo t;

cout<< ‘’A hora militar eh’’;t.PrintMilitar();

::}

Cria o objeto

Usa a função membro


Onde ficam as classes?A implementação pode ser feita na própria definição

da classe (inline);Usual:

Definições (protótipos das funções membro e dados) em arquivo cabeçalho;

Implementação em arquivo .cpp;


Especificadores de acesso as classes

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.

private: Qualquer membro de dados ou função membro são acessíveis somente pelas funções membro da classe.


Mas o que é uma função amiga?São rotinas que pertencem a uma classe, mas podem

ser usadas em outra sem qualquer vínculo de Herança ou Associativo com esta.


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:


Definindo objetos

Tempo sunset, ArraydeTempos[5], *ptToTime;


Escopo da Classe e acesso a membros Membro de dados e funções membro formam o

escopo da classe; Variáveis definidas em uma função membro tem

o escopo da função; Os membros são acessados por operadores de

acesso a membros.


Operadores de acesso a membrosOperador ponto (.) - Combina o nome do objeto com

uma referência ao objeto para acessar membro;Operador seta (->) - Combina um ponteiro para um

objeto para acessar os membros do objeto.


Exemplo

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();

}


Revisão Classes habilitam a modelagem dos objetos com atributos e

comportamentos; Em C++, as classes são definidas usando a palavra reservada

class (obs: struct); O nome da classe é utilizado para declarar os objetos

pertencentes a classe; As definições de classe começam com a palavra reservada class.

O corpo da classe é delimitado por “{“e “ }” e termina com “;”; 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.


Qualquer membro de dados ou função membro declarada depois de private: só é visível para friends e outros membros da classe;

Um construtor é uma função membro especial, usada para inicializar os membros de um objeto da classe;

A interface da classe é definida pelas funções membro public; Funções membro definidas fora da classe: Usar operador :: Funções definidas fora da classe estão dentro do escopo da

classe; Acesso aos membros: operadores . e -> Definições da classe colocadas em arquivos cabeçalhos Definições das funções membro em arquivo .cpp com mesmo

nome base


Dentro do escopo da classe a referência aos membros é feita através do nome do membro;

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;

Normalmente os membros de dados de uma classe são declarados private e as funções membro declaradas como public;

Algumas funções membro podem ser private (funções de baixo nível);

Inicializadores do objeto são fornecidos pelos construtores da classe;


Aponte os errosvoid ~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)


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ê idealizouem 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çãoconstrutora 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 defaultigual a 1. Forneça as funções get e set, tanto para o comprimento quanto para a altura.


//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 defaultfloat y; //sao ocultos por default};


//Arquivo 2 , ponto.cpp , implementacao para a classe ponto.#include <iostream.h>#include "ponto.h" 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 << "X:" << x << " , Y:" << y << endl;}


//Arquivo 3 . Programa principal: princ.cpp#include "ponto.h" void main(){ponto ap; //instanciacaoap.inicializa(0.0,0.0);//metodos publicap.mostra(); //metodos public


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.

Resumo das operações matemáticas envolvidas: Simplificação de fração: (a/b)=( (a/mdc(a,b)) / (b/mdc(a,b)) ) Onde mdc(a,b) retorna o máximo divisor comum de ab. Soma de fração: (a/b)+(c/d)=( (a.d+c.b) / b.d ) simplificada. Multiplicação de fração: (a/b) * (c/d)= ( (a*c) / (b*d) ) simplificada. Igualdade: (a/b)== (c/d) se a*d == b*c. Não igualdade: (a/b) != (c/d) se a*d b*c

Maior ou igual que:(a/b)(c/d) se a*d b*c


//File easyfra.h

long mdc(long n,long d);//maximo divisor comum metodo de Euclides. class fracao {private:

long num; //numeradorlong den; //denominador

public:fracao(long t,long m); //construtor comumvoid simplifica(void); //divisao pelo mdc ~fracao() { /* nao faz nada*/ }

//operacoes matematicas basicas

fracao soma (fracao j);fracao multiplicacao(fracao j);

//operacoes de comparacaoint 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};


//implementacao para a classe fracao.#include <iostream.h>#include "easyfra.h" 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 comumnum=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.}


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 << "(" << num << "/" << den << ")";} void fracao::cria(void) { cout << "Numerador:"; cin >> num; cout << "Denominador:"; cin >> den; simplifica(); }


double fracao::convertedbl(void){double dbl;dbl=(double(num)/double(den));return dbl;} //conversao para longlong fracao::convertelng(void){long lng;lng=num/den;return lng;}


#include <iostream.h>#include "easyfra.h"//nossa definicao da classe#include <stdio.h>main(){fracao a(0,1),b(0,1);cout << " Entre com fracao a: ";a.cria();a.mostra();cout << " Entre com fracao b: ";b.cria();b.mostra();fracao c(a.soma(b));//c(a+b)cout << endl << "c de a+b:";c.mostra();

cout << endl << "a*b";c=a.multiplicacao(b);c.mostra();cout << endl << "a+b";c=a.soma(b);c.mostra();cout << endl << "a>=b";cout << a.maiorouigual(b);cout << endl << "a==b";cout << a.igual(b);cout << endl << "a!=b";cout << a.diferente(b);cout << endl << "long(a) ";cout << a.convertelng();cout << endl << "double(a) ";cout << a.convertedbl();return 0;}

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' bomfloat y;//sao ocultos por defaultpublic://daqui em diante tudo e acessivel em main. ponto(float a,float b) { x=a; y=b; } void mostra(void) const {cout << "X:" << x << " , Y:" << 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 }};


void main(){ponto ap(3.0,4.0);//instanciacaoap.mostra();//funcoes membro publicconst ponto origem(ZERO,ZERO);//defino objeto constanteorigem.mostra();cout << "Distancia da origem:" << origem.distancia(ap); }


Uso do constConst 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


#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++


#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] << " " << vet[1] << " " << vet[2] << endl;}//funcao membro para mostrar o conteudo do vetor};

Alocação Estática


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.}


#include <iostream.h>//vetor alocado dinamicamentevoid main(){int tamanho; int* vet; cout << "Entre com o tamanho do vetor a criar";cin >> tamanho; vet=new int[tamanho]; //alocando vetor de "tamanho" posicoes comecando em a[0] for (int i=0;i<tamanho;i++){cout << "Entre com o valor da posicao " << i << ":";cin >> vet[i];cout << endl;} for (int j=0;j<tamanho;j++){cout << "Posicao " << j << ":" << vet[j]<<endl;}}

Alocação Dinâmica


//file exvet1.h//header file para classe vetor const int inicio=0; class vetor{private:int* v; //este e' o vetorint 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 vetorint conteudo(int index); //retorna conteudo de posicao do vetorint maximo(void); //retorna o maior elemento do vetorint primeiro(void); //primeiro indice do vetorint ultimo(void); //ultimo indice do vetor~vetor() {delete v;} //inline function ou use delete v[];};

TAD Vetor


//codigo, implementacao, para o header file#include <iostream.h>#include <stdlib.h>#include "exvet1.h" 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 << "Fora dos limites"; 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];}


//programa pricipal#include <iostream.h>#include "exvet1.h" main(){int aux; //para ler valor a atribuirvetor meu(5);for (int i=meu.primeiro();i<=meu.ultimo();i++){ cout << "Entre com valor da posicao:" << i << "\n"; cin >> aux; meu.atribui(i,aux);}for (int j=meu.primeiro();j<=meu.ultimo();j++) cout<< meu.conteudo(j)<< " ";

cout <<endl << "Maximo:" << meu.maximo();return 0;}

Projeto de Programas OO

É 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.

Estabelecer quais as classes, objetos e métodos são necessários para um programa, e definir quais classes e objetos devem se interrelacionar.


3 Etapas Planejamento da Interface Abstrata

Requer tempo adicional ao projetoEntretanto, aproveita-se a mesma classe em diferentes

aplicações


Refinamento do ProtocoloEstender a definição original dos objetos através da

incorporação de novos métodos a seu protocolo Definir o protocolo mínimo da classe 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;


Aspectos importantes para identificação de novos métodos:

Para cada método, identificar se deve existir outro com efeito inverso;

Necessidade de métodos complementares; Métodos distintos (identificar métodos que utilizem como

parâmetros apenas poucos valores aceitáveis, substituí-lo por vários métodos individuais;

Verificar que métodos devem ser adicionados para tornar a classe conceitualmente completa;


Planejamento da Hierarquia de Classes Enfoque:

Top-down 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.

Bottom-Up Novas superclasses são conseqüências da generalização das

propriedades das classes existentes;


Uma quarta etapa pode ser a construção das tabelas CRC (Classe, Responsabilidade, Correspondência).


É sempre bom lembrar:

Variáveis da classe Só existe uma cópia de cada variável Todos as instâncias acessam a mesma cópia das variáveis São criadas apenas uma vez assim que o sistema reconhece a classe

Variáveis da Instância Existe uma cópia para cada instância criada Cada instância acessa a sua cópia São criadas sempre quando uma nova instância é gerada


Métodos de Classe

Podem acessar apenas variáveis da classe Podem ser acessados pela classe ou pela instância

Métodos de Instância

Podem acessar variáveis da classe e da instância Só podem ser acessados por instâncias


Para que objetos se comuniquem eles precisam se relacionar Associação: conexão entre classes Agregação: especialização de uma associação onde um todo é

relacionado com suas partes (relacionamento “parte-de” ou “contenção” Herança: um dos princípios da OO, permite a reutilização, uma nova

classe pode ser definida a partir de outra já existente


Associação: descreve uma relação entre duas classes

Usuário possui bicicleta

Agregação: descreve o relacionamento entre um todo e sua parte são indicadas por frases do tipo “tem um”, “é parte de”

Uma teclado é parte de um notebook


Generalização / Herança descreve o relacionamento entre classes definidas a partir de outras

classes. toda a subclasse herda os estados e os comportamentos definidos na

superclasse as subclasses não estão limitadas a estes estados e comportamentos.

Uma mountain bike é uma bicicleta


Aluno Disciplina

Uma associação é usualmente um relacionamento bidirecional

Dado uma instância de Aluno, há um objeto Disciplina associado

Dado uma instância de Disciplina, há um objeto Aluno associado


Tipos de associações Unidirecional Bidirecional Indeterminada

Classe A Classe B

Classe A Classe B

ou unidirecional

bidirecional

Classe A Classe B bidirecionalou

não determinada



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 DsiciplinaCursa


Aluno Disciplinacursa

tem matriculado

Aluno DisciplinaCursa

Tem matriculado


Multiplicidade para Associações Multiplicidade é o número de instâncias de uma classe

relacionada com UMA instância de outra classe Para cada associação, há duas decisões a fazer: uma para

cada lado da associação Por exemplo, na conexão entre Aluno e Disciplina:

Para cada instância de Aluno, podem ocorrer muitas (zero ou mais) Disciplinas

Para cada instância de Disciplina, podem ocorrer uma ou várias instâncias de alunos matriculados


Muitos *Exatamente um 1

Zero ou mais 0..*

Um ou mais 1..*Zero ou um 0..1

Faixa especificada 2..4

Pessoa DisciplinaAluno1..* 1..*


Associação em C++E realizado através da inclusão de atributos nas

classes envolvidas;

ExemploSejam as classes TCliente e TProduto. Suponhamos

que o relacionamento entre elas seja "Um Cliente possui vários Produtos" .Este tipo de associação é Unidirecional, com duas formas de implementação.


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


class TCliente{protected:int nClientCod;char* pcNome;char* pcEndereco; public:...} class TProduto{protected:int nProdCod;char* pcDescri;int nClientCod; //qual cliente o possuipublic:...

}

Uma instância de Produto sabe qual o Cliente a possui


Observemos agora a relação entre as classes TAluno e TProfessor. Neste caso temos uma associação Bidirecional, visto que "Um Aluno tem vários Professores e um Professor tem vários Alunos".


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


Agregação Agregação é uma forma especializada de associação

no qual um todo é relacionado com sua(s) parte(s) Agregação é conhecido como um relacionamento de

contenção ou “todo-parte”.


O relacionamento é descrito com uma frase “parte de” Uma placa é “parte de” um computador

Algumas operações no todo são automaticamente aplicadas a suas partes?

Transportar o computador, Transportar a placa

Alguns valores de atributos são propagados do todo para todos ou algumas de suas partes?

Características do barramento

Existe uma assimetria inerente no relacionamento onde uma classe é subordinada a outra?

Uma placa É parte de um computador, um computador NÃO É parte de uma placa


Todo

Parte1 Parte2


Turma Aluno

1..* *


Em uma agregação, a parte pode estar contida, ou não, em mais de um todo.

Quando isto ocorre, chamamos agregação compartilhada (losango branco).

Quando uma parte não pode estar em mais de um todo, chamamos composição (losango preto).

Na composição, quando o objeto todo é destruído, o objeto parte é também destruído.


Departamento

*

Disciplina


Associação ou Agregação? Se dois objetos são altamente acoplados por um

relacionamento todo-parte O relacionamento é uma agregação

Se dois objetos são usualmente considerados como independentes, mesmo que eles estejam freqüentemente ligados

O relacionamento é uma associação


Curso

1..* 0..*

Disciplina Aluno

3..10

Curso e disciplina são altamente acoplados (1 curso é formado por 1 ou mais disciplinas)

Objetos independentes


Identificando Objetos Em uma sala existe um conjunto de objetos físicos que podem ser

facilmente identificados, modelados e classificados como objetos OO. Mas em um problema onde o espaço é uma aplicação de software, os

objetos podem não ser facilmente encontrados. Os objetos podem ser identificados analisando-se o problema ou

fazendo um “parser gramatical” do texto contendo a descrição do problema

Objetos são determinados sublinhando-se cada substantivo ou oração (parte de uma frase)

Projeto de Programas OO Candidatos a objeto:

Entidade externa que produz ou consome informação para ser usada por um sistema computacional (ex.: outros sistemas, devices, pessoas)

Coisas que são parte do domínio da informação do problema (ex.: um sinal, uma carta, um display)

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ô)

Papeis(roles) desempenhados por pessoas que interagem com o sistema (ex.: gerente, engenheiro, vendedor)

Unidades de organização que são relevantes a uma aplicação (ex.: divisões, grupo, time) Lugares que estabelecem o contexto do problema (ex.: galpão, estaleiro) Estruturas que definem a classe de um objeto (ex.: sensor, computador, veículo 4-rodas)


Atributos

Nome do objeto

Operações

Unidades organizacionais

Estrutura

Lugar

Entidades externas

PapéisEventos

Coisas


Escolhendo classes Uma classe deveria capturar uma e somente uma

abstração chave Abstração ruim: classe “Aluno” que conhece a

informação do aluno e as disciplinas que aquele aluno está matriculado

Boa abstração: separar em uma classe para Aluno e uma classe para Disciplina


Nomes para classes Uma classe deveria ser um substantivo singular que

melhor caracteriza a abstração Dificuldades na nomeação das classes podem indicar

abstrações mal definidas Nomes deveriam surgir diretamente do domínio do

problema


Um guia de estilo deveria ditar convenções de nomeação para classes

Uma proposta simples: Classes são nomeadas com um substantivo no singular O nome de uma classe inicia com a primeira letra maiúscula 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

Exemplos: Aluno, Professor, ControleAcadêmico


Uma classe deveria capturar uma e somente uma abstração chave

Abstração ruim: classe “Aluno” que conhece a informação do aluno e as disciplinas que aquele aluno está matriculado

Boa abstração: separar em uma classe para Aluno e uma classe para Disciplina


Semântica da Classe Após encontrar o nome da classe, é importante que seja feita

uma breve (mas concisa) descrição da mesma O foco deve ser no propósito da classe e não na implementação

O nome da classe e sua descrição formarão a base para um dicionário do modelo

As classes desta fase devem somente relatar o domínio do problema

Herança e Polimorfismo em C++

Relações entre classes: Generalização(Herança); Agregação; Associação.


Hierarquia Classificação:

Classificar significa agrupar objetos com base e estrutura semelhante.

Instanciação: Instanciar significa gerar novos exemplares a partir de

uma descrição abstrata para gerar um objeto.


GeneralizaçãoGeneralizar significa remover restrições para se obter

abstrações mais genéricas; Especialização

Especializar significa buscar características que diferenciem abstrações afins


AgregaçãoAgregar significa combinar abstrações para se obter

estruturas e comportamentos mais complexos; Decomposição

Decompor significa detalhar uma abstração dividindo-a em seu elementos constituintes


O mecanismo de herança possibilita: A derivação de um tipo mais específico a partir de tipos

mais genéricos; subclasses herdam os dados e os métodos da subclasse

permitindo ainda modificações nos mesmos; herança simples: subclasse deriva somente de uma

superclasse; herança múltipla: subclasse deriva de várias superclasses.


As classes podem ser organizadas em hierarquia de herança


Uma subclasse pode redefinir métodos herdados de uma superclasse modificando uma parte de seu comportamento

class ClasseHerdeira : public ClasseBase{

//atributos da classe filha

};

class ClasseHerdeira : private ClasseBase{

//atributos da classe filha

};


Regras de visibilidade A classe derivada pode ajustar o direito de

acesso a um membro de uma classe base através de uma declaração de acesso;

A classe derivada pode reduzir ou ampliar o direito de acesso a um membro da classe base.


Ao derivar uma classe, a classe base pode ser herdada como:

PublicPrivateProtected

Raramente utilizado


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é redefinirfunções membro herdadas . Os atributos da classe pai não sãoacessí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.


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.

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.

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.


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.


Diagrama de acesso


Public Protected Private

Public Public Protected Não acess.

Private Private Private Não acess.

Tipo de acesso original na Classe base

Tipo de acesso resultante na classe derivada

Tipo de herança


Exemplo


//header fileclass 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);};


//implementation file#include <iostream.h>#include "pontos.h" 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 << "(" << x << "," << y << ")" <<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());} 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);}


#include <iostream.h>#include "pontos.h" void main(){ ponto_reflete p1(3.14,2.17); p1.reflete(); cout << "P1"; p1.mostra(); ponto_move p2(1.0,1.0); p2.move(.5,.5); cout << "P2"; p2.mostra();}

Resultado do programa:P1(-3.14,-2.17)P2(1.5,1.5)


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.


protected deixa os atributos da classe pai visíveis, acessíveis “hierarquia abaixo”.

O uso de protected serve como um nível intermediáriode proteção entre o acesso public e o private. Membros protected da classe podem ser acessados por membros friendsDa classe base e por membros friend das classes derivadas;Nenhuma outra função pode acessar membros protected de umaClasse base.


Exemplo – Redefinição de método herdadoUma 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”.


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.


//header fileclass ponto{private:float x; //sao ocultos por defaultfloat y; //sao ocultos por defaultpublic: //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 membropublic: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};


//implementation file#include <iostream.h>#include "pontos.h" 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 << "(" << x << "," << y << ")" <<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 << "X:" << retorna_x() << " Y:";cout << retorna_y() << endl; }//somente altera o formato de impressaoponto_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);}


#include <iostream.h>#include "pontos.h" void main(){ ponto_reflete p1(3.14,2.17); p1.reflete(); cout << "P1"; p1.mostra(); ponto_move p2(1.0,1.0); p2.move(.5,.5); cout << "P2"; p2.mostra(); }

Resultado do programa:P1X:-3.14 Y:-2.17P2(1.5,1.5)


Herança Múltipla 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 (:)

Exemploclass Derivada : public Base1, public Base2 {

//descrição da classe

};


Algumas “dicas”: Um objeto de uma classe derivada pode ser atribuído a um objeto de uma

classe base; Um ponteiro para um objeto de uma classe devida pode ser

implicitamente convertido para um ponteiro para um objeto da classe base;

A classe base específica o que há de comum; Relacionamento “é um” é herança; Relacionamento “tem um” é composição; Ler declarações de classes derivadas pode ser confuso! (os membros

herdados não aparecem na declaração) 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.


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;

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.

Tratar objetos da classe base como objetos da classe derivada pode causar erros!

Herde sempre a classe mais próxima daquilo que você necessita. Use protected em último recurso. Herança múltipla pode aumentar a complexidade do sistema. Muito

cuidado!


Exercícios1) Defina: Herança, Herança Múltipla, classe base e classe

derivada.2) Qual a diferença entre Herança simples e Herança

Múltipla?3) (F/V) Uma classe derivada é também chamada de

subclasse por ser um subconjunto da classe base.4) (F/V) Um objeto da classe derivada também é um objeto

da classe base.5) (F/V) O protected rompe o encapsulamento.


Polimorfismo e Funções virtual 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.


Funções virtuais Uma função virtual é uma função que é declarada

como virtual em uma classe base e redefinida pela classe derivada.

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.


#include<iostream.h>

class Base{ public:

virtual void vfunc(){cout<<“esta e vfunc() da base \n”;

}}; class Derivada1:public base{ public:

void vfunc(){cout<<“esta e vfunc() da derivada1 \n”;

}}; class Derivada2:public base{ public: void vfunc(){

cout <<“esta e vfunc() da derivada2 \n”;}};


main(){ Base *p, b; Derivada1 d1; Derivada2 d2;

p = &b;p->vfunc();p = &d1;p->vfunc();p = &d2;p->vfunc();

Return 0;}


Observações: a declaração de vfunc() deve ser precedida pela palavra chave

virtual; a palavra chave virtual não é necessária na declaração das funções

vfunc() das classes derivadas; 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;

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.


A redefinição de uma função virtual por uma classe derivada é similar a sobrecarga de funções. Entretanto, há diversas diferenças:

o protótipo para uma função virtual deve combinar exatamente o protótipo especificado para a classe base

funções virtuais devem ser membros da classe das quais elas fazem parte -- não podem simplesmente ser funções amigas.

Por estes motivos, a redefinição de funções virtuais por classes derivadas é usualmente chamada de sobreposição, e não de sobrecarga.


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.


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.


Sobrecarga de Função 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.


//header file funcover.hfloat abs(float a);int abs(int a);

//implementation file#include "funcover.h" 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 "funcover.h"

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;

}


Outro exemplo de sobrecarga de funções//header file funcover.hfloat max(float a,float b);float max(float a,float b,float c);int max(int a,int b);

#include "funcover.h" 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;}


#include <iostream.h>#include "funcover.h" 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));}


Sobrecarga de Operadores//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 vetorint primeiro(void);int ultimo(void);};


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 << "Fora dos limites! Exit program"; 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];}


iteradorvetor(vetor & v); :Construtor, já cria o iterador de vetor inicializando-o para apontar para o começo do vetor.

virtual int comeca(); : Inicializa o iterador para o começo do vetor.

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.


virtual int operator ++ (); : Faz o iterador mover adiante uma posição.

virtual float operator() (); :Retorna o elemento daquela posição do vetor.

virtual void operator= (float entra); : Atribui a posição atual do vetor.

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.


//it.h , arquivo com definicoes do iterador. class iteradorvetor{private:

vetor vetorref;int posicao;

public:iteradorvetor(vetor & v);int comeca();int operator!();int operator ++ ();float operator() ();void operator= (float entra);int pos(); //retorna posicao, n~ virtual pq n~ faz sentido p/ arvore por ex.};


int iteradorvetor::pos(){return posicao;}int iteradorvetor::operator!(){return posicao<=vetorref.ultimo();}iteradorvetor::iteradorvetor(vetor & vet):vetorref(vet){comeca();}


int iteradorvetor::comeca(){posicao=vetorref.primeiro();return operator!();} int iteradorvetor::operator ++(){posicao++;return operator!();}


void iteradorvetor::operator=(float entra){vetorref[posicao]=entra;}float iteradorvetor::operator() (){float copia;copia=vetorref[posicao];return copia;}


#include <iostream.h>#include "vet.h"#include "it.h"main(){int repete=0;int ind;float item;vetor meu(5);iteradorvetor itmeu(meu); for (itmeu.comeca();!itmeu;++itmeu){ cout << "Entre com valor da posicao:" << itmeu.pos() << "\n"; cin >> item; itmeu=item;}


for (itmeu.comeca();!itmeu;++itmeu) cout<< itmeu()<< " ";

cout << "\nEntre com o indice da posicao a atualizar:\n";

cin >> ind;

cout << "Entre com o valor a incluir:";

cin >> item;

meu[ind]=item;

for (int k=meu.primeiro();k<=meu.ultimo();k++) cout<< meu[k]<< " ";

cout <<endl << "Maximo:" << meu.maximo();

return 0;

}


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...


Funções Virtuais Puras e Classes Abstratas 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.


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

virtual tipo nome_função (lista-args) = 0;


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.

Classes que contenham pelo menos uma função virtual pura são chamadas de classes abstratas.


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.


Vantagem?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.


//exvetit6 , arquivo com definicoes do iterador.class iterador{ //classe base abstratapublic: int comeca(void) {cout << "Erro, classe abstrata!";} float operator()() {cout << "Erro, classe abstrata!"; 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();


Funções Amigas (Friend) 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.

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).


Uma classe inteira pode ser declarada como friend de outra classe;

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;

Para declarar uma classe amiga de outra

friend class ClasseDois; na definição da ClasseUm.


#include <iostream>

class Count {

friend void setX( Count &, int );

public:

Count() { x = 0; } // constructor

void print() const { cout << x << endl; } // output

private:

int x; // data member

};


void setX( Count &c, int val ) { c.x = val; // legal: setX is a friend of Count}int main(){ Count counter; cout << "counter.x depois da instancicao "; counter.print(); cout << "counter.x depois da chamada da funcao amiga SetX: "; setX( counter, 8 ); // atribui um valor a x com SetX counter.print(); return 0;}


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.


#include <iostream.h>

class relogio{friend class caixa_de_mensagem;//permitiu acesso as definicoes private e publicprivate: int hora; int minuto; int segundo; //atributos private, encapsuladospublic: relogio(int h,int m,int s) {hora=h; minuto=m; segundo=s;}} ;


class caixa_de_mensagem{

public:

void imprime(relogio a){

cout << a.hora << ":" << a.minuto << ":" << a.segundo << endl;

}

} ;

void main(){

relogio meurolex(11,30,10);

caixa_de_mensagem ativa;

ativa.imprime(meurolex);

}


O uso do ponteiro this Todo objeto tem acesso ao seu próprio endereço

através do ponteiro this. O ponteiro this é implicitamente usado para

prover referência tanto para membros de dados quanto para as funções membro do objeto


#include <iostream>class Test {public: Test( int = 0 ); void print() const;private: int x;};


Test::Test( int a ) { x = a; } // constructor

void Test::print() const {

cout << " x = " << x

<< "\n this->x = " << this->x

<< "\n(*this).x = " << ( *this ).x << endl;

}


int main(){ Test testObject( 12 );

testObject.print();

return 0;}


Algumas “Dicas” Classes abstratas não são instânciadas; Se uma classe é derivada de uma classe com função virtual

pura, então a classe derivada tb é abstrata; 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;

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;


Declare o destrutor da classe base como virtual se a classe possui funções virtuais;

É erro tentar instanciar um objeto de uma classe abstrata; Construtores não podem ser virtuais (erro). Uma classe é tornada abstrata quando se declara uma ou

mais funções membro virtual; Uma função virtual pura é uma função com um

inicializador =0 em sua declaração;


#ifndef SHAPE_H#define SHAPE_Hclass Shape {public: virtual double area() const { return 0.0; } virtual double volume() const { return 0.0; }

// pure virtual functions overridden in derived classes virtual void printShapeName() const = 0; virtual void print() const = 0;};#endif


#ifndef POINT1_H#define POINT1_H#include <iostream>#include "shape.h"class Point : public Shape {public: Point( int = 0, int = 0 ); // default constructor void setPoint( int, int ); int getX() const { return x; } int getY() const { return y; } virtual void printShapeName() const { cout << "Point: "; } virtual void print() const;private: int x, y; // x and y coordinates of Point};

#endif


//point.cpp#include "point1.h"Point::Point( int a, int b ) { setPoint( a, b ); }void Point::setPoint( int a, int b ){ x = a; y = b;}void Point::print() const { cout << '[' << x << ", " << y << ']'; }


#ifndef CIRCLE1_H#define CIRCLE1_H#include "point1.h"class Circle : public Point {public: // default constructor Circle( double r = 0.0, int x = 0, int y = 0 ); void setRadius( double ); double getRadius() const; virtual double area() const; virtual void printShapeName() const { cout << "Circle: "; } virtual void print() const;private: double radius; // radius of Circle};#endif


//circle1.cpp#include <iostream>#include "circle1.h"Circle::Circle( double r, int a, int b ) : Point( a, b ) // call base-class constructor{ setRadius( r ); }void Circle::setRadius( double r ) { radius = r > 0 ? r : 0; }double Circle::getRadius() const { return radius; }double Circle::area() const { return 3.14159 * radius * radius; }void Circle::print() const{ Point::print(); cout << "; Radius = " << radius;}


#ifndef CYLINDR1_H#define CYLINDR1_H#include "circle1.h"class Cylinder : public Circle {public: // default constructor Cylinder( double h = 0.0, double r = 0.0, int x = 0, int y = 0 ); void setHeight( double ); double getHeight(); virtual double area() const; virtual double volume() const; virtual void printShapeName() const {cout << "Cylinder: ";} virtual void print() const;private: double height; // height of Cylinder};


#include <iostream>#include "cylindr1.h"Cylinder::Cylinder( double h, double r, int x, int y ): Circle( r, x, y ) //constructor{ setHeight( h ); }void Cylinder::setHeight( double h ) { height = h > 0 ? h : 0; }double Cylinder::getHeight() { return height; }double Cylinder::area() const{ // surface area of Cylinder return 2 * Circle::area() + 2 * 3.14159 * getRadius() * height;}double Cylinder::volume() const { return Circle::area() * height; }void Cylinder::print() const{ Circle::print(); cout << "; Height = " << height;}


Polimorfismo Paramétrico (template) 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.


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.


Se optar por templates, siga os seguintes passos: 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.

Construa seu programa para operar em um só destes tipos.

Termine incluindo as definições dos templates no programa e testando para os demais tipos.

Corrija as eventuais falhas de substituição


Templates de ClasseUm 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.


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;


// exemplo de declaracao main () { Vector <int> ix(5); // gera um vetor de inteiros Vector <float> fx(6); // gera vetor de floats

//... }


classes gabaritos (as instâncias de gabaritos de classes) devem ser explícitas sobre os parâmetros sobre os quais elas irão instanciar.


Templates de funções Considere a seguinte função que troca os valores

de dois inteiros: void swap (int& x, int& y) { int tmp = x; x = y; y = tmp; }


E se desejarmos trocar floats e longs? E exemplo a seguir ilustra o uso do template template <class T> void swap (T& x, T& y) { T tmp = x; x = y; y =tmp; }


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

E/S com streams em C++

Recursos de E/S Biblioteca<iostream.h> Streams = sequência de bytes Disponível E/S no estilo C <stdio.h> Uso dos recursos do C++ facilita a portabilidade

Do código


A biblioteca iostrema Fornece recursos de E/S Define objetos do tipo cin, cout, cerr, clog; <iomanip> declara processamento com arquivos

controlado pelo usuário;


Exemplos cin >> nome cout << nome endl // gera um caracter de nova linha cout << flush; //esvazia o buffer de saída


Encadeamento (c/ << sobregarregado)cout << “2 mais 3 é” << (2+3) << endl;

Saída de char char *string = “teste”;

cout << “valor da string” << string;


Permite ainda: E/S formatada (classe ios)

Skipws (ignora espaços em branco) Left (justifica a esquerda) Right (justifica a direita) Dec (inteiros na base 10) Oct (inteiros na base 8) Hex (inteiros na base 16) Showpoint (especifica o número em ponto flutuante) Uppercase (letras maiúsculas) etc


Manipulação de arquivos Notação científica Vínculo de E/S

#include <iostream>using std::cout;using std::endl;#include <iomanip>using std::ios;#include <cmath>int main(){ cout << "Before setting the ios::showpoint flag\n" << "9.9900 prints as: " << 9.9900 << "\n9.9000 prints as: " << 9.9000 << "\n9.0000 prints as: " << 9.0000 << "\n\nAfter setting the ios::showpoint flag\n"; cout.setf( ios::showpoint ); cout << "9.9900 prints as: " << 9.9900 << "\n9.9000 prints as: " << 9.9000 << "\n9.0000 prints as: " << 9.0000 << endl; return 0;}

Programação C++

Não se integra a definição da classe com arquivos cabeçalhos, por dois motivos:

desempenho de compilação: 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;

Programação C++

segredo tecnológico: 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.

Programação em C++

Arquivos Cabeçalhos (header) 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


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.


#ifndef VEHICLE_H #define VEHICLE_H class vehicle { protected: int wheels; float weight; public: void initialize(int in_wheels, float in_weight);int get_wheels(void); float get_weight(void);float wheel_loading(void); }; #endif


Algumas 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.


1. Otimize código apenas quando você sabe que você tem um problema de desempenho. Pense duas vezes antes de fazê-lo.

2. Um arquivo de cabeçalho não deve conter mais do que uma definição de classe.

3. 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.


4. 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

5. Todos arquivos devem incluir informação de copyright.

6. Escreva comentários descritivos antes de cada função. 7. Todo arquivo de cabeçalho deve conter o mecanismo

para evitar múltiplas inclusões do mesmo arquivo.


8. Escolha nomes de variáveis que sugiram o seu uso.

9. Na definição de classes, ordene a declaração de seções na ordem: pública, protegida, privativa.

10. Não define funções membro dentro da definição da classe.

11. Sempre explicite o tipo de retorno de uma função. 12. Não especifique dados na seção pública de uma

classe.


13. Funções pequenas (por exemplo, simplesmente retornar um valor de um membro da classe) devem ser definidas como função em linha.

14. Contrutores e destrutores não devem ser definidos como funções em linha.

15. Uma função membro que não afeta o estado de um objeto deve ser declarada como const.

16. Use sobrecarga de operadores com parcimônia e de maneira uniforme.


17. Quando dois operadores têm usualmente significados opostos (como == e !=), é apropriado definir ambos.

18. Evite funções com muitos argumentos.

19. Evite o uso de número variável de argumentos.

20. Quando sobrecarregando funções, todas as variações devem ter a mesma semântica, isto é, devem ser usadas para o mesmo fim.


21. Uma função pública nunca deve retornar uma referência ou um apontador para uma variável local.

22. Evite funções longas e complexas. 23. Não use a diretiva de processador #define para

definir macros; prefira a definição de funções em linha.

24. Defina constantes usando const ou enum; nunca use #define.


25. Evite o uso de valores numéricos no código; dê preferência ao uso de valores simbólicos.

26. Variáveis devem ser declaradas dentro do menor escopo possível.

27. Toda variável que é declarada deve receber um valor antes de ser utilizada.

28. Evite o uso de apontadores para apontadores. 29. Evite o uso de conversões explícitas de tipos

(casts).


30. Não escreva código que dependa de funções que usam conversão implícita de tipos.

31. O código após um case deve sempre ser seguido por um comando break.

32. Um comando switch deve sempre ter uma opção default para manipular casos inesperados.

33. Nunca use goto. 34. Sempre use unsigned para uma variável que se

espera que não vá assumir valores negativos.


35. Evite o uso de continue.

36. O uso de break para sair de laços deve ser preferido ao uso de variáveis de flag.

37. Use parênteses para deixar claro a ordem de avaliação de operadores em expressões.

38. Não use malloc, realloc ou free.

39. Sempre use colchetes vazios ([]) quando removendo arranjos com delete.


40. Evite usar dados globais. 41. Não aloque memória esperando que outro alguém irá

desalocá-la mais tarde. 42. Verifique os códigos de falhas de funções de

bibliotecas por mais seguro que as chamadas possam parecer.

43. Não assuma que um int tem 32 bits ou que tem o mesmo tamanho de um long ou de um apontador.

44. Não assuma que você sabe como um certo tipo de dado é representado em memória.

Referências

Object-Oriented Modeling and Design James Rumbaugh, Michael Blaha, William Premerlani, Frederick Eddy, William Lorensen Prentice Hall International Editions, 1991.

The C ++ Programming Language, 2nd Edition Bjarne Stroustrup Addison Wesley, 1991.

C ++: the Complete Reference Herbert Schildt Osborne/McGraw-Hill, 1991.

01 orientacao a objetos programacao

Technology