Learn Rust Coding · Lektion

Foreign Function Interface (FFI)

Lernen Sie, C-Bibliotheken aus Rust aufzurufen und Rust-Funktionen mithilfe von FFI für andere Sprachen bereitzustellen.

Foreign Function Interface (FFI) ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Was ist FFI?

FFI steht für Foreign Function Interface. Damit können Programme, die in einer Programmiersprache geschrieben wurden, Funktionen aufrufen oder Datenstrukturen verwenden, die in einer anderen Sprache definiert sind.

In Rust ermöglicht FFI die Interaktion mit Code, der in anderen Sprachen geschrieben wurde, meist in C. Das ist besonders nützlich, um vorhandene Bibliotheken oder System-APIs einzubinden.

Warum FFI verwenden?

FFI ist kein Werkzeug für den täglichen Einsatz, aber sehr leistungsfähig, wenn Sie Folgendes benötigen:

Vorhandene C-Bibliotheken nutzen: Viele leistungsstarke und ausgereifte Bibliotheken sind in C/C++ geschrieben. Mit FFI kann Rust sie direkt verwenden.
System-APIs: Interagieren Sie mit Betriebssystemfunktionen, die möglicherweise nur C-Schnittstellen bereitstellen.
Interoperabilität: Erstellen Sie eine Rust-Bibliothek, die aus anderen Sprachen wie Python, Java oder JavaScript über Node.js aufgerufen werden kann.

C aus Rust aufrufen: Deklaration

Um eine C-Funktion aus Rust aufzurufen, müssen Sie zunächst ihre Signatur in einem extern "C"-Block deklarieren. Dadurch weiß Rust, wie die C-Funktion aufgebaut ist, ohne dass ihre Implementierung angegeben wird.

Der Teil "C" legt die C-Aufrufkonvention fest und stellt sicher, dass die Funktionsaufrufe kompatibel sind.

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 aus Rust aufrufen: Der `unsafe`-Block

Das zentrale Versprechen von Rust ist Speichersicherheit. Wenn Sie jedoch über FFI mit C-Code interagieren, kann Rust die Sicherheit des fremden Codes nicht garantieren.

Daher muss jeder Aufruf einer C-Funktion, die in einem extern "C"-Block deklariert wurde, in einen unsafe-Block eingeschlossen werden. Damit signalisieren Sie dem Compiler und anderen Entwicklern, dass Sie für die Einhaltung der Sicherheitsgarantien verantwortlich sind.

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.");
}

Typzuordnung: Rust zu C

Bei der Verwendung von FFI müssen Sie sicherstellen, dass Rust-Typen korrekt auf C-Typen abgebildet werden. Rust stellt dafür spezielle Typen in std::os::raw und std::ffi bereit.

i32 -> std::os::raw::c_int
f32 -> std::os::raw::c_float
bool -> std::os::raw::c_uchar (oder ein ähnlicher Typ; C besitzt keinen standardisierten booleschen Typ)
&str -> *const std::os::raw::c_char (C-Zeichenketten benötigen eine Nullterminierung, die häufig von std::ffi::CString übernommen wird)
&mut [T] -> *mut T

Verwenden Sie immer diese expliziten C-Typen, um undefiniertes Verhalten zu vermeiden.

Beispiel: Eine C-`add`-Funktion aufrufen

Stellen Sie sich vor, wir hätten eine C-Bibliothek mit einer Funktion int add(int a, int b);. So würden wir sie aus Rust aufrufen. Beachten Sie die Verwendung von c_int für Ganzzahltypen.

(Dieser Code veranschaulicht die FFI-Syntax, kann aber ohne eine kompilierte und extern verknüpfte C-Bibliothek nicht ausgeführt werden.)

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 für C verfügbar machen: Grundlagen

Damit eine Rust-Funktion aus C aufgerufen werden kann, benötigen Sie zwei Dinge:

#[no_mangle]: Dieses Attribut verhindert, dass der Rust-Compiler den Namen der Funktion „mangelt“ (verändert). C-Compiler erwarten einfache Namen ohne Name Mangling.
extern "C": Damit wird festgelegt, dass die Funktion die C-Aufrufkonvention verwendet und somit mit C kompatibel ist.

Beispiel: Rust-Funktion für C

Hier sehen Sie eine Rust-Funktion, die eine Summe berechnet und aus einem C-Programm aufgerufen werden könnte. Beachten Sie die Attribute #[no_mangle] und extern "C".

(Dieser Code ist dafür vorgesehen, als Bibliothek für C kompiliert zu werden, enthält aber für interne Tests in dieser Umgebung eine main-Funktion.)

#[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);
}

Speicherverwaltung bei FFI

Die Speicherverwaltung über FFI-Grenzen hinweg ist entscheidend. Wenn Rust Speicher (z. B. für eine Zeichenkette) reserviert und einen Zeiger an C übergibt, muss C entweder die Daten kopieren oder für deren korrekte Freigabe verantwortlich sein.

Umgekehrt gilt: Wenn C Speicher reserviert und einen Zeiger an Rust übergibt, sollte Rust ihn nicht freigeben, außer dies wurde ausdrücklich vereinbart. Andernfalls muss Rust die Daten kopieren.

Werkzeuge wie std::ffi::CString und CStr helfen dabei, C-kompatible Zeichenketten sicher zu verwalten, indem sie die Nullterminierung und die korrekte Übertragung des Besitzes handhaben.

Kurzer FFI-Test

Testen wir Ihr Verständnis von Rusts Foreign Function Interface.

FFI: Eine Brücke zwischen Welten

Sie haben Rusts Foreign Function Interface kennengelernt!

FFI macht Rust zu einer äußerst leistungsfähigen Lösung für Interoperabilität. Damit können Sie:

Funktionen aus C-Bibliotheken mit extern "C" und unsafe-Blöcken aufrufen.
Rust-Funktionen mit #[no_mangle] und pub extern "C" für andere Sprachen verfügbar machen.
Die Typzuordnung mit Typen aus std::os::raw sorgfältig handhaben.

FFI ist ein leistungsfähiges Werkzeug, um Rust in unterschiedliche Ökosysteme zu integrieren. Denken Sie jedoch daran, wie wichtig eine sorgfältige Verwendung ist, insbesondere im Hinblick auf Sicherheit und Speicherverwaltung.

Häufig gestellte Fragen

Ist die Lektion „Foreign Function Interface (FFI)“ kostenlos?

Ja — der vollständige Text von „Foreign Function Interface (FFI)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Foreign Function Interface (FFI)“?

Lernen Sie, C-Bibliotheken aus Rust aufzurufen und Rust-Funktionen mithilfe von FFI für andere Sprachen bereitzustellen. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „Foreign Function Interface (FFI)“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding