शुरुआत के सूचक मूल बातें

परिचय

आज, प्रौद्योगिकी के सुधार और सस्ते होने के कारण, स्मृति और प्रसंस्करण शक्ति की मात्रा लगातार बढ़ रही है।

मूर के नियम के अनुसार:

एक एकीकृत सर्किट चिप पर रखे गए ट्रांजिस्टर की संख्या हर 24 महीने में दोगुनी हो जाती है।

यह ध्यान दिया जाना चाहिए कि दो पैरामीटर बदले गए हैं:

• ट्रांजिस्टर की संख्या
• मॉड्यूल आयाम

रैम (DRAM) की मात्रा पर समान सिद्धांतों का अनुमान लगाया जाता है।

अब स्मृति का मुद्दा तीव्र नहीं है, क्योंकि पिछले 10 वर्षों में स्मृति की मात्रा प्रति मृत्यु 16 गुना बढ़ गई है।

अधिकांश उच्च स्तरीय प्रोग्रामिंग लैंग्वेज (पीएल) पहले से ही "बॉक्स से बाहर" प्रोग्रामर से मेमोरी के साथ काम छिपाते हैं। और, चूंकि यह सवाल सो रहा था, प्रोग्रामर की एक नई जाति दिखाई देती है जो समझ में नहीं आते हैं या यह नहीं समझना चाहते हैं कि मेमोरी के साथ काम कैसे होता है।

इस विषय में, हम C ++ भाषा के उदाहरण का उपयोग करके मेमोरी के साथ काम करने के मुख्य बिंदुओं पर विचार करेंगे, क्योंकि यह उन कुछ अनिवार्य भाषाओं में से एक है जो मेमोरी के साथ सीधे काम का समर्थन करता है और OOP का समर्थन करता है।

इसके लिए क्या है आईटी?

यहां यह ध्यान देने योग्य है, यह लेख उन लोगों के लिए बनाया गया है जो अभी C ++ में अपना रास्ता शुरू कर रहे हैं या बस गतिशील स्मृति के बारे में एक विचार रखना चाहते हैं।

रनटाइम में, कोई भी प्रोग्राम DRAM में अपने लिए स्मृति का एक टुकड़ा रखता है। अन्य सभी DRAM मुक्त स्थान को "हीप" (अंग्रेज़ी में "हीप") कहा जाता है। कार्यक्रम की जरूरतों के लिए निष्पादन के दौरान स्मृति का आवंटन ठीक ढेर से होता है और इसे गतिशील मेमोरी का आवंटन कहा जाता है।

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

नया और हटाएं

मेमोरी आवंटन स्थिर और गतिशील हो सकता है। मेमोरी का स्थैतिक आवंटन कार्यक्रम संकलन के दौरान मेमोरी का एकमुश्त आवंटन कहा जाता है, और स्थैतिक मेमोरी की मात्रा रनटाइम पर नहीं बदलती है। एक क्लासिक उदाहरण पूर्णांक चर या सरणी की घोषणा है। लेकिन क्या होगा अगर प्रोग्रामर पहले से नहीं जानता है कि कंटेनर में कितने तत्वों की आवश्यकता है?
डायनेमिक मेमोरी का उपयोग उचित है जब आवश्यक हो तो कार्यक्रम की जरूरतों के लिए मेमोरी के आवंटन को व्यवस्थित करना आवश्यक है।
नया ऑपरेटर C ++ में डायनामिक मेमोरी को आवंटित करने के लिए जिम्मेदार है, और इसे हटाने के लिए डिलीट करना जिम्मेदार है।
नया ऑपरेटर अपने ऑपरेशन के परिणाम को कक्षा के एक नए उदाहरण के लिए लौटाता है।
वाक्य रचना यह है:

| डेटा प्रकार (T1) सूचक | * सूचक नाम | = नया | टाइप T1 |

नए ऑपरेटर के बाद, आप क्लास के क्षेत्रों को इनिशियलाइज़ करने के लिए, कंस्ट्रक्टर का उपयोग कर सकते हैं।
यह ध्यान देने योग्य है कि जब प्रोग्रामर अपने आवंटन पर नियंत्रण खो देता है तो ठीक उसी तरह की मेमोरी लीक होती है।

यह याद रखना महत्वपूर्ण है:
यदि आप "खर्च किए गए" अनावश्यक तत्वों की गतिशील मेमोरी को साफ़ करने के बारे में भूल गए, तो जल्दी या बाद में एक महत्वपूर्ण क्षण आएगा जब स्मृति बस लेने के लिए कहीं नहीं होगी।

स्मृति आवंटन और इसकी सफाई का एक उदाहरण:

