Todos os programas têm que decidir de que forma vão utilizar a memória do computador durante sua execução.
Existe linguagens que abordam o garbage collection (coleta de lixo) que simplesmente buscam espaço em memória que não estão em uso naquele momento.
Outra abordagem em outras linguagens é que, o programador deve alocar o espaço em memória e liberar.
No Rust usa uma abordagem diferente que é memória gerenciada através de um sistema de posse que contém um conjunto de regras que isso é verificado em tempo de compilação.
Regras de Owneship
- Cada valor em Rust possui uma variável que é dita seu owner (sua dona).
- Pode apenas haver um owner por vez.
- Quando o owner sai fora de escopo, o valor será destruído.
Para que possamos ilustrar o conjunto de regras precisamos de um tipo de dados que seja complexo abordagem porque esses dados são armazenados na pilha e assim retirada quando o escopo acaba.
Vamos para o exemplo.
fn main() {
let x = String::from("Higor Diego");
println!("{}", x);
}
/*
Higor Diego
*/
Em post anteriores vimos string literais onde o valor da string é fixado elas são convenientes mas se adequam em situação que queremos textos em nossos programas. Uma das característica delas que são imutáveis.
No exemplo usamos o String::From o :: é um operador que nos permiti indicar o namespace da função from que se caracteriza como uma string.
Vamos para o exemplo abaixo.
fn main() {
let mut x = String::from("Higor Diego");
x.push_str(" é o meu nome");
println!("{}", x);
}
/*
Higor Diego é o meu nome
*/
Fica uma pergunta no ar, porque as String podem ser alterada e as literais não? O detalhe disso é como eles lidam com a memória.
Quando uma String literal é declarada já está explícito o conteúdo com isso injetado no software assim fazendo elas serem rápidas.
Segue o exemplo.
{
let x = String::from("escopo");
}
No exemplo acima temos um escopo que é declarado pela chaves dentro dele temos uma variável x que é uma string após o fechamento da chaves a variável não é mais valida pois o escopo fechou.
No Rust quando a variável sai do escopo automaticamente chamamos uma função especial chamada drop. Parece simples mas quando temos múltiplas variáveis como seria ?
Segue o exemplo.
fn main() {
let number_1 = 10;
let number_2 = number_1;
}
No caso acima temos uma variável chamada number_1 que recebe um valor de 10 e temos number_2 que associada a variável anterior. Temos duas variáveis com o mesmo valor isso acontece porque números possuem um tamanho fixo.
No caso de uma String como seria ?
fn main() {
let n_1 = String::from("higor");
let n_2 = n_1;
println!("{}", n_1);
}
/*
--> main.rs:27:20
|
25 | let n_2 = n_1;
| --- value moved here
26 |
27 | println!("{}", n_1)
| ^^^ value used here after move
|
= note: move occurs because `n_1` has type `std::string::String`, which does not implement the `Copy` trait
error: aborting due to previous error
*/
Se analisar o exemplo anterior com esse, seria basicamente a mesma coisa só que existe uma diferença, porque estamos falando de "cópia rasa" e "copia profunda".
O Rust nesse exemplo está invalidando a primeira variável no lugar de chamar a "copia rasa" isso é conhecido como move. Após a locação da variável para n_2 com n_1 o Rust libera o espaço de valor da n_1 em memória e a loca n_2 no seu lugar assim invalidando a variável n_1.
Para resolução vamos utilizar uma função chamada clone() que no caso seria uma copia profunda da variável declarada.
Segue o exemplo.
fn main() {
let n_1 = String::from("higor");
let n_2 = n_1.clone();
println!("n_1: {}, n_2: {}", n_1, n_2);
}
/*
n_1: higor, n_2: higor
*/
Vamos testar o mesmo conceito com funções.
fn main() {
let x1 = retorna_string();
let x2 = x1;
println!("x1: {}, x2: {}", x1, x2);
}
fn retorna_string() -> String {
return String::from("olá");
}
/*
--> main.rs:4:30
|
3 | let x2 = x1;
| -- value moved here
4 | println!("x1: {}, x2: {}", x1, x2);
| ^^ value used here after move
|
= note: move occurs because `x1` has type `std::string::String`, which does not implement the `Copy` trait
error: aborting due to previous error
*/
Ahhhhh, mas está fácil. Para que possa corrigir só usar o clone().
Segue o exemplo.
fn main() {
let x1 = retorna_string();
let x2 = x1.clone();
println!("x1: {}, x2: {}", x1, x2);
}
fn retorna_string() -> String {
return String::from("olá");
}
*/
x1: olá, x2: olá
*/
Então galera é isso, espero que tenham gostado até a próxima.
Top comments (0)