रस्ट में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग कॉन्सेप्ट को कैसे लागू करें

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (ओओपी) वास्तविक दुनिया की संस्थाओं और अवधारणाओं का प्रतिनिधित्व करने के लिए वस्तुओं के उपयोग पर जोर देकर सॉफ्टवेयर डिजाइन को सरल बनाती है। ओओपी वस्तुओं के भीतर कार्यक्षमता को समाहित करके रखरखाव को प्रोत्साहित करता है।

जंग एक लचीली भाषा है जो कार्यात्मक और प्रक्रियात्मक प्रोग्रामिंग का समर्थन करती है। हालाँकि यह मूल रूप से ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग का समर्थन नहीं करता है, आप रस्ट के अंतर्निर्मित डेटा प्रकारों का उपयोग करके OOP अवधारणाओं को लागू कर सकते हैं।

जंग में एनकैप्सुलेशन

एनकैप्सुलेशन कोड को स्व-निहित इकाइयों में व्यवस्थित करने पर जोर देता है जो आंतरिक विवरण छिपाते हैं जटिलता को कम करने और कोड में सुधार करने के लिए बाहरी संपर्क के लिए एक सार्वजनिक इंटरफ़ेस को उजागर करना रख-रखाव।

आप मॉड्यूल के साथ रस्ट कोड को एनकैप्सुलेट कर सकते हैं। एक मॉड्यूल कार्यों, structs, enums, और स्थिरांक सहित वस्तुओं का एक संग्रह है। जंग मॉड्यूल एक कार्यक्रम के कुछ हिस्सों के बीच समूहीकरण और सीमाओं को परिभाषित करने के लिए कार्यक्षमता प्रदान करते हैं।

डेटा और कार्यों को समाहित करने के लिए मॉड्यूल का उपयोग करना

आप का उपयोग करके एक मॉड्यूल को परिभाषित कर सकते हैं आधुनिक कीवर्ड के बाद एक नाम:

आधुनिक my_module {
// मॉड्यूल आइटम यहां जाएं
}

आप उनकी घोषणाओं को नेस्ट करके मॉड्यूल को श्रेणीबद्ध रूप से व्यवस्थित कर सकते हैं:

आधुनिक माता-पिता_मॉड्यूल {
आधुनिक my_module {
// मॉड्यूल आइटम यहां जाएं
 }
}

फिर आप नेस्टेड मॉड्यूल को पूर्ण पदानुक्रम के साथ संदर्भित कर सकते हैं, प्रत्येक मॉड्यूल को डबल कोलन से अलग कर सकते हैं, उदाहरण के लिए, माता-पिता_मॉड्यूल:: my_module.

डिफ़ॉल्ट रूप से, मॉड्यूल के भीतर आइटम निजी होते हैं और केवल उसी मॉड्यूल के भीतर कोड तक पहुंच योग्य होते हैं। लेकिन आप का उपयोग करके मॉड्यूल को सार्वजनिक कर सकते हैं पब कीवर्ड:

आधुनिक my_module {
पबfnmy_function() {
// फंक्शन बॉडी यहां जाती है
 }
}

तब आप पहुँच सकते हैं my_function आपके कार्यक्रम के अन्य भागों से।

व्यवहारों को परिभाषित करने के लिए लक्षणों का उपयोग करना

एक और तरीका है कि रस्ट इनकैप्सुलेशन को सक्षम बनाता है जो लक्षणों के उपयोग के माध्यम से होता है। लक्षण उन व्यवहारों को परिभाषित करते हैं जो प्रकार लागू कर सकते हैं और यह सुनिश्चित करते हैं कि विभिन्न प्रकार एक ही इंटरफ़ेस के अनुरूप हों।

पबप्रवृत्तिछापने योग्य {
fnछपाई(&खुद);
}
पबstructमेरी तरह {
// यहां स्ट्रक्चर फील्ड
}
प्रत्यय छापने योग्य के लिए मेरी तरह {
fnछपाई(&खुद) {
// कार्यान्वयन यहाँ
 }
}

छापने योग्य विशेषता है छपाई विधि, और मेरी तरह संरचना लागू करता है छापने योग्य विशेषता को लागू करके छपाई तरीका।

