Declaração de classes Uma classe em C++ é uma extensão do ...

CARACTERÍSTICAS DE C++ QUE IMPLEMENTAM
CONCEITOS DE ORIENTAÇÃO A OBJETOS
Declaração de classes
Uma classe em C++ é uma extensão do
registro (struct) em C, adicionando-se a
possibilidade de definir componentes que são
funções (métodos).
Formato:
class
{
public
};
onde...
identificador da classe. Pode ser
qualquer nome único no escopo.
lista das classes-base (super-classes)
das quais a classe é derivada
declaração dos membros
privados da classe.
declaração dos membros
públicos da classe.

exemplo:
______________________________________________
class intervalo
{
float esq, dir;
public:
void intervalo (float e, float d)
{
esq = e;
dir = d;
}
float LimiteEsq( )
{ return esq; }
float LimiteDir( )
{ return dir; }
bool Contem(float f)
{ if ( (f>esq) && (f

Obs:
A primeira parte da definição, acima da linha
public:
é a parte privada, que é visível somente dentro
da classe.
Na parte pública é definida uma função com
mesmo nome da classe (intervalo), que é
usada para construção de objetos e é chamada
de construtor da classe.
Especificadores de acesso
Membros de uma classe (variáveis ou
funções) podem adquirir atributos de acesso
por default ou através do uso dos
especificadores public, private e
protected. Isso especifica a visibilidade do
elemento fora da classe.

Se um membro é público, ele pode ser
referenciado em qualquer parte do programa.
Se privado, só pode ser referenciado pelas
funções-membro da classe onde foi declarado
e pelas funções amigas (friend - ver adiante).
Membros de uma classe são privados por
default.
Um membro protegido é referenciado da
mesma maneira que um privado. Além disso,
porém, o membro pode ser usado pelas
funções-membro das classes derivadas
(subclasses) da classe onde foi declarado.
Obs: Os especificadores de acesso têm estreita
relação com o conceito de encapsulamento.

Objetos
Objetos de uma classe são criados em C++
declarando-os de forma semelhante às
variáveis. Por exempo, x poderia ser declarado
como um objeto da classe intervalo por:
intervalo x;
Esse objeto possui suas próprias variáveis
privadas - esq e dir – e está equipado com as
funções definidas na sua classe.
O construtor (a função intervalo) pode
ser ativado para a criação de um objeto com
dois parâmetros. Por exemplo, x poderia ser
inicializado como o intervalo (1.5, 2.8) pela
declaração
intervalo x(1.5, 2.8);
Uma vez executada a declaração de um
objeto, qualquer de seus elementos públicos
podem ser referenciados prefixando-se o nome
do objeto ao nome do componente, usando-se
um ponto como separador.

Por exemplo, o limite esquerdo do intervalo x
poderia ser obtido por
x.LimiteEsq( )
Essa é a única forma de acesso aos
elementos na área privada do objeto. Eles não
estão disponíveis a operações que não façam
parte da definição da classe a qual pertence o
objeto.
>> encapsulamento.
Amigos (friends)
Pode-se dar a uma função externa direito
de acesso aos elementos privados de uma
classe, declarando aquela função como amiga
(friend) no interior da declaração da classe.
Um amigo, mesmo não sendo membro
daquela classe, possui completo direito de
acesso aos seus membros.

Ex:
A função ImprimeIntervalo (externa à
classe intervalo) poderia ser definida assim:
void ImprimeIntervalo(Intervalo x)
{
cout

Herança
Herança é implementada em C++ através
do conceito de classe derivada.
Uma classe derivada herda todos os
membros da classe-base (superclasse).
A sintaxe para declarar uma classe derivada é:
Class:public
{
}
Essa declaração torna todos os membros
públicos da classe-base membros públicos da
classe derivada.
Outra alternativa seria:
class :
{
}

Sobrescrita de funções e Polimorfismo
É possível acontecer que classes
derivadas implementem diferentes versões de
uma função da classe base.
Se essa redefinição ocorrer com a mesma
assinatura (nome, lista de parâmetros e tipo
de retorno), ocorre sobrescrita (overiding) - a
subclasse reescreve a função, quebrando,
portanto a herança para aquela função.
OBS: se houver na subclasse uma função com
mesmo nome de uma presente na classe base,
porém com lista de parâmtros e/ou tipo de
retorno diferentes, estará havendo sobrecarga
(overloading).
A subclasse herda normalmente a função,
porém dispõe de outra operação (com mesmo
nome).
Para que essa redefinção seja permitida, a
função deve ser declarada como virtual.
Funções virtuais são fundamentais para a
implementação do conceito de polimorfismo.

O exemplo a seguir ilustra esses conceitos:
#include
class Quadrilatero
{
struct TipoPonto
{
float X;
float Y;
};
protected:
struct TipoPonto P1,P2,P3,P4;
public:
Quadrilatero() { }
virtual void QuemSou()
{
cout

class Trapezio: public Quadrilatero
{
public:
Trapezio(): Quadrilatero() { }
virtual void QuemSou() {
cout

}
// vetor de ponteiros para
// quadriláteros:
Quadrilatero * ConjQuad[19];
ConjQuad[0] = &X;
ConjQuad[1] = &Y;
ConjQuad[2] = &Z;
ConjQuad[3] = &K;
for (int i=0; i QuemSou();
OBS: o polimorfismo é um conceito muito útil na
prática.
>> no exemplo acima, um conjunto de objetos
de classes diferentes (porém da mesma hierarquia
de classes) pode ser tratado de maneira uniforme. A
mesma mensagem ativará funções diferentes,
conforme a classe do objeto-alvo.