प्रोग्रामिंग भाषाएं इस बात में भिन्न होती हैं कि वे स्मृति को कैसे संभालती हैं और स्मृति प्रबंधन नियमों को लागू करती हैं। गो और पायथन कचरा संग्रहकर्ताओं को नियुक्त करते हैं, इसलिए डेवलपर्स कोड लिखने पर ध्यान केंद्रित कर सकते हैं। C और C++ प्रोग्रामर्स को निचले स्तर पर मेमोरी को मैनेज करने की जिम्मेदारी देते हैं।
जंग स्मृति प्रबंधन को अलग तरह से मानता है, अवधारणाओं का उपयोग करके इसे स्वामित्व और उधार लेना कहते हैं। यह मेमोरी सुरक्षा को कुशलतापूर्वक लागू करने के लिए "उधार चेकर" का उपयोग करता है।
स्वामित्व क्या है?
स्वामित्व जंग की एक विशेषता और परंपरा है जो कचरा संग्रहकर्ता के बिना कार्यक्रमों की स्मृति सुरक्षा सुनिश्चित करने में मदद करती है। यह निपटने का एक और तरीका है मेमोरी लीक की समस्या आपके कोड में।
जंग संकलक जाँचता है कि क्या कोई कार्यक्रम संकलन समय पर स्वामित्व नियमों का पालन करता है। यदि प्रोग्राम इन नियमों का पालन करता है, तो यह चल सकता है। यदि ऐसा नहीं होता है, तो संकलक निष्पादन योग्य बनाने से इंकार कर देता है।
जंग का उपयोग करके स्वामित्व नियमों की पुष्टि करता है उधार चेकर। उधार चेकर स्वामित्व मॉडल की पुष्टि करता है और तय करता है कि स्मृति में कोई मान (
ढेर या ढेर) दायरे से बाहर है या नहीं। यदि कोई मूल्य इसके दायरे से बाहर है, तो यह कार्यक्रम के अन्य भागों के लिए तब तक पहुंच योग्य नहीं है जब तक कि इसे उधार नहीं लिया जाता है।स्वामित्व नियम
रस्ट में, प्रत्येक वेरिएबल उस मान का स्वामी होता है जिसके साथ इसे प्रारंभ किया गया है, और केवल एक ही स्वामी हो सकता है। एक बार मालिक के दायरे से बाहर हो जाने के बाद, मूल्य गिरा दिया जाता है। स्वामित्व नियमों के विवरण को समझना महत्वपूर्ण है।
पहला स्वामित्व नियम यह है कि प्रत्येक चर का अपना प्रारंभिक मूल्य होता है।
होने देना मालिक = डोरी::एक से");
मालिक ऊपर चर स्ट्रिंग का मालिक है एक और, पायथन और गो जैसी भाषाओं के विपरीत, उस मान को परिवर्तनशील पुनर्निर्धारण पर छोड़ दिया जाएगा।
दूसरा स्वामित्व नियम यह है कि दो चर एक ही स्मृति स्थान को इंगित नहीं कर सकते हैं; प्रत्येक मान का केवल एक स्वामी हो सकता है।
होने देना नया_स्वामी = स्वामी;
नया मालिक चर अब स्मृति स्थान पर संग्रहीत मान का स्वामी है मालिक चर। यदि आप का उपयोग करने का प्रयास करते हैं मालिक चर, संकलक घबरा जाएगा, और यह निष्पादन योग्य उत्पन्न करने से इंकार कर देगा।
कचरा संग्रहकर्ता का उपयोग करने वाली अधिकांश भाषाओं में, दो चर एक ही स्मृति स्थान को इंगित कर सकते हैं। समकक्ष जावास्क्रिप्ट कोड का एक उदाहरण यहां दिया गया है:
होने देना मालिक = "मालिक";
होने देना नया_स्वामी = स्वामी;
सांत्वना देनालॉग (new_owner);
ऊपर दिए गए जावास्क्रिप्ट कोड को चलाना बिना किसी त्रुटि के काम करता है, और यदि आप गो या पायथन में भी ऐसा ही करते हैं, तो आपका प्रोग्राम बिना त्रुटियों के भी काम करेगा।
तीसरा स्वामित्व नियम यह है कि एक बार एक चर घोषित दायरे से बाहर हो जाने पर, मान गिरा दिया जाता है, और स्मृति को हटा दिया जाता है।
// एक अलग दायरे में एक चर
{
होने देना उदाहरण = डोरी:: से ("यहां एक नया दायरा है");
}
प्रिंट!("{}", उदाहरण)
आप एक्सेस नहीं कर सकते उदाहरण इसके दायरे से बाहर परिवर्तनशील; ऐसा करने की कोशिश करने से कंपाइलर घबरा जाएगा।
कार्यों में स्वामित्व
जब आप किसी फ़ंक्शन के लिए एक तर्क के रूप में एक मान पास करते हैं, तो फ़ंक्शन उस चर तक पहुंच सकता है, भले ही इसे इसके दायरे में घोषित नहीं किया गया हो:
एफएनमुद्रक(मूल्य: डोरी) -> डोरी {
वापसी मूल्य
}एफएनमुख्य() {
होने देना एक्स = डोरी:: से ("एक मूल्य प्रिंट करता है"); // x स्ट्रिंग मान का मालिक है
// स्वामित्व को यहां प्रिंटर फ़ंक्शन में ले जाया गया है
प्रिंट!("{} परिणाम प्रिंटिंग एक्स का यह है कि यह -:", प्रिंटर (x));
}
फ़ंक्शन उस चर का उपयोग कर सकता है क्योंकि रस्ट इसके स्वामित्व को संकलन समय पर फ़ंक्शन पर ले जाता है।
आप सोच सकते हैं कि बाद में इसके मूल दायरे में चर का उपयोग करना अभी भी संभव है:
एफएनमुद्रक(मूल्य: डोरी) -> डोरी {
वापसी मूल्य
}एफएनमुख्य() {
होने देना एक्स = डोरी:: से ("एक मूल्य प्रिंट करता है");
प्रिंट!("{} परिणाम मुद्रण x का यह है कि यह -:", प्रिंटर (x));
// इसके मूल्य के स्वामित्व को स्थानांतरित करने के बाद चर का उपयोग करने की कोशिश कर रहा है
प्रिंट्लन!("{} पहुंच योग्य नहीं होना चाहिए", x)
}
लेकिन अगर आप यह कोशिश करते हैं, तो संकलक घबरा जाएगा और निष्पादन योग्य उत्पादन करने से इंकार कर देगा:
जंग कोड पुन: प्रयोज्यता को प्राथमिकता देता है
कोड पुन: प्रयोज्य एक आवश्यक अभ्यास है, लेकिन कोड पुन: प्रयोज्य का अभ्यास करने के लिए आपको रस्ट के स्वामित्व नियमों को समझने की आवश्यकता है।
जंग एक बहुत ही लचीली प्रोग्रामिंग भाषा है। यह परिवर्तनीय पुन: प्रयोज्य के लिए उधार लेने, स्थानांतरित करने, प्रतिलिपि बनाने और स्वामित्व की क्लोनिंग जैसी अवधारणाएं प्रदान करता है।
