खरोंच से उद्देश्य-सी

जो कोई भी अपने जीवन में Apple उत्पादों के लिए कार्यक्रम लिखना चाहता है वह एक क्षण आता है जब उसे एक नई प्रोग्रामिंग भाषा सीखनी होती है - ऑब्जेक्टिव-सी। एक बार इस खुशी के पल ने मुझे विवश कर दिया। और इस भाषा की मुख्य विशेषताओं को बेहतर ढंग से याद रखने के लिए, मैंने इसके प्रलेखन को समझने के दौरान अपने विचारों को रेखांकित करने का निर्णय लिया, जिसे मैं आपके साथ साझा करता हूं।

ओओपी के उद्भव का मुख्य सिद्धांत

लिखित कोड और उसके पोर्टेबिलिटी को पुन: उपयोग करने की समस्या लगातार प्रोग्रामर को इसे व्यवस्थित करने, संरचित करने और अमूर्त करने के नए तरीकों की तलाश करती है। इन समस्याओं को हल करने के लिए, नए प्रोग्रामिंग प्रतिमान, डिजाइन पैटर्न, नई भाषाएं, कंपाइलर और उनके लिए मानक पुस्तकालय, सॉफ्टवेयर प्लेटफॉर्म और फ्रेमवर्क बनाए जाते हैं। यह है कि उपप्रोग्राम (प्रक्रियाओं) के प्रतिमान का गठन किया गया था, जिसे CALL \ RET प्रोसेसर निर्देशों और स्टैक का उपयोग करके कार्यान्वित किया गया था (वास्तव में, निष्पादन थ्रेड को वर्तमान कमांड के बाद अगले एक के बजाय एक मनमाना के पते पर स्थानांतरित करना, इसके बाद वापसी)। फिर, मॉड्यूल प्रतिमान (प्रत्येक फ़ाइल एक अलग अनुवाद इकाई है), जिसने दो-चरण अनुवाद को जन्म दिया: मॉड्यूल का संकलन, और फिर उनकी विधानसभा (स्थिर या गतिशील) एक निष्पादन योग्य मॉड्यूल में।



परियोजनाओं में कोड की मात्रा में वृद्धि और इसे समर्थन करने की कठिनाइयों के कारण, 1960 के दशक में एक नए, ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग प्रतिमान बनने शुरू हो गए, यहां तक ​​कि छोटे घटकों - डेटा प्रकारों में कार्यक्रमों को तोड़ दिया। इसका सार एक दूसरे को संदेश भेजकर संस्थाओं (वस्तुओं) की बातचीत में निहित है। प्रत्येक ऑब्जेक्ट प्रोग्रामर (तथाकथित वर्ग) द्वारा परिभाषित डेटा प्रकार का एक चर है। इस तरह के एक विशेष उपयोगकर्ता डेटा प्रकार (वर्ग) की परिभाषा में दो चीजें शामिल हैं: डेटा के एक सेट की परिभाषा (अपरिवर्तनवादी, सदस्य) और दिनचर्या का एक सेट (विधियाँ) जो उनकी सेवा करेगी।









एक वर्ग को आमतौर पर प्रोग्रामर द्वारा परिभाषित एक प्रकार के रूप में स्वरूपित किया जाता है, जो अंतर्निर्मित (भाषा) डेटा प्रकारों और / या अन्य वर्गों पर आधारित होता है। एक सी भाषा के लिए जो एक वस्तु-उन्मुख प्रतिमान का समर्थन नहीं करता है, यह एक संरचना हो सकती है। दिनचर्या के एक सेट को सामान्य कार्यों के रूप में लागू किया जाता है, जो आवश्यक रूप से कम से कम एक पैरामीटर लेता है - संसाधित होने के लिए डेटा के सेट के लिए एक संकेतक।



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









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



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



ऑब्जेक्ट-ओरिएंटेड दृष्टिकोण का समर्थन करने वाली पहली भाषा Simula67 थी। फिर स्मालटाक आया। और 80 के दशक में सी ++ ने आकार लेना शुरू किया - आधुनिक सिस्टम प्रोग्रामिंग की मुख्य भाषा। 90 के दशक में इसके विस्तार और सुधार ने कई प्रतिमानों और डिजाइन पैटर्न को जन्म दिया, और उद्देश्य-सी भाषा सहित वस्तु-उन्मुख दृष्टिकोण की आधुनिक दृष्टि पर एक अपरिवर्तनीय प्रभाव पड़ा।

थोड़ा इतिहास

ऑब्जेक्टिव-सी 80 के दशक में स्मॉलटाक की ओर सी के संशोधन के रूप में उत्पन्न हुआ। इसके अलावा, इस संशोधन में नए सिंथैटिक कंस्ट्रक्शन और उनके लिए एक विशेष प्रीप्रोसेसर को जोड़ने (जो कोड से गुजरते हुए, उन्हें साधारण सी फ़ंक्शन कॉल में परिवर्तित किया गया), साथ ही एक रनटाइम लाइब्रेरी (इन प्रोसेसिंग कॉल) शामिल थे। इस प्रकार, शुरू में ऑब्जेक्टिव-सी को ऐड-ऑन सी के रूप में माना जाता था। एक अर्थ में, यह अभी भी मामला है: आप शुद्ध सी में एक प्रोग्राम लिख सकते हैं, और फिर ऑब्जेक्टिव-सी (यदि आवश्यक हो) से कुछ निर्माण जोड़ सकते हैं, या इसके विपरीत, यह उद्देश्य-सी पर कार्यक्रमों में सी का उपयोग करने के लिए स्वतंत्र है। इसके अलावा, यह सब C ++ प्रोग्राम पर लागू होता है। 1988 में, NeXT (और बाद में Apple) ने ऑब्जेक्टिव-सी को लाइसेंस दिया और इसके लिए एक संकलक और एक मानक पुस्तकालय (अनिवार्य रूप से एसडीआर) लिखा। 1992 में, GNU परियोजना के डेवलपर्स भाषा और संकलक में सुधार के लिए OpenStep परियोजना में शामिल हुए। तब से, जीसीसी ने ऑब्जेक्टिव-सी का समर्थन किया है। NeXT खरीदने के बाद, Apple ने उनके SDK (संकलक, पुस्तकालय, IDE) को उनके आगे के विकास के आधार के रूप में लिया। कोड के लिए IDE को Xcode कहा जाता था, और GUI के लिए इसे इंटरफ़ेस बिल्डर कहा जाता था। GUI विकास के लिए कोको रूपरेखा (और न केवल) उद्देश्य-सी कार्यक्रमों के लिए अब तक का सबसे महत्वपूर्ण विकास वातावरण है।

उद्देश्य-सी

ऑब्जेक्टिव-सी मॉड्यूल फाइलों में एक्सटेंशन ".m" होता है (यदि C ++ और ऑब्जेक्टिव-सी का मिश्रण इस्तेमाल किया गया था, तो एक्सटेंशन ".mm" है)। हेडर फाइलें ".h" हैं। ऑब्जेक्टिव-सी में बनाई गई सभी वर्ग की वस्तुओं को गतिशील मेमोरी में आवंटित किया जाना चाहिए। इसलिए, विशेष महत्व आईडी प्रकार है, जो कि किसी भी वर्ग की वस्तु के लिए एक संकेतक है (अनिवार्य रूप से शून्य *)। नल पॉइंटर को नील स्थिरांक कहा जाता है। इस प्रकार, किसी भी वर्ग के लिए एक संकेतक को आईडी प्रकार में डाला जा सकता है। एक समस्या है: आप कैसे जानते हैं कि आईडी के तहत किसी वस्तु को छिपाने वाला वर्ग किस वर्ग का है? यह आइसा अपरिवर्तनीयता के लिए किया जाता है जो कि विशेष बेस क्लास NSObject (एनएस उपसर्ग नेक्सटी स्टेप के लिए खड़ा है) के वर्ग के किसी भी ऑब्जेक्ट में मौजूद है। Isa invariant आरक्षित वर्ग का है। इस प्रकार की एक वस्तु आपको अपने स्वयं के और आधार वर्ग के नाम का पता लगाने की अनुमति देती है, वर्ग आक्रमणकारियों का एक सेट, साथ ही उन सभी तरीकों के प्रोटोटाइप जो इस ऑब्जेक्ट ने लागू किए हैं और उनके पते (चयनकर्ताओं की एक स्थानीय सूची के माध्यम से)। सभी ऑब्जेक्टिव-सी आरक्षित शब्द जो कि सी आरक्षित शब्दों से भिन्न हैं, एक @ (उदाहरण के लिए, @प्रोकोल, चयनकर्ता , इंटरफ़ेस ) से शुरू होते हैं। आमतौर पर एक सीमित दायरे (@ पाइरेक्ट, प्रोटेक्टेड ) वाले वर्गों के आक्रमणकारियों के नाम अंडरस्कोर से शुरू होते हैं। कोको स्ट्रिंग्स के लिए एक बहुत ही सुविधाजनक NSString वर्ग है। इस वर्ग के स्ट्रिंग स्थिरांक को @ "नमस्ते दुनिया" के रूप में लिखा जाता है, न कि स्ट्रिंग स्थिरांक "हैलो वर्ल्ड" के लिए सामान्य रूप से सी। BOOL प्रकार (अनिवार्य रूप से अहस्ताक्षरित चार) निरंतर मान YES और NO ले सकता है। ऑब्जेक्टिव-सी (जो C से भिन्न हैं और objc / objc.h हेडर फाइल में स्थित हैं) के लिए विशिष्ट सभी आरक्षित शब्द नीचे सूचीबद्ध हैं:

• इंटरफ़ेस एक वर्ग या श्रेणी (श्रेणी - श्रेणी को बिना वंशानुक्रम के साथ विस्तारित करना) घोषित करना शुरू करता है
• @ कार्यान्वयन वर्ग या श्रेणी की परिभाषा शुरू करता है
• @protocol एक प्रोटोकॉल घोषणापत्र शुरू करता है (विशुद्ध रूप से आभासी कार्यों से मिलकर C ++ वर्ग का एनालॉग)
• अंत किसी भी वर्ग, श्रेणी या प्रोटोकॉल के घोषणापत्र की परिभाषा को समाप्त करता है
• @ उपयुक्त कक्षा के आवेगों का दायरा वर्ग विधियों (C ++ के समान) तक सीमित करता है
• संरक्षित यह डिफ़ॉल्ट रूप से है। वर्ग के तरीकों और व्युत्पन्न कक्षाओं के तरीकों के वर्ग अक्रियाशील का दायरा सीमित करता है (C ++ के समान)
• @ रिपब्लिक दृश्यता पर प्रतिबंध हटाता है (C ++ के समान)
• संभव अपवाद पीढ़ी के साथ ब्लॉक को परिभाषित करें (C ++ के समान)
• @throw एक अपवाद ऑब्जेक्ट (C ++ के समान) फेंकता है
• पकड़ () पिछले प्रयास ब्लॉक में उठाए गए अपवाद को संभालता है (C ++ के समान)
• अंत में ब्लॉक को परिभाषित करता है कि कोशिश ब्लॉक के बाद पिकअप को वितरित किया जाता है, भले ही कोई अपवाद न फेंका गया हो
• वर्ग घोषित करने के लिए @class संक्षिप्त रूप (केवल नाम (C ++ के समान))
• चयनकर्ता (method_name) विधि नाम method_name के लिए संकलित चयनकर्ता लौटाता है
• @protocol (प्रोटोकॉल_name) प्रोटोकॉल वर्ग का एक उदाहरण देता है जिसका नाम प्रोटोकॉल_नाम है
• @encode (type_spec) एक वर्ण स्ट्रिंग को प्रारंभ करता है जिसका उपयोग type_spec के डेटा को एन्क्रिप्ट करने के लिए किया जाएगा
• @synchronized () समय में किसी भी बिंदु पर केवल एक थ्रेड द्वारा निष्पादित कोड के एक ब्लॉक को परिभाषित करता है।

संदेश सेवा

किसी विधि को निष्पादित करने के लिए किसी वस्तु को बाध्य करने के लिए, आपको इसे एक संदेश भेजने की आवश्यकता है, जिसका नाम आवश्यक विधि के समान है। इस तरह के संदेश को एक विधि चयनकर्ता कहा जाता है। पैकेज का सिंटैक्स निम्नानुसार है:

[receiver method];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

