Belajar Pengaturcaraan Rust · Pelajaran

Antara Muka Fungsi Asing (FFI)

Pelajari cara memanggil pustaka C dari Rust dan mendedahkan fungsi Rust kepada bahasa lain menggunakan FFI demi kebolehoperasian.

Pelajaran 1 daripada 311 langkah

Antara Muka Fungsi Asing (FFI) ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 daripada 3. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah FFI?

FFI ialah singkatan bagi Antara Muka Fungsi Asing. Ia ialah cara untuk program yang ditulis dalam satu bahasa pengaturcaraan memanggil fungsi atau menggunakan struktur data yang ditakrifkan dalam bahasa lain.

Dalam Rust, FFI membolehkan anda berinteraksi dengan kod yang ditulis dalam bahasa lain, paling lazimnya C. Ini sangat berguna untuk mengintegrasikan pustaka sedia ada atau API sistem.

Mengapa Menggunakan FFI?

FFI bukan alat yang digunakan setiap hari, tetapi ia berkuasa apabila anda perlu:

Memanfaatkan pustaka C sedia ada: Banyak pustaka berprestasi tinggi dan matang ditulis dalam C/C++. FFI membolehkan Rust menggunakannya secara langsung.
API sistem: Berinteraksi dengan ciri sistem pengendalian yang mungkin hanya mempunyai antara muka C.
Saling kendali: Membina pustaka Rust yang boleh dipanggil daripada bahasa lain seperti Python, Java atau JavaScript melalui Node.js.

Memanggil C daripada Rust: Pengisytiharan

Untuk memanggil fungsi C daripada Rust, anda perlu mengisytiharkan tandatangannya terlebih dahulu menggunakan blok extern "C". Ini memberitahu Rust rupa bentuk fungsi C tersebut tanpa menyediakan pelaksanaannya.

Bahagian "C" menentukan konvensyen panggilan C, bagi memastikan panggilan fungsi serasi.

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;
}

Memanggil C daripada Rust: Blok `unsafe`

Janji asas Rust ialah keselamatan memori. Walau bagaimanapun, apabila anda berinteraksi dengan kod C melalui FFI, Rust tidak dapat menjamin keselamatan kod asing tersebut.

Oleh itu, setiap panggilan kepada fungsi C yang diisytiharkan dalam blok extern "C" mesti dibungkus dalam blok unsafe. Ini menandakan kepada pengompil dan pembangun lain bahawa anda bertanggungjawab untuk mengekalkan jaminan keselamatan.

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

Pemetaan Jenis: Rust kepada C

Apabila menggunakan FFI, anda mesti memastikan jenis Rust dipetakan dengan betul kepada jenis C. Rust menyediakan jenis khusus dalam std::os::raw dan std::ffi untuk tujuan ini.

i32 -> std::os::raw::c_int
f32 -> std::os::raw::c_float
bool -> std::os::raw::c_uchar (atau yang serupa, kerana C tidak mempunyai boolean piawai)
&str -> *const std::os::raw::c_char (rentetan C memerlukan penamat nol, yang sering dikendalikan oleh std::ffi::CString)
&mut [T] -> *mut T

Sentiasa gunakan jenis C yang jelas ini untuk mengelakkan tingkah laku yang tidak ditakrifkan.

Contoh: Memanggil fungsi C `add`

Bayangkan kita mempunyai pustaka C dengan fungsi int add(int a, int b);. Beginilah cara kita memanggilnya daripada Rust. Perhatikan penggunaan c_int untuk jenis integer.

(Kod ini menunjukkan sintaks FFI tetapi tidak akan dijalankan tanpa pustaka C yang telah dikompil dan dipautkan secara luaran.)

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

Mendedahkan Rust kepada C: Asas

Untuk menjadikan fungsi Rust boleh dipanggil daripada C, anda memerlukan dua perkara:

#[no_mangle]: Atribut ini menghalang pengompil Rust daripada "mengubah nama" fungsi. Pengompil C menjangkakan nama yang ringkas dan tidak diubah.
extern "C": Ini menentukan bahawa fungsi tersebut harus menggunakan konvensyen panggilan C, supaya serasi dengan C.

Contoh: Fungsi Rust untuk C

Berikut ialah fungsi Rust yang mengira jumlah dan boleh dipanggil daripada program C. Perhatikan atribut #[no_mangle] dan extern "C".

(Kod ini direka untuk dikompil sebagai pustaka bagi C, tetapi menyertakan main untuk pengujian dalaman dalam persekitaran ini.)

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

Pengurusan Memori FFI

Pengurusan memori merentasi sempadan FFI amat penting. Jika Rust memperuntukkan memori seperti rentetan dan menghantar penuding kepada C, C mesti menyalin data tersebut atau bertanggungjawab untuk membebaskannya dengan betul.

Sebaliknya, jika C memperuntukkan memori dan menghantar penuding kepada Rust, Rust tidak sepatutnya membebaskannya kecuali diarahkan secara jelas, atau Rust mesti menyalin data tersebut.

Alat seperti std::ffi::CString dan CStr membantu mengurus rentetan yang serasi dengan C dengan selamat melalui pengendalian penamat nol dan pemastian pemindahan pemilikan yang betul.

Semakan Ringkas FFI

Mari uji pemahaman anda tentang Antara Muka Fungsi Asing Rust.

Jawab dalam pelajaran interaktif

FFI: Jambatan antara Dua Dunia

Anda telah mempelajari Antara Muka Fungsi Asing Rust!

FFI membolehkan Rust menjadi alat saling kendali yang benar-benar berkuasa, dengan membolehkan anda:

Memanggil fungsi daripada pustaka C menggunakan extern "C" dan blok unsafe.
Mendedahkan fungsi Rust kepada bahasa lain menggunakan #[no_mangle] dan pub extern "C".
Mengendalikan pemetaan jenis dengan teliti menggunakan jenis std::os::raw.

FFI ialah alat yang berkuasa untuk mengintegrasikan Rust ke dalam pelbagai ekosistem, tetapi ingat kepentingan penggunaannya secara cermat, terutamanya berkaitan keselamatan dan pengurusan memori!

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 144

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Antara Muka Fungsi Asing (FFI)” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Antara Muka Fungsi Asing (FFI)”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Antara Muka Fungsi Asing (FFI)”?

Pelajari cara memanggil pustaka C dari Rust dan mendedahkan fungsi Rust kepada bahasa lain menggunakan FFI demi kebolehoperasian. Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 3.

Berapa lamakah pelajaran “Antara Muka Fungsi Asing (FFI)” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Belajar Pengaturcaraan Rust