3EDPOO

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

SEM0543 – Organização de Dados em 
Computadores
Estruturas de dados
Programação Orientada a Objetos
3
OO – Conceitos Básicos
Orientação a Objetos (OO):
(1) Orientação a Objetos (OO) é uma abordagem de programação 
que utiliza objetos da computação de forma análoga aos 
objetos existentes no mundo real.
(2) Os objetos trocam mensagens entre si.
(3) As mensagens resultam na invocação de métodos que 
realizam as ações necessárias
(4) Os objetos similares que respondem as mesmas mensagens 
são agrupados em classes. 
(5) Objetos são dinâmicos durante a execução dos sistema e 
podem: (a) ser construídos; (b) executar ações; (c) ser 
destruídos; (d) tornar inacessíveis.
4
OO – Objetos e Classes
5
OO – Classe: Atributos e Métodos
Automóvel
marca
placa
ano
registrar
transferirProprietário
Métodos
Atributos
proprietário
6
OO – Métodos e Mensagens
7
OO - Analogia
Analogia dos conceitos principais no paradigma orientado a 
objeto e no paradigma procedimental:
Orientado a Objetos Procedimental
Objeto ------------------> Valor
Classe ------------------> Tipo (TAD)
Mensagem -------------> Chamada de Procedimento
Método ------------------> Procedimento ou Função
Dados Procedimentos
Dados
Operações
Encapsulamento
8
C++
Algumas características básicas do C++:
(a) fornece um mecanismo para empacotar struct 
(C) e correspondentes métodos juntos (classes)
(b) proteger estruturas de dados internas do 
exterior (keyword private). As keywords private e 
public denotam quais itens podem ou não podem 
ser modificados por programas externos. Uma 
convenção comum (embora opcional) é colocar 
um sufixo _ nos nomes das variáveis para ajudá-
las a identificá-las. 
(c) fornece um mecanismo para inicialização e 
finalização das estruturas de dados do usuários 
(constructors/destructors)
9
Ciclo de Vida de um Programa C++
C++ source code
Makefile
Programmer
(you)
object code 
(binary, one per compilation unit) .o
make
“make” utility
xterm
console/terminal
Runtime/utility 
libraries
(binary) .lib .a .so
g++
gcc
compiler
link
linker executable
program
Eclipse
debugger
precompiler
compiler
10
C++ (cont.)
Compilar
g++ -c main.cc
g++ -o main main.cc sum.cc –lm
Namespaces
permite agrupar entidades como classes, objetos e funções em 
um nome. Dessa maneira um escopo global pode ser dividido em 
"sub-escopos", cada um com seu próprio nome. 
Namespace std
Todos os arquivos da biblioteca padrão em C++ declaram todas 
as suas entidades dentro do namespace std
Sobrecarga de operador:
Dados os números complexos, u, v, w, e z, qual é mais fácil de ler?
w = z*(u + v);
ou
Complex t;
C_add(&t, u, v);
C_mult(&w, z, t);
Consultas adicionais: www.cplusplus.com - C++ Language Tutorial
11
Classe : Exemplo
// exemplo de classe 
#include <iostream>
using namespace std; 
class CRectangle {
private:
int x_, y_;
public:
void set_values (int,int);
int area () {return (x_*y_);}
};
void CRectangle::set_values (int a, int b) {
x_ = a;
y_ = b;
}
int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;
}
12
Constructors e destructors 
// classes example
#include <iostream>
using namespace std;
class CRectangle {
private:
int x_, y_;
public:
CRectangle (int,int);
int area () {return (x_*y_);}
};
CRectangle::CRectangle (int a, int b) {
x_ = a;
y_ = b;
}
int main () { 
CRectangle rect (3,4); 
CRectangle rectb (5,6); 
cout << "rect area: " << rect.area() << endl; 
cout << "rectb area: " << rectb.area() << endl; 
return 0;
}
13
Constructors e destructors (cont.) 
#include <iostream>
using namespace std;
class CRectangle {
private:
int *x_, *y_;
public:
CRectangle (int,int);
~CRectangle ();
int area () {return (*x_ * *y_);}
};
CRectangle::CRectangle (int a, int b) {
x_ = new int;
y_ = new int;
*x_ = a;
*y_ = b;
}
CRectangle::~CRectangle () {
delete x_;
delete y_;
}
14
C++: sobrecarga de operador
#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
class CVector {
private:
int x_, y_;
public:
CVector();
CVector(int,int);
CVector operator + (CVector);
int x() {return x_;}
int y() {return y_;}
~CVector();
};
CVector::CVector (int a, int b) {
x_ = a;
y_ = b;
}
CVector::CVector () {
x_ = 0;
y_ = 0;
}
CVector::~CVector () {
}
15
C++: sobrecarga de operador (cont.)
CVector CVector::operator+ (CVector param) {
CVector temp;
temp.x_ = x_ + param.x_;
temp.y_ = y_ + param.y_;
return (temp);
}
int main () {
CVector a(3,1);
CVector b(1,2);
CVector c;
c = a + b; // c = a.operator+ (b);
cout << c.x() << "," << c.y();
getchar();
return 0;
}