Delphi Generics: Diferenças entre compiladores

Tanto o Free Pascal Compiler (FPC) quanto o CodeGear Delphi possuem suporte a generics, as extensões que permitem definir quais tipos de dados serão usados por classes ou funções (por exemplo) no momento de sua declaração. Hoje há uma tendência da adoção de generics em praticamente todas as linguagens OO. C++ tem seus templates desde o ISO C++94, Java adotou generics a partir de sua versão J2SE 5.0 (em 2004), C# a partir da versão 2.0, e agora é a vez do Object Pascal. (Apesar das diferenças de implementação e uso de generics em cada linguagem, o conceito é basicamente o mesmo.)

Pois bem. A comunidade do FPC terminou implementação de generics para sua versão 2.1.2 (em 2007) . Logo depois, a CodeGear anunciou sua intensão de incluir generics na próxima versão de seu compilador, porém com a sintaxe "ligeiramente" diferente.

Agora, com o lançamento do Delphi 2009, a CodeGear confirma a implementação da sintaxe antes exibida, para desespero da comunidade e, principalmente, dos usuários do FPC...

A sintaxe é "quase" a mesma. Mas como o "quase" faz não compilar, há muita gente de cabelo em pé.

The FPC Way...

view plainprint?

1. type  
2.   generic MeuVetor< T > = class  
3.   private  
4.     _vetor: array of T;  
5.     _limite: Integer;  
6.     _atual: Integer;  
7.   public  
8.     constructor Create(tamanho: Integer);  
9.     function Adicionar(item: T): Boolean;  
10.     function Item(posicao: Integer): T;  
11.   end;  
12.   
13.   constructor MeuVetor.Create(tamanho: Integer);  
14.   begin  
15.     inherited Create();  
16.     SetLength( _vetor, tamanho );  
17.     _limite := tamanho;  
18.     _atual := 0;  
19.   end;  
20.   
21.   function MeuVetor.Adicionar(item: T): Boolean;  
22.   begin  
23.     if ( _atual < _limite ) then  
24.     begin  
25.       _vetor[ _atual ] := item;  
26.       Inc( _atual );  
27.       Result := True;  
28.     end  
29.     else  
30.       Result := False;  
31.   end;  
32.   
33.   function MeuVetor.Item(posicao: Integer): T;  
34.   begin  
35.     if ( ( posicao >= 0 ) and ( posicao < _limite ) ) then  
36.       Result := _vetor[ posicao ]  
37.     else  
38.       raise Exception.Create( 'Posição fora da faixa.' );  
39.   end;  

type
  generic MeuVetor< T > = class
  private
    _vetor: array of T;
    _limite: Integer;
    _atual: Integer;
  public
    constructor Create(tamanho: Integer);
    function Adicionar(item: T): Boolean;
    function Item(posicao: Integer): T;
  end;

  constructor MeuVetor.Create(tamanho: Integer);
  begin
    inherited Create();
    SetLength( _vetor, tamanho );
    _limite := tamanho;
    _atual := 0;
  end;

  function MeuVetor.Adicionar(item: T): Boolean;
  begin
    if ( _atual < _limite ) then
    begin
      _vetor[ _atual ] := item;
      Inc( _atual );
      Result := True;
    end
    else
      Result := False;
  end;

  function MeuVetor.Item(posicao: Integer): T;
  begin
    if ( ( posicao >= 0 ) and ( posicao < _limite ) ) then
      Result := _vetor[ posicao ]
    else
      raise Exception.Create( 'Posição fora da faixa.' );
  end;

The Delphi 2009 Way...

view plainprint?

1. type  
2.   MeuVetor< T > = class  
3.   private  
4.     _vetor: array of T;  
5.     _limite: Integer;  
6.     _atual: Integer;  
7.   public  
8.     constructor Create(tamanho: Integer);  
9.     function Adicionar(item: T): Boolean;  
10.     function Item(posicao: Integer): T;  
11.   end;  
12.   
13.   constructor MeuVetor< T >.Create(tamanho: Integer);  
14.   begin  
15.     inherited Create();  
16.     SetLength( _vetor, tamanho );  
17.     _limite := tamanho;  
18.     _atual := 0;  
19.   end;  
20.   
21.   function MeuVetor< T >.Adicionar(item: T): Boolean;  
22.   begin  
23.     if ( _atual < _limite ) then  
24.     begin  
25.       _vetor[ _atual ] := item;  
26.       Inc( _atual );  
27.       Result := True;  
28.     end  
29.     else  
30.       Result := False;  
31.   end;  
32.   
33.   function MeuVetor< T >.Item(posicao: Integer): T;  
34.   begin  
35.     if ( ( posicao >= 0 ) and ( posicao < _limite ) ) then  
36.       Result := _vetor[ posicao ]  
37.     else  
38.       raise Exception.Create( 'Posição fora da faixa.' );  
39.   end;  

type
  MeuVetor< T > = class
  private
    _vetor: array of T;
    _limite: Integer;
    _atual: Integer;
  public
    constructor Create(tamanho: Integer);
    function Adicionar(item: T): Boolean;
    function Item(posicao: Integer): T;
  end;

  constructor MeuVetor< T >.Create(tamanho: Integer);
  begin
    inherited Create();
    SetLength( _vetor, tamanho );
    _limite := tamanho;
    _atual := 0;
  end;

  function MeuVetor< T >.Adicionar(item: T): Boolean;
  begin
    if ( _atual < _limite ) then
    begin
      _vetor[ _atual ] := item;
      Inc( _atual );
      Result := True;
    end
    else
      Result := False;
  end;

  function MeuVetor< T >.Item(posicao: Integer): T;
  begin
    if ( ( posicao >= 0 ) and ( posicao < _limite ) ) then
      Result := _vetor[ posicao ]
    else
      raise Exception.Create( 'Posição fora da faixa.' );
  end;

Notou as diferenças ? Particularmente, eu prefiro sem a palavra generic na frente do nome da classe. Acho desnecessária. Como outras linguagens, também acho que deixar explícito na implementação dos métodos da classe a indicação de que ela recebe um parâmetro deixa o código mais fácil de entender. Na maneira implementada pelo FPC, se você não olhar a declaração, não vai saber que a classe é um generic. Não vai saber que "T" é um tipo que é parametrizado para a classe.

Em os futuros posts provavelmente darei exemplos de classes implementadas com generics em Object Pascal. Nessas usarei a sintaxe do Delphi 2009.

Espero que em breve possa haver um consenso. De imediato, seria bom se o FPC fizesse com que a palavra "generic" e a indicação dos tipos parametrizados na implementação dos métodos fossem opcionais. Poderia resolver temporariamente algum problema de portabilidade.

C++: Multi-dimensional analog literals

Interessante as coisas que podemos fazer com C++ padrão.
Veja um exemplo de uma biblioteca construída com templates para simular a construção de objetos multi-dimensionais através de seu formato. Criar linhas, retângulos e cubos assim fica até mais divertido. ;)

Multi-Dimensional Analog Literals

Evento: C e C++ para Sistemas Embarcados

Acontece em São Paulo no dia 8 de novembro, sábado, um evento sobre Sistemas Embarcados, onde serão abordados algumas temas interessantes, como:

• Técnicas de Programação em C para Sistemas Embarcados
• Utilização de C++ em Microcontroladores
• Explorando os 16 bits da Microchip e as ferramentas de trabalho
• Otimização de código C para sistemas embarcados
• Desenvolvimento Embedded no Mundo da eLua
  

As inscrições podem ser feitas pelo site da TempoReal Eventos.