गुणों का उपयोग करके, आप यह सुनिश्चित कर सकते हैं कि कोई भी प्रकार जो लागू करता है छापने योग्य विशेषता है छपाई तरीका। जेनेरिक कोड के साथ काम करते समय यह आसान होता है जिसे एक सामान्य व्यवहार साझा करने वाले विभिन्न प्रकारों के साथ इंटरऑपरेट करने की आवश्यकता होती है।

जंग में विरासत

विरासत आपको एक वर्ग को एक अलग वर्ग के आधार पर परिभाषित करने देता है. उप-वर्ग अपने माता-पिता के गुणों और विधियों को प्राप्त करेगा।

जंग में, आपको वंशानुक्रम के बजाय रचना का उपयोग करने के लिए प्रोत्साहित किया जाता है। रचना मौजूदा वस्तुओं को जोड़कर नई वस्तुओं को बनाने की एक प्रक्रिया है। एक नया वर्ग बनाने के बजाय जो आधार वर्ग से कार्यक्षमता प्राप्त करता है, आप एक नई संरचना बना सकते हैं जिसमें आधार संरचना और उसके क्षेत्रों का एक उदाहरण होता है।

मौजूदा प्रकारों को मिलाकर नए प्रकार बनाना

आप नए प्रकार बनाने के लिए एनम और स्ट्रक्चर का उपयोग करेंगे। Enums परिमित मान वाले प्रकारों के लिए उपयोगी होते हैं, और structs कई फ़ील्ड्स को होल्ड कर सकते हैं।

आप विभिन्न प्रकार के जानवरों के लिए एक एनम प्रकार बना सकते हैं।

एनुमजानवर {
 बिल्ली,
 कुत्ता,
 चिड़िया,
// ...
}

वैकल्पिक रूप से, आप प्रत्येक जानवर के प्रकार के लिए फ़ील्ड वाली संरचना बना सकते हैं। स्ट्रक्चर्स में एनम और अन्य प्रकार हो सकते हैं।

structजानवर {
 नाम: डोरी,
 आयु: यू8,
 पशु प्रकार: पशु प्रकार,
}
एनुमपशु प्रकार {
 बिल्ली,
 कुत्ता,
 चिड़िया,
// ...
}

जानवर संरचना के मान रखती है पशु प्रकार गणना प्रकार।

आप वंशानुक्रम को लागू करने के लिए लक्षणों का उपयोग कर सकते हैं और एक नया निर्माण किए बिना व्यवहार को एक प्रकार में जोड़ सकते हैं।

प्रवृत्तिउड़ना {
fnउड़ना(&खुद);
}

यहां बताया गया है कि आप इसे कैसे लागू कर सकते हैं उड़ना कई प्रकार के लिए विशेषता।

structचिड़िया {
 नाम: डोरी,
 विंगस्पैन: f32,
}
प्रत्यय उड़ना के लिए चिड़िया {
fnउड़ना(&खुद) {
प्रिंटल!("{} उड़ रही है!", खुद।नाम);
 }
}
structविमान {
 नमूना: डोरी,
 अधिकतम चाल: यू32,
}
प्रत्यय उड़ना के लिए विमान {
fnउड़ना(&खुद) {
प्रिंटल!("{} उड़ रही है!", खुद।नमूना);
 }
}

चिड़िया और विमान स्ट्रक्चर लागू करते हैं उड़ना के साथ विशेषता और प्रिंट तार प्रिंटल! मैक्रो।

आप कॉल कर सकते हैं उड़ना उनके विशिष्ट प्रकारों को जाने बिना दोनों संरचनाओं पर विधि।

fnमुख्य() {
होने देना पक्षी = पक्षी {
 नाम: डोरी::से("गरुड़"),
 विंगस्पैन: 2.0,
 };
होने देना विमान = विमान {
 नमूना: डोरी::से("बोइंग 747"),
 अधिकतम चाल: 900,
 };
होने देना फ्लाइंग_ऑब्जेक्ट्स: वी.ई.सीडाइन फ्लाई> = वीसी![और पक्षी, और विमान];
के लिए वस्तु में फ्लाइंग_ऑब्जेक्ट्स {
 ऑब्जेक्ट फ्लाई ();
 }
}