int main{ // ,       new int *ptr = new int(); //   cout<<*ptr<<endl; // ,     delete ptr; //  delete     ,         return 0; } 

यह आलेख तथाकथित "स्मार्ट" पॉइंटर्स पर चर्चा नहीं करेगा, क्योंकि विषय बहुत व्यापक है, लेकिन, संक्षेप में: "स्मार्ट पॉइंटर्स प्रोग्रामर के लिए मेमोरी को साफ़ करने की प्रक्रिया को आंशिक रूप से स्वचालित करते हैं।"

संकेत

सी ++ में गतिशील मेमोरी के साथ काम करने के लिए पॉइंटर्स जिम्मेदार हैं। यह एक ऐसा विषय है जिससे भूख शुरुआती को बिगाड़ देती है।

आप * ऑपरेटर का उपयोग करके पॉइंटर घोषित कर सकते हैं। डिफ़ॉल्ट रूप से, यह मेमोरी के कुछ यादृच्छिक क्षेत्र को इंगित करेगा। ताकि हम अपनी आवश्यकता वाले मेमोरी क्षेत्र तक पहुंच सकें, हमें वांछित चर के लिए एक लिंक (ऑपरेटर) पास करना होगा।

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

महत्वपूर्ण वापसी

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

 int main() { // ,          int* pNum= new int(1) ; cout<<*pNum<<endl; //    ,        ,       (   int   ) pNum++; cout<<*pNum<<endl; // ,         return 0; } 

ऐसे उदाहरणों को देखते हुए, मैं पूछना चाहता हूं: "यह आवश्यक क्यों है यदि आप तुरंत एक चर प्राप्त कर सकते हैं?"

एक और उदाहरण:

हमारे पास एक प्रोग्रामर वर्ग है जो प्रोग्रामर की एक टीम के सदस्यों का वर्णन करता है जो संकेत के बारे में नहीं जानते हैं।

  class Programmers{ public: Programmers(){} Programmers(int iWeight, int iAge){ this->weight = iWeight; this->age = iAge; } int weight; int age; }; int main() { //     Programmers int size = 9; Programmers *prog [size]; //  Programmers Programmers *ptr = nullptr; //     Programmers       //          for (int i =0;i<size;i++) { ptr=new Programmers(i+100,i); prog[i]=ptr; } return 0; } 

इस तरह, स्मृति को हेरफेर किया जा सकता है जैसा कि हम कृपया। और यही कारण है, जब स्मृति के साथ काम करते हैं, तो आप "अपने आप को पैर में गोली मार सकते हैं।" यह ध्यान दिया जाना चाहिए कि सूचक के साथ काम करना बहुत तेज है, क्योंकि मूल्य स्वयं कॉपी नहीं है, लेकिन केवल एक विशिष्ट पते के लिए लिंक इसे सौंपा गया है।

वैसे, इस तरह का एक लोकप्रिय कीवर्ड वर्तमान क्लास ऑब्जेक्ट को एक पॉइंटर प्रदान करता है। ये संकेत हर जगह हैं।

रोज़मर्रा के जीवन में एक सूचक का उदाहरण:

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


वापस हमारे प्रोग्रामर के लिए। मान लें कि अब हमें ओपीओ से एनकैप्सुलेशन के सिद्धांत के रूप में कक्षा क्षेत्रों को निजी अनुभाग में ले जाने की आवश्यकता है, तो हमें इन क्षेत्रों तक पढ़ने के लिए गेटवेटर की आवश्यकता है। लेकिन कल्पना कीजिए कि हमारे पास 2 फ़ील्ड नहीं हैं, लेकिन 100 हैं, और इसके लिए हमें प्रत्येक के लिए अपना एक्सेसरी लिखना होगा?


ऐसा करने के लिए, हम टाइप "शून्य" का एक "एक्सेसर" बनाएंगे और इसे संदर्भ द्वारा तर्क पास करेंगे। संदर्भ द्वारा तर्क पारित करने का अर्थ यह है कि तर्क के मूल्य की नकल नहीं की जाती है, लेकिन केवल वास्तविक तर्क का पता प्रेषित किया जाता है। इस प्रकार, इस तरह के एक तर्क के मूल्य को बदलते समय, वर्तमान तर्क के मेमोरी सेल में डेटा भी बदल जाएगा।
यह समग्र प्रदर्शन को भी प्रभावित करता है, क्योंकि संदर्भ द्वारा तर्क पारित करना मूल्य से गुजरने की तुलना में तेज है। और यह तत्वों के बड़े संग्रह का उल्लेख नहीं है।

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

 class Programmers{ public: Programmers(){} Programmers(int iWeight, int iAge){ this->weight = iWeight; this->age = iAge; } //    ,   main     void getParams(int &w, int &a){ w=weight; a=age; } private: int weight; int age; }; int main() { int size = 9; Programmers *prog [size]; Programmers *ptr=nullptr; for (int i =0;i<size;i++) { ptr=new Programmers(i+100,i); prog[i]=ptr; } int w,a; int count = 9; //    //        Programmers **iter = prog; for (int i=0;i<count;i++) { ptr = *iter++; ptr->getParams(w,a); if(*(iter-1) != nullptr){ delete *(iter-1); ptr = nullptr; } cout<<w<<"\t"<<a<<endl; } return 0; } 

इस उदाहरण में, मैं आपको इस तथ्य का सार बताना चाहता हूं कि जब आप पॉइंटर के पते के मूल्य को बदलते हैं, तो आप मेमोरी के दूसरे क्षेत्र तक पहुंच सकते हैं।

डेटा संरचनाएं जैसे सूचियां, वैक्टर आदि। संकेत के आधार पर, और इसलिए गतिशील डेटा संरचनाएं कहा जाता है। और उन पर पुनरावृति करने के लिए पुनरावृत्तियों का उपयोग करना अधिक सही है। एक पुनरावृत्ति डेटा संरचना के एक तत्व के लिए एक संकेतक है और कंटेनर के तत्व तक पहुंच प्रदान करता है।

निष्कर्ष में

पॉइंटर्स के विषय को समझने के बाद, मेमोरी के साथ काम करना प्रोग्रामिंग का एक सुखद हिस्सा बन जाता है, और एक पूरी समझ के रूप में कि मशीन मेमोरी के साथ कैसे काम करती है और इसे कैसे प्रबंधित करना है। एक मायने में, "मेमोरी के साथ काम करना" की अवधारणा के पीछे एक दर्शन है। अपनी उंगलियों पर, आप चार्ज को बहुत छोटे कैपेसिटर की प्लेटों पर भी बदलते हैं।