Post: [Generics] Listas genéricas – TStack

Alessandro Medeiros

Fala ai Radizeiros e Radizeiras, tudo bem com vocês?

Essa nossa série de post aqui no blog falando sobre generics tem sido fantástica.

Eu tenho curtido muito e sei que tem sido bem proveitoso para cada um de vocês.

Estamos conhecendo os quatros tipos de lista dentro de generics.

E no post de hoje estarei falando da TStack, que é representado através de pilhas.

Falamos sobre a lista, usando o TList, falamos da fila, usando o TQueue, e agora estamos vendo as pilhas, com o TStack.

Com toda certeza você já quebrou a cabeça na faculdade para criar uma pilha, nas suas aulas de lógica de programação, para fazer pilha, fila, e tudo mais.

E olha que maravilhoso, o Delphi já entrega isso prontinho.

Vamos ver?

Como já é de costume aqui dentro do post, já possuo um exemplo prontinho para falar sobre as pilhas.

Mas o que é pilha?

Observe que na imagem acima, tenho uma pilha de livros.

Então como que funciona a pilha? 

Todas as vezes que é insiro um registro na pilha, ele vai para o topo da pilha, e quando eu for retirar, estarei retirando sempre o item do topo da pilha, e o primeiro a entrar será o último a sair, seguindo a lógica de pilhas.

Desta forma quando quiser desmontar uma pilha, se eu começar de baixo irá cair tudo não é? Então o que eu faço é pegar o primeiro da pilha e retirá-lo.

Exatamente é esse o conceito de pilha, dentro da lógica de programação, onde o último a entrar é o primeiro a sair.

Do contrário da fila, que o primeiro a entrar é o primeiro a sair.

Vamos ver dentro do Delphi como podemos fazer isso?

Para criarmos nossa pilha é preciso instanciar no Delphi, então como fizemos nos demais posts, iremos no private do formulário e adicionamos uma variável do tipo genérico TStack, que irá receber um atributo genérico do tipo primitivo String.

private
{ Private declarations }
Pilha : TStack<String>;

Como estamos tratando de um objeto genérico, podemos passar para ele qualquer coisa, seja Inteiro, Float, Boolean, TForm, e por aí vai.

Você que acompanha nossa série de generics já deve está acostumado com os objetos genéricos.

Para que possamos trabalhar com a pilha é necessário instanciar.

Dentro do create do formulário, iremos instanciar o nosso objeto para que ao executar o exemplo a pilha já esteja instanciada, e aí teremos acessos ao seus métodos.

procedure TForm1.FormCreate(Sender: TObject);
begin
Pilha := TStack<String>.Create;
end;

A partir desse momento podemos fazer o que quisermos com essa nossa pilha.

Agora se você observar a imagem do nosso exemplo, temos alguns métodos.

Por exemplo, temos o método de Push, dentro desse botão podemos observar o método dentro dele implementado.

procedure TForm1.Button1Click(Sender: TObject);
begin
Pilha.Push(Edit1.Text);
end;

Esse método adiciona um registro na pilha.

Todas as vezes que quiser adicionar um registro dentro dessa pilha, eu chamo esse método passando o valor e pronto, agora esse registro já está dentro da pilha.

Agora o Pop, não é daquela música dos Engenheiros do Hawaii, “O Papa É Pop”…rsrs

Esse método é usado para retirar o primeiro registro da fila.

A pilha semelhante a fila, não temos com varrer ela usando index, igual vimos no post anterior sobre TList.

Com a Pilha, podemos saber qual é o próximo, onde já temos um método que já nos informa qual é.

Então preciso saber qual é o próximo que preciso remover, então chamo o método Peek, onde esse método irá me retornar qual é o próximo da pilha.

procedure TForm1.Button4Click(Sender: TObject);
begin
Memo1.Lines.Add(Pilha.Peek);
end;

Muito simples não né?

Vamos rodar o exemplo.

Viu como adicionei o Thulio na pilha usando o Push, e ao chamar o Peek, é mostrado quem é o próximo da pilha, ou seja, quem está no topo da pilha, que será o próximo a sair, que é o Thulio.

Agora se eu adicionar um próximo registro, por exemplo o João, e o próximo a sair será o João, lembra o conceito de pilha, que o último a entrar é o primeiro a sair?

