Guerra silenciosa, sem vítimas

Com o lançamento quase simultâneo do Mozilla Firefox e do Internet Explorer 7, esquentou a discussão sobre a preferência dos browsers em todo o mundo. O fato foi ainda evidenciado pelo envio de um bolo (bolo mesmo, como o de aniversário) pela equipe de desenvolvimento do IE7 para a equipe do FF, no qual o motivo foi o retorno do interesse da equipe em desenvolver o browser (que estava claramente estagnado por falta de estímulo, como um browser que ameaçasse seu posto...).

Quase que indiscutivelmente, hoje o Firefox apresenta uma gama maior de funcionalidades, pelo uso de seus extensões (plug-ins) e tem ganhado cada vez mais adeptos, mesmo por usuários não-técnicos.

Um grande debate que ainda ocorre é a falta de padrão do IE7 em relação ao DOM (Document Object Model). Ou melhor, não exatamente a falta, mas é que a Microsoft segue seu próprio padrão ao invés do da W3C (Word Wide Web Consortium, uma espécie de comitê que estabelece padrões para a Internet). Isso faz com que as páginas da internet carreguem diferentemente nos dois browsers, o que enlouquece a vida dos webdesigners.

Os "cabeças" do desenvolvimento dos dois browsers concederam entrevista ao Slashdot. Fique por dentro do que vem por aí:

Entrevista com Dean Hachamovitch, líder do IE Team

Entrevista com Chris Beard, líder do FF Team

De volta, com o WLW

Espero estar podendo voltar a postar regularmente, agora sem a complicação editor de conteúdo do Blogger...

Este é o primeiro post que faço usando o Windows Live Writer e ele me parece muito bom. Leve, simples e eficaz. Resolve as dores de cabeça das transições "quebradas" entre HTML e texto que o editor do Blogger apresenta e dá mais opções - como inserir tags e mapas - além de estar integrado a serviços de sites populares.

Enfim, de volta a ativa...

Dica C++: Destrutor virtual abstrato

Em uma classe base, métodos virtuais são aqueles que podem ter sua implementação sobrescrita por uma classe filha.
Isto é uma verdade para métodos, mas não para destrutores. A implementação de um destrutor virtual em uma classe filha não sobrescreve a implementação da classe base. Ela estende.
Primeiro é executado o código do destrutor da classe filha, depois o código do destrutor da classe base.

Exemplo:

class Base
{
public:
      virtual ~Base()
      {
              cout<< "\nDestrutor da classe base." << endl;
      };

      virtual void Metodo()
      {
              cout << "\nMétodo da classe base." << endl;
      };
};

class Derivada : public Base
{
public:
      virtual ~Derivada()
      {
              cout<< "\nDestrutor da classe derivada." << endl;    
      };

      virtual void Metodo()
      {
              cout << "\nMétodo da classe derivada." << endl;
      };
};

// ...

int main()
{
      Base *obj = new Derivada;

      obj->Metodo();

      delete obj;
}

No exemplo acima, se um destrutor virtual não fosse declarado, o destrutor da classe filha não seria executado.

O destrutor virtual da classe filha extender o código do destrutor da classe base,claro, tem sua razão de ser. Se não fosse esse mecanismo, por exemplo, para uma classe base que tem objetos que são desalocados no momento de sua destruição, a classe filha teria que fazer todo o trabalho novamente...

E quando desejarmos criar uma classe puramente abstrata, ou seja, uma interface ?
O destrutor dela provavelmente teria de ser virtual, mas sendo abstrata não poderia ter código. Bom, e como não vai ter código se há a necessidade de executar o código de destruição, pelo destrutor ser virtual ???

Simples, declare um destrutor virtual abstrato com implementação.
Mas se é abstrato como terá implementação ?¿?
Bom, infelizmente C++ não foi bem planejado nesta parte... :(

No arquivo .h, declare normalmente:

class BasePura
{
public:
    virtual ~BasePura() = 0; // destrutor virtual abstrato

    virtual void Metodo() = 0;
};

No arquivo .cpp (implementação), implemente o destrutor:

BasePura::~BasePura()
{
    // implementacao normalmente vazia
}

Esta é uma das partes mal planejadas do C++, que devem ser corrigidas futuramente
pelos novos padrões da linguagem, definidas pelo ISO C++ Standards Commitee.