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

Rust में जेनेरिक कोड लिखना

ऐसे फ़ंक्शन और डेटा-संरचनाएँ लिखना सीखिए जो अनेक प्रकारों के साथ काम करें, जिससे प्रकार-सुरक्षा से समझौता किए बिना कोड का पुनःप्रयोग बढ़े।

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

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

जेनेरिक कोड क्यों लिखें?

कल्पना करें कि आपको ऐसी फ़ंक्शन चाहिए जो किसी सूची में सबसे बड़ी वस्तु खोजे। यदि आपको इसे संख्याओं, फिर वर्णों और फिर कस्टम ऑब्जेक्ट्स के लिए उपयोग करना हो तो?

जेनेरिक्स के बिना, आप प्रत्येक प्रकार के लिए अलग फ़ंक्शन लिखेंगे, जिससे बहुत-सा दोहराया हुआ कोड बनेगा। यहीं जेनेरिक्स काम आते हैं!

जेनेरिक्स का परिचय

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

इन्हें ऐसे खाके की तरह समझें जिसे अलग-अलग सामग्रियों के अनुसार ढाला जा सकता है।

आपका पहला जेनेरिक फ़ंक्शन

किसी फ़ंक्शन को जेनेरिक बनाने के लिए, हम फ़ंक्शन नाम के बाद कोणीय कोष्ठकों <> में प्रकार पैरामीटर घोषित करते हैं। एक सामान्य प्रकार पैरामीटर नाम T होता है (Type के लिए)।

यह print_anything फ़ंक्शन अब किसी भी प्रकार को प्रिंट कर सकता है!

fn print_anything<T>(item: T) {
    println!("The item is: {}", item);
}

pub fn main() {
    print_anything(5);
    print_anything("hello");
    print_anything(true);
}

प्रकार पैरामीटर की व्याख्या

fn print_anything<T>(item: T) में <T> का अर्थ है कि T किसी प्रकार के लिए स्थानधारक है। जब आप फ़ंक्शन को i32 के साथ कॉल करते हैं, तो T i32 बन जाता है।

प्रकार पैरामीटर: जेनेरिक प्रकारों के नाम आमतौर पर बड़े अक्षरों से रखे जाते हैं, जैसे T, U, V।
लचीलापन: कंपाइलर कंपाइल समय पर वास्तविक प्रकार का पता लगा लेता है।

व्यवहार जोड़ना: ट्रेट सीमाएँ

कभी-कभी आपके जेनेरिक फ़ंक्शन को अपने प्रकार पैरामीटर T में विशिष्ट व्यवहार चाहिए होता है। उदाहरण के लिए, यदि आप दो T मानों की तुलना करना चाहते हैं, तो T की तुलना की जा सकने योग्य होना आवश्यक है।

इन आवश्यकताओं को निर्दिष्ट करने के लिए हम ट्रेट सीमाएँ जोड़ते हैं। यहाँ T: PartialOrd + Copy का अर्थ है कि T को PartialOrd (तुलना के लिए आंशिक क्रम) और Copy ट्रेट लागू करने होंगे।

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}

pub fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    println!("Largest number: {}", largest(&number_list));

    let char_list = vec!['y', 'm', 'a', 'q'];
    println!("Largest char: {}", largest(&char_list));
}

एकाधिक ट्रेट सीमाओं का सिंटैक्स

आप + सिंटैक्स का उपयोग करके जेनेरिक प्रकार के लिए कई ट्रेट आवश्यक कर सकते हैं, जैसे T: TraitA + TraitB।

जटिल सीमाओं के लिए, आप फ़ंक्शन सिग्नेचर के बाद where क्लॉज़ का भी उपयोग कर सकते हैं, जिससे सिग्नेचर अधिक साफ़ दिख सकता है:

fn some_function<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug { /* ... */ }

जेनेरिक स्ट्रक्चर

फ़ंक्शनों की तरह, आप स्ट्रक्चर को भी एक या अधिक प्रकार पैरामीटर के लिए जेनेरिक परिभाषित कर सकते हैं। इससे आपकी डेटा संरचनाएँ किसी भी निर्दिष्ट प्रकार का डेटा रख सकती हैं।

Point<T> स्ट्रक्चर किसी भी प्रकार T के निर्देशांक रख सकता है, जैसे i32 और f64।

struct Point<T> {
    x: T,
    y: T,
}

pub fn main() {
    let integer_point = Point {
        x: 5,
        y: 10
    };
    let float_point = Point {
        x: 1.0,
        y: 4.0
    };

    println!("Int Point: ({}, {})", 
             integer_point.x, integer_point.y);
    println!("Float Point: ({}, {})", 
             float_point.x, float_point.y);
}

जेनेरिक स्ट्रक्चर पर विधियाँ लागू करना

जेनेरिक स्ट्रक्चर के लिए विधियाँ लागू करते समय, आपको impl के बाद जेनेरिक प्रकार पैरामीटर निर्दिष्ट करने होंगे।

यदि किसी विधि को अपने जेनेरिक प्रकारों से विशेष व्यवहार चाहिए, तो आप उसमें ट्रेट सीमाएँ भी जोड़ सकते हैं।

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

pub fn main() {
    let p = Point {
        x: 5,
        y: 10
    };
    println!("p.x = {}", p.x());
}

जेनेरिक्स और प्रदर्शन

Rust की एक विशेषता यह है कि जेनेरिक्स शून्य-लागत अमूर्तन हैं। इसका अर्थ है कि जेनेरिक्स का उपयोग करने पर रनटाइम प्रदर्शन पर कोई अतिरिक्त दंड नहीं लगता।

Rust इसे मोनोमोर्फ़ाइज़ेशन के माध्यम से प्राप्त करता है: कंपाइल समय पर कंपाइलर आपके जेनेरिक कोड के प्रत्येक वास्तविक प्रकार के लिए विशेष संस्करण बनाता है। इसलिए largest<i32> और largest<char> दो अलग-अलग, अनुकूलित फ़ंक्शन बन जाते हैं।

अपना ज्ञान जाँचें

Rust जेनेरिक्स के बारे में निम्नलिखित में से कौन-से कथन सही हैं?

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

पुनरावलोकन: जेनेरिक्स की शक्ति

इस पाठ में आपने Rust में जेनेरिक कोड लिखने की मूल बातें सीखी हैं:

ये क्या हैं: लचीला और पुनः उपयोग योग्य कोड लिखने का एक तरीका।
जेनेरिक फ़ंक्शन: प्रकार पैरामीटर के लिए <T> का उपयोग।
ट्रेट सीमाएँ: T: Trait के साथ आवश्यक व्यवहार निर्दिष्ट करना।
जेनेरिक स्ट्रक्चर: जेनेरिक प्रकार रखने वाली डेटा संरचनाएँ बनाना।
शून्य-लागत: Rust के जेनेरिक्स विशिष्ट कोड में कंपाइल होते हैं, जिससे रनटाइम पर कोई अतिरिक्त दंड नहीं लगता।

जेनेरिक्स सुव्यवस्थित Rust की आधारशिला हैं और शक्तिशाली, प्रकार-सुरक्षित अमूर्तन सक्षम करते हैं!

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

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

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

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

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

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

क्या “Rust में जेनेरिक कोड लिखना” पाठ निःशुल्क है?

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

“Rust में जेनेरिक कोड लिखना” में मैं क्या सीखूँगा?

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

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

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

“Rust में जेनेरिक कोड लिखना” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

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