Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

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:

Nome do arquivo: src/main.rs
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.

Três tabelas: a tabela de s contém apenas um ponteiro para a tabela de
s1. A tabela de s1 contém os dados de s1 na stack e aponta para os dados da string
no heap.

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!

Nome do arquivo: src/main.rs
fn main() {
    let s = String::from("hello");

    change(&s);
}

fn change(some_string: &String) {
    some_string.push_str(", world");
}
Listagem 4-6: Tentando modificar um valor emprestado

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:

Nome do arquivo: src/main.rs
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:

Nome do arquivo: src/main.rs
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:

Nome do arquivo: src/main.rs
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:

Nome do arquivo: src/main.rs
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.