Rust कोडिंग सीखें · पाठ

विदेशी फ़ंक्शन इंटरफ़ेस (FFI)

Rust से C पुस्तकालयों को कॉल करना और अंतर-संचालनीयता के लिए FFI का उपयोग करके अन्य भाषाओं के लिए Rust फ़ंक्शन उपलब्ध कराना सीखिए।

पाठ 1, कुल 3 में से11 चरण

विदेशी फ़ंक्शन इंटरफ़ेस (FFI), CoddyKit पर Rust कोडिंग सीखें का एक निःशुल्क पाठ है। यह 3 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Rust कोडिंग सीखें सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Rust कोडिंग सीखें पाठ्यक्रम में कुल 3 पाठ शामिल हैं।

FFI क्या है?

FFI का अर्थ Foreign Function Interface है। यह एक ऐसा तरीका है, जिससे एक प्रोग्रामिंग भाषा में लिखे गए प्रोग्राम दूसरी भाषा में परिभाषित फ़ंक्शन को कॉल कर सकते हैं या उसके डेटा ढाँचों का उपयोग कर सकते हैं।

Rust में, FFI की सहायता से आप दूसरी भाषाओं, विशेष रूप से C, में लिखे कोड के साथ इंटरैक्ट कर सकते हैं। मौजूदा लाइब्रेरी या सिस्टम API को जोड़ने के लिए यह बहुत उपयोगी है।

FFI का उपयोग क्यों करें

FFI रोज़मर्रा में उपयोग होने वाला उपकरण नहीं है, लेकिन यह तब शक्तिशाली होता है जब आपको इनकी आवश्यकता हो:

मौजूदा C लाइब्रेरी का लाभ उठाना: कई उच्च-प्रदर्शन वाली, परिपक्व लाइब्रेरी C/C++ में लिखी गई हैं। FFI की सहायता से Rust उनका सीधे उपयोग कर सकता है।
सिस्टम API: ऑपरेटिंग सिस्टम की उन सुविधाओं के साथ इंटरैक्ट करना, जिनके लिए संभवतः केवल C इंटरफ़ेस उपलब्ध हों।
इंटरऑपरेबिलिटी: ऐसी Rust लाइब्रेरी बनाना जिसे दूसरी भाषाओं, जैसे Python, Java या Node.js के माध्यम से JavaScript, से कॉल किया जा सके।

Rust से C को कॉल करना: घोषणा

Rust से किसी C फ़ंक्शन को कॉल करने के लिए, आपको पहले extern "C" ब्लॉक का उपयोग करके उसका सिग्नेचर घोषित करना होगा। इससे Rust को पता चलता है कि C फ़ंक्शन कैसा दिखता है, लेकिन उसका कार्यान्वयन उपलब्ध नहीं कराया जाता।

"C" वाला भाग C की कॉलिंग कन्वेंशन निर्दिष्ट करता है, जिससे फ़ंक्शन कॉल संगत रहती हैं।

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 से C को कॉल करना: `unsafe` ब्लॉक

Rust का मुख्य वादा मेमोरी सुरक्षा है। हालांकि, जब आप FFI के माध्यम से C कोड के साथ इंटरैक्ट करते हैं, तो Rust विदेशी कोड की सुरक्षा की गारंटी नहीं दे सकता।

इसलिए, extern "C" ब्लॉक में घोषित C फ़ंक्शन की किसी भी कॉल को unsafe ब्लॉक में रखना आवश्यक है। इससे कंपाइलर और अन्य डेवलपरों को संकेत मिलता है कि सुरक्षा संबंधी गारंटी बनाए रखने की ज़िम्मेदारी आपकी है।

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

प्रकारों का मानचित्रण: Rust से C

FFI का उपयोग करते समय, आपको यह सुनिश्चित करना होगा कि Rust के प्रकार C के प्रकारों से सही ढंग से मेल खाते हों। Rust इस उद्देश्य के लिए std::os::raw और std::ffi में विशेष प्रकार उपलब्ध कराता है।

i32 -> std::os::raw::c_int
f32 -> std::os::raw::c_float
bool -> std::os::raw::c_uchar (या इसी प्रकार का अन्य प्रकार; C में मानक बूलियन प्रकार नहीं होता)
&str -> *const std::os::raw::c_char (C स्ट्रिंग के अंत में null होना आवश्यक है, जिसे अक्सर std::ffi::CString संभालता है)
&mut [T] -> *mut T

अपरिभाषित व्यवहार से बचने के लिए हमेशा इन स्पष्ट C प्रकारों का उपयोग करें।

उदाहरण: C के `add` फ़ंक्शन को कॉल करना

मान लीजिए कि हमारे पास एक C लाइब्रेरी है, जिसमें int add(int a, int b); फ़ंक्शन है। इसे Rust से इस प्रकार कॉल किया जा सकता है। ध्यान दें कि पूर्णांक प्रकारों के लिए c_int का उपयोग किया गया है।

(यह कोड FFI सिंटैक्स दिखाता है, लेकिन बाहर से लिंक की गई कंपाइल की गई C लाइब्रेरी के बिना नहीं चलेगा।)

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 के लिए उपलब्ध कराना: मूल बातें

किसी Rust फ़ंक्शन को C से कॉल करने योग्य बनाने के लिए आपको दो चीज़ों की आवश्यकता होती है:

#[no_mangle]: यह एट्रिब्यूट Rust के कंपाइलर को फ़ंक्शन के नाम को "mangling" (बदलने) से रोकता है। C कंपाइलर सरल, बिना बदले हुए नामों की अपेक्षा करते हैं।
extern "C": यह निर्दिष्ट करता है कि फ़ंक्शन C की कॉलिंग कन्वेंशन का उपयोग करे, जिससे वह C के साथ संगत हो जाता है।

उदाहरण: C के लिए Rust फ़ंक्शन

यहाँ एक Rust फ़ंक्शन है, जो योग की गणना करता है और जिसे C प्रोग्राम से कॉल किया जा सकता है। #[no_mangle] और extern "C" एट्रिब्यूट पर ध्यान दें।

(यह कोड C के लिए लाइब्रेरी के रूप में कंपाइल किए जाने के लिए बनाया गया है, लेकिन इस वातावरण में आंतरिक परीक्षण के लिए इसमें main शामिल है।)

#[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 मेमोरी प्रबंधन

FFI सीमाओं के आर-पार मेमोरी प्रबंधन अत्यंत महत्वपूर्ण है। यदि Rust मेमोरी (जैसे कोई स्ट्रिंग) आवंटित करके उसका पॉइंटर C को देता है, तो C को या तो डेटा की कॉपी बनानी होगी या उसे सही तरीके से मुक्त करने की ज़िम्मेदारी लेनी होगी।

इसके विपरीत, यदि C मेमोरी आवंटित करके उसका पॉइंटर Rust को देता है, तो Rust को उसे तब तक मुक्त नहीं करना चाहिए जब तक ऐसा करने के लिए स्पष्ट रूप से न कहा गया हो; अन्यथा उसे डेटा की कॉपी बनानी होगी।

std::ffi::CString और CStr जैसे उपकरण null समाप्ति संभालकर और स्वामित्व का सही हस्तांतरण सुनिश्चित करके C-संगत स्ट्रिंग को सुरक्षित रूप से प्रबंधित करने में सहायता करते हैं।

FFI की त्वरित जाँच

आइए, Rust के Foreign Function Interface की आपकी समझ जाँचते हैं।

इंटरैक्टिव पाठ में इसका उत्तर दें

FFI: दुनियाओं के बीच सेतु

आपने Rust के Foreign Function Interface के बारे में सीख लिया है!

FFI Rust को इंटरऑपरेबिलिटी का एक शक्तिशाली माध्यम बनाता है और आपको यह करने देता है:

extern "C" और unsafe ब्लॉक का उपयोग करके C लाइब्रेरी के फ़ंक्शन कॉल करना।
#[no_mangle] और pub extern "C" का उपयोग करके Rust फ़ंक्शन दूसरी भाषाओं के लिए उपलब्ध कराना।
std::os::raw प्रकारों की सहायता से प्रकारों का सावधानीपूर्वक मानचित्रण करना।

Rust को विभिन्न पारिस्थितिक तंत्रों में जोड़ने के लिए FFI एक शक्तिशाली उपकरण है, लेकिन सावधानीपूर्वक उपयोग के महत्व को याद रखें, विशेष रूप से सुरक्षा और मेमोरी प्रबंधन के संबंध में!

शुरुआत निःशुल्क

एआई शिक्षक के साथ Rust सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 39
पाठ: 144

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “विदेशी फ़ंक्शन इंटरफ़ेस (FFI)” पाठ निःशुल्क है?

हाँ — Rust कोडिंग सीखें अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “विदेशी फ़ंक्शन इंटरफ़ेस (FFI)” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Rust कोडिंग सीखें पाठ्यक्रम में कुल 3 पाठ शामिल हैं।

“विदेशी फ़ंक्शन इंटरफ़ेस (FFI)” में मैं क्या सीखूँगा?

Rust से C पुस्तकालयों को कॉल करना और अंतर-संचालनीयता के लिए FFI का उपयोग करके अन्य भाषाओं के लिए Rust फ़ंक्शन उपलब्ध कराना सीखिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Rust कोडिंग सीखें का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Rust कोडिंग सीखें शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Rust कोडिंग सीखें शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 3 में से 1वाँ पाठ है।

“विदेशी फ़ंक्शन इंटरफ़ेस (FFI)” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Rust कोडिंग सीखें पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Rust कोडिंग सीखें पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Rust कोडिंग सीखें पर वापस जाएँ