Ao clicar no Peek é retornado o João, e nesse caso ao clicar no Pop, ele remove o João, e agora o próximo da fila passa a se o Thulio.

Viu como é simples, um conceito muito fácil de se entender e poder trabalhar com as pilhas.

A pilha possui alguns métodos semelhantes a fila.

Por exemplo o Extract, que faz a mesma coisa do Pop, o TrimExcess, que reduz a capacidade, deixando no tamanho real de objetos dentro da pilha.

Todas as vezes que adicionando objetos dentro da Pilha, ele vai reservando espaço na memória para mais registros, é aí que entra o TrimExcess.

Observe que executei o TrimExcess e logo em seguida executei o Pop para retirar o Thulio da pilha, e ao executar o Count pode ser visto que não tenho ninguém mais na Pilha.

Quando eu adiciono mais registros na pilha minha capacidade vai aumentando, como pode ser visto no exemplo logo abaixo.

Com o Capacity podemos ver qual é a capacidade de registros reservados para que possamos usar na pilha.

Tenho dois registro e uma capacidade para 5 registros, ao adicionar mais 5 registros eu fiquei com 7 registros, e com uma capacidade de 9 registros.

Agora ao remover esses 7 registros, não teremos mais nada na pilha, mas essa pilha ainda permanece com 9.

Para que possamos limpar esses espaços que ficaram na memória, você que tem acompanhado a série de generics deve lembrar, eu uso o método TrimExcess.

Como foi dito anteriormente, esse método limpa os registros reservados na memória, deixando com a capacidade real da pilha.

Agora eu tenho 0 de quantidade e 0 de capacidade.

Observe os códigos de TrimExcess, Count e Capacity, como é muito simples suas implementações.

procedure TForm1.Button5Click(Sender: TObject);
begin
Pilha.TrimExcess;
end;

procedure TForm1.Button6Click(Sender: TObject);
begin
Memo1.Lines.Add(Pilha.Count.ToString);
end;

procedure TForm1.Button7Click(Sender: TObject);
begin
Memo1.Lines.Add(Pilha.Capacity.ToString);
end;

Ambos os códigos de Count e Capacity me retorna um inteiro, por este motivo foi passado o ToString para que esses valores fossem repassados como String, pois o Memo está esperando um valor String.

Viu como a implementação, e claro, a utilização das Pilhas é muito simples?

Usando pilhas, listas, filas, e muitas outras funcionalidades que os generics nos proporciona, irá reduzir muitas linhas de códigos.

Agora se você conhece alguém que está se matando para implementar pilhas e filas, e escrevendo diversas linhas de códigos, apresenta para ele essa série e salva-o dessa mar de de linhas intermináveis de códigos, e mergulhe nesse oceano de generics.

Eu tenho certeza que assim como você que está navegando nessa oceano, outros poderão navegar também, saindo do sufoco que tem passado, nadando e não saindo da praia.

E caso você tenha interesse de conhecer mais sobre generics acessa o nosso portal do CLUBE DE PROGRAMADORES EM DELPHI, onde você não só terá conteúdos relacionados aos generics, mas uma quantidade enorme de conteúdos que poderá lhe ajudar muito no seu dia a dia, é uma verdadeira NETFLIX para os programadores Delphi.

CLIQUE AQUI E SAIBA MAIS SOBRE O CLUBE DOS PROGRAMADORES DELPHI




Faça sua busca

CATEGORIAS

POSTS RECENTES

E caso você tem interesse de conhecer mais sobre [Generics] Listas genéricas – TStack, acesse o nosso portal do CLUBE DE PROGRAMADORES EM DELPHI
Você não terá só conteúdos relacionados ao [Generics] Listas genéricas – TStack, mas uma quantidade enorme de conteúdos que poderá lhe ajudar muito no seu dia a dia, é uma verdadeira NETFLIX para os programadores Delphi.
Gostou?
Compartilhe:

Embarque no foguete com milhares de devs para aprender desenvolvimento, evoluir de forma contínua e se manter relevante no mercado.

Sobre
Dúvidas
Cadastre-se em nossa lista

Para ter acesso em primeira mão, a tudo que acontece na Academia do Código, basta se cadastrar em nossa lista

Grupo Thulio Bittencourt | Academia do Código

#FaçaPartedaHistória

Copyright © 2022 – Todos os direitos reservados