12 TP Programação Orientada A Objeto PDF

Técnicas de
Programação
Prof. Protásio
Laboratório de Microengenharia/DEE/CEAR/UFPB
Programação Orientada a Objeto (POO)
Object-oriented programming (OOP)
▪ POO é um paradigma (modelo, padrão) de
programação que foca no uso de objetos na
construção de programas.
▪ Objetos são entidades que contém estados
(variáveis), comportamento (funções que atuam
nessas variáveis) e interfaces (funções que
comunicam o objeto com o “mundo exterior”).
▪ Objetos tentam retratar objetos do mundo real.
▪ Objetos são prototipados (projetados) por meio de
classes.
▪ Herança: uma das características de POO em que
classes podem herdar estados e comportamentos
de uma outra classe.
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 2
▪ Objeto: entidade de SW que modela “coisas”
do mundo real
▪ Exemplo: sistema de direção θ = Ângulo da
direção desejada
Interface
Objeto: Sistema de Direção
Comportamento
θ Φ=f(θ)
Φ estados
Φ = ângulo resultante
▪ Objeto: Sistema de Freio
▪ Objeto
▪ Variável
▪ Intensidade da força no pedal de freio (F)
▪ Resultante
▪ Frenagem do carro
Objeto:
F Sistema
Prof. Protásio – DEE/CEAR/UFPB

de Freio

▪ Vantagens da orientação a objeto
▪ Os objetos são reusáveis
▪ Exemplo:
▪ O objeto carro é igual para todos os carros, mas os
mecanismos internos variam de acordo com o fabricante
▪ Os objetos contêm significados
▪ Pois modelam o mundo real ou algo que tenha
significado
▪ Programas orientado a objeto são:
▪ Mais fáceis de entender
▪ Melhor organizados
▪ De manutenção mais fácil
▪ Modulares
▪ Classes e Objetos
▪ Classe
▪ É uma estrutura de dados que
pode conter:
▪ Dados (variáveis-membro), e
▪ Funções (funções-membro).
▪ Objeto
▪ É uma instância de uma classe.
▪ É a “concretização” de uma classe.
▪ Quando um objeto é criado, memória é
alocada a esse.

Declaração de classes
▪ Classes são declaradas pela palavra-chave class
SINTAXE EXEMPLO
class nome_da_classe{ class cubo {
Especificador_de_acesso_1:
membro1;
private:
Ξ int x, y;
membroN public:
Especificador_de_acesso_2: int z,
membroA;
Ξ int area(void);
membroM };
};
▪ nome_da_classe
▪ É um identificador válido para a classe.
▪ Especificador_de_acesso
▪ private:
▪ Membros privados podem ser acessados somente por membros da mesma classe.
▪ public:
▪ Membros públicos podem ser acessados em qualquer escopo em que a classe é visível.

Declaração de classes
▪ Exemplo class Retangulo {
private:
int x, y;
public:
void setar_valores(int, int);
int area(void);
};
▪ Por padrão, todos os membros declarados em

um especificador de acesso são privados
class Retangulo { class Retangulo {
private:
int x, y; int x, y;
public: public:
void setar_valores (int, int); void setar_valores (int, int);
int area (void); int area (void);
}; };

Criando (instanciando) um objeto
class Retangulo {
int x, y;
public:
void setar_valores (int, int);
int area (void);
};
Retangulo Ret;
▪ Como posso criar um outro objeto da classe Retangulo?

#include <iostream>
Meu using namespace std;
primeiro
class Retangulo {
código int x, y;
baseado public:
em POO int area () {return (x*y);}
};
void Retangulo :: setar_valores (int a, int b) {

x = a;
y = b;
}
int main () {
Retangulo Ret;
Ret.setar_valores(3, 4);
cout << “Area = " << Ret.area();
return 0;
}

#include <iostream>
primeiro
class Retangulo {
erro int x, y;
baseado public:
em POO int area () {return (x*y);}
};

