Spec Sistemas Com Rust • Trilha Progressiva em 4 Níveis

🎯 Nível 1: Fundamentos

Problema 19.1 — Bloco unsafe e Desreferenciação de Raw Pointers (*const T, *mut T)

Contexto: Bloco unsafe e Desreferenciação de Raw Pointers (*const T, *mut T) no contexto de Unsafe Rust, Ponteiros Brutos e FFI (C Interop).

Requisitos de Execução:

  1. Criar ponteiros brutos a partir de referências e desreferenciar dentro de bloco unsafe.

Resultado Esperado

Ponteiro bruto desreferenciado com segurança dentro de bloco unsafe delimitado.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_19_1_SeuNome
  2. Envie na tarefa: Atividade Cap 19 - Unsafe Rust, Ponteiros Brutos e FFI (C Interop)
🔑 Gabarito de Código & Solução Comentada 
// unsafe_raw_pointers.rs
fn main() {
    let mut valor = 42;
    let r1 = &valor as *const i32;
    let r2 = &mut valor as *mut i32;

    unsafe {
        *r2 += 10;
        println!("Valor lido via raw pointer: {}", *r1);
    }
}

🔍 Nível 2: Prática

Problema 19.2 — Chamada de Funções da Biblioteca C (libc) com extern ‘C’

Contexto: Chamada de Funções da Biblioteca C (libc) com extern ‘C’ no contexto de Unsafe Rust, Ponteiros Brutos e FFI (C Interop).

Requisitos de Execução:

  1. Declarar assinatura externa extern 'C' { fn abs(i: i32) -> i32; } e invocar a função C nativa.

Resultado Esperado

Função C nativa da libc invocada com sucesso via FFI.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_19_2_SeuNome
  2. Envie na tarefa: Atividade Cap 19 - Unsafe Rust, Ponteiros Brutos e FFI (C Interop)
🔑 Gabarito de Código & Solução Comentada 
// ffi_libc.rs
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    let negativo = -100;
    let absoluto = unsafe { abs(negativo) };
    println!("abs({}) = {}", negativo, absoluto);
}

⚡ Nível 3: Integração

Problema 19.3 — Encapsulamento Seguro (Safe Wrapper) de Código Unsafe

Contexto: Encapsulamento Seguro (Safe Wrapper) de Código Unsafe no contexto de Unsafe Rust, Ponteiros Brutos e FFI (C Interop).

Requisitos de Execução:

  1. Criar abstração segura em torno de ponteiros brutos garantindo invariantes de memória no tipo público.

Resultado Esperado

Abstração segura fornecida sem expor complexidade unsafe ao consumidor.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_19_3_SeuNome
  2. Envie na tarefa: Atividade Cap 19 - Unsafe Rust, Ponteiros Brutos e FFI (C Interop)
🔑 Gabarito de Código & Solução Comentada 
// safe_wrapper.rs
pub struct BufferSeguro { ptr: *mut u8, len: usize }

impl BufferSeguro {
    pub fn new(len: usize) -> Self {
        let mut layout = vec![0u8; len];
        let ptr = layout.as_mut_ptr();
        std::mem::forget(layout);
        Self { ptr, len }
    }
}

fn main() {
    let _b = BufferSeguro::new(64);
    println!("Buffer seguro instanciado.");
}

🏆 Nível 4: Desafio Corporativo

Problema 19.4 — Exportação de Funções Rust para C com #[no_mangle]

Contexto: Exportação de Funções Rust para C com #[no_mangle] no contexto de Unsafe Rust, Ponteiros Brutos e FFI (C Interop).

Requisitos de Execução:

  1. Criar função Rust exportada para shared library (.so / .dll) consumível por programas C/Python.

Resultado Esperado

Função Rust com convenção C ABI e sem mangle de símbolos exportada.

📤 Instruções de Entrega (Microsoft Teams)

  1. Salve o arquivo como: Atividade_19_4_SeuNome
  2. Envie na tarefa: Atividade Cap 19 - Unsafe Rust, Ponteiros Brutos e FFI (C Interop)
🔑 Gabarito de Código & Solução Comentada 
// export_ffi.rs
#[no_mangle]
pub extern "C" fn calcular_soma_rust(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let res = calcular_soma_rust(15, 35);
    println!("Soma C ABI: {}", res);
}