PM 05/09/2011

// notasdogarcia.blog.com

Se declaro em uma classe uma função:

class A
{
  A operator=(A a) { ... }
}

E escrevo a função:

int main()
{
  A dia, mes;

  dia = mes;
}
O compilador vai entender que voce desejava fazer isso:

dia.operator=(mes);

Entendido?

Assim voce pode redefinir o significado dos operadores de C++, Fantástico não? E super confuso tb!

Isso se chama sobrecarga de operador.

Se quer que o operador "+" possa "somar" a classe batata com um inteiro, como se faz?

Bem assim:

class batata
{
  int feijoada = 10;
  batata operator+(int i) { this->feijoada += i; return (*this); }
}
Pronto,

Mas e se o usuario quiser usar:
dia = 21 + A?

Seguindo aquela regra do compilador ele tentaria fazer algo como:

  21.operator+(...) ?

E num ia dar certo né.

Então voce pode fazer o seguinte para receber um parametro antes.

  batata operator+(int i, batata A) { ... }

Assim o compilador já substitui pra voce a chamada de função com os 2 parâmetros jogando o 21 no parametro i e o tipo A no parametro a.

// Não se deve usar isso aqui com mta frequencia ou sem atenção, pois isso dificulta a legibilidade do código de um tanto.

// Isso funciona para varios operadores inclusive [], >, <, ==, etc.
// Mas não funciona para .* e uns outros e esqueci de anotar e não me lembro mais agora =].

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Como comumente se trata erros e exceções em um programa?

  A maneira mais básica é verificar o retorno de cada função e colocar um if para o caso de a função retornar um aviso de erro.

  Assim o código fica enorme e cheio de ifs, e elses, um tanto dificil de ler.

  Existe outro modo?

  Sim existe o sistema de try/catch e lançamento de exceção (throw)
  Uma função quando perceber que ocorreu um erro em sua execução pode usar o comando throw ##classeDeTratamento##();
  Assim a função construtora da "##classeDeTratamento##" é chamada, a função é encerrada,
  e uma exceção de nome "##classeDeTratamento##" é lançada.

  E o try-catch, faço o que com ele?
  Para voce captar a exceção que foi lançada voce precisa que ela seja lançada dentro de um "try",
  e é preciso que depois do try haja um catch(##classeDeTratamento##){ ... } para receber e tratar a o erro.
  Ou seja suponha que a função erroTeste() retorna uma exceção de nome "Batata":

    try
    {
      erroTeste();
    }catch(Batata)
    {
      printf("  O erro Batata ocorreu, o programa será encerrado!, tire essa batata de perto do computador seu gorduxinho!\n");
      exit(1);
    }

  E é assim que um erro da classe Batata seria tratado. E como seria essa classe?
  Assim:

    class Batata
    {
      public:
      Batata(){};
      // Essa função construtora simples já é o suficiente. (eu acho xP)
    }

  Voce pode acrescentar outros catchs após o primeiro para pegar outros erros.
  E se voce digitar o catch assim: "catch(...)", ele irá pegar qualquer lançamento de erro que passar por ele,
  como se fosse um "default:" em um switch.
  funcao() deve ser uma funcao construtora de uma classe.

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

  Agora porque uma classe para representar um erro? o que eu ganho com essa complicação?

  Seguinte, ao inicializar a função construtora de uma classe voce pode por exemplo salvar nas variáveis da própria classe
  informações importantes para o tratamento do erro ex:

    class acessoInvalido
    {
      int tamanhoDoArranjo;
      int posicaoAcessada;

      public:
      acessoInvalido(int tm, int ps)
      {
        new acessoInvalido a;
        a.tamanhoDoArranjo = tm;
        a.posicaoAcessada = ps;
        return a;
      }
    }

  Agora para receber esse objeto durante o tratamento (ou seja dentro do catch() { } )
  voce deve colocar dentro do catch:

    catch(acessoInvalido obj){ printf("  Voce tentou acessar a posição: %d, em um arranjo de comprimento %d\n", obj.posicaoAcessada, obj.tamanhoDoArranjo); }

  Entendido?

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

  Se dentro de um catch() {} voce lança um throw, sem nada assim:

    try{ }
    catch(acessoInvalido obj){ printf("bla bla bla\n"); throw; }

  Voce pode tratar uma parte do erro, e re-lançar o erro para ser captado por algum outro catch mais atrás no código.

  Assim a função continua buscando um catch, sempre que não encontra um ela retorna a função chamada para anterior.
  Se eventualmente chegar no main e não houver um try-catch lá para receber o throw, o main é retornado e o programa encerrado, com uma menssagem de erro
  de nome "acessoInvalido".

  Se um catch é preparado para receber o erro de uma "classe B::extend public C{...}", e recebe um erro de nome C, ela irá tratar o erro.

  ou seja o catch: catch(B) {...} ira também aceitar um erro de C.

  // Olha eu posso ter entendido algo errado vai ver é o contrário o se fosse catch(C) ele aceitaria erros de B,
  // Mas bem, testes voces isso, se tiverem com paciencia, por enquanto não estou =].

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

  Na declaração de uma função ou de um protótipo dela, voce pode incluir os tipos de erros que ela está apta para aceitar.
  Para faze-lo faça:

    void f(int a) throw(x2,x3)
    {
      ...
    }

  Se um erro não contido nessa especificação surgir, é chamada uma função "unexpected()" (ou algo assim) e o programa é encerrado.

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

  Se voce deseja que dizer que uma função não deve lançar nenhuma excessão, use:

    void f() throw();

  Assim, ela chamará a unexpected() para qualquer excessão que for lançada dentro dela.

// Uma função sem nenhuma especificação de lançamento obviamente aceita lançar qualquer erro sem restrições.
// Ou seja: f() { ... } aceita lançamento de qualquer erro dentro dela, como era esperado.

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

  Ao definir em uma função os erros que ela lança, deve-se ser coerente com todos os protótipos dela,
  ou seja, não se pode declarar que ela lança erro A e B, na especificação
  e em um protótipo esquecer de escrever isso, ou escrever que ela lança apenas A.

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

  Ao redeclarar uma função de uma classe pai, voce pode aumentar as restrições de erros dela, porém não pode diminuir essa restrição.
  Ou seja, se uma função f() não tinha restrições, voce pode escrever ela agora com uma ou mais restrições,
  ex:
    f() throw(A,B) {...}

  Se f já lançava A e B voce pode escrever isso:

    f() throw(A) { ... }

  mas não pode escrever

    f() throw(A,B,C) { ... }

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Nota: voce pode declarar uma classe dentro de outra!

Se ela for private só pode ser usada dentro da classe mãe.

// Beim fim da aula, até a próxima!