Yabancı İşlev Arayüzü (FFI)
Birlikte çalışabilirlik için Rust'tan C kütüphanelerini çağırmayı ve FFI kullanarak Rust işlevlerini diğer dillere açmayı öğrenin.
Yabancı İşlev Arayüzü (FFI), CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 3 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Learn Rust Coding öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Learn Rust Coding kursu toplamda 3 dersten oluşur.
FFI Nedir?
FFI, Yabancı İşlev Arayüzü anlamına gelir. Bir programlama dilinde yazılmış programların başka bir dilde tanımlanmış işlevleri çağırmasını veya veri yapılarını kullanmasını sağlayan bir yoldur.
Rust'ta FFI, diğer dillerde, çoğunlukla C'de, yazılmış kodlarla etkileşim kurmanızı sağlar. Bu, mevcut kitaplıklarla veya sistem API'leriyle bütünleşmek için son derece kullanışlıdır.
FFI Neden Kullanılır?
FFI günlük kullanılan bir araç değildir, ancak şunlara ihtiyaç duyduğunuzda güçlüdür:
- Mevcut C kitaplıklarından yararlanma: Yüksek performanslı ve olgun birçok kitaplık C/C++ ile yazılmıştır. FFI, Rust'ın bunları doğrudan kullanmasını sağlar.
- Sistem API'leri: Yalnızca C arayüzlerine sahip olabilecek işletim sistemi özellikleriyle etkileşim kurma.
- Birlikte çalışabilirlik: Diğer dillerden (örneğin Python, Java veya Node.js aracılığıyla JavaScript) çağrılabilen bir Rust kitaplığı oluşturma.
Rust'tan C Çağrısı Yapma: Bildirim
Rust'tan bir C işlevini çağırmak için önce imzasını bir extern "C" bloğu kullanarak bildirmeniz gerekir. Bu, uygulamasını sağlamadan Rust'a C işlevinin nasıl göründüğünü bildirir.
"C" bölümü, işlev çağrılarının uyumlu olmasını sağlayan C çağrı kuralını belirtir.
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;
}Rust'tan C Çağrısı Yapma: `unsafe` Bloğu
Rust'ın temel vaadi bellek güvenliğidir. Ancak FFI aracılığıyla C koduyla etkileşim kurduğunuzda Rust, yabancı kodun güvenliğini garanti edemez.
Bu nedenle bir extern "C" bloğunda bildirilen C işlevine yapılan her çağrı bir unsafe bloğuna sarılmalıdır. Bu, güvenlik garantilerini korumaktan sizin sorumlu olduğunuzu derleyiciye (ve diğer geliştiricilere) bildirir.
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.");
}Tür Eşleme: Rust'tan C'ye
FFI kullanırken Rust türlerinin C türleriyle doğru şekilde eşleştiğinden emin olmalısınız. Rust bu amaçla std::os::raw ve std::ffi içinde özel türler sağlar.
i32->std::os::raw::c_intf32->std::os::raw::c_floatbool->std::os::raw::c_uchar(veya benzeri; C'de standart bir mantıksal tür yoktur)&str->*const std::os::raw::c_char(C dizeleri null sonlandırması gerektirir; bu işlem genelliklestd::ffi::CStringtarafından yapılır)&mut [T]->*mut T
Tanımsız davranıştan kaçınmak için her zaman bu açık C türlerini kullanın.
Örnek: Bir C `add` İşlevini Çağırma
int add(int a, int b); işlevine sahip bir C kitaplığımız olduğunu düşünün. Bunu Rust'tan şu şekilde çağırırız. Tamsayı türleri için c_int kullanımına dikkat edin.
(Bu kod FFI söz dizimini gösterir, ancak harici olarak bağlanmış derlenmiş bir C kitaplığı olmadan çalışmaz.)
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'ı C'ye Açma: Temel Bilgiler
Bir Rust işlevinin C'den çağrılabilmesini sağlamak için iki şeye ihtiyacınız vardır:
#[no_mangle]: Bu öznitelik, Rust derleyicisinin işlev adını "karıştırmasını" (değiştirmesini) önler. C derleyicileri basit, değiştirilmemiş adlar bekler.extern "C": Bu, işlevin C çağrı kuralını kullanmasını belirtir ve C ile uyumlu olmasını sağlar.
Örnek: C İçin Rust İşlevi
Burada toplam hesaplayan ve bir C programından çağrılabilecek bir Rust işlevi bulunuyor. #[no_mangle] ve extern "C" özniteliklerine dikkat edin.
(Bu kod, C için bir kitaplık olarak derlenmek üzere tasarlanmıştır, ancak bu ortamda dahili test için bir main içerir.)
#[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);
}FFI Bellek Yönetimi
FFI sınırları boyunca bellek yönetimi kritik öneme sahiptir. Rust belleği (ör. bir dizeyi) ayırır ve C'ye bir işaretçi iletirse C, verileri kopyalamalı veya belleği doğru şekilde serbest bırakma sorumluluğunu üstlenmelidir.
Tersine, C belleği ayırır ve Rust'a bir işaretçi iletirse Rust, açıkça kendisine söylenmediği sürece bu belleği serbest bırakmamalı veya verileri kopyalamalıdır.
std::ffi::CString ve CStr gibi araçlar, null sonlandırmasını yöneterek ve uygun sahiplik aktarımını sağlayarak C uyumlu dizeleri güvenli biçimde yönetmeye yardımcı olur.
FFI Kısa Kontrolü
Rust'ın Yabancı İşlev Arayüzü konusundaki anlayışınızı test edelim.
FFI: Dünyalar Arasında Köprü
Rust'un Foreign Function Interface'ini öğrendiniz!
FFI, Rust'un gerçek bir birlikte çalışabilirlik gücü olmasını sağlar ve size şunları yapma olanağı tanır:
extern "C"veunsafebloklarını kullanarak C kitaplıklarındaki işlevleri çağırmak.#[no_mangle]vepub extern "C"kullanarak Rust işlevlerini diğer dillere açmak.std::os::rawtürleriyle tür eşlemelerini dikkatli bir şekilde gerçekleştirmek.
FFI, Rust'u çeşitli ekosistemlere entegre etmek için güçlü bir araçtır; ancak özellikle güvenlik ve bellek yönetimi açısından dikkatli kullanımın önemini unutmayın!
Sıkça Sorulan Sorular
“Yabancı İşlev Arayüzü (FFI)” dersi ücretsiz mi?
Evet — “Yabancı İşlev Arayüzü (FFI)” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Learn Rust Coding kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Learn Rust Coding kursu toplamda 3 dersten oluşur.
“Yabancı İşlev Arayüzü (FFI)” dersinde ne öğreneceğim?
Birlikte çalışabilirlik için Rust'tan C kütüphanelerini çağırmayı ve FFI kullanarak Rust işlevlerini diğer dillere açmayı öğrenin. Learn Rust Coding ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.
Learn Rust Coding öğrenmeye başlamak için deneyim gerekli mi?
Önceden deneyim gerekmez. CoddyKit'te Learn Rust Coding, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 3 dersinin 1. dersidir.
“Yabancı İşlev Arayüzü (FFI)” dersi ne kadar sürer?
Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.
Bu Learn Rust Coding dersinde kod yazıp çalıştırabilir miyim?
Evet. Her Learn Rust Coding dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.
Bu kursun tüm dersleri
- Yabancı İşlev Arayüzü (FFI)
- Rust'tan WebAssembly'ye (WASM)
- Karşılaştırmalı Ölçüm ve Performans Ayarlama