Classes
EStruturas de Dados e Algoritmos
Class
Classe: tipo de dados definido com class
– é uma generalização do conceito de estrutura em C
– Para além de dados (membros-dados), uma classe pode também conter funções de manipulação
desses dados (membros-funções), restrições de acesso a ambos (dados e funções) e redefinições de
quase todos os operadores de C++ para objetos da classe
Class
Dados Funções
Membros-dados Membros-funções
atributos métodos
ESDA
Rui Camacho e Pedro Costa 2
|
Classes – Tipo de acesso
Tipo de acesso de uma classe define como os membros podem ser
acessíveis.
class name_class {
public: // Public access specifier
Public - os membros são acessíveis de fora da classe. Através de
data members (Membros-dados)
qualquer objeto da classe.
functions (Membros-funções)
Private - os membros não podem ser acedidos (ou visualizados) de
private: // Private access specifier
fora da classe
data members (Membros-dados)
functions (Membros-funções)
Protected - os membros não podem ser acedidos de fora da classe, no
entanto, eles podem ser acedidos em classes herdadas.
protected: // Protected access specifier
data members (Membros-dados)
Todos os membros de uma classe - dados e métodos - são private por
functions (Membros-funções)
default
};
ESDA
Rui Camacho e Pedro Costa 3
|
Classes vs Objetos
Conceito de objeto: instância de uma classe
em vez de variáveis (do tipo T) fala-se em objetos (da classe ou tipo T)
semelhante a “int i” em que int é o tipo - classe e i é a variável - objeto
class Room
{
private:
//membros-
dados
Class
//membros-
funções
public:
//membros-
dados
//membros- Objects
funções
}
Room r1 Room r2 Room r3
ESDA
Rui Camacho e Pedro Costa 4
|
Exemplo - public
#include <iostream>
int main() {
using namespace std;
Room room1; // cria um objeto chamado room1
class Room {
[Link] = 42.5; // como são publicos , consigo aceder
public:
[Link] = 30.8;
double length;
[Link] = 19.2;
double breadth;
double height;
cout << "Area of Room = " << [Link]() << endl;
cout << "Volume of Room = " << [Link]() << endl;
double calculateArea() {
return length * breadth;
return 0;
}
}
double calculateVolume() { Resultado
return length * breadth * height; Area of Room = 1309
Volume of Room = 25132.8
}
};
ESDA
Rui Camacho e Pedro Costa 5
|
Exemplo - private
#include <iostream>
using namespace std; int main() {
class Room { Room room1; // cria um objeto chamado room1
private: [Link] = 42.5; // inválido
double length; cout << "length = “<< length << endl; // inválido
double breadth; [Link](42.5, 30.8, 19.2);
double height;
cout << "Area of Room = " << [Link]() << endl;
public:
void initData(double len, double brth, double hgt) { cout << "Volume of Room = " << [Link]() << endl
length = len;
breadth = brth; return 0;
height = hgt; }
}
Resultado
double calculateArea() {
Area of Room = 1309
return length * breadth; Volume of Room = 25132.8
}
double calculateVolume() {
return length * breadth * height;
}
}; ESDA
Rui Camacho e Pedro Costa 6
|
Construtores
❑ Um membro-função com o mesmo nome da classe é um construtor
⮚ construtores não podem especificar tipos ou valores de retorno
❑ O construtor serve para inicializar os membros-dados
⮚ podem-se definir construtores com argumentos para receber valores a usar na inicialização
Room(double len, double brea,double hei)
{ length =len;
breadth = brea;
height=hei;
}
❑ Construtores podem ser overloaded ( existir vários construtores com o mesmo nome )
⮚ Desde que os parâmetros de entrada sejam diferentes em número ou em tipo, para que quando
são chamados consigam encontrar a correspondência
Room() Room( Room &r)
{ length =0; { length =r. length;
breadth = 0; breadth = r. breadth;
height=0; height=r. breadth;
} }
ESDA
Rui Camacho e Pedro Costa 7
|
Construtores
❑ O construtor é invocado automaticamente sempre que é criado um objeto da classe
⮚ para objetos globais, o construtor é chamado no início da execução do programa
⮚ para objetos locais (automáticos ou estáticos), o construtor é chamado quando a execução passa
pelo ponto em que são definidos
Room r1 (40.5, 30.3,10.2); // válido construtor com 3 argumentos do tipo double
Room r2 ; // válido , construtor sem argumentos
Room r3 (40,30); // inválido não existe construtor com 2 argumentos
Room r4 = (30,40,50) // inválido
Room r5=r1;
ESDA
Rui Camacho e Pedro Costa 8
|
Objectos e membros constantes (const)
❑ Objecto constante:
⮚ declarado com prefixo const
⮚ especifica que o objecto não pode ser modificado
⮚ como não pode ser modificado, tem de ser inicializado
Exemplo : const Room r1(double len, double brea,double hei);
❑ Membro-dado constante:
⮚ declarado com prefixo const
⮚ especifica que não pode ser modificado (tem de ser inicializado)
Exemplo: private:
const double length;
❑ Membro-função constante:
⮚ declarado com sufixo const (a seguir ao fecho de parêntesis)
⮚ As funções de membro const são as funções que são declaradas como constantes no programa. O objeto chamado
por essas funções não pode ser modificado. Recomenda-se usar a palavra-chave const para evitar alterações
acidentais no objeto.
Exemplo: double calculateArea() const {
return length * breadth;
}
ESDA
Rui Camacho e Pedro Costa 9
|
Header files (Bibliotecas de classes)
As funções definidas dentro da classe são funções inline
Funções maiores devem ser apenas declaradas dentro da classe, e definidas fora da mesma, precedendo o nome da função do nome da
classe seguido do operador de “Scope” ::
A função vê os membros da classe da mesma forma, quer seja definida dentro ou fora da classe
Permite separar o interface (o que interessa a quem acede à classe, normalmente colocado em "header files") da implementação
(normalmente colocada em "source code files")
#ifndef _ROOM_H_
#define _ROOM_H_ #include “room.h“
Room::Room()
#include <iostream> { length =0;
using namespace std; breadth = 0;
class Room { height=0;
}
private:
double length; Room::Room(double len, double brea,double hei)
double breadth; { length =len;
double height; breadth = brea;
height=hei;
public: }
Room() ;
Room(double len, double brea,double hei); double Room::calculateArea() {
double calculateArea(); return length * breadth;
double calculateVolume(); }
} double Room:calculateVolume() {
#endif return length * breadth * height;
}
ESDA
Rui Camacho e Pedro Costa 10
|
Criação de objetos com new
❑ Criação de objecto
Room *roomPtr;
roomPtr = new ROOM;
⮚ cria um objeto do tamanho apropriado, chama o construtor para o objeto (se existir) e
devolve um apontador do tipo do objeto ou 0 (se não há espaço).
Room *roomPtr = new Room (40, 30, 20);
Para aceder aos membros de uma classe através de apontadores, usa-se o operador ->
cout << roomptr->calculateArea()<< endl;
cout << roomptr-> double calculateVolume() << endl;
ESDA
Rui Camacho e Pedro Costa 11
|
Destruição de objetos com delete - Destructor
❑ Destruição de objeto
delete roomPtr;
❑ invoca o destrutor para o objeto (se existir) e só depois liberta a memória
Destructor
❑ Um membro-função com o mesmo nome da classe precedido do til (~) é um destrutor
~Room()
❑ Destrutores não recebem parâmetros e não retornam valor
❑ O destrutor da classe é invocado automaticamente sempre que um objeto deixa de existir
⮚ do bloco em que são definidos) para objetos globais e objetos locais estáticos, o destrutor é chamado
no fim da execução do programa
⮚ para objetos locais automáticos, o destrutor é chamado quando estes saem do âmbito (scope)
Destrutores servem normalmente para libertar recursos (memória dinâmica, etc.) associados ao objeto
ESDA
Rui Camacho e Pedro Costa 12
|
Destructor - exemplo
#include<iostream>
#include <fstream>
using namespace std;
class Test
{
int *p;
ifstream fis;
Test (int n,string f)
{
p = new int[n];
[Link] (f);
}
~Test ()
{
delete[]p;
[Link] ();
}
};
ESDA
Rui Camacho e Pedro Costa 13
|
Class - this
this é um apontador que aponta para o objeto(instância) atual da #include <iostream>
classe. using namespace std;
class Employee {
⮚ Usado para passar o objeto atual como um parâmetro public:
para outro método. int id;
string name;
⮚ Usado para referenciar a variável de instância da classe
float salary;
atual. Employee(int id, string name, float salary)
⮚ Usada para encadear funções e excluir objetos por meio {
de suas funções de membro. this->id = id;
this->name = name;
this->salary = salary;
}
void display()
{
cout<<id<<" "<<name<<" "<<salary<<endl;
}
};
ESDA
Rui Camacho e Pedro Costa 14
|
this - encadeamento
#include <iostream> void display()
#include <string> {
using namespace std; cout << name << endl;
cout << age << endl;
class Person }
{ };
string name;
int age;
int main()
public: {
Person setName(string name)
{ Person p1;
this->name = name;
return *this;
} p1 = [Link]("Pedro").setData(40);
Person setData(int age) [Link]();
{ return 0;
this->age = age; }
return *this;
}
ESDA
Rui Camacho e Pedro Costa 15
|