Interface de Funções Estrangeiras (FFI)
Aprenda a chamar bibliotecas C a partir de Rust e a disponibilizar funções Rust para outras linguagens utilizando FFI para garantir interoperabilidade.
Interface de Funções Estrangeiras (FFI) é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 1 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.
O que é FFI?
FFI significa Interface de funções estrangeiras. É uma forma de permitir que programas escritos em uma linguagem de programação chamem funções ou usem estruturas de dados definidas em outra linguagem.
No Rust, a FFI permite interagir com código escrito em outras linguagens, mais frequentemente C. Isso é muito útil para integrar bibliotecas existentes ou APIs do sistema.
Por que usar FFI?
A FFI não é uma ferramenta usada todos os dias, mas é poderosa quando você precisa de:
- Aproveitar bibliotecas C existentes: muitas bibliotecas maduras e de alto desempenho são escritas em C/C++. A FFI permite que o Rust as use diretamente.
- APIs do sistema: interagir com recursos do sistema operacional que talvez tenham apenas interfaces C.
- Interoperabilidade: criar uma biblioteca Rust que possa ser chamada por outras linguagens (como Python, Java ou JavaScript por meio do Node.js).
Chamando C a partir do Rust: declaração
Para chamar uma função C a partir do Rust, primeiro você precisa declarar sua assinatura usando um bloco extern "C". Isso informa ao Rust como é a função C sem fornecer sua implementação.
A parte "C" especifica a convenção de chamada de C, garantindo que as chamadas de função sejam compatíveis.
extern "C" {
// Declare C functions here
// Example: int puts(const char *s);
fn puts(s: *const std::os::raw::c_char) -> std::os::raw::c_int;
// Example: int add(int a, int b);
fn add(a: std::os::raw::c_int, b: std::os::raw::c_int) -> std::os::raw::c_int;
}Chamando C a partir do Rust: o bloco `unsafe`
A principal promessa do Rust é a segurança da memória. No entanto, ao interagir com código C por meio de FFI, o Rust não consegue garantir a segurança do código estrangeiro.
Por isso, qualquer chamada a uma função C declarada em um bloco extern "C" deve ser envolvida em um bloco unsafe. Isso sinaliza ao compilador e a outros desenvolvedores que você é responsável por manter as garantias de segurança.
extern "C" {
// We're declaring that a C function `puts` exists.
fn puts(s: *const std::os::raw::c_char) -> std::os::raw::c_int;
}
fn main() {
let rust_string = "Hello from Rust via C!";
// C strings need to be null-terminated.
let c_string = std::ffi::CString::new(rust_string).expect("CString failed");
unsafe {
// Calling the C 'puts' function. This requires 'unsafe'.
puts(c_string.as_ptr());
}
println!("C function call demonstrated.");
}Mapeamento de tipos: Rust para C
Ao usar FFI, você deve garantir que os tipos do Rust sejam mapeados corretamente para os tipos C. O Rust fornece tipos específicos em std::os::raw e std::ffi para essa finalidade.
i32->std::os::raw::c_intf32->std::os::raw::c_floatbool->std::os::raw::c_uchar(ou semelhante; C não tem um booleano padrão)&str->*const std::os::raw::c_char(as cadeias de caracteres C precisam terminar com nulo, algo geralmente gerenciado porstd::ffi::CString)&mut [T]->*mut T
Use sempre esses tipos C explícitos para evitar comportamento indefinido.
Exemplo: chamando uma função C `add`
Imagine que temos uma biblioteca C com uma função int add(int a, int b);. Veja como a chamaríamos a partir do Rust. Observe o uso de c_int para tipos inteiros.
(Este código demonstra a sintaxe de FFI, mas não será executado sem uma biblioteca C compilada e vinculada externamente.)
extern "C" {
// Declaration of the C function `add`
fn add(a: std::os::raw::c_int, b: std::os::raw::c_int) -> std::os::raw::c_int;
}
fn main() {
let x = 10;
let y = 20;
let result = unsafe {
// Call the C 'add' function within an unsafe block
add(x as std::os::raw::c_int, y as std::os::raw::c_int)
};
println!("Attempted to call C add. Result (if linked): {}", result);
}Expondo o Rust para C: conceitos básicos
Para tornar uma função Rust chamável a partir de C, você precisa de duas coisas:
#[no_mangle]: este atributo impede que o compilador do Rust faça o “emaranhamento” (alteração) do nome da função. Os compiladores C esperam nomes simples e não alterados.extern "C": isso especifica que a função deve usar a convenção de chamada de C, tornando-a compatível com C.
Exemplo: função Rust para C
Esta é uma função Rust que calcula uma soma e poderia ser chamada por um programa C. Observe os atributos #[no_mangle] e extern "C".
(Este código foi projetado para ser compilado como uma biblioteca para C, mas inclui um main para testes internos neste ambiente.)
#[no_mangle]
pub extern "C" fn rust_add_and_print(
a: std::os::raw::c_int,
b: std::os::raw::c_int
) -> std::os::raw::c_int {
let sum = a + b;
println!("Rust function received: {} + {} = {}", a, b, sum);
sum
}
fn main() {
println!("This Rust code exposes a function for C.");
// We can also call it internally for demonstration
let result = rust_add_and_print(5, 7);
println!("Internal call result: {}", result);
}Gerenciamento de memória em FFI
O gerenciamento de memória entre os limites da FFI é fundamental. Se o Rust alocar memória (por exemplo, uma cadeia de caracteres) e passar um ponteiro para C, C deverá copiar os dados ou ser responsável por liberá-los corretamente.
Da mesma forma, se C alocar memória e passar um ponteiro para o Rust, o Rust não deverá liberá-la, a menos que receba instruções explícitas para isso; caso contrário, deverá copiar os dados.
Ferramentas como std::ffi::CString e CStr ajudam a gerenciar cadeias de caracteres compatíveis com C com segurança, tratando a terminação nula e garantindo a transferência adequada de propriedade.
Verificação rápida de FFI
Vamos testar sua compreensão sobre a Interface de funções estrangeiras do Rust.
FFI: uma ponte entre mundos
Você aprendeu sobre a Interface de Funções Estrangeiras do Rust!
FFI permite que Rust seja uma verdadeira potência de interoperabilidade, possibilitando que você:
- Chame funções de bibliotecas C usando
extern "C"e blocosunsafe. - Exponha funções Rust para outras linguagens usando
#[no_mangle]epub extern "C". - Faça o mapeamento de tipos com cuidado usando os tipos de
std::os::raw.
FFI é uma ferramenta poderosa para integrar Rust a diversos ecossistemas, mas lembre-se da importância de usá-la com cuidado, especialmente no que diz respeito à segurança e ao gerenciamento de memória!
Perguntas Frequentes
A aula “Interface de Funções Estrangeiras (FFI)” é grátis?
Sim — o texto completo de “Interface de Funções Estrangeiras (FFI)” é 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 “Interface de Funções Estrangeiras (FFI)”?
Aprenda a chamar bibliotecas C a partir de Rust e a disponibilizar funções Rust para outras linguagens utilizando FFI para garantir interoperabilidade. 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 1 de 3.
Quanto tempo leva a aula “Interface de Funções Estrangeiras (FFI)”?
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
- Interface de Funções Estrangeiras (FFI)
- Rust para WebAssembly (WASM)
- Avaliação Comparativa e Otimização do Desempenho