Aprendendo Rust: 07 - Regiões da memória usadas pela Rust
Tags: rust, tutorial
Published: 2020-08-14 10:45:51

E aee jovens, tudo bem com vocês?

Para conseguirmos entender como funciona uma das principais características da linguagem _Rust_ o _ownership_, precisamos entender como _Rust_ utiliza a memória do computador.

Esta postagem não terá exemplo prático, iremos entender um pouco sobre as regiões da memória onde os dados são armazenados.

Então, lets'go!!!

## Data Memory (Memória de dados)

_Data memory_ é onde são salvos os dados com tamanho fixo e estático, são os dados que sempre estarão disponíveis para utilizarmos durante a vida útil do programa. Por exemplo um texto, os dados são somente lidos nunca escritos, então eles são colocados nesta região. Esses dados são sempre muito rápidos para utilizarmos, pois o compilador consegue realizar muitas otimizações.

## Stack Memory (Memória de pilha)

A _stack memory_ armazena os dados em forma de pilha, ou seja, armazena os dados na ordem que eles chegam e os remove na ordem inversa, também conhecido como _lifo (last in, first out)_ ultimo a chegar, primeiro a sair.
Como padrão dizemos _fazer um push_ quando estamos inserindo um dado na pilha e _fazer um pop_ quando estamos removendo.

Ela é mais rápida do que a _heap memory_ pois ela não precisa procurar um lugar pra adicionar um dado, ou procurar onde está algum dado pois sempre será retirado o ultimo dado que foi inserido. E todos os dados que ela tem deve ter um tamanho fixo e conhecido tornando ela mais rápida.

As variáveis primitivas são um exemplo de dados salvos na _stack memory_.

## Heap Memory

A _heap memory_ é um pouco mais complexa, e diferentemente da _stack memory_ os dados são adicionados com um tamanho desconhecido em tempo de compilação, ou com um tamanho dinâmico. Quando estamos adicionando dados nessa região chamamos de _alocação_ e quando estamos removendo de _desalocação_.

Quando estamos alocando na _heap memory_, o sistema operacional encontrará um espaço vazio que seja grande o suficiente, marcará este espaço como _"em uso"_ e nos retorna um _ponteiro_ com o endereço deste local. Este ponteiro fica armazenado na _stack memory_, e se quisermos buscar o dado que esteja na _heap memory_ devemos seguir este ponteiro.

Acessar os dados na _heap memory_ é mais lento do que na _stack memory_ pois os dados não ficam de uma forma organizada, e é necessário seguir um ponteiro pra chegar onde eles estão.

"Rastrear quais partes do código estão usando quais dados na _heap_, minimizar a quantidade de dados duplicados na _heap_ e limpar segmentos inutilizados da _heap_ para que não fiquemos sem espaço são todos problemas tratados pelo _ownership_. Uma vez que você entende _ownership_, você não vai mais precisar pensar tanto sobre a _stack_ e a _heap_, mas saber que _ownership_ existe para gerenciar os dados na _heap_ pode ajudar a explicar como e por que ele funciona." (Trecho retirado do [book](https://doc.rust-lang.org/book/)).

Na próxima postagem veremos como funciona o _Ownership_.

O fonte das postagens estão no _Github_, segue o link: [Aprendendo Rust](https://github.com/RichardJd/aprendendo-rust)

Quaisquer dúvidas ou sugestões para que eu melhore nas postagens deixe um comentário, e continue acompanhando os próximos posts.

# Referencias

[O livro de Rust](https://doc.rust-lang.org/book/)

[Tour of Rust](https://tourofrust.com/)

[CodeShow](https://www.twitch.tv/codeshow)