PM 12/09/2011

// notasdogarcia.blog.com

// A aula de hoje é uma revisão preparando para a prova que será segunda feira.

NOTA:
Quando declarar uma variável estática dentro de uma classe declare também um protótipo dela, na forma:

tipo nomeDaClasse::nomeDaVariavel;

do lado de fora da classe, ou haverá erro de linkagem durante a compilação.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

NOTA:
Se uma classe possui uma função "virtual pura" ela não pode estanciar um objeto pois ela se torna uma classe abstrata.
Ou seja nunca faça new A() se A é abstrata.

ex:

class B
{
  int a;
  float c;

  public:

  int d;

  char leStr();

  int f() = 0;
}

Esse f() é uma função virtual pura e a classe B portanto é abstrata e só tem significado se for herdada por outra classe que não seja abstrata.

Uma função virtual pura é uma função que precisa de uma redefinição em uma classe filha para que tenha sentido.

ex:

class C : public B
{
  public:
  int f() { ... }
}

Essa funçào f() definida aqui tem acesso à variável d, da classe B e tem acesso a função leStr() também da classe B.
Um objeto da classe C pode ser alocado com new C(); porém um objeto da classe B não pode, devido a sua função virtual pura.

Qual o sentido de se criar uma função virtual pura?
Lembram-se da caracteristica de se poder criar um ponteiro para um pai, e usa-lo para apontar para um filho?
Se voce desejar usar uma função do filho, usando este ponteiro para pai, voce precisa que o pai tenha essa função de mesmo nome, mas com uma declaração virtual,
ou virtual pura.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Lembrete:

Um catch(A) é capaz de pegar exceções do tipo A.
Mas não apenas isso.
Se B é filho de A um catch(A) também captura uma exceção do tipo B.

Então se voce quiser colocar dois catchs um para cada faça assim:

catch(B) { }
catch(A) { }

Se voce fizer:

catch(A) { }
catch(B) { }

O segundo catch nunca será ativado, pois tanto as exceções A quanto as B serão pegas pelo catch(A).

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

Criação de objetos com Template.

Seja a declaração de um template:

template <class T> class Stack
{
  T* v;
  T* p;
  int sz;

  public:
  T pop(){ return * --p; }
  void push(T);
}

Para usar essa classe, voce precisa declara-la assim:

Stack<char> pilha;

Esse objeto que declarei agora é um objeto com 2 chars e um inteiro. Legal não?

Eu posso usar como tipo T qualquer tipo cujas operações que eu uso dentro das funçòes também funcionem para o tipo que eu desejo.

 - - -

Caso eu queira definir uma função fora do template faço assim:

template <class T> push<T>(){...}

 - - - - -

Voce pode fazer vários e vários parametros para um template.
Assim pode-se fazer:

template <class T, int size>
ou etc.

// fim da aula =].