Referências e borrowing
O problema do código com tupla da Listagem 4-5 é que precisamos devolver a String para a função que chamou, para podermos continuar usando a String depois da chamada a calculate_length, porque a String foi movida para dentro de calculate_length. Em vez disso, podemos fornecer uma referência ao valor String. Uma referência é como um ponteiro, no sentido de que é um endereço que podemos seguir para acessar os dados armazenados naquele endereço; esses dados pertencem a alguma outra variável. Diferentemente de um ponteiro, uma referência tem a garantia de apontar para um valor válido de um tipo específico durante toda a vida dessa referência.
Aqui está como você definiria e usaria uma função calculate_length que tem uma referência a um objeto como parâmetro, em vez de tomar a posse do valor:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{s1}' is {len}.");
}
fn calculate_length(s: &String) -> usize {
s.len()
}
Primeiro, repare que todo o código com tupla, tanto na declaração da variável quanto no valor de retorno da função, sumiu. Segundo, note que passamos &s1 para calculate_length e, na definição dela, recebemos &String em vez de String. Esses & representam referências, e elas permitem que você se refira a algum valor sem tomar a sua posse. A Figura 4-6 ilustra esse conceito.
Figura 4-6: Um diagrama do &String s apontando para a
String s1
Nota: O oposto de referenciar usando
&é desreferenciar, o que é feito com o operador de desreferência,*. Vamos ver alguns usos do operador de desreferência no Capítulo 8 e discutir os detalhes da desreferência no Capítulo 15.
Vamos examinar mais de perto a chamada de função aqui:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{s1}' is {len}.");
}
fn calculate_length(s: &String) -> usize {
s.len()
}
A sintaxe &s1 nos permite criar uma referência que se refere ao valor de s1, mas não é dona dele. Como a referência não é dona do valor, o valor para o qual ela aponta não será descartado quando a referência deixar de ser usada.
Da mesma forma, a assinatura da função usa & para indicar que o tipo do parâmetro s é uma referência. Vamos acrescentar algumas anotações explicativas:
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{s1}' is {len}.");
}
fn calculate_length(s: &String) -> usize { // s is a reference to a String
s.len()
} // Here, s goes out of scope. But because s does not have ownership of what
// it refers to, the String is not dropped.
O escopo em que a variável s é válida é o mesmo de qualquer parâmetro de função, mas o valor apontado pela referência não é descartado quando s deixa de ser usada, porque s não tem a posse. Quando funções recebem referências como parâmetros em vez dos valores em si, não precisamos devolver os valores para devolver a posse, porque nunca tivemos a posse.
Chamamos a ação de criar uma referência de borrowing (empréstimo). Assim como na vida real: se uma pessoa é dona de algo, você pode pegar esse algo emprestado dela. Quando terminar, precisa devolver. Você não é o dono.
E então, o que acontece se tentarmos modificar algo que estamos tomando emprestado? Experimente o código da Listagem 4-6. Alerta de spoiler: não funciona!
fn main() {
let s = String::from("hello");
change(&s);
}
fn change(some_string: &String) {
some_string.push_str(", world");
}
Aqui está o erro:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
--> src/main.rs:8:5
|
8 | some_string.push_str(", world");
| ^^^^^^^^^^^ `some_string` is a `&` reference, so it cannot be borrowed as mutable
|
help: consider changing this to be a mutable reference
|
7 | fn change(some_string: &mut String) {
| +++
For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
Assim como variáveis são imutáveis por padrão, as referências também são. Não podemos modificar algo para o qual temos uma referência.
Referências mutáveis
Podemos corrigir o código da Listagem 4-6 para permitir modificar um valor emprestado com apenas alguns pequenos ajustes, usando, em vez disso, uma referência mutável:
fn main() {
let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}
Primeiro, mudamos s para ser mut. Depois, criamos uma referência mutável com &mut s no ponto em que chamamos a função change, e atualizamos a assinatura da função para aceitar uma referência mutável com some_string: &mut String. Isso deixa bem claro que a função change vai mutar o valor que ela toma emprestado.
Referências mutáveis têm uma grande restrição: se você tem uma referência mutável para um valor, não pode ter nenhuma outra referência para esse mesmo valor. Este código, que tenta criar duas referências mutáveis para s, vai falhar:
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{r1}, {r2}");
}
Aqui está o erro:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
--> src/main.rs:5:14
|
4 | let r1 = &mut s;
| ------ first mutable borrow occurs here
5 | let r2 = &mut s;
| ^^^^^^ second mutable borrow occurs here
6 |
7 | println!("{r1}, {r2}");
| -- first borrow later used here
For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
Esse erro diz que este código é inválido porque não podemos tomar s emprestado como mutável mais de uma vez ao mesmo tempo. O primeiro empréstimo mutável está em r1 e precisa durar até ser usado no println!, mas, entre a criação dessa referência mutável e o seu uso, tentamos criar outra referência mutável em r2, que toma emprestados os mesmos dados de r1.
A restrição que impede múltiplas referências mutáveis para os mesmos dados ao mesmo tempo permite a mutação, mas de uma maneira bem controlada. É algo com que os novos Rustaceans costumam ter dificuldade, porque a maioria das linguagens deixa você mutar sempre que quiser. A vantagem dessa restrição é que o Rust consegue impedir data races (condições de corrida de dados) em tempo de compilação. Uma data race é parecida com uma condição de corrida (race condition) e acontece quando estes três comportamentos ocorrem:
- Dois ou mais ponteiros acessam os mesmos dados ao mesmo tempo.
- Pelo menos um dos ponteiros está sendo usado para escrever nos dados.
- Não há nenhum mecanismo sendo usado para sincronizar o acesso aos dados.
Data races causam comportamento indefinido e podem ser difíceis de diagnosticar e corrigir quando você tenta rastreá-las em tempo de execução; o Rust evita esse problema recusando-se a compilar código com data races!
Como sempre, podemos usar chaves para criar um novo escopo, o que permite múltiplas referências mutáveis, desde que elas não sejam simultâneas:
fn main() {
let mut s = String::from("hello");
{
let r1 = &mut s;
} // r1 goes out of scope here, so we can make a new reference with no problems.
let r2 = &mut s;
}
O Rust impõe uma regra semelhante para combinar referências mutáveis e imutáveis. Este código resulta em erro:
fn main() {
let mut s = String::from("hello");
let r1 = &s; // no problem
let r2 = &s; // no problem
let r3 = &mut s; // BIG PROBLEM
println!("{r1}, {r2}, and {r3}");
}
Aqui está o erro:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
--> src/main.rs:6:14
|
4 | let r1 = &s; // no problem
| -- immutable borrow occurs here
5 | let r2 = &s; // no problem
6 | let r3 = &mut s; // BIG PROBLEM
| ^^^^^^ mutable borrow occurs here
7 |
8 | println!("{r1}, {r2}, and {r3}");
| -- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
Uf! Também não podemos ter uma referência mutável enquanto temos uma imutável para o mesmo valor.
Quem usa uma referência imutável não espera que o valor mude de repente debaixo dos seus pés! Porém, múltiplas referências imutáveis são permitidas, porque ninguém que apenas lê os dados tem a capacidade de afetar a leitura dos dados feita por outra pessoa.
Repare que o escopo de uma referência começa onde ela é introduzida e continua até a última vez em que essa referência é usada. Por exemplo, este código compila porque o último uso das referências imutáveis está no println!, antes de a referência mutável ser introduzida:
fn main() {
let mut s = String::from("hello");
let r1 = &s; // no problem
let r2 = &s; // no problem
println!("{r1} and {r2}");
// Variables r1 and r2 will not be used after this point.
let r3 = &mut s; // no problem
println!("{r3}");
}
Os escopos das referências imutáveis r1 e r2 terminam depois do println! onde elas são usadas pela última vez, que fica antes de a referência mutável r3 ser criada. Esses escopos não se sobrepõem, então este código é permitido: o compilador consegue perceber que a referência não está mais sendo usada em um ponto anterior ao fim do escopo.
Mesmo que os erros de empréstimo às vezes sejam frustrantes, lembre-se de que é o compilador do Rust apontando um possível bug cedo (em tempo de compilação, e não em tempo de execução) e mostrando exatamente onde está o problema. Assim, você não precisa rastrear por que os seus dados não são o que você achava que fossem.
Referências pendentes
Em linguagens com ponteiros, é fácil criar por engano um ponteiro pendurado (dangling pointer): um ponteiro que referencia uma posição de memória que pode ter sido entregue a outra pessoa, ao liberar um pedaço de memória enquanto se mantém um ponteiro para ele. No Rust, por outro lado, o compilador garante que as referências nunca serão pendentes: se você tem uma referência a algum dado, o compilador garante que o dado não sairá de escopo antes da referência.
Vamos tentar criar uma referência pendente para ver como o Rust as impede com um erro em tempo de compilação:
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String {
let s = String::from("hello");
&s
}
Aqui está o erro:
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
--> src/main.rs:5:16
|
5 | fn dangle() -> &String {
| ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
|
5 | fn dangle() -> &'static String {
| +++++++
help: instead, you are more likely to want to return an owned value
|
5 - fn dangle() -> &String {
5 + fn dangle() -> String {
|
For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error
Essa mensagem de erro se refere a um recurso que ainda não abordamos: os lifetimes. Vamos discutir lifetimes em detalhes no Capítulo 10. Mas, se você desconsiderar as partes sobre lifetimes, a mensagem contém a chave para entender por que este código é um problema:
this function's return type contains a borrowed value, but there is no value
for it to be borrowed from
Vamos olhar mais de perto o que acontece em cada etapa do nosso código dangle:
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String { // dangle returns a reference to a String
let s = String::from("hello"); // s is a new String
&s // we return a reference to the String, s
} // Here, s goes out of scope and is dropped, so its memory goes away.
// Danger!
Como s é criada dentro de dangle, quando o código de dangle termina, s será desalocada. Mas tentamos retornar uma referência a ela. Isso significaria que a referência apontaria para uma String inválida. Isso não pode acontecer! O Rust não nos deixa fazer isso.
A solução aqui é retornar a String diretamente:
fn main() {
let string = no_dangle();
}
fn no_dangle() -> String {
let s = String::from("hello");
s
}
Isso funciona sem nenhum problema. A posse é transferida para fora, e nada é desalocado.
As regras das referências
Vamos recapitular o que discutimos sobre referências:
- Em qualquer momento, você pode ter ou uma referência mutável ou qualquer número de referências imutáveis.
- As referências devem ser sempre válidas.
A seguir, veremos outro tipo de referência: as slices.