Learn Rust Coding · Aula

Interação com Rust Não Seguro

Compreenda quando e como utilizar blocos `unsafe` para contornar as verificações de segurança do Rust, permitindo FFI e operações de baixo nível na memória.

Interação com Rust Não Seguro é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 3 aulas no total.

Rust inseguro: uma introdução

Boas-vindas ao Rust inseguro! Embora o Rust seja famoso pelas suas garantias de segurança de memória, há situações específicas em que pode ser necessário ignorar algumas dessas verificações.

A palavra-chave unsafe no Rust permite fazer exatamente isso. Ela não é uma forma de escrever código “ruim”, mas uma ferramenta para casos de uso avançados nos quais você precisa de controle mais direto sobre a memória ou o hardware.

Os cinco superpoderes do código inseguro

Ao usar um bloco unsafe, você obtém acesso a cinco ações especiais que o compilador do Rust normalmente impede:

Desreferenciar ponteiros brutos: acessar diretamente endereços de memória.
Chamar funções ou métodos unsafe: executar funções com pré-condições que o compilador não consegue verificar.
Implementar traços unsafe: declarar que o seu tipo mantém invariantes específicos.
Acessar ou modificar variáveis estáticas mutáveis: compartilhar estado mutável globalmente, com risco de condições de corrida.
Acessar campos de unions: ler uma união, que pode ter um tipo inválido para os dados atuais.

Desreferenciando ponteiros brutos

Ponteiros brutos são endereços de memória sem as garantias usuais de segurança do Rust. Você pode criá-los a partir de referências (&T, &mut T), mas desreferenciá-los exige um bloco unsafe.

Isso significa que você, como programador, é responsável por garantir que o ponteiro seja válido e aponte para memória alocada.

fn main() {
  let mut num = 5;
  let r1 = &num as *const i32; // Immutable raw pointer
  let r2 = &mut num as *mut i32; // Mutable raw pointer

  unsafe { // The `unsafe` block starts here
    println!("r1 points to: {}", *r1);
    *r2 = 10; // Modify data through mutable raw pointer
    println!("r2 points to: {}", *r2);
  } // The `unsafe` block ends here

  println!("Num is now: {}", num);
}

Chamando funções inseguras

Algumas funções são marcadas como unsafe fn. Isso significa que a função tem pré-condições que o compilador do Rust não consegue garantir. Por exemplo, uma função pode exigir um endereço de memória válido, mas não conseguir verificá-lo.

As chamadas a essas funções devem ser envolvidas em um bloco unsafe, indicando que você, como chamador, garante que todas as pré-condições foram atendidas.

unsafe fn dangerous_operation() {
  println!("This operation could be dangerous if preconditions aren't met!");
}

fn main() {
  println!("Attempting a dangerous operation...");
  unsafe { // Calling an unsafe function requires `unsafe`
    dangerous_operation();
  }
  println!("Operation completed.");
}

Variáveis estáticas mutáveis

Por padrão, o Rust impede o estado mutável global para evitar condições de corrida. No entanto, você pode declarar variáveis estáticas mutáveis usando static mut.

Acessar ou modificar essas variáveis é considerado unsafe, pois várias threads podem tentar acessá-las simultaneamente, causando comportamento indefinido. A sincronização adequada é de sua responsabilidade.

static mut COUNTER: i32 = 0; // A mutable static variable

fn add_to_counter(inc: i32) {
  unsafe { // Modifying `static mut` requires `unsafe`
    COUNTER += inc;
  }
}

fn main() {
  add_to_counter(5);
  unsafe { // Reading `static mut` also requires `unsafe`
    println!("COUNTER after first add: {}", COUNTER);
  }

  add_to_counter(10);
  unsafe {
    println!("COUNTER after second add: {}", COUNTER);
  }
}

Implementando traços inseguros

Alguns traços no Rust são marcados como unsafe trait. Isso indica que implementá-los exige manter determinados invariantes que o compilador não consegue verificar.

Um exemplo comum são os traços Send e Sync, relacionados à segurança de threads. Se você implementar manualmente um unsafe trait, deverá usar unsafe impl Trait for Type e garantir suas propriedades de segurança.

Para a maioria dos iniciantes, isso aparece com menos frequência, pois o Rust geralmente cuida dessas implementações automaticamente ou por meio de abstrações seguras.

Acessando campos de uniões

Uma union é um tipo especial que pode armazenar o valor de *uma* de suas variantes a qualquer momento, mas todas as variantes compartilham o mesmo local de memória. Ela é semelhante às uniões da linguagem C.

Acessar um campo de uma union exige um bloco unsafe, pois o compilador não consegue saber qual campo está ativo no momento. Ler um campo inativo pode causar comportamento indefinido ou interpretação incorreta dos dados.

union Data {
  integer: u32,
  float: f32,
}

fn main() {
  let mut d = Data { integer: 42 }; // Initialize with an integer

  unsafe {
    // Accessing 'integer' is safe here
    println!("Integer value: {}", d.integer);

    // Accessing 'float' is unsafe, as 'integer' was initialized.
    // This would interpret the integer's bits as a float.
    // println!("Float value (unsafe): {}", d.float);
  }

  d.float = 3.14; // Now initialize with a float
  unsafe {
    // Accessing 'float' is safe now
    println!("Float value: {}", d.float);
  }
}

Cenários práticos de uso de código inseguro

Embora unsafe deva ser usado com moderação, ele é essencial para várias tarefas avançadas de programação:

Interface de funções estrangeiras (FFI): interagir com código escrito em outras linguagens (como bibliotecas C/C++).
Otimizações de desempenho: às vezes, ignorar as verificações do Rust pode gerar pequenos ganhos de desempenho em seções críticas (mas meça primeiro!).
Programação de sistemas de baixo nível: escrever sistemas operacionais, controladores de dispositivos ou sistemas embarcados.
Construção de abstrações seguras: implementar estruturas de dados ou APIs seguras sobre primitivas inseguras (por exemplo, como Vec é construído).

Sua responsabilidade ao usar código inseguro

Ao usar unsafe, você assume a responsabilidade de manter manualmente as garantias de segurança do Rust. Isso significa:

Garantir que a memória seja válida e esteja corretamente alinhada.
Evitar condições de corrida ao lidar com estado mutável compartilhado.
Evitar ponteiros pendentes ou erros de uso após liberação.
Garantir que todas as pré-condições das funções sejam atendidas.

O uso incorreto de unsafe pode causar comportamento indefinido, que é o pior tipo de erro e pode ser muito difícil de depurar.

Verificação de conhecimentos sobre código inseguro

Qual das ações a seguir exige um bloco unsafe no Rust?

Recapitulação: Rust inseguro

Você aprendeu sobre o Rust inseguro, um recurso poderoso que permite ignorar algumas verificações de segurança em tempo de compilação do Rust para situações específicas e avançadas.

Lembre-se de que unsafe não desativa completamente o verificador de empréstimos, mas transfere inteiramente para você, o programador, a responsabilidade pela segurança da memória e pelos invariantes. Use-o com critério e extrema cautela, normalmente para FFI, otimizações de baixo nível ou construção de abstrações seguras.

Perguntas Frequentes

A aula “Interação com Rust Não Seguro” é grátis?

Sim — o texto completo de “Interação com Rust Não Seguro” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 3 aulas no total.

O que vou aprender em “Interação com Rust Não Seguro”?

Compreenda quando e como utilizar blocos `unsafe` para contornar as verificações de segurança do Rust, permitindo FFI e operações de baixo nível na memória. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 3.

Quanto tempo leva a aula “Interação com Rust Não Seguro”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding