Quem é o Responsável por Liberar os Objetos?


Você consideraria um bom design para seu projeto, ter métodos ou funções que criam objetos que serão liberados em outro local, por outro objeto ou função?

Unsplash image Photo by W A T A R I on Unsplash

Em linguagens onde a liberação de memória e recursos é algo manual que depende do desenvolvedor, ter funções ou métodos (vamos nos referir apenas a métodos de agora em diante) que criam novos objetos para que “alguém”, em algum lugar, faça a limpeza da memória é uma má ideia.

Ao longo dos anos tenho visto código como esse:

function TFoo.Build(const Name: string; Value: Integer): TBar;
begin
  Result := TBar.Create;
  Result.Name := Name;
  Result.Value := Value;
end;

Uma classe TFoo que, através do método Build, retorna uma nova instância de TBar sem manter uma referência para o objeto criado.

Acredito que esses tipos de métodos são criados com a intenção de “facilitar” a codificação. Ao invés de criar um objeto TBar e ter que iniciar suas propriedades em muitos lugares no código, cria-se um método que encapsula a criação do objeto sem ter que duplicar o código em outros lugares.

Parece bom?

Eu considero essa abordagem péssima, pois é o início para ocorrer eventuais vazamentos de memória.

A linguagem Object Pascal não obriga o desenvolvedor a armazenar o retorno de um método em alguma variável — assim como Java e C#. Então, se não tivermos uma referência através de um variável, o objeto não seria liberado, gerando um vazamento de memória.

Mas você poderia dizer que não há sentido em criar um objeto e não fazer nada com ele, então o desenvolvedor iria ter uma variável… bem, nem sempre. Mas no caso acima, eu concordo.

Então, digamos que o desenvolvedor armazena o objeto em uma variável.

Infelizmente, isso também não garante que ele irá liberar a memória após seu uso.

OK. Esse não é um problema. Sei que isso é intrínseco ao design da linguagem: O desenvolvedor deve liberar os objetos chamando os destrutores.

No entanto, há uma grande diferença.

Por exemplo: Quando temos objetos que possuem objetos, naturalmente não nos preocupamos quem irá liberar a memória alocada. Sabemos que alguém irá liberá-los. O motivo é simples: não fomos nós que os criamos.

Então, temos uma regra aqui:

Aquele que cria é também o responsável por destruir a instância e/ou liberar o recurso.

Mas, quando utilizamos métodos que retornam objetos, como saber se devemos ou não liberar os recursos manualmente?

Será que o próprio objeto irá fazer o trabalho?

Como o desenvolvedor iria saber?

Só lendo a documentação ou código da classe, o que é um péssimo design de projeto.

Ao voltarmos para o nosso primeiro exemplo, a instância da classe TFoo seria, então, responsável por liberar quaisquer objetos que porventura tenha criado para estar de acordo com a regra acima. O que não é o caso.

O que fazer?

Existe alguma técnica que nos permite criar e retornar novos objetos sem ter de nos preocupar (muito) quem irá liberar a memória?

Sim, contanto que você utilize interfaces ao invés de instâncias de classes. Para esses casos eu proponho a técnica do método estático New.

Até logo.

Posts Relacionados

  • Records - Antiga Nova Tecnologia

  • Builder Classes Simplificado

  • Como Transformar uma Instância de Classe em Instância de Interface

  • Interfaces e Casting

  • Como Trabalhar com Libraries sem Pacotes

  • Free Pascal Macros

  • fpWeb: Verificando Vazamentos de Memória

  • Construindo uma Aplicação Básica com fpWeb

  • Desenvolvimento Web com fpWeb Framework

  • Encapsulamento