संदेश में, आप पैरामीटर को विधि में पास कर सकते हैं:

 [receiver method: 20.0 : 30.0];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रत्येक पैरामीटर को एक बृहदान्त्र से पहले होना चाहिए। कितने कॉलोन - इतने सारे पैरामीटर। प्रत्येक ऐसे कोलोन-पैरामीटर के बाद विधि का नाम जारी रह सकता है:

 [receiver methodWithFirstArgument: 10 andSecondArgument: 20];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

निम्नलिखित सिंटैक्स द्वारा असीमित संख्या में तर्कों के साथ तरीके लागू किए जाते हैं:

 [receiver undefinedNumberParameters: one, two, three, four, five, six, seven];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

संदेश भेजना, किसी भी C फ़ंक्शन की तरह, एक विशिष्ट (शायद शून्य) मान लौटाता है:

 BOOL booleanValue; booleanValue = [reveiver method];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

शून्य संदेश भेजते समय, यह गायब हो जाता है। किसी ऑब्जेक्ट को संदेश भेजते समय जो उस वर्ग से संबंधित होता है जिसने आदेशित विधि को लागू नहीं किया था, एक अपवाद होता है, यदि पकड़ा नहीं गया, तो पूरे कार्यक्रम को अनियोजित समाप्ति की ओर ले जाता है। यह जांचने के लिए कि कोई दी गई वस्तु संदेश पर प्रतिक्रिया देती है या नहीं, आप निम्न कोड टेम्पलेट का उपयोग कर सकते हैं:

 if ([anObject respondsToSelector: @selector(myMethodWith2Argumets::)]) { //  [anObject myMethodWith2Argumetns: @”first” : @”second”]; } else { //      }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मैसेजिंग कैसे काम करती है

संदेश भेजना सी-फ़ंक्शन में प्रोटोटाइप के साथ प्रसारित होता है:

 id objc_msgSend(id receiver, SEL method, ...);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एसईएल प्रकार, वास्तव में, चार कास्ट * के रूप में परिभाषित किया गया है, लेकिन इसे इंटिमेट के रूप में व्याख्या करना बेहतर है, क्योंकि रन के समय में सभी चयनकर्ताओं को वैश्विक चयनकर्ता तालिका के अनुसार पूर्णांक मानों के साथ अनुक्रमित किया जाता है।









रिसीवर ऑब्जेक्ट के आइसा इनवेरिएंट का उपयोग करना (जब फाउंडेशन फ्रेमवर्क का उपयोग करना, जो कोको के लिए बुनियादी है, सभी वर्गों को NSObject क्लास को इनहेरिट करना होगा, इसलिए आइसा का अस्तित्व अपरिहार्य है), यह फ़ंक्शन यह निर्धारित करने के लिए क्लास के सूत्रों की स्थानीय सूची को स्कैन करता है कि क्या इस क्लास का ऑब्जेक्ट विधि संदेश पर प्रतिक्रिया करता है। यदि ऐसा चयनकर्ता पाया जाता है, तो नियंत्रण को उस वर्ग की संबंधित विधि में स्थानांतरित कर दिया जाता है जिसमें ऑब्जेक्ट आईडी (उसके चालकता के लिए एक सूचक) और चयनकर्ता के पास होने के बाद निर्दिष्ट objc_msgSend () फ़ंक्शन के पैरामीटर हैं। संदेश भेजे जाने के परिणामस्वरूप विधि द्वारा दिया गया मान लौटा दिया जाता है। यदि रिसीवर ऑब्जेक्ट में यह चयनकर्ता नहीं है, तो objc_msgSend () फ़ंक्शन इसके आधार वर्ग के चयनकर्ताओं की सूची को स्कैन करता है।









इस योजना के साथ, उदाहरण के लिए, एक कॉल:

 [receiver ddObject: otherObject];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रसारण:

 objc_msgSend(receiver, 12, otherObject);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चूंकि वैश्विक चयनकर्ता तालिका 12 स्ट्रिंग "एडऑब्जेक्ट:" से मेल खाती है। इसके बाद, objc_msgSend () फ़ंक्शन रिसीवर ऑब्जेक्ट के चयनकर्ताओं की सूची को खोजता है और, इसे ढूंढता है (इसे NSArray वर्ग का ऑब्जेक्ट होने दें जो चयनकर्ता 12 के साथ विधि को लागू करता है), प्रकार की कॉल करता है:

 addObject(receiver, otherObject);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

विधि घोषणा

यह ध्यान रखना दिलचस्प है कि वर्ग घोषणा में पिछले अनुभाग से addObject विधि का प्रोटोटाइप इस तरह दिखता था:

 - (void)addObject: (id)otherObject;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यही है, यह केवल एक पैरामीटर लिया। लेकिन, एक वस्तु-उन्मुख प्रतिमान के सिद्धांत पर आधारित है कि विधियाँ रूटीन हैं जो कुछ डेटा सेट को संसाधित करती हैं, विधि को संसाधित होने के लिए डेटा के पते को पास करना होगा। इसलिए, इस तरह के एक पैरामीटर को किसी भी वर्ग विधि को अंतर्निहित रूप से पारित किया जाता है। इस अतिरिक्त पैरामीटर के बारे में संकलक यह शून्य ("-") को स्पष्ट करता है, जो विधि के प्रोटोटाइप में पहला है। इस तरह की विधि (सामने माइनस के साथ) को ऑब्जेक्ट (या उदाहरण) विधि कहा जाता है, क्योंकि केवल कुछ वर्ग की वस्तु पर कॉल किया जा सकता है। विधि के शरीर में, डेटा सूचक (या संदेश को भेजे गए ऑब्जेक्ट का पता) के लिए यह सूचक आरक्षित शब्द स्वयं (सी ++ में इस के अनुरूप) के माध्यम से सुलभ है, और आधार वर्ग आवृत्ति के लिए सूचक आरक्षित शब्द सुपर के माध्यम से सुलभ है। इसके अलावा, वैश्विक चयनकर्ता तालिका से इस पद्धति के चयनकर्ता निहित पैरामीटर _cmd को ऑब्जेक्ट विधि में भी पास किया जाता है। C ++ प्रोग्रामर के दृष्टिकोण से, Objective-C में सभी ऑब्जेक्ट विधियाँ आभासी कीवर्ड के साथ घोषित की जाती हैं, और हमेशा गतिशील बहुरूपता का पालन करती हैं।



यदि आप प्रोटोटाइप विधि की शुरुआत में एक प्लस चिह्न ("+") डालते हैं, तो ऐसी विधि को एक वर्ग विधि माना जाएगा, और निश्चित रूप से, निहित पैरामीटर स्वयं को स्वीकार नहीं करेगा (यह C ++ में एक स्थिर विधि घोषित करने के समान है)। और वस्तु के आईए के बिना स्वयं द्वारा इंगित किए बिना, सुपर पॉइंटर निश्चित रूप से या तो काम नहीं करेगा।

इस प्रकार, किसी भी विधि का प्रोटोटाइप इस तरह घोषित किया जाता है:

 -|+ (<  >)  [ : (<  >) [ [] : (<  >)] … ]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उदाहरण के लिए:

 + (Class)class; + (id)alloc; - (id)init; - (void)addObject: (id)anObject; + (NSString *)stringWithCString: (const char*)aCString usingUncoding: (enum NSStringEncoding)encoding; - (NSString *)initStringWithFormat: (NSString *)format, …;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यदि विधि एक ऑब्जेक्ट (आईडी प्रकार) या एक वर्ग (क्लास प्रकार) लौटाती है, तो आप नेस्टेड कॉल सिंटैक्स का उपयोग कर सकते हैं:

 [myLabel setText: [[NSString stringWithString: @”Hello”] stringByAppendingString: @” world”]];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यहाँ, UIKit फ्रेमवर्क से UILabel वर्ग का ऑब्जेक्ट स्ट्रिंग @ "हेल्लो वर्ल्ड" के बराबर इंवेरिएंट टेक्स्ट के मान पर सेट है। यह स्ट्रिंग, बदले में, @ "हैलो" और @ "दुनिया" के तार को मिलाकर बनाई गई है। पहला @ "हैलो" निरंतर पैरामीटर के साथ NSString वर्ग को एक stringWithString संदेश भेजने का परिणाम है। इस तरह के कॉल पैरामीटर स्ट्रिंग द्वारा आरंभीकृत NSString वर्ग की एक वस्तु देता है। फिर @ ऑब्जेक्ट दुनिया के पैरामीटर के साथ एक stringByAppendingString संदेश इस ऑब्जेक्ट पर भेजा जाता है। इस संदेश को भेजने का परिणाम NSString वर्ग का एक ऑब्जेक्ट है जिसमें रिसीवर ऑब्जेक्ट के मान और स्ट्रिंग तर्क का संयोजन है। यह ऑब्जेक्ट सेटटेक्स्ट में भी आता है: एक पैरामीटर के रूप में myLabel ऑब्जेक्ट का संदेश।

वर्ग घोषणा

Complex.h फ़ाइल में एक साधारण जटिल संख्या वर्ग घोषित करें:

 #import <Foundation/Foundation.h> // NSObject   NSString @interface Complex : NSObject { double _re; //    double _im; //    NSString *_format; //    description } - (id)initWithRe: (double)re andIm: (double)im; //  + (Complex *)complexWithRe: (double)re andIm: (double)im; //      - (Complex *)add: (Complex *)other; //   - (Complex *)sub: (Complex *)other; //   - (NSString *)format; //   _format - (void)setFormat: (NSString *)format; //  _format - (double)re; //        - (void)setRe: (double)re; - (double)im; - (void)setIm: (double)im; @end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जैसा कि आप देख सकते हैं, पूरा विज्ञापन कीवर्ड इंटरफ़ेस और अंत में संलग्न है। पहला कदम आक्रमणकारियों (ब्रेसिज़ में) की घोषणा करना है। घुंघराले ब्रैकेट के बाहर, विधियां घोषित की जाती हैं। विवरण विधि एक कारण से वर्ग घोषणा से गायब है। तथ्य यह है कि यह डीललॉक और इनिट विधियों की तरह, वर्ग परिभाषा में मौजूद है। कॉम्प्लेक्स वर्ग की किसी वस्तु को विवरण संदेश भेजते समय, इसके चयनकर्ताओं की स्थानीय सूची पर विचार किया जाएगा, जहां, संकलन के बाद, इस ऑब्जेक्ट के वर्ग द्वारा लागू किए गए सभी तरीकों के चयनकर्ता जिन्हें इंटरफ़ेस भाग में भी घोषित नहीं किया गया है। अर्थात्, init, description और dealloc बिल्कुल सही तरीके से कॉल करेगा।

ऑब्जेक्ट बनाएँ

इस तथ्य के कारण कि सभी वस्तुओं को गतिशील मेमोरी में वितरित किया जाता है, एक वस्तु का निर्माण दो चरणों में किया जाना है: 1) मेमोरी आवंटन (आवंटन संदेश) और 2) इन्वर्टर (क्लास कंस्ट्रक्टर्स) का आरंभीकरण।

 MyClass *myObject = [[MyClass alloc] init]; //  MyClass alloc          ,   init    myObject
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ऑब्जेक्ट बनाने के बाद, आप इसे सुरक्षित रूप से उपयोग कर सकते हैं:

 NSMutableArray *array = [[NSMutableArray alloc] init]; //   MyClass *myObject = [[MyClass alloc] init]; //  [myObject myMethod]; //   [array addObject: myObject]; //    MyClass *otherObject = [array getLastObject:]; //   ,      [otherObject myOtherMethod: YES]; //       BOOL
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 + (NSString *)stringWithCString: (char const *)string encoding: (NSStringEncoding)encoding;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह आबंटित शून्य के साथ संगत लाइन द्वारा तैयार एक तैयार स्ट्रिंग लौटाता है, बिना आबंटित और init कॉल के:

 NSString *myString = [NSString stringWithCString: “Bla-bla-bla” encoding: NSASCIIStringEncoding];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