मुख्य फ़ंक्शन तत्काल करता है विमान और चिड़िया प्रकार। flight_objects वेक्टर ऑब्जेक्ट इंस्टेंसेस का एक वेक्टर है, और के लिए लूप वेक्टर के माध्यम से घूमता है और कॉल करता है उड़ना उदाहरणों पर विधि।

जंग में बहुरूपता को लागू करना

एक वर्ग या प्रकार है बहुरूपी यदि एकाधिक प्रकार एक इंटरफ़ेस का प्रतिनिधित्व करते हैं. चूंकि लक्षण रस्ट में व्यवहार को परिभाषित करने के लिए कार्यक्षमता प्रदान करते हैं, जबकि सामान्य कोड लिखने के लिए एक सामान्य इंटरफ़ेस प्रदान करते हुए, आप बहुरूपता को लागू करने के लिए लक्षणों का उपयोग कर सकते हैं।

यहाँ एक विशेषता का नाम दिया गया है खींचने योग्य जो स्क्रीन पर ऑब्जेक्ट रेंडर करने के व्यवहार को परिभाषित करता है:

प्रवृत्तिखींचने योग्य {
fnखींचना(&खुद);
}

ड्रॉएबल विशेषता को लागू करने वाले प्रकार तक पहुंच सकते हैं खींचना समारोह।

structआयत {
 चौड़ाई: यू32,
 ऊंचाई: यू32,
}
प्रत्यय खींचने योग्य के लिए आयत {
fnखींचना(&खुद) {
// स्क्रीन पर आयत प्रस्तुत करें
 }
}

आप सामान्य कोड लिख सकते हैं जो उन वस्तुओं को खींचता है जो इसे लागू करते हैं खींचने योग्य प्रवृत्ति।

fndraw_object(ऑब्जेक्ट: & टी) {
 ऑब्जेक्ट ड्रा ();
}

draw_object समारोह एक सामान्य प्रकार लेता है टी इनपुट के रूप में जो लागू करता है खींचने योग्य विशेषता और कॉल करता है खींचना विशेषता पर विधि। विभिन्न वस्तुएं कार्यान्वित कर सकती हैं खींचने योग्य विशेषता और कार्यक्षमता तक पहुँचें।

जंग में अमूर्तता को लागू करना

अमूर्त OOP अवधारणा है जहां कक्षाएं और इंटरफेस निर्दिष्ट वस्तुओं और प्रकारों के लिए सुलभ हैं। आप गुणों के साथ जंग में अमूर्तता को लागू कर सकते हैं।

मीडिया प्लेयर के लिए यहां एक उदाहरण विशेषता है:

प्रवृत्तिमिडिया {
fnखेल(&खुद);
}

स्ट्रक्चर और एनम जो लागू करते हैं मिडिया विशेषता के लिए एक कार्यान्वयन प्रदान करना चाहिए खेल तरीका।

structगाना {
 शीर्षक: डोरी,
 कलाकार: डोरी,
}
प्रत्यय मिडिया के लिए गाना {
fnखेल(&खुद) {
प्रिंटल!("गाना बजा रहा है: {} by {}", खुद।शीर्षक, खुद।कलाकार);
 }
}

गाना संरचना लागू करता है मिडिया के लिए एक कार्यान्वयन प्रदान करके विशेषता खेल विधि जो किसी संदेश को फ़ील्ड के साथ प्रिंट करती है गाना कंसोल के लिए structs।

fnमुख्य() {
// सॉन्ग स्ट्रक्चर का एक उदाहरण बनाएं
होने देना गीत = गीत {
 शीर्षक: डोरी::से("बोहेमिनियन गाथा"),
 कलाकार: डोरी::से("रानी"),
 };
// गाने के उदाहरण पर प्ले विधि को कॉल करें
 गीत.प्ले ();
}

गाना चर का एक उदाहरण है गाना संरचना, और चर का उपयोग और कॉल कर सकते हैं खेल तरीका।

रस्ट कोड को व्यवस्थित करना आसान है

वस्तु-उन्मुख प्रोग्रामिंग कोड संगठन में मदद करती है। रस्ट के मॉड्यूल सिस्टम के लिए धन्यवाद, आप अपने कोड को व्यवस्थित, प्रबंधनीय और सहज रखने के लिए अपने आवेदन के लिए OOP अवधारणाओं को लागू करते हुए आसानी से अपने रस्ट कोड को व्यवस्थित कर सकते हैं।