Foreign Function Interface (FFI)
Leer C-bibliotheken vanuit Rust aanroepen en Rust-functies met FFI beschikbaar maken voor andere talen, zodat interoperabiliteit ontstaat.
Foreign Function Interface (FFI) is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 1 van 3. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer programmeren met Rust. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.
Wat is FFI?
FFI staat voor Foreign Function Interface. Het is een manier waarop programma's die in de ene programmeertaal zijn geschreven functies kunnen aanroepen of gegevensstructuren kunnen gebruiken die in een andere taal zijn gedefinieerd.
Met FFI kun je in Rust communiceren met code die in andere talen is geschreven, meestal C. Dit is erg handig voor integratie met bestaande bibliotheken of systeem-API's.
Waarom FFI gebruiken?
FFI is geen hulpmiddel voor dagelijks gebruik, maar het is krachtig wanneer je het volgende nodig hebt:
- Bestaande C-bibliotheken benutten: Veel krachtige, volwassen bibliotheken zijn geschreven in C/C++. Met FFI kan Rust ze rechtstreeks gebruiken.
- Systeem-API's: Communiceren met functies van het besturingssysteem die misschien alleen C-interfaces hebben.
- Interoperabiliteit: Een Rust-bibliotheek bouwen die vanuit andere talen kan worden aangeroepen, zoals Python, Java of JavaScript via Node.js.
C aanroepen vanuit Rust: declaratie
Om een C-functie vanuit Rust aan te roepen, moet je eerst de signatuur ervan declareren met een extern "C"-blok. Daarmee geef je Rust aan hoe de C-functie eruitziet, zonder de implementatie ervan te geven.
Het gedeelte "C" specificeert de aanroepconventie van C, zodat functieaanroepen compatibel zijn.
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;
}C aanroepen vanuit Rust: het blok `unsafe`
De belangrijkste belofte van Rust is geheugenveiligheid. Wanneer je via FFI met C-code communiceert, kan Rust de veiligheid van de externe code echter niet garanderen.
Daarom moet elke aanroep van een C-functie die in een extern "C"-blok is gedeclareerd, worden omgeven door een unsafe-blok. Daarmee geef je aan de compiler en andere ontwikkelaars aan dat je zelf verantwoordelijk bent voor het handhaven van de veiligheidsgaranties.
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.");
}Typetoewijzing: Rust naar C
Wanneer je FFI gebruikt, moet je ervoor zorgen dat Rust-typen correct overeenkomen met C-typen. Rust biedt hiervoor specifieke typen in std::os::raw en std::ffi.
i32->std::os::raw::c_intf32->std::os::raw::c_floatbool->std::os::raw::c_uchar(of een vergelijkbaar type; C heeft geen gestandaardiseerd booleaans type)&str->*const std::os::raw::c_char(C-tekenreeksen moeten met een null-teken eindigen; dit wordt vaak afgehandeld doorstd::ffi::CString)&mut [T]->*mut T
Gebruik altijd deze expliciete C-typen om ongedefinieerd gedrag te voorkomen.
Voorbeeld: een C-functie `add` aanroepen
Stel dat we een C-bibliotheek hebben met een functie int add(int a, int b);. Zo roepen we die vanuit Rust aan. Let op het gebruik van c_int voor gehele getallen.
(Deze code demonstreert de FFI-syntaxis, maar wordt niet uitgevoerd zonder een gecompileerde C-bibliotheek die extern is gekoppeld.)
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);
}Rust beschikbaar maken voor C: de basis
Om een Rust-functie vanuit C aanroepbaar te maken, heb je twee dingen nodig:
#[no_mangle]: Dit attribuut voorkomt dat de compiler van Rust de naam van de functie verandert. C-compilers verwachten eenvoudige namen zonder naamvervorming.extern "C": Hiermee geef je aan dat de functie de aanroepconventie van C moet gebruiken, zodat deze compatibel is met C.
Voorbeeld: Rust-functie voor C
Dit is een Rust-functie die een som berekent en vanuit een C-programma kan worden aangeroepen. Let op de attributen #[no_mangle] en extern "C".
(Deze code is bedoeld om als bibliotheek voor C te worden gecompileerd, maar bevat een main voor interne tests in deze omgeving.)
#[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);
}Geheugenbeheer met FFI
Geheugenbeheer over FFI-grenzen heen is cruciaal. Als Rust geheugen toewijst, bijvoorbeeld voor een tekenreeks, en een pointer aan C doorgeeft, moet C de gegevens kopiëren of verantwoordelijk zijn voor het correct vrijgeven ervan.
Omgekeerd geldt dat Rust geheugen niet mag vrijgeven als C geheugen toewijst en een pointer aan Rust doorgeeft, tenzij dat uitdrukkelijk is aangegeven. Anders moet Rust de gegevens kopiëren.
Hulpmiddelen zoals std::ffi::CString en CStr helpen om C-compatibele tekenreeksen veilig te beheren door de beëindiging met een null-teken af te handelen en ervoor te zorgen dat het eigenaarschap correct wordt overgedragen.
Snelle FFI-controle
Laten we controleren of je de Foreign Function Interface van Rust begrijpt.
FFI: een brug tussen werelden
Je hebt geleerd over de Foreign Function Interface van Rust!
Met FFI kan Rust uitstekend interopereren, zodat je:
- functies uit C-bibliotheken kunt aanroepen met
extern "C"enunsafe-blokken; - Rust-functies beschikbaar kunt maken voor andere talen met
#[no_mangle]enpub extern "C"; - typen zorgvuldig kunt toewijzen met typen uit
std::os::raw.
FFI is een krachtig hulpmiddel om Rust in uiteenlopende ecosystemen te integreren, maar vergeet niet hoe belangrijk zorgvuldig gebruik is, vooral als het gaat om veiligheid en geheugenbeheer.
Leer Rust met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 144
Veelgestelde vragen
Is de les “Foreign Function Interface (FFI)” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Foreign Function Interface (FFI)”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer programmeren met Rust bevat in totaal 3 lessen.
Wat leer ik in “Foreign Function Interface (FFI)”?
Leer C-bibliotheken vanuit Rust aanroepen en Rust-functies met FFI beschikbaar maken voor andere talen, zodat interoperabiliteit ontstaat. Je oefent met Leer programmeren met Rust door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Leer programmeren met Rust te beginnen?
Ervaring vooraf is niet nodig. Leer programmeren met Rust op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 3.
Hoe lang duurt de les “Foreign Function Interface (FFI)”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Leer programmeren met Rust?
Ja. Elke les over Leer programmeren met Rust bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Foreign Function Interface (FFI)
- Van Rust naar WebAssembly (WASM)
- Benchmarking en prestatieoptimalisatie