वस्तु जीवन भर

जैसे ही ऑब्जेक्ट के लिए पॉइंटर अपने दायरे से बाहर जाता है, इसके लिए आवंटित की गई मेमोरी इरिट्रेटिवली खो जाती है (जब तक कि, निश्चित रूप से, यह उस ऑब्जेक्ट का आखिरी पॉइंटर था) और एक लीक होता है। इस तरह के अवांछनीय परिणामों से बचने के लिए, उद्देश्य-सी संसाधनों के लिंक की गिनती के प्रतिमान का समर्थन करता है। इस प्रकार, प्रत्येक ऑब्जेक्ट में एक पूर्णांक काउंटर होता है जो इसे इंगित करने वालों की संख्या दिखाता है। जब यह काउंटर शून्य तक पहुंच जाता है, तो इस ऑब्जेक्ट के लिए आवंटित मेमोरी सिस्टम में वापस आ जाती है। आवंटित वर्ग की विधि को कॉल करने के बाद, यह काउंटर एक के बराबर है। इसके मूल्य को बढ़ाने के लिए वस्तु को बनाए रखने के लिए एक संदेश भेजना आवश्यक है, और कम करने के लिए - रिलीज। इन सभी तरीकों को NSObject द्वारा कार्यान्वित किया जाता है, जो कि हमारे किसी भी वर्ग को निश्चित रूप से विरासत में मिलेगा। यह ध्यान रखना दिलचस्प है कि NSString वर्ग की स्थिर वस्तुओं के लिए काउंटर मूल्य (उदाहरण के लिए @ "मैं एक स्ट्रिंग हूं") -1 है, जो कि अधिकतम संभव है। यहाँ एक काउंटर के साथ काम करने का एक उदाहरण है:

 id anObject = [SomeClass alloc]; //  == 1 [anObject init]; //    [anObject reatin]; //   (  == 2) [anObject release]; // (  == 1     ) [anObject release]; // ,   1         
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 - (id)init { self = [super init]; //     //   if (self) //        //    ,      nil { //       } return self; //    }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यहां एक वर्ग के लिए एक विशिष्ट विशिष्ट (डिफ़ॉल्ट नहीं) कंस्ट्रक्टर है जो एक वर्ग के दो सदस्यों और एक पूर्णांक इनवॉयरमेंट के साथ है:

 - (id)initWithInt: (int)number { if (self = [super init]) { _myMember1 = [[SomeClass alloc] init]; //  :  ,    _myMember2 = [[SomeClass alloc] init]; _myIntMember = number; //     //   } return self; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

NSObject के लिए रिलीज़ और रिटेन का कार्यान्वयन वैचारिक रूप से निम्नलिखित में से लगभग एक है, और इसे संदर्भ वर्गों के लिए प्रवेश की कमी के कारण व्युत्पन्न वर्गों में पुनर्परिभाषित करने की आवश्यकता नहीं है:

 - (void)retain { [_internalLock lock]; //   _referenceCounter++; //  _referenceCounter –    [_internalLock unlock]; } - (void)release { [_internalLock lock]; _referenceCounter--; //  if (!_referenceCounter) //    { [_internalLock unlock]; [self dealloc]; // ,    (  ) } [_internalLock unlock]; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

 - (void)dealloc { [_myMember1 release]; //    [_myMember2 release]; //     //[_myIntMember release];   , ..           [super dealloc]; //c   ,     }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

पहुंच के तरीके

एक विधि से किसी वस्तु का पता वापस करते समय या किसी औपचारिक पैरामीटर के साथ किसी अपरिवर्तनीय को इनिशियलाइज़ करते हुए संदर्भ गिनती के साथ सही काम बहुत महत्वपूर्ण है। आमतौर पर ऐसी चीजें तथाकथित एक्सेस विधियों द्वारा की जाती हैं, जो वस्तुओं के आक्रमणकारियों को वापस करती हैं और सेट करती हैं। यह एक विधि का नाम देने के लिए प्रथागत है, जो एक अपरिवर्तनीय का मान लौटाता है, साथ ही एक अपरिवर्तनीय, और विधि का नाम जो इसके मूल्य को निर्धारित करता है, शब्द सेट के साथ शुरू होता है:

 - (void)setRe: (double)re { _re = re; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चूंकि _re अपरिवर्तित अंतर्निहित प्रकार से संबंधित है, इसलिए इसके मूल्य को बदलने में कोई कठिनाई नहीं है। लेकिन यदि अपरिवर्तनीय एक निश्चित वर्ग की वस्तु है, तो साधारण असाइनमेंट अपरिहार्य है, क्योंकि संदर्भ काउंटर को ध्यान में रखा जाना चाहिए। इस समस्या को हल करने के लिए निम्नलिखित तीन विधियों का उपयोग किया जाता है:

 //,      [label setText: @”Hello world”]; //  text // label     NSString * //  setText   UILabel ( №1) - (void)setText: (NSString *)text { [text retain]; //      [_text release]; //       _text _text = text; //    } //  setText   UILabel ( №2) - (void)setText: (NSString *)text { if (_text != text) //c    { [_text release]; //     //  _text _text = [text retain]; //   //       } } //  setText   UILabel ( №3 – ) - (void)setText: (NSString *)text { if (_text != text) { [_text autorelease]; // e   // _text    _text = [text retain]; //   //       } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

विकल्प # 3 बहुत सफल नहीं है क्योंकि यह वर्तमान स्व-लोडिंग पूल को रोक देता है, लेकिन यह आमतौर पर बहुत वांछनीय नहीं है (अगला अनुभाग देखें)।

एक अपरिवर्तनीय का मान पढ़ने की पहुंच विधि हमेशा बहुत सरल होती है:

 - (NSString *)text { return _text; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रोग्राम थ्रेड्स में स्व-लोडिंग पूल

आइए अब इसके अंदर बनाई गई वस्तु को विधि से लौटाने की कोशिश करते हैं:

 -(NSString *)sayHelloToName: (NSString *)name withSurname: (NSString *)surname { NSString *retString = [[NSString alloc] initWithFormat: @”%@ %@!”, name, surname]; //      return retString; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रारूप स्ट्रिंग सी भाषा मानक के अनुरूप है। लेकिन यदि इसमें आईडी प्रकार निर्दिष्ट करना आवश्यक है, तो% @ प्रारूप विनिर्देशक का उपयोग किया जाता है। एक प्रारूप पार्सिंग विधि कैसे समझती है कि आईडी के लिए कौन से वर्ण स्थानापन्न हैं? यह केवल स्थानापन्न करेगा जो दिए गए ऑब्जेक्ट के विवरण का विवरण विधि लौटाता है। यह विधि मूल रूप से NSObject वर्ग के लिए घोषित की गई थी। NSString ने इसकी स्ट्रिंग सामग्री को आउटपुट करने के लिए इसे फिर से परिभाषित किया। इसे फिर से परिभाषित करके, कोई भी वस्तु इसकी स्ट्रिंग सामग्री का प्रतिनिधित्व कर सकती है। उदाहरण के लिए, एक जटिल संख्या का एक वर्ग, जो डबल प्रकार के दो आक्रमणकारियों के साथ कर सकता है:

 - (NSString *)description { return [NSString stringWithFormat: @”re: %lf im: %lf”, _re, _im]; //  @“re: 1.0 im: 2.5”  _re == 1.0  _im == 2.5 }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

SayHelloToName के बाद: withSurname: पद्धति को निष्पादित किया जाता है, एक मेमोरी रिसाव निश्चित रूप से होगा, क्योंकि कॉलिंग कोड सबसे अधिक संभावना नहीं है कि प्रसंस्करण के बाद लौटे ऑब्जेक्ट को एक रिलीज संदेश भेजने की आवश्यकता है। यहां तक ​​कि अगर वह ऐसा करने का अनुमान लगाता है, तो यह संभव है कि एक सूचक वस्तु के अपरिवर्तित में वापस आ गया था, जिसका अर्थ है कि इसका विनाश गंभीर परिणामों से भरा है। मैं भविष्य में वस्तुओं के आत्म-मुक्ति के लिए एक तंत्र रखना चाहूंगा, ताकि उपयोगकर्ता कोड उन्हें मुक्त करने के बारे में बिल्कुल न सोचें। यह समस्या NSAutoreleasePool वर्ग की वस्तुओं का उपयोग करके हल की गई है - वस्तुओं का एक आत्म-लोडिंग पूल।



इस वर्ग की एक वस्तु बनाने के बाद, इसके बाद बनाई गई सभी वस्तुओं को ऑटोरेलिज संदेश भेजा जा सकता है। इस स्थिति में, इस ऑब्जेक्ट को वर्तमान (अंतिम निर्मित) सेल्फ-पेड पूल में रखा गया है। जब एक निश्चित पूल को एक रिलीज संदेश प्राप्त होता है, तो वह अपनी सभी वस्तुओं को एक ही संदेश भेजेगा, उनकी संदर्भ संख्या कम कर देगा (अनिवार्य रूप से, इसे नष्ट करना)। इस तरह से। सेल्फ-लोडिंग पूल में रखी गई वस्तु पूल के जीवन भर स्मृति को जीवित और घेरे रहती है। यह छोटी अस्थायी वस्तुओं के लिए उपयोगी है, लेकिन समय के साथ महत्वपूर्ण मात्रा में स्मृति ले सकता है। इसलिए, यह अनुशंसा की जाती है कि बड़ी संख्या में अस्थायी वस्तुओं को उत्पन्न करने में सक्षम लूप जो स्व-लोडिंग पूल में भेजे जाते हैं उन्हें स्थानीय (नेस्टेड) ​​पूल के साथ फंसाया जाए।



कोको का उपयोग करते हुए एक कार्यक्रम में किसी भी धागे को बहुत शुरुआत में (अन्य वस्तुओं को बनाने से पहले) NSAutoreleasePool वर्ग का एक ऑब्जेक्ट बनाना होगा, और इसे बहुत अंत में नष्ट करना होगा (अन्य सभी वस्तुओं को नष्ट करने के बाद)। मुख्य () फ़ंक्शन, जो किसी भी उद्देश्य-सी कार्यक्रम का मुख्य धागा है, को कोको रूपरेखा का उपयोग करते समय हमेशा इस तरह दिखना चाहिए:

 int main(int argc, char *argv[]) //    main() { NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; // ,     int retVal; //    [pool drain]; //    ,     autorelease return retVal; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और सही sayHelloToName: withSurname: विधि अब इस तरह दिखेगा:

 -(NSString *)sayHelloToName: (NSString *)name withSurname: (NSString *)surname { NSString *retString = [[NSString alloc] initWithFormat: @”%@ %@!”, name, surname]; //      [retString autorelease]; //  ,  retString     return retString; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

वैसे, एक सेल्फ पास्ड पूल की ड्रेन विधि केवल अंतर होने के साथ रिलीज़ होने के समान है, जो स्वयं और सभी निहित वस्तुओं को मुक्त करने के अलावा, यह कचरा कलेक्टर को गेम में प्रवेश करने का संकेत भी देता है। हालांकि, यह केवल मैक ओएस 10.4 और उच्चतर के लिए प्रासंगिक है, क्योंकि आईओएस पर कोई कचरा संग्रह नहीं है।

कक्षा की परिभाषा

अब जटिल वर्ग के तरीकों की परिभाषा के साथ Complex.m फाइल पर विचार करें:

 #import “Complex.h” @implementation Complex - (id)init { return [self initWithRe: 0.0 andIm: 0.0]; } - (id)initWithRe: (double)re andIm: (double)im { if (self = [super init]) { _re = re; _im = im; _format = @”re: %.1lf im: %.1lf”; //    } } + (Complex *)complexWithRe: (double)re andIm: (double)im { return [[[Complex alloc] initWithRe: re andIm: im] autorelease]; } - (Complex *)add: (Complex *)other { return [[Complex alloc] initWithRe: _re + other->_re andIm: _im + other->_im]; } - (Complex *)sub: (Complex *)other { return [[Complex alloc] initWithRe: _re – other->_re andIm: _im – other->_im]; } - (NSString *)format { return _format; } - (void)setFormat: (NSString *)format {//    - [format retain]; [_format release]; _format = format; } - (double)re { return _re; } - (void)setRe: (double)re { _re = re; } - (double)im { return _im; } - (void)setIm: (double)im { _im = im; } - (NSString *)description {//    return [NSString stringWithFormat: _format, _re, _im]; } - (void)dealloc { [_format release]; //    dealloc [super dealloc]; } @end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

डिफ़ॉल्ट निर्माता विशिष्ट प्रारंभिक मापदंडों के साथ एक विशेष निर्माता को कॉल करता है। ComplexWithRe: andIm: पद्धति वर्तमान सेल्फ-लोडिंग पूल में स्थित कॉम्प्लेक्स क्लास की एक प्रारंभिक ऑब्जेक्ट लौटाती है। विवरण विधि वही करती है, जो एनएसएसट्रिंग वर्ग की एक वस्तु लौटाती है। यहां एक उदाहरण कार्यक्रम है जहां परिसर वर्ग का उपयोग किया जाता है:

 #import “Complex.h” #import <stdio.h> // printf() int main() { NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; Complex *num1 = [[Complex alloc] init]; //0.0+0.0*i Complex *num2 = [[Complex alloc] initWithRe: 1.5 andIm: -2]; //1.5-2.0*i Complex *num3 = [Complex complexWithRe: 5 andIm: 7]; //5.0+7.0*i printf(“%s\n”, [[num2 description] cStringUsingEncoding: NSASCIIStringEncoding]); //> re: 1.5 im: -2.0 printf(“%s\n”, [[[num2 add: num3] description] cStringUsingEncoding: NSASCIIStringEncoding]); //> re: 6.5 im: 5.0 [num1 setRe: [num2 re]]; // _re  num1   num2 [num1 setIm: [num3 im]]; // _im  num1   num3 [num1 setFormat: @”%.2lf+%.2lf*i”]; //    num1 printf(“%s\n”, [[num1 description] cStringUsingEncoding: NSASCIIStringEncoding]); //> 1.50+7.00*i [num1 release]; [num2 release]; //[num3 release];  , ..      [pool drain]; return 0; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

श्रेणियाँ और एक्सटेंशन

यदि आपको पहले से लिखे गए वर्ग (और संभवतः संकलित) में विरासत के बिना कुछ तरीकों को जोड़ने की आवश्यकता है, तो श्रेणियां आपको बहुत प्रयास किए बिना ऐसा करने की अनुमति देती हैं:

 // “CategorizedComplex.h” #import “Complex.h” @interfce Complex (CategorizedComplex) - (Complex *)mul: (Complex *)other; - (Complex *)div: (Complex *)other; @end // “CategorizedComplex.m” #import “CategorizedComplex.h” @implementation Complex (CategorizedComplex) - (Complex *)mul: (Complex *)other { return [Complex complexWithRe: _re * other->_re - _im * other->_im andIm: _re * other->_im + _im * other->_re]; } - (Complex *)div: (Complex *)other { double retRe, retIm, denominator; denominator = other->_re * other->_re + other->_im * other->_im; if (!denominator) return nil; retRe = (_re * other->_re + _im * other->_im) / denominator; retIm = (_im * other->_re - _re * other->_im) / denominator; return [Complex complexWithRe: retRe andIm: retIm]; } @end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और आप इसे इस तरह से उपयोग कर सकते हैं:

 CategorizdComplex *num1 = [[CategorizedComplex alloc] initWithRe: 1 andIm: 999]; Complex *num2 = [Complex complexWithRe: 0 andIm: 0]; CategorizedComplex *num3 = [num1 div: num2]; //num3 == nil
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक्सटेंशन अच्छी सेवाओं को नामहीन श्रेणियों के रूप में ले जाते हैं:

 // “CategorizedComplex.m” #import “CategorizedComplex.h” @interface Complex () - (void)zeroComplex; //     @end @implementation Complex - (void)zeroComplex //       { _re = 0; _im = 0; } @end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

प्रोटोकॉल

ऑब्जेक्टिव-सी प्रोटोकॉल, विधियों के एक समूह की एक औपचारिक घोषणा है, जो यदि वांछित है, तो किसी भी वर्ग (सी ++ में कक्षा का एनालॉग, जहां सभी विधियों को आभासी ... = 0 विनिर्देशक के साथ घोषित किया जाता है) द्वारा लागू किया जा सकता है। संस्करण 2.0 में, प्रोटोकॉल विधियों की आवश्यकता हो सकती है (@required विनिर्देशक, इसे चुप माना जाता है) और चयनात्मक (@optional विनिर्देशक)। यदि किसी भी वर्ग ने आवश्यक प्रोटोकॉल विधियों को लागू किया है, तो इसे एक वर्ग कहा जाता है जो इस प्रोटोकॉल का समर्थन करता है। प्रोटोकॉल, और इसका समर्थन करने वाले वर्ग को इस तरह घोषित किया जाता है:

 @protocol MyPrinterProtocol @required - (void)print; - (BOOL)switchedOn; @optional - (void)loadPapaer: (int)numberOfPages; @end @interface MyPrinter : NSObject <MyPrinterProtocol> // MyPrinter   MyPrinterProtocol { BOOL _state; int _numberOfPages; } - (id)initWithState: (BOOL)state andPagesCount: (int)pages; - (BOOL)state; @end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

MyPrinter वर्ग की एक वस्तु को प्रिंट और स्विच्डऑन संदेश भेजने की गारंटी दी जा सकती है, और, उत्तर के लिए जाँच के बादसंचालन:, एक loadPaper: संदेश भेजा जा सकता है, जैसे कि इसके कार्यान्वयन में मौजूद विधियों की परिभाषा होनी चाहिए। एक वर्ग वस्तु की घोषणा करना जो एक प्रोटोकॉल का समर्थन करता है, इस प्रकार है:

 MyPrinter *printer; id anotherPrinter = [[MyPrinter alloc] init]; [anotherPrinter print]; //       
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इसके अलावा, एक वर्ग कई प्रोटोकॉल को पूरा कर सकता है। ऐसा करने के लिए, आप वर्ग घोषणा में कोण कोष्ठक में अल्पविराम द्वारा उन्हें सूचीबद्ध कर सकते हैं।

 @interface MyPrinter : NSObject <MyPrinterProtocol, OtherProtocol>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और कुछ प्रोटोकॉल के अनुसार अज्ञात वर्ग (आईडी) की एक वस्तु घोषित करने के लिए, वे इस तरह लिखते हैं:

 id <MyPrinterProtocol> somePrinter;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अपवाद

त्रुटि से निपटने के दो मुख्य दृष्टिकोण हैं: वैश्विक स्थिति चर, जिसका मूल्य पिछले ऑपरेशन की सफलता और अपवादों की पीढ़ी के बारे में सूचित करता है। दोनों का सार यह है कि जिस कोड में त्रुटि हुई, वह उम्मीद करता है कि जिस कोड ने उसे हल किया है, इसलिए यह स्थिति को यथासंभव विस्तृत रूप से रिपोर्ट करते हुए, इसे नियंत्रित करता है। ऑब्जेक्टिव-सी इन दोनों तरीकों का समर्थन करता है।



एक अपवाद कुछ वर्ग का एक वस्तु है। वह (यहां तक ​​कि अपने प्रकार से) स्थिति के बारे में कुछ जानकारी रखता है। सुविधा के लिए, कोको में एक NSException क्लास है जिसे दो NSString ऑब्जेक्ट्स के साथ आरंभीकृत किया जा सकता है और एक मनमाना क्लास (आईडी प्रकार) का एक ऑब्जेक्ट:

 - (id)initWitnName: (NSString *)name reason: (NSString *)reason userInfo: (id)userInfo;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आप एक अपवाद फेंक सकते हैं और इस प्रकार, @throw ऑपरेटर का उपयोग करके कॉल स्टैक प्रमोशन मैकेनिज्म शुरू कर सकते हैं। उत्पन्न अपवाद को पकड़ने के लिए, कोड का वह हिस्सा जहां इसे उत्पन्न किया जा सकता है, को विशेष प्रयास में शीर्षक शीर्षक के साथ संलग्न किया जाना चाहिए (ऐसे ब्लॉक को नेस्ट किया जा सकता है)। और फिर, इस ब्लॉक के बाद, शीर्षक पकड़ने () के साथ एक ब्लॉक रखें , जहां कोष्ठक में कथित अपवाद के प्रकार को इंगित करें। ब्लाकों पकड़ () ब्लॉक के बाद कोशिश कई हो सकता है। एक अपवाद फेंक दिए जाने के बाद, नियंत्रण, स्टैक को स्पिन करना, कोशिश ब्लॉक को बाहर करता है और, बदले में सभी कैच () ब्लॉक की जांच करता है , उस कैच ब्लॉक में जाता है(), घुंघराले कोष्ठकों में जिनमें से एक प्रकार है जिसमें अपवाद का प्रकार निहित है (सटीक मिलान, सूचक को आधार वर्ग या आईडी)। यदि प्रकार अपवाद किसी भी पकड़ () ब्लॉक से मेल नहीं खाता है , तो नियंत्रण जारी रहता है। यदि किसी कोशिश हेडर के साथ एक ब्लॉक के बाद अंत में हेडर के साथ एक ब्लॉक होता है , तो इसके बिना नियंत्रण को पारित किया जाएगा कि क्या कोशिश ब्लॉक में एक अपवाद हुआ (और कुछ कैच () ब्लॉक संसाधित किया गया था ), या इसके अंतिम निर्देश को निष्पादित किया गया था। निम्न में से एक में कप क्लास के ऑब्जेक्ट के साथ काम करने का एक उदाहरण है, जिसमें एक अपवाद होता है:

 Cup *cup = [[Cup alloc] init]; @try { [cup fill]; // fill    NSException } @catch (NSException *exception) {//     NSLog NSLog(@"main: Caught %@: %@", [exception name], [exception reason]); } @finally //  @try    { [cup release]; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

गुण

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

 // “Complex.h” #import <Foundation/Foundation.h> // NSObject   NSString @interface Complex : NSObject { double _re; //    double _im; //    NSString *_format; //    description } - (id)initWithRe: (double)re andIm: (double)im; + (Complex *)complexWithRe: (double)re andIm: (double)im; - (Complex *)add: (Complex *)other; //   - (Complex *)sub: (Complex *)other; //   @property (nonatomic, retain) NSString *format; //   @property (nonatomic, assign) double re; //   @property (nonatomic, assign) double im; @end // “Complex.m” #import “Complex.h” @implementation Complex @synthesize format = _format; //   @synthesize re = _re; //    @synthesize im = _im; //      - (id)init { return [self initWithRe: 0.0 andIm: 0.0]; } - (id)initWithRe: (double)re andIm: (double)im { if (self = [super init]) { _re = re; _im = im; _format = @”re: %.1lf im: %.1lf”; //    } } + (Complex *)complexWithRe: (double)re andIm: (double)im { return [[[Complex alloc] initWithRe: re andIm: im] autorelease]; } - (Complex *)add: (Complex *)other { return [[Complex alloc] initWithRe: _re + other.re andIm: _im + other.im]; //  re  im } - (Complex *)sub: (Complex *)other { return [[Complex alloc] initWithRe: _re – other.re andIm: _im – other.im]; //  re  im } @end
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक संपत्ति एक ऐसा नाम है जो पॉइंटर के माध्यम से किसी वस्तु तक डॉट ऑपरेटर के माध्यम से पहुँचा जा सकता है। संपत्तियों का उपयोग एक्सेसर विधियों के बजाय किसी ऑब्जेक्ट के इनवेरिएंट को सेट या सेट करने के लिए किया जाता है। संपत्ति की घोषणा करते समय, कई पैरामीटर निर्दिष्ट किए जाते हैं जो संपत्ति द्वारा उत्पन्न एक्सेस विधियों की सुविधाओं का वर्णन करते हैं।

• getter = getterName, setter = setterName बताता है कि रीड एक्सेस विधि को गेटटरनेम कहा जाएगा, और परिवर्तन के लिए, इसे सेटरनेम कहा जाएगा
• आसानी से परिवर्तन के लिए पहुँच विधि उत्पन्न न करें
• readwrite दोनों एक्सेस के तरीके उत्पन्न करता है
• असाइन करें परिवर्तन पहुंच विधि एक साधारण असाइनमेंट का उपयोग करके कार्यान्वित की जाती है।
• संदेश प्राप्त करने के लिए प्राप्त किए गए मूल्य को बनाए रखें, जारी करने के लिए अपरिवर्तनीय का पिछला मूल्य और स्वीकृत मूल्य को असाइन करने के लिए
• प्रतिलिपि सामान्य असाइनमेंट ऑपरेटर का उपयोग करें, लेकिन स्वीकृत मूल्य की प्रतिलिपि असाइन करें (असाइनमेंट से पहले, एक कॉपी संदेश भेजा जाता है)
• नॉनटोमिक, जेनरेट किए गए एक्सेस मेथड में कई थ्रेड्स को सिंक्रोनाइज़ करने के लिए इंटरनल लॉक्स का उपयोग नहीं करते हैं (डिफ़ॉल्ट रूप से, सिंक्रोनाइज़ेशन का उपयोग किया जाता है)

अब कॉम्प्लेक्स क्लास की परिभाषा में, हमें मैन्युअल तरीके से लिखने की आवश्यकता नहीं है। वे संकलक द्वारा उत्पन्न होते हैं और उन लोगों के समान होंगे जो पहले थे।



सौभाग्य है