x = a;
y = b;
}
int main () {
Retangulo Ret;
Ops!!! Algo errado na cout << “Area = " << Ret.area();
compilação? cout << “x = " << x << “ y = " << y;
return 0;
}
#include <iostream>
segundo class Retangulo {

erro int x, y;
public:
baseado void setar_valores (int, int);
int area () {return (x*y);}
em POO };

x = a;
y = b;
}
int main () {
Retangulo Ret;
Ops!!! Algo errado na cout << “Area = " << Ret.area();
compilação de novo? cout << “x = " << Ret.x << “ y = " << Ret.y;
return 0;
}

#include <iostream>
segundo class Retangulo {

Código int x, y;
public:
em POO void mostrar () { cout << “x = " << x << “ y = " << y; }
};
Ufa!!! void Retangulo :: setar_valores (int a, int b) {

x = a; y = b;
}
O que é possível int main () {
fazer para x e y Retangulo Ret;
serem acessados Ret.setar_valores(3, 4);
pelo main? cout << “Area = " << Ret.area();
Ret.mostrar ();
Tornar x e y return 0;
públicos! }
Não recomendado!

#include <iostream>
using namespace std;
Protegendo class Retangulo {
dados public:
int x, y;

No mundo real, os lados int area () {return (x*y);}
de um retângulo sempre };
são maiores que zero void Retangulo :: setar_valores (int a, int b) {
(positivos). if (a >= 0)
x = a;
else{
x = -a; cout << "valor corrigido" << endl;
}
if (b >= 0)
y = b;
else{
y = -b; cout << "valor corrigido" << endl;
}
}
int main () {
Retangulo Ret;
Ret.setar_valores(3, -4);
cout << "Area = " << Ret.area();
return 0;
}

Usando Objetos
▪ Desvantagens de tornar dados públicos:
▪ Os dados ficam desprotegidos
▪ Em geral, ter acesso aos dados, podem causar problemas de:
▪ Acesso não permitido
▪ Encapsulamento
▪ Com os dados-membros desprotegidos, o objeto perde sua
capacidade de encapsulamento
▪ Consistência
▪ Conversão incorreta de tipos de dados
▪ A melhor forma de acessar dados-membros é

através da criação de funções de:
▪ Set: setar os valores dos dados-membros
▪ Get: pegar os valores dos dados-membros

#include <iostream>
terceiro class Retangulo {

código int x, y;
public:
int getX () {return x;}
em POO int getY () {return y;}
};
void Retangulo :: setar_valores (int a, int b) { x = a; y = b;}
int main () {
Retangulo Ret;
cout << “Area = " << Ret.area();
cout << “x = " << Ret.getX() << “ y = " << Ret.getY();
return 0;
}

Exercício
▪ Considerando o programa anterior, crie 2
objetos da classe Retangulo, receba seus
valores de x e y pelo teclado e mostre as
área na tela.

Ponteiros para objetos
#include <iostream>
class Retangulo {
int x, y;
public:
void setar_valores (int a, int b) { x = a; y = b;}
};
int main () {
Retangulo Ret;// cria um objeto
Retangulo *Ret2;// cria um ponteiro para objeto
Ret2 = &Ret;// Faz com que o ponteiro Ret2 aponte para Ret
Ret2->setar_valores(3, 4);
cout << "Area = " << Ret2->area();
return 0;
}

Exercício
▪ Crie uma classe Circulo e elabore funções
desta classe para calcular sua área e seu
perímetro.
▪ Após crie um objeto dessa classe e solicite ao
usuário o valor do raio e mostre a área e
perímetro.
▪ Acesse as funções através de ponteiros.

Funções Construtoras
▪ As funções construtoras são chamadas
automaticamente na criação de um objeto e
serve para, por exemplo:
▪ Inicializar variáveis-membros,
▪ Alocar memória dinamicamente, e
▪ Evitar o uso de valores inesperados.
▪ Características de uma função construtora:
▪ Tem o mesmo nome da classe
▪ E não deve ter nenhum tipo de retorno (nem mesmo
void)

#include <iostream>
class Retangulo {
int x, y;
public:
Retangulo(); // Função construtora da classe Retangulo
};
// Função construtora da classe Retangulo

