<h2>Ownership: O Fundamento Invisível do Rust</h2>
<p>Ownership é o sistema de gerenciamento de memória que diferencia Rust de praticamente todas as outras linguagens de programação. Em vez de usar garbage collection (como Python e Java) ou exigir que você gerencie memória manualmente (como C e C++), Rust enforça regras de propriedade em tempo de compilação. Essas regras garantem segurança de memória sem overhead de runtime, resultando em código que é simultaneamente seguro e rápido.</p>
<p>A ideia central é simples: cada valor em Rust tem um único proprietário. Quando o proprietário sai de escopo, o valor é automaticamente liberado. Compreender isso é compreender 80% dos problemas que você enfrentará no Rust. Não se trata apenas de sintaxe — é um novo paradigma de pensamento sobre dados e sua vida útil.</p>
<h2>As Três Regras Imutáveis do Ownership</h2>
<h3>A Regra Fundamental</h3>
<blockquote><p>Cada valor tem exatamente um proprietário por vez. Quando o proprietário sai de escopo, o valor é descartado.</p></blockquote>
<pre><code class="language-rust">fn main() {
let s1 = String::from("hello");
let s2 = s1; // propriedade é MOVIDA de s1 para s2
println!("{}", s1); // ERRO: s1 não é mais válido
println!("{}", s2); // OK: s2 agora é o proprietário
}</code></pre>
<p>Quando você atribui <code>s1</code> a <code>s2</code>, a propriedade se move. Rust invalida <code>s1</code> para garantir que apenas um proprietário exista. Isso é radicalmente diferente de linguagens que copiam valores automaticamente. Tipos simples como números são copiáveis por padrão, mas tipos complexos como <code>String</code> são movidos por padrão.</p>
<h3>Borrowing (Empréstimo)</h3>
<p>Às vezes você precisa usar um valor sem transferir propriedade. Rust permite isso através de referências. Uma referência é um "empréstimo" — você pode emprestar um valor, usá-lo, mas a propriedade permanece com o proprietário original.</p>
<pre><code class="language-rust">fn main() {
let s1 = String::from("hello");
let len = calcular_comprimento(&s1); // passa uma REFERÊNCIA
println!("A string '{}' tem comprimento {}", s1, len);
}
fn calcular_comprimento(s: &String) -> usize {
s.len()
} // s sai de escopo, mas não descarta String porque não é proprietário</code></pre>
<p>Existem dois tipos de referências. <strong>Referências imutáveis</strong> (<code>&T</code>) permitem múltiplos empréstimos simultâneos, mas você não pode modificar o valor. <strong>Referências mutáveis</strong> (<code>&mut T</code>) permitem modificação, mas apenas uma por vez.</p>
<pre><code class="language-rust">fn main() {
let mut s = String::from("hello");
adicionar_mundo(&mut s); // pasa referência mutável
println!("{}", s); // "hello world"
}
fn adicionar_mundo(s: &mut String) {
s.push_str(" world");
}</code></pre>
<h3>A Regra de Empréstimo</h3>
<p>Rust impõe uma regra estrita: você não pode ter referências mutáveis e imutáveis simultaneamente no mesmo escopo. Isso previne data races em tempo de compilação.</p>
<pre><code class="language-rust">let mut s = String::from("hello");
let r1 = &s; // OK: referência imutável
let r2 = &s; // OK: outra referência imutável
let r3 = &mut s; // ERRO: não pode emprestar como mutável enquanto há imutáveis
println!("{}, {}, {}", r1, r2, r3);</code></pre>
<h2>Move Semantics e Cópia de Dados</h2>
<h3>Por que Strings se movem, mas números não?</h3>
<p>Tipos que implementam o trait <code>Copy</code> (como <code>i32</code>, <code>f64</code>, <code>bool</code>) são copiados implicitamente durante atribuição. Tipos que não implementam <code>Copy</code> (como <code>String</code>, <code>Vec</code>) têm seus dados movidos. A razão é performance: copiar um inteiro é trivial, mas copiar uma string gigante na heap é caro.</p>
<pre><code class="language-rust">fn main() {
let x = 5;
let y = x; // cópia implícita
println!("{}, {}", x, y); // OK: ambos válidos
let s1 = String::from("rust");
let s2 = s1; // MOVE: s1 inválido agora
println!("{}", s1); // ERRO
}</code></pre>
<h3>Clone: Cópia Explícita</h3>
<p>Se você realmente precisa copiar dados de um tipo não-Copy, use <code>.clone()</code>:</p>
<pre><code class="language-rust">fn main() {
let s1 = String::from("rust");
let s2 = s1.clone(); // cópia profunda
println!("{}, {}", s1, s2); // OK: ambas válidas
}</code></pre>
<h2>Na Prática: Um Exemplo Real</h2>
<p>Imagine uma função que processa um arquivo. Com ownership explícito, você entende exatamente quem é responsável pelo arquivo:</p>
<pre><code class="language-rust">use std::fs::File;
use std::io::{self, Read};
fn main() -> io::Result<()> {
let mut arquivo = File::open("dados.txt")?;
let conteudo = ler_arquivo(arquivo)?;
println!("{}", conteudo);
Ok(())
}
fn ler_arquivo(mut arquivo: File) -> io::Result<String> {
let mut conteudo = String::new();
arquivo.read_to_string(&mut conteudo)?;
Ok(conteudo)
// arquivo é descartado aqui, fechando o arquivo automaticamente
}</code></pre>
<p>Este código é seguro porque: (1) a função <code>ler_arquivo</code> recebe propriedade do arquivo, (2) sabe que é responsável por limpeza e (3) garante que o arquivo seja fechado. Não há vazamentos de memória, deadlocks ou use-after-free. O compilador verifica tudo.</p>
<h2>Conclusão</h2>
<p>Ownership em Rust resolve o problema clássico da programação: como gerenciar memória segura e eficientemente? Ao enforçar propriedade única e borrowing em tempo de compilação, Rust elimina categorias inteiras de bugs sem sacrificar performance. Os três pontos-chave que você deve internalizar são: (1) <strong>cada valor tem um proprietário</strong>, (2) <strong>você pode emprestar sem transferir propriedade através de referências</strong>, e (3) <strong>as regras de empréstimo previnem data races</strong>. Domine esses conceitos e você dominará Rust.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html" target="_blank" rel="noopener noreferrer">The Rust Book - Understanding Ownership</a></li>
<li><a href="https://doc.rust-lang.org/rust-by-example/scope/move.html" target="_blank" rel="noopener noreferrer">Rust by Example - Ownership</a></li>
<li><a href="https://doc.rust-lang.org/nomicon/safety.html" target="_blank" rel="noopener noreferrer">The Rustonomicon - Memory Safety</a></li>
<li><a href="https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/" target="_blank" rel="noopener noreferrer">Programming Rust: Fast and Safe Systems Development</a></li>
</ul>