Aula 2

Aula 02

Exemplo
{
X x;
}

Alocação Dinâmica

Em C++ um objeto é criado dinâmicamente, com o operador new o qual retorna o endereço da região de memória do primeiro byte ocupado pelo objeto.

X* p=new X(); ou X *p=new X;

Objetos criados dinâmicamente residem no heap do sistema,que é a área destinada a um programa pelo SO(sistema operacional) para alocação dinâmica(em tempo de execução de memória). Ao contrário de objetos estáticos, os objetos criados dinâmicamente devem ser explicitamente destruidos, através do operador delete. Ao contrário de new, delete invoca o destrutor e em seguida libera a memória do heap ocupada pelo objeto.

delete p;

Obs. Manipulação explicita de ponteiros é uma das causas mais comuns de erros em C++(coisa que não existe em Java).

O tempo de vida útil de um objeto começa imediatamente após sua criação e dura até o instante imediatamente antes de sua instrução. Durante sua vida útil o objeto pode ser usado de duas maneiras:

1- Acessando um atributo do objeto:

int a=x.a; //acesso de leitura: x.a é um rvalue (valor que esta dp lado direito, não pode ser modificado)
p->a=a; //acesso de escrita: p->a é um lvalue (trabalha com o endereço)
//mesma coisa que a de cima (*p).a=a;

2- Enviando uma mensagem para o objeto:

x.m();
p->m();

Como resposta à mensagem o receptor acopla o método

X::m() //X(qualificador) e X::m(nome qualificado).

Acoplar significa: descobrir na classe do receptor um método cujo nome é o mesmo do seletor da mensagem e cujos parâmetros casam em número e tipo com os argumentos da mensagem, e em seguida invocar tal método. Sintaticamente enviar uma mensagem é similar a acessar um atributo, com a diferença que depois do nome do método vem o par de parênteses com os argumentos da mensagem em seu interior. É como se estivessemos chamando um função para um objeto. Semânticamente porém deve se ter em mente que se esta enviando uma mensagem e que a função a ser invocada é consequência do acoplamento.

Obs. X::m é um nome qualificado sendo o nome simples 'm' o nome de um método(o nome simples de um nome qualificado pode ser o nome de qualquer membro de uma classe). O qualificador de um nome qualificado é um nome de classe que precede o operador de escopo, nesse caso o 'X'. “m é da classe X”

Em C++, o operador de escopo ::a é um nome totalmente qualificado, sendo 'a' um nome declarado globalmente(o qualificador é nulo).

Exemplo
int a;
void f(int a)
{
::a=a;
}

Propriedades da Orientação e Objeto

-> Encapsulamento
-> Herança
-> Polimorfismo

Atributos de Métodos de Classes

Ao contrário de atributo de instância,um atributo de classe não pertence à estrutura de dados de objetos da classe. Há apenas uma cópia do atributo(que pode ser intendido como sendo de propriedade da classe) ao invés de uma cópia para cada objeto da classe. Os objetos da classe compartilham esta cópia única. Em C++ um atributo de classe é definido como modificador "static".

Obs Em C++ a variável uma variável estática declarada em uma classe(geralmente em uma arquivo .h) é definida em um arquivo .cpp.

//
//Início do x.h
//
#include

class X
{
public:
int a, b;
static int sa; //atributo de classe

void f()
{
a=sa;
}

};

//
//Fim do x.h
//

//
//Início do x.cpp
//
#include "x.h"

int X::sa=4;
int main()
{
X x1, x2;
int a=x1.a;

a=X::sa;
x1.sa=3;
printf("Tamanho de x: %d, valor de X::sa: \n", sizeof(x1), X2.sa);
return 0;
}

//
//Fim do x.cpp
//

Um método de classe:

• não pode ser invocado como resultado do acoplamento mensagem método.
  
• não pode acessar atributos de instância de "this"(Não é possível usar this em um método de classe).
  
• é como se fosse uma função global pertencente à classe. Em C++ um método de classe é declarado como modificador "static".

Tratamento de Exceções

O tratamento de exceções constitui-se em:

1. Lançamento da exceção. Quando um método verifica a ocorrência de uma situação excepcional, este pode lançar uma exceção. Lançar uma exceção significa criar um objeto que transportará em seus atributos(conforme definido em sua classe) com as informações relevantes sobre a exceção detectada. Uma vez criado este objeto ele é lançado em uma sentença "throw". Em C++ uma exceção pode ser um objeto de qualquer tipo. Em Java uma exceção é uma instância que o objeto da classe "Exception" ou dela derivado. O código abaixo da sentença "throw" não é executado quando no lançamento da exceção.
   
2. Tratamento da exceção propriamente dito. Todo código em que uma exceção pode ocorrer deve ser enclausurado em um bloco "try". Se em algum ponto do "try" uma exceção for lançada, o código restante após o ponto de lançamento não é executado. Após o bloco "try" deve se ter uma ou mais blocos "catch", parametrizados cada um deles com um dos tipos de exceção que podem ocorrer no "try". Na ocorrência de uma exceção o fluxo de controle é transferido para o primeiro bloco "catch" cujo parâmetro é do tipo da exceção lançada. O código do "catch" efetua o tratamento da exceção, e o fluxo de controle é desviado para o código após o último "catch". Senão houver um "catch" para o tipo de exceção lançada uma função global de tratamento de exceções invocadas é chamada(geralmente esta aborta a execução do programa). O exemplo a seguir ilustra:
   

#include
void* malloc(size_t);

struct my_out_of_memory
{
my_out_of_memory(size_t size)
{
this->size=size;
}//end myoutofsize
size_t size;
};

void* my_alloc(size_t size)
{

void* ptr=malloc(size);

if(ptr==NULL)
{
throw my_out_of_memory(size);
}//endif

return ptr;

}//end voidmyalloc

void q()
{

void* b1=NULL;
void* b2=NULL;
void* b3=NULL;

try
{
void* b1= my_malloc(1000);
void* b2= my_malloc(3000);
void* b3= my_malloc(4000);
//faça ago
}//end try

catch(my_out_of_memory& e)
{
printf("out of memory(%d bytes)\n", e.size);
}//end catch

free(b1);
free(b2);
free(b3);

}//end voidq