0Pricing
Learn Rust Coding · Pelajaran

Antarmuka Fungsi Asing (FFI)

Pelajari cara memanggil pustaka C dari Rust dan mengekspos fungsi Rust ke bahasa lain menggunakan FFI untuk interoperabilitas.

Antarmuka Fungsi Asing (FFI) adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 3. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Apa Itu FFI?

FFI adalah singkatan dari Antarmuka Fungsi Asing. Ini merupakan cara bagi program yang ditulis dalam satu bahasa pemrograman untuk memanggil fungsi atau menggunakan struktur data yang didefinisikan dalam bahasa lain.

Di Rust, FFI memungkinkan Anda berinteraksi dengan kode yang ditulis dalam bahasa lain, paling umum C. Ini sangat berguna untuk mengintegrasikan pustaka yang sudah ada atau API sistem.

Mengapa Menggunakan FFI?

FFI bukan alat yang digunakan sehari-hari, tetapi sangat berguna ketika Anda perlu:

  • Memanfaatkan pustaka C yang sudah ada: Banyak pustaka berkinerja tinggi dan matang ditulis dalam C/C++. FFI memungkinkan Rust menggunakannya secara langsung.
  • API sistem: Berinteraksi dengan fitur sistem operasi yang mungkin hanya menyediakan antarmuka C.
  • Interoperabilitas: Membangun pustaka Rust yang dapat dipanggil dari bahasa lain seperti Python, Java, atau JavaScript melalui Node.js.

Memanggil C dari Rust: Deklarasi

Untuk memanggil fungsi C dari Rust, Anda harus terlebih dahulu mendeklarasikan tanda tangannya menggunakan blok extern "C". Ini memberi tahu Rust seperti apa fungsi C tersebut tanpa menyediakan implementasinya.

Bagian "C" menentukan konvensi pemanggilan C, sehingga pemanggilan fungsi tetap kompatibel.

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 dari Rust: Blok `unsafe`

Jaminan utama Rust adalah keamanan memori. Namun, ketika Anda berinteraksi dengan kode C melalui FFI, Rust tidak dapat menjamin keamanan kode asing tersebut.

Karena itu, setiap pemanggilan fungsi C yang dideklarasikan dalam blok extern "C" harus dibungkus dalam blok unsafe. Ini memberi sinyal kepada kompiler dan pengembang lain bahwa Anda bertanggung jawab untuk mempertahankan jaminan keamanan.

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 Tipe: Rust ke C

Saat menggunakan FFI, Anda harus memastikan bahwa tipe Rust dipetakan dengan benar ke tipe C. Rust menyediakan tipe 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 tipe serupa; C tidak memiliki boolean standar)
  • &str -> *const std::os::raw::c_char (string C memerlukan terminasi null, yang sering ditangani oleh std::ffi::CString)
  • &mut [T] -> *mut T

Selalu gunakan tipe C yang eksplisit ini untuk menghindari perilaku yang tidak terdefinisi.

Contoh: Memanggil fungsi C `add`

Bayangkan kita memiliki pustaka C dengan fungsi int add(int a, int b);. Berikut cara memanggilnya dari Rust. Perhatikan penggunaan c_int untuk tipe bilangan bulat.

(Kode ini mendemonstrasikan sintaks FFI, tetapi tidak akan berjalan tanpa pustaka C yang dikompilasi dan ditautkan dari luar.)

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

Mengekspos Rust ke C: Dasar-Dasar

Untuk membuat fungsi Rust dapat dipanggil dari C, Anda memerlukan dua hal:

  1. #[no_mangle]: Atribut ini mencegah kompiler Rust mengubah nama fungsi. Kompiler C mengharapkan nama yang sederhana dan tidak diubah.
  2. extern "C": Ini menentukan bahwa fungsi harus menggunakan konvensi pemanggilan C, sehingga kompatibel dengan C.

Contoh: Fungsi Rust untuk C

Berikut fungsi Rust yang menghitung jumlah dan dapat dipanggil dari program C. Perhatikan atribut #[no_mangle] dan extern "C".

(Kode ini dirancang untuk dikompilasi sebagai pustaka untuk C, tetapi menyertakan main untuk pengujian internal dalam lingkungan 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);
}

Manajemen Memori FFI

Manajemen memori di seluruh batas FFI sangat penting. Jika Rust mengalokasikan memori, misalnya string, lalu meneruskan penunjuk ke C, C harus menyalin data tersebut atau bertanggung jawab untuk membebaskannya dengan benar.

Sebaliknya, jika C mengalokasikan memori dan meneruskan penunjuk ke Rust, Rust tidak boleh membebaskannya kecuali diperintahkan secara eksplisit, atau Rust harus menyalin datanya.

Alat seperti std::ffi::CString dan CStr membantu mengelola string yang kompatibel dengan C secara aman dengan menangani terminasi null dan memastikan pemindahan kepemilikan yang benar.

Pemeriksaan Singkat FFI

Mari uji pemahaman Anda tentang Antarmuka Fungsi Asing Rust.

FFI: Jembatan Antar Dunia

Anda telah mempelajari Antarmuka Fungsi Asing Rust!

FFI memungkinkan Rust menjadi sarana interoperabilitas yang sangat kuat, sehingga Anda dapat:

  • Memanggil fungsi dari pustaka C menggunakan extern "C" dan blok unsafe.
  • Mengekspos fungsi Rust ke bahasa lain menggunakan #[no_mangle] dan pub extern "C".
  • Menangani pemetaan tipe dengan cermat menggunakan tipe std::os::raw.

FFI adalah alat yang kuat untuk mengintegrasikan Rust ke berbagai ekosistem, tetapi ingat pentingnya penggunaan yang cermat, terutama terkait keamanan dan manajemen memori!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Antarmuka Fungsi Asing (FFI)” gratis?

Ya — teks lengkap “Antarmuka Fungsi Asing (FFI)” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 3 pelajaran total.

Apa yang akan aku pelajari di “Antarmuka Fungsi Asing (FFI)”?

Pelajari cara memanggil pustaka C dari Rust dan mengekspos fungsi Rust ke bahasa lain menggunakan FFI untuk interoperabilitas. Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 3.

Berapa lama pelajaran “Antarmuka Fungsi Asing (FFI)” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Antarmuka Fungsi Asing (FFI)
  2. Rust ke WebAssembly (WASM)
  3. Pembandingan Kinerja dan Penyetelan Performa
← Kembali ke Learn Rust Coding