Retangulo::Retangulo () {
x = 0;
y = 0;
cout << "Construtora chamada" << endl;
}
int main () {
Retangulo A;// cria um objeto
cout << "Area = " << A.area() << endl;
return 0;
}

#include <iostream>
class Retangulo {
int x, y;
public:
};

x = 0;
y = 0;
}
int main () {
Retangulo A[10];// cria um objeto
cout << "Area = " << A[0].area() << endl;
return 0;
}

#include <iostream>
class Retangulo {
int x, y;
public:
};

x = 0;
y = 0;
}
int main () {
Retangulo A[10];// cria um objeto
for (int i =0; i < 10; i++)
cout << "Area = " << A[i].area() << endl;
return 0;
}

#include <iostream>
using namespace std; Construtora com
parâmetros
class Retangulo {
int x, y;
public:
Retangulo (int a, int b);
};

Retangulo::Retangulo (int a, int b) {
x = a;
y = b;
}
int main () {
Retangulo A(3,4);// cria um objeto
Retangulo B(10,2);// cria um objeto
cout << "Area = " << B.area() << endl;
return 0;
}

Funções Destrutoras
▪ Fazem o oposto da funções construtoras
▪ São automaticamente chamadas quando
um objeto é destruído, ou seja:
▪ O escopo do objeto é finalizado
▪ Exemplo: um objeto é definido localmente dentro de uma
função e a função termina.
▪ O objeto é alocado dinamicamente na memória
e é usado o operador delete do objeto.
▪ O destrutor tem o mesmo nome da classe,
mas:
▪ é precedido de ~
▪ Não retorna nenhum tipo
#include <iostream>
class Retangulo {
int x, y;
public:
Retangulo();
Retangulo (int a, int b); SOBRECARGA DE CONTRUTORA
~Retangulo(); // Função destrutora da classe Retangulo
int area () {return x*y;}
};
Retangulo::Retangulo () {// Função construtora da classe Retangulo

x = 0;
y = 0;
cout << "Construtora SEM PARAMETROS chamada" << endl;
}

Retangulo::Retangulo (int a, int b) {
x = a;
y = b;
cout << "Construtora COM PARAMETROS chamada" << endl;
}
Retangulo::~Retangulo () {// Função destrutora da classe Retangulo

cout << "Destrutora chamada" << endl;
}
int main () {
Retangulo A(2,7);
Retangulo B[10];
for (int i =0; i < 10; i++){
cout << "Area = " << B[i].area() << endl;
}
return 0;
} Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB
Prof. 26
Arrays de objetos criados dinamicamente
#include <iostream>
class Retangulo {
int x, y;
public:
Retangulo (){x = 5;y = 5;} // Função Construtora
~Retangulo (){cout << "Bye" << endl ;} // Função Destrutora
int area () {return x * y;}
};
int main () {
int i;
cout << "Quantos objetos retangulo deseja criar?" << endl;
cin >> i;
Retangulo *Ret= new Retangulo[i];

for (int j = 0; j < i; j++)
cout << "Area" << "[" << j << "] = " << Ret[j].area() << endl;
delete[] Ret;
return 0;
}
Membros estáticos
▪ Um classe pode ter membros estáticos
▪ Um membro estático contém o mesmo
valor para todos os objetos da classe
▪ Sintaxe:
static int n;
static float A;

Exemplo: contagem do número de objetos criados e destruídos
#include <iostream>
class Retangulo {
int x, y;
public:
static int n; // n é uma variável estática
Retangulo (){n++;} // Função Construtora
~Retangulo (){n--;} // Função Destrutora
};
int Retangulo::n=0; // Inicialização da variável estática n (DEVE SER DECLARADA COMO GLOBAL)
int main () {
Retangulo *Ret= new Retangulo[5];
cout << "n = " << Retangulo::n << endl;
Retangulo *A= new Retangulo;
delete[] Ret;
delete A;
Retangulo *B= new Retangulo[3];

delete[] B;
Retangulo C, D;
return 0;
}

Exercícios
▪ Faça um programa baseado na declaração
de um classe “aluno”, que:
▪ Tenha como variáveis membros: nome, idade,
matrícula, endereço, CEP e CRE, e que, sendo
estas variáveis privadas, só aceitem dados com
verificação de conteúdo (por exemplo, CRE
deve estar entre 0 e 10; idade sempre positiva,
etc.).
▪ Após isso, faça o cadastro de alguns alunos da
turma e mostre na tela o cadastro.

Exercício
▪ Faça um programa que solicite ao usuário se ele quer
criar objetos Retângulos ou Círculos, crie arrays de
objetos dinamicamente (de acordo com a quantidade de
objetos que o usuário desejar) e mostre os resultados
das áreas na tela.

Herança
▪ É uma forma de reutilização de software em
que o programador cria uma classe que herda
dados e funções de uma classe existente e os
aprimora com novas capacidades.
▪ É uma forma de reusar ou aproveitar software
já testados e depurados
▪ Denominações
Em C++ Java
Classe Original Classe Base Superclasse
Nova Classe Classe Derivada subclasse

Herança
Classe quadrado Largura e comprimento
Base
Herança
Classe
Derivada cubo Largura, comprimento e altura

Herança class quadrado {
public:
int largura;
Classe quadrado int comprimento;
void set_largura(int x) {largura = x;};
Base void set_comprimento(int y) {comprimento = y;};
};
class cubo : public quadrado {

public:
Classe int altura;
Derivada cubo void set_altura(int z) {altura = z;};
};
#include <iostream>
int main () {
cubo C;
C.set_altura(3);
C.set_largura(2); // herdada
C.set_comprimento(5); // herdada
cout << C.altura << " " << C.largura << " " << C.comprimento << endl;
return 0;
}

class quadrado {
public:
Herança int largura;
int comprimento;
void set_largura(int x) {largura = x;};
void set_comprimento(int y) {comprimento = y;};
};
quadrado
class cubo : public quadrado {
public:
int altura;
void set_altura(int z) {altura = z;};
cubo };
class cubo_colorido : public cubo {

public:
cubo colorido int cor;
void set_cor(int w) {cor = w;};
};
#include <iostream>
int main () {
cubo_colorido CC;
CC.set_altura(3);
CC.set_largura(2); // herdada
CC.set_comprimento(5); // herdada
CC.set_cor(0)
cout << CC.altura << " " << CC.largura << " " << CC.comprimento << " " << CC.cor << endl;
return 0;
}

Herança
▪ Especificador de acesso protected
▪ Fora os especificadores de acesso public e
private, existe o protected que é estritamente
relacionado com herança.
▪ Um membro protected funciona como um
private: é acessível dentro da classe, mas não
fora dela.
▪ A diferença é que um membro protected é
visível pelas classes derivadas, já um private
não é.

Herança
▪ Especificador de acesso protected
class Y : public X {
class X { public:
private:
int a; Ñ int geta(){return a; }; //ERRO, pois a não é visível
protected:
int b; S int getb(){return b; }; //Ok, b é protegido (a classe derivada tem acesso)
public:
int c; S int getc(){return c; }; //Ok, c é público
};
};
Só c, que é público, passa!
int main () {
X cx;
Y cy;
cx.a; //ERRO, pois a não é visível (private)
cx.b; //ERRO, pois b não é visível fora da classe (protegido)
cx.c; //Ok, c é público
cy.a; //ERRO, pois a não é visível (private)

cy.b; //ERRO, pois b não é visível fora da classe (protegido)
cy.c; //Ok, c é público
}

Herança
▪ Controle de acesso
▪ Ao se construir uma classe que herda de uma outra classe, o
programador deve definir o controle de acesso:
class Y : public X
▪ private
▪ Herda os membros public e protected como private
▪ É o acesso padrão, por isso que colocamos public.
▪ public
▪ Não altera a visibilidade dos membros da classe.
▪ protected
▪ Herda os membros public e protected como protected.

Herança Mude o acesso e avalie o resultado
▪ Controle de acesso
class Y : public X {
class X { public:
private:
int a; Ñ int geta(){return a; }; //ERRO, pois a não é visível
protected:
int b; S int getb(){return b; }; //Ok, b é protegido (a classe derivada tem acesso)
public:
int c; S int getc(){return c; }; //Ok, c é público
};
};
Só c, que é público, passa!
int main () {
X cx;
Y cy;
cx.a; //ERRO, pois a não é visível (private)
cx.b; //ERRO, pois b não é visível fora da classe (protegido)
cx.c; //Ok, c é público
cy.a; //ERRO, pois a não é visível (private)

cy.b; //ERRO, pois b não é visível fora da classe (protegido)
cy.c; //Ok, c é público
}

Herança
▪ Outro exemplo
Rodas
Classe Veículo Número de passageiros
Base
Classes
Caminhão carga Automóvel tipo; //0 = Van, 1=Carro e 2=SUV
Derivadas

Herança (classe base)
▪ Classe VEICULO
▪ No trecho de código abaixo, tem-se a definição
da classe veiculo
class veiculo {
private:
int passageiros;
int rodas;
public:
void set_rodas(int num) {rodas = num;};
int get_rodas() {return rodas;};
void set_pass(int num) {passageiros = num;};
int get_pass() {return passageiros;};
};

Herança
▪ Classe CAMINHÃO (sem herança)
class caminhao { Repetição do
int passageiros; mesmo código da
int rodas; classe veiculo
int carga;
public:
void set_rodas(int num) { rodas = num; } ;
int get_rodas() { return rodas; };
void set_pass(int num) { passageiros = num; } ;
int get_pass() { return passageiros; };
void set_carga(int num) { carga = num; };

int get_carga() { return carga; };
void show();
};
▪ Claramente ver-se que boa parte do código de veículo pode ser aproveitada na classe
caminhão
▪ Ver-se que as particularidades de caminhão (carga, etc...) é que precisam ser programadas

Herança (classe derivada)
▪ Classe CAMINHÃO (com herança)
class veiculo {
Classe Base
private:
int passageiros;
int rodas;
public: public  não altera a visibilidade dos
membros da classe (o que é público,
void set_pass(int num) {passageiros = num;}; mantem-se publico)
}; O “:” indica que a classe
caminhao herda da classe
veiculos seus membros
class caminhao : public veiculo {

Classe Derivada
int carga;
public:
void show();
};

Herança (classe derivada)
▪ Classe automovel(com herança)
class veiculo {
Classe Base
private:
int passageiros;
int rodas;
public:
void set_pass(int num) {passageiros = num;};
};
class automovel : public veiculo {

Classe Derivada
int tipo; // 0 = Van, 1 = Carro e 2 = SUV

public:
void set_type(int t) {tipo = t; };
int get_type() { return tipo; };
void show();
};

Herança
▪ Funções-membros
// Descrição das Funções
void caminhao::show(){
cout << endl "Informacao do Caminhao" << endl;
cout << "Quantidade de rodas: " << get_rodas() << endl;
cout << "Quantidade maxima de passageiros: " << get_pass() << endl;
cout << "Capacidade maxima para transporte (carga): " << get_carga() << endl;
}
void automovel::show(){
cout << endl << "Informacao do Automovel" << endl;
cout << "Tipo de automovel: ";
switch(get_type()) {
case 0: cout << " Van\n";
break;
case 1: cout << " Carro\n";
break;
case 2: cout << " SUV\n";
break;
}
}
Herança int main()
{
caminhao t1, t2;
▪ Programa Principal automovel c;
t1.set_rodas(18);
t1.set_pass(2);
t1.set_carga(3200);
t2.set_rodas(6);
t2.set_pass(3);
t2.set_carga(1200);
t1.show();
t2.show();
c.set_rodas(4);
c.set_pass(10);
c.set_type(0);
c.show();
return 0;
}

Separando as definições de classes em
arquivos de cabeçalho
▪ Considere o programa anterior
▪ Coloque a definição da classe veiculo em
arquivo separado do arquivo que contém o
main.
▪ Passos
▪ Crie um arquivo de cabeçalho e inclua no
projeto
▪ Minhas_classes.h
▪ No arquivo principal, inclua:
▪ #include "Minhas_classes.h"

#include <iostream>
class veiculo {// Definicao da classe generica veiculo
int passageiros; int rodas;
Minhas_classes.h
public:
void set_rodas(int num) { rodas = num; } ;
int get_rodas() { return rodas; };
void set_pass(int num) { passageiros = num; } ;
int get_pass() { return passageiros; };
};
class caminhao : public veiculo {// Definicao da classe caminhao
int carga;
public:
void show();
};
class automovel : public veiculo {// Definicao da classe automovel
int tipo; // 0 = Van, 1 = Carro e 2 = SUV
public:
void set_type(int t) {tipo = t; };
int get_type() { return tipo; };
void show();
};
void caminhao::show() { // Descrição das Funções
cout << endl << "Informacao do Caminhao" << endl ;
cout << "Capacidade maxima para transporte (carga): " << get_carga() << endl;
}
void automovel::show()
{ cout << endl << "Informacao do Automovel" << endl;
cout << "Tipo de automovel: ";
switch(get_type()) {
case 0: cout << " Van\n";
break;
case 1: cout << " Carro\n";
break;
case 2: cout << " SUV\n";
break;
}
}
#include <iostream> Arquivo Fonte Principal
#include "Minhas_classes.h"
int main(){
caminhao t1, t2;
automovel c;
t1.set_rodas(18);
t1.set_pass(2);
t1.set_carga(3200);
t2.set_rodas(6);
t2.set_pass(3);
t2.set_carga(1200);
t1.show();
t2.show();
c.set_rodas(4);
c.set_pass(10);
c.set_type(0);
c.show();
system("pause");
return 0;
}

Exercício
▪ Programe a classe motocicleta que seja
derivada da classe básica veiculo e que
contenha:
▪ Membros privados:
▪ numero_capacete
▪ Funções públicas:
▪ Para setar o número de capacetes disponíveis
▪ Para pegar o número de capacetes disponíveis

Sobrecarga de operador
▪ Suponha a seguinte classe:
class Retangulo {
int x, y;
public:
Retangulo (){x =0 ; y = 0;} // Função Construtora
void set(int a, int b){x =a; y = b;}
};
▪ E considere os seguintes objetos:

Retangulo A, B, C;
▪ O que aconteceria se a seguinte operação
for realizada:
C = A + B;
▪ Erro de compilação!!!
#include <iostream>
using namespace std; Sobrecarga do operador binário
class Retangulo {
“+”
int x, y;
public:
Retangulo (){x =0 ; y = 0;}
Retangulo operator + (Retangulo); // Função sobrecarregada do operador "+"
void mostra(){cout << "(x= " << x << ", y= " << y << ")" << endl;};
};
Retangulo Retangulo::operator + (Retangulo Temp){

Retangulo Temp2;
Temp2.x = x + Temp.x;
Temp2.y = y + Temp.y;
return Temp2;
}
int main () {
Retangulo A, B, C;
A.set(1,2);
B.set(3,4);
C = A + B;
C.mostra();
return 0;
} Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 52
#include <iostream>
Nova sobrecarga do operador
class Retangulo { binário “+”
int x, y;
public:
Retangulo operator + (Retangulo); // Função sobrecarregada do operador "+“
Retangulo operator + (int); // Nova função sobrecarregada do operador "+"
};

Retangulo Temp2;
Temp2.x = x + Temp.x; Temp2.y = y + Temp.y; return Temp2;
}
Retangulo Retangulo::operator + (int a){

Retangulo Temp2;
Temp2.x = x + a;
Temp2.y = y + a;
return Temp2;
}
int main () {
Retangulo A, B, C;
A.set(1,2);
B.set(3,4);
C = A + B;
C.mostra();
C = A + 6;
C.mostra(); 53
Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB
#include <iostream>
using namespace std; Sobrecarga de operador Unário
class Retangulo {
“++”
int x, y;
public:
Retangulo operator + (Retangulo);
void operator ++ () // Função sobrecarregada do operador unário "++"
{ x++; y++; }
};

Retangulo Temp2;
Temp2.x = x + Temp.x;
Temp2.y = y + Temp.y;
return Temp2;
}
int main () {
Retangulo A, B, C;
A.set(1,2);
B.set(3,4);
C = A + B;
C.mostra();
++A; // Operador unário sobrecarregado
A.mostra();
return
Prof.0;
Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 54
Sobrecarga de operador
▪ Observações gerais:
▪ Em geral, é adequado respeitar a definição original do
operador
▪ Exemplo: sobrecarregar o operador + deve ser algo relacionado
com adição
▪ Não é possível mudar o operador de unário para
binário.
▪ Não se pode inventar novos operadores.
▪ Não é possível modificar a precedência de operadores
por meio de sobrecarga.
▪ Operadores que não podem ser sobrecarregados:
▪ . (operador ponto)
▪ :: (operador de resolução de escopo)
▪ ? : (operador ternário)

Exercício
▪ Faça a sobrecarga dos operadores abaixo:
▪ - (subtração)
▪ -- (decremento)

A palavra-chave this
 Representa um ponteiro para o objeto corrente
cuja função está sendo executada.
 This também é conhecido como operador de
AUTOREFERÊNCIA

#include <iostream>
class Retangulo {
int x, y;
public:
Retangulo (){x =0 ; y = 0;} // Função Construtora
Retangulo operator + (Retangulo); // Função sobrecarregada do operador binário "+"
void operator ++ () // Função sobrecarregada do operador unário "++"
{ x++; y++; }
};

this->x = x + Temp.x;
this->y = y + Temp.y;
return *this;
}
int main () {
Retangulo A, B, C;
A.set(1,2);
B.set(3,4);
C = A + B;
C.mostra();
++A; // Operador unário sobrecarregado
A.mostra();
return 0;
}
Exercícios
1. Crie uma classe para representar uma pessoa, com os atributos privados de nome, idade
e altura. Crie os métodos públicos necessários para sets e gets e também um métodos
para imprimir os dados de uma pessoa.
2. Crie uma classe em C++ chamada Relogio para armazenar um horário, composto por
hora, minuto e segundo. A classe deve representar esses componentes de horário e deve
apresentar os métodos a seguir:
I. um método chamado setHora, que deve receber o horário desejado por parâmetro
(hora, minuto e segundo);
II. um método chamado getHora para retornar o horário atual, através de 3 variáveis
passadas por referência;
III. um método para avançar o horário para o próximo segundo (lembre-se de atualizar o
minuto e a hora, quando for o caso).
3. Definir uma classe que represente um círculo. Essa classe deve possuir métodos Privados
para:
I. calcular a área do círculo;
II. calcular a distância entre os centros de 2 círculos;
III. calcular a circunferência do círculo.
IV. E métodos Públicos para:
a) definir o raio do círculo, dado um número real;
b) aumentar o raio do círculo, dado um percentual de aumento;
c) definir o centro do círculo, dada uma posição (X,Y);
d) imprimir o valor do raio;
e) imprimir o centro do círculo.
f) imprimir a área do círculo. FONTE: CLASSES em C++. Márcio Sarroglia Pinho.
Programação Orientada a Objetos. Marco Antonio M. Carvalho
V. Criar um programa principal para testar a classe.
Exercícios
5. Implemente um carro. O tanque de combustível do carro armazena no máximo 50 litros de gasolina. O
carro consome 15 km/litro. Deve ser possível:
I. Abastecer o carro com uma certa quantidade de gasolina;
II. Mover o carro em uma determinada distância (medida em km);
III. Retornar a quantidade de combustível e a distância total percorrida.
IV. No programa principal, crie 2 carros. Abasteça 20 litros no primeiro e 30 litros no segundo. Desloque o
primeiro em 200 km e o segundo em 400 km. Exiba na tela a distância percorrida e o total de
combustível restante para cada um.
6. Implemente uma televisão. A televisão tem um controle de volume do som e um controle de seleção de
canal. O controle de volume permite aumentar ou diminuir a potência do volume de som em uma unidade
de cada vez. O controle de canal também permite aumentar e diminuir o número do canal em uma
unidade, porém, também possibilita trocar para um canal indicado. Também devem existir métodos para
consultar o valor do volume de som e o canal selecionado. No programa principal, crie uma televisão e
troque de canal algumas vezes. Aumente um pouco o volume, e exiba o valor de ambos os atributos.
FONTE: CLASSES em C++. Márcio Sarroglia Pinho.


Exercícios
7. Crie uma classe Empresa capaz de armazenar os dados de uma empresa (Nome, Endereço, Cidade,
Estado, CEP e Telefone). Inclua um construtor sem argumentos e um com argumentos para inicialização
dos atributos. Crie métodos que funcionem como getter e setter e print.
I. Utilize a classe Empresa como base para criar a classe Restaurante. Esta classe derivada deve conter atributos que representem o tipo de comida e o
preço médio de um prato. Crie um construtor para esta classe que chame explicitamente o construtor da classe Empresa, um getter e um setter, além
de um método print, que utiliza o método print da classe base. Crie um driver para testar sua aplicação.
8. Crie a classe Veiculo, contendo o peso, a velocidade máxima, e o preço. Inclua um construtor sem
argumentos e um com argumentos para inicialização dos atributos. Crie métodos que funcionem como
getter e setter e print.
I. Crie a classe Motor, contendo o número de cilindros e a potência. Inclua um construtor sem
argumentos e um com argumentos para inicialização dos atributos. Crie métodos que funcionem como
getter e setter e print.
II. Crie a classe CarroPasseio, derivada das classes Veiculo e Motor. Inclua atributos como modelo e
cor. Crie um construtor para esta classe que chame explicitamente o construtor das classes base, um
getter e um setter, além de um método print, que utiliza o método print da classe base. Crie um driver
para testar sua aplicação.
III. Crie a classe Caminhao, derivada das classes Motor e Veiculo. Inclua os atributos toneladas, altura
máxima e comprimento. Crie um construtor para esta classe que chame explicitamente o construtor
das classes base, um getter e um setter, além de um método print, que utiliza o método print da classe
base. Crie um driver para testar sua aplicação.
FONTE: CLASSES em C++. Márcio Sarroglia Pinho.


12 TP Programação Orientada A Objeto PDF

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

12 TP Programação Orientada A Objeto PDF

Загружено:

Авторское право:

Доступные форматы

Técnicas de

Prof. Protásio – DEE/CEAR/UFPB

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 4

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 6

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 7

▪ Por padrão, todos os membros declarados em

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 8

▪ Como posso criar um outro objeto da classe Retangulo?

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 9

void Retangulo :: setar_valores (int a, int b) {

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 10

void Retangulo :: setar_valores (int a, int b) {

segundo class Retangulo {

void Retangulo :: setar_valores (int a, int b) {

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 12

segundo class Retangulo {

Ufa!!! void Retangulo :: setar_valores (int a, int b) {

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 13

void setar_valores (int, int);

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 14

▪ A melhor forma de acessar dados-membros é

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 15

terceiro class Retangulo {

void Retangulo :: setar_valores (int a, int b) { x = a; y = b;}

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 16

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 17

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 18

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 19

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 20

// Função construtora da classe Retangulo

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 21

// Função construtora da classe Retangulo

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 22

// Função construtora da classe Retangulo

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 23

// Função construtora da classe Retangulo

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 24

Retangulo::Retangulo () {// Função construtora da classe Retangulo

// Função construtora da classe Retangulo

Retangulo::~Retangulo () {// Função destrutora da classe Retangulo

Retangulo *Ret= new Retangulo[i];

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 28

Retangulo *B= new Retangulo[3];

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 29

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 30

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 31

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 32

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 33

class cubo : public quadrado {

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 34

class cubo_colorido : public cubo {

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 35

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 36

cy.a; //ERRO, pois a não é visível (private)

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 37

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 38

cy.a; //ERRO, pois a não é visível (private)

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 39

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 40

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 41

void set_carga(int num) { carga = num; };

Prof. Protásio / Laboratório de Microengenharia/DEE/CEAR/UFPB 42