Como Usar TList com Records em Delphi e Lazarus

 

Em Delphi e Lazarus, TList é uma classe poderosa e versátil para armazenar listas de ponteiros que podem referenciar qualquer tipo de dado. Quando usamos records com TList, obtemos uma maneira eficiente de gerenciar estruturas de dados com tipos fixos e organizados. No entanto, é essencial entender como manipular memória corretamente, já que TList não gerencia automaticamente a alocação e liberação de memória.

Neste post, você aprenderá:

• O que é TList e como funciona.
• O que são records e quando usá-los.
• Como integrar TList e records.
• Boas práticas para manipulação de memória.

 

O que é TList?

TList é uma classe da unidade Classes em Delphi e Lazarus que armazena ponteiros genéricos em uma lista dinâmica. Ela permite:

• Adicionar elementos dinamicamente.
• Acessar elementos diretamente pelo índice.
• Remover ou limpar elementos de forma eficiente.

Entretanto, como TList armazena ponteiros (Pointer), o programador é responsável por alocar e liberar a memória dos dados associados a esses ponteiros.

Exemplo básico de uso:

var
  Lista: TList;
begin
  Lista := TList.Create;
  try
    // Manipulação de elementos aqui...
  finally
    Lista.Free;
  end;
end;

 

O que são Records?

Records em Delphi e Lazarus são estruturas de dados estáticas que permitem agrupar diferentes tipos de variáveis. Eles são ideais para representar entidades simples, como coordenadas de um ponto, dados de uma pessoa ou informações de um produto.

Exemplo de definição de record:

type
  TFuncionario = record
    Nome: string;
    Idade: Integer;
    Salario: Double;
  end;

O record acima pode armazenar informações sobre um funcionário, como nome, idade e salário.

 

Por que usar TList com Records?

Combinar TList com records oferece flexibilidade e desempenho em situações como:

1. Gerenciamento de Dados Complexos: Permite armazenar múltiplos registros de forma dinâmica.
2. Eficiente em Memória: Os registros são mais leves do que classes, ideais para listas grandes.
3. Facilidade de Ordenação e Busca: Pode-se implementar algoritmos customizados para gerenciar os dados armazenados.

Porém, usar TList com records exige atenção especial ao gerenciamento de memória, já que records não são gerenciados automaticamente como objetos.

 

Integração de TList com Records

Ao armazenar records em um TList, não armazenamos o record diretamente, mas sim um ponteiro para ele. Isso ocorre porque o TList funciona exclusivamente com ponteiros.

Definição de Record com Ponteiro

type
  TFuncionario = record
    Nome: string;
    Idade: Integer;
    Salario: Double;
  end;
  PFuncionario = ^TFuncionario; // Ponteiro para o record

 

Criando, Adicionando e Manipulando Registros

Veja o exemplo prático e detalhado:

uses
  Classes, SysUtils;

type
  TFuncionario = record
    Nome: string;
    Idade: Integer;
    Salario: Double;
  end;
  PFuncionario = ^TFuncionario; // Ponteiro para o record

var
  ListaFuncionarios: TList;

procedure AdicionarFuncionario(const Nome: string; Idade: Integer; Salario: Double);
var
  Funcionario: PFuncionario;
begin
  New(Funcionario); // Aloca memória para o record
  Funcionario^.Nome := Nome;
  Funcionario^.Idade := Idade;
  Funcionario^.Salario := Salario;
  ListaFuncionarios.Add(Funcionario); // Adiciona o ponteiro na TList
end;

procedure ListarFuncionarios;
var
  I: Integer;
  Funcionario: PFuncionario;
begin
  WriteLn('---------------------------------------------');
  WriteLn(' Lista de Funcionários');
  WriteLn('---------------------------------------------');
  WriteLn(Format('%-20s | %-5s | %-10s', ['Nome', 'Idade', 'Salário']));
  WriteLn('---------------------------------------------');
  
  for I := 0 to ListaFuncionarios.Count - 1 do
  begin
    Funcionario := PFuncionario(ListaFuncionarios[I]);
    WriteLn(Format('%-20s | %-5d | R$ %-10.2f',
      [Funcionario^.Nome, Funcionario^.Idade, Funcionario^.Salario]));
  end;

  WriteLn('---------------------------------------------');
end;

procedure LiberarMemoria;
var
  I: Integer;
begin
  for I := 0 to ListaFuncionarios.Count - 1 do
    Dispose(PFuncionario(ListaFuncionarios[I])); // Libera memória de cada ponteiro
  ListaFuncionarios.Free; // Libera a lista
end;

begin
  // Inicializa a lista
  ListaFuncionarios := TList.Create;

  try
    // Adicionando funcionários
    AdicionarFuncionario('Ana Silva', 30, 3000.50);
    AdicionarFuncionario('Carlos Almeida', 45, 4500.75);
    AdicionarFuncionario('Maria Oliveira', 28, 2800.00);

    // Listando os funcionários
    ListarFuncionarios;

  finally
    // Liberando a memória
    LiberarMemoria;
  end;
end.

 

Saída no Console

Ao executar o programa, a saída será semelhante a esta:

---------------------------------------------
 Lista de Funcionários
---------------------------------------------
Nome                 | Idade | Salário    
---------------------------------------------
Ana Silva            | 30    | R$ 3000.50
Carlos Almeida       | 45    | R$ 4500.75
Maria Oliveira       | 28    | R$ 2800.00
---------------------------------------------

 

Boas Práticas ao Usar TList com Records

Gerenciamento de Memória
Sempre libere os ponteiros armazenados no TList antes de liberar a lista com Free. Isso evita vazamentos de memória.

Use Estruturas Modernas Sempre que Possível
Em versões mais recentes do Delphi, considere usar TList<T> (Generics), que simplifica o gerenciamento de memória ao evitar ponteiros.

Evite Misturar Dados
Certifique-se de que todos os itens armazenados na lista são do mesmo tipo, evitando erros de acesso.

Documente o Código
Por lidar com ponteiros, o código pode se tornar confuso. Adicione comentários claros para facilitar o entendimento.

 

Conclusão

O uso de TList com records é uma solução eficiente para gerenciar dados estruturados em Delphi e Lazarus. Embora exija cuidado com alocação e liberação de memória, oferece grande flexibilidade e desempenho.

Se você utiliza versões mais recentes do Delphi, explorar generics pode ser uma opção mais segura e moderna.

 

 

💬 Gostou do artigo?

Deixe suas dúvidas ou compartilhe sua experiência nos comentários! 🚀

 

 

Lembre de compartilhar este post com amigos e colegas que tenham interesse no assunto! 👫🔗

 

 

📚 Obrigado por acompanhar até aqui! Explore outros posts relacionados no blog e continue evoluindo suas habilidades. Tem mais conteúdos sobre diversos assuntos te esperando! 👩‍💻 🔍✨

Até o próximo post. Valeu! 👋📖

 

 

#Delphi #Lazarus

#Programação #TList #Records

#DesenvolvimentoDeSoftware

#BoasPráticas #Desenvolvimento

#GiovaniDaCruz