टैग किए गए संकेत, या एक अंतर में किसी वस्तु को कैसे फिट किया जाए

यदि आपने कभी ऑब्जेक्टिव-सी एप्लिकेशन लिखा है, तो आपको NSNumber क्लास से परिचित होना चाहिए, एक रैपर जो किसी ऑब्जेक्ट में नंबर को बदल देता है। एक क्लासिक उपयोग का मामला प्रपत्र की वस्तुओं से भरा एक संख्यात्मक सरणी बनाना है [NSNumber numberWithInt: someIntVideue]; ।

ऐसा लगता है, एक संपूर्ण ऑब्जेक्ट क्यों बनाया जाए, इसके लिए मेमोरी आवंटित करें, फिर इसे साफ करें यदि हमें एक नियमित छोटे इंट की आवश्यकता है? Apple ने भी ऐसा सोचा था, और क्योंकि NSNumber अक्सर एक वस्तु नहीं है, और इसके पीछे सूचक के पीछे छिपा हुआ है ... शून्यता।

यदि आप रुचि रखते हैं कि यह कैसे निकलता है, और चिह्नित संकेतकर्ताओं को इसके साथ क्या करना है, तो बिल्ली का स्वागत करें!

सूचक संरेखण सिद्धांत का एक सा

हर कोई जानता है कि एक सूचक एक नियमित इंट है, जो सिस्टम स्मृति में एक पते के लिए लेता है। एक ऑब्जेक्ट के लिए एक पॉइंटर रखने वाला चर 0x7f84a41000c0 फॉर्म के मान के साथ एक इंट है। "इंगित करने" की पूरी प्रकृति इस बात में निहित है कि कार्यक्रम इसका उपयोग कैसे करता है। सी में, हम साधारण कास्टिंग द्वारा पॉइंटर का इंट वैल्यू प्राप्त कर सकते हैं:

void *somePointer = ...; uintptr_t pointerIntegerValue = (uintptr_t)somePointer; 

( uintptr_t पूर्णांक के लिए एक मानक सरणी टाइपडिफ़ है जो एक पॉइंटर को पकड़ने के लिए पर्याप्त है। यह आवश्यक है क्योंकि बिंदुओं का आकार भिन्न होता है, प्लेटफॉर्म पर निर्भर करता है)

लगभग हर कंप्यूटर आर्किटेक्चर में पॉइंटर्स के अलाइनमेंट जैसी कोई चीज होती है। इसके द्वारा हमारा मतलब है कि डेटा प्रकार के लिए एक सूचक दो की शक्ति का एक गुणक होना चाहिए। उदाहरण के लिए, 4-बाइट int के लिए एक सूचक चार में से कई होना चाहिए। संरेखण बिंदुओं द्वारा लगाए गए प्रतिबंधों के उल्लंघन से प्रदर्शन में उल्लेखनीय कमी या आवेदन में पूरी तरह से गिरावट आ सकती है। स्मृति के लिए परमाणु पढ़ने और लिखने के लिए सही संरेखण भी आवश्यक है। संक्षेप में, संरेखण बिंदु एक गंभीर बात है, और आपको इसे तोड़ने की कोशिश नहीं करनी चाहिए।

यदि आप एक चर बनाते हैं, तो संकलक संरेखण की जांच कर सकता है:

  void f(void) { int x; } 

हालाँकि, गतिशील रूप से आवंटित स्मृति के साथ चीजें इतनी सरल नहीं हैं:

  int *ptr = malloc(sizeof(*ptr)); 

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

संरेखण के कारण, अप्रयुक्त बिट्स सूचक में रहते हैं। यहाँ 16 बाइट्स के साथ संरेखित हेक्स पॉइंटर ऐसा दिखता है:

  0x-------0 

हेक्स का अंतिम अंक हमेशा शून्य होता है। सामान्य तौर पर, एक पूरी तरह से वैध सूचक हो सकता है जो इन स्थितियों (उदाहरण के लिए, चार *) का अनुपालन नहीं करता है, लेकिन किसी वस्तु के लिए सूचक हमेशा शून्य बिट्स के साथ समाप्त होना चाहिए।

लेबल बिंदुओं का एक छोटा सिद्धांत

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

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

यह वह है जो एक वैध बाइनरी ऑब्जेक्ट की तरह दिखाई देगा:

 ....0000 ^    

और यह एक चिह्नित सूचक है:

 ....xxx1 ^    

यह सभी विभिन्न तरीकों से लागू किया जा सकता है, लेकिन ऑब्जेक्टिव-सी में लेबल सूचक का कम से कम महत्वपूर्ण बिट हमेशा एक होता है, और अगले तीन सूचक वर्ग को इंगित करते हैं।

लेबल पॉइंटर्स का उपयोग

टैग किए गए संकेत अक्सर उन भाषाओं में उपयोग किए जाते हैं जहां सब कुछ एक वस्तु है। संगति, जब 3 एक ऑब्जेक्ट है, और 3 + 4 में दो ऑब्जेक्ट शामिल हैं, और यहां तक ​​कि एक तीसरा भी बना रहा है, ऑब्जेक्ट के लिए मेमोरी आवंटित करना और उनसे डेटा निकालना समग्र प्रदर्शन में महत्वपूर्ण भूमिका निभाना शुरू करता है। यह सब वस्तुओं के निर्माण के साथ उपद्रव, धीमी स्मृति तक पहुंच, किसी ऐसी वस्तु में मूल्यों का प्रवेश करना है जिसका कोई उपयोग नहीं करता है, इसके अलावा लागत की तुलना में कई गुना अधिक है।

लेबल पॉइंटर्स का उपयोग हमें उन सभी प्रकारों के लिए इन प्रतिकूलताओं से छुटकारा दिलाता है जो उन्हीं खाली बिट्स में फिट होते हैं। छोटे ints इस भूमिका के लिए आदर्श उम्मीदवार हैं - वे बहुत कम जगह लेते हैं और हर जगह उपयोग किए जाते हैं।

यह एक साधारण तिकड़ी है:

 0000 0000 0000 0000 0000 0000 0000 0011 

और यहाँ तीन सूचक में छिपा हुआ है:

  0000 0000 0000 0000 0000 0000 0011 1011 ^ ^ ^   | | |    (5) |   

यहाँ मैंने सुझाव दिया कि पाँच का उपयोग इंट को इंगित करने के लिए किया जाता है, लेकिन, वास्तव में, यह प्रणाली के विवेक पर रहता है, और किसी भी समय सब कुछ बदल सकता है।

पर्यवेक्षक पाठक ने शायद पहले ही ध्यान दिया कि हमारे पास 32-बिट सिस्टम पर केवल 28 बिट्स बचे हैं और 64-बिट पर 60 बिट्स हैं। और पूर्णांक महान मूल्यों पर ले जा सकते हैं। यह सही है, हर इंट को एक लेबल सूचक में छिपाया नहीं जा सकता है, कुछ के लिए आपको एक पूर्ण ऑब्जेक्ट बनाना होगा।

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

सूचक में डेटा प्रकार को इंगित करने वाली बिट्स की उपस्थिति से न केवल इंट, बल्कि फ्लोटिंग-पॉइंट नंबर, और यहां तक ​​कि कई ASCII वर्ण (64-बिट सिस्टम के लिए 8) को स्टोर करना संभव हो जाता है। यहां तक ​​कि एक तत्व के लिए एक सूचक के साथ एक सरणी एक लेबल सूचक में फिट हो सकती है! सामान्य तौर पर, किसी भी पर्याप्त रूप से छोटे और व्यापक रूप से उपयोग किए जाने वाले डेटा प्रकार टैग किए गए पॉइंटर के भीतर उपयोग के लिए एक उत्कृष्ट उम्मीदवार है।

ठीक है, सुंदर सिद्धांत, चलो अभ्यास करने के लिए आगे बढ़ें!

हम आधार को NSNumber के एक कस्टम कार्यान्वयन के रूप में MANumber लेंगे, और वहां लेबल किए गए पॉइंटर्स के लिए समर्थन जोड़ेंगे।

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

हालांकि, कुछ भी हमें उनके साथ खेलने से रोकता है, भले ही हमारे पास उन्हें सुरक्षित रूप से उपयोग करने का अवसर न हो।

अच्छा, चलिए शुरू करते हैं। निजी _objc_insert_tagged_isa फ़ंक्शन आपको एक विशिष्ट टैग के लिए एक निश्चित वर्ग को पिन करने की अनुमति देता है। यहाँ उसका प्रोटोटाइप है:

  void _objc_insert_tagged_isa(unsigned char slotNumber, Class isa); 

आप इसमें स्लॉट नंबर (टैग) और आवश्यक वर्ग पास करते हैं, और यह उन्हें रनटाइम पर भविष्य के उपयोग के लिए एक निश्चित तालिका में रखता है।

लेबल किए गए बिंदुओं पर लगभग किसी भी वर्ग को एक जुड़वां वर्ग की आवश्यकता होती है जो कि पॉइंटर के भीतर मान फिट नहीं होने पर एक सामान्य ऑब्जेक्ट बनाएगा। NSNumber के लिए, ये विशेष रूप से बड़े ints और युगल होंगे, जो एक पॉइंटर में रटना बहुत मुश्किल है, और मैं यहां ऐसा नहीं करूंगा।

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

एक चर के मूल्य को संग्रहीत करने के लिए, मैंने संघ का उपयोग किया:

  union Value { long long i; unsigned long long u; double d; }; 

निम्नलिखित कुछ स्थिरांक हैं जो एक लेबल सूचक में सूचना को परिभाषित करते हैं। पहला - स्लॉट नंबर, मैंने इसे एक के बराबर लिया:

  const int kSlot = 1; 

मैंने लेबल किए गए बिंदुओं की संख्या निर्धारित करने का भी फैसला किया है - मूल्यों के आगे निष्कर्षण के लिए यह आवश्यक है:

  const int kTagBits = 4; 

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

  const int kTypeBits = 2; 

हालाँकि मैंने दोहरे समर्थन को लागू नहीं किया था, फिर भी मैंने इसके लिए एक जगह छोड़ दी ताकि सामान्य मैनम्बर के साथ एकरूपता बनाए रख सके और भविष्य में अपने आप को दोहरे समर्थन की सुविधा मिल सके।

और अंत में, चूंकि हमारे द्वारा संग्रहीत किए जाने वाले पूर्णांक का प्रकार लंबा है, इसलिए यह जानना अच्छा होगा कि इसमें कितने बिट्स लगते हैं:

  const int kLongLongBits = sizeof(long long) * CHAR_BIT; 

यहां मैं मानता हूं कि पॉइंटर का प्रकार लंबा है, मैंने 32-बिट सिस्टम का समर्थन करने की कोशिश नहीं की।

सुविधा के लिए, मैंने कुछ सहायक कार्य लिखे। पहले एक लेबल किए गए MANumber बनाता है, इनपुट के रूप में डेटा प्रकार और मान लेता है:

  static id TaggedPointer(unsigned long long value, unsigned type) { 

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

  id ptr = (__bridge id)(void *)((value << (kTagBits + kTypeBits)) | (type << kTagBits) | (kSlot << 1) | 1); 

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

यह सब है, और अब मैं नए बनाए गए पॉइंटर को लौटा रहा हूं:

  return ptr; } 

इसके अलावा, मैंने एक फ़ंक्शन बनाया जो यह जांचता है कि सूचक चिह्नित है या नहीं। वह सभी कम-ऑर्डर बिट की जांच करती है, लेकिन बेवकूफ डबल कास्ट के कारण, उसे एक अलग फ़ंक्शन में रखा जाना था।

  static BOOL IsTaggedPointer(id pointer) { uintptr_t value = (uintptr_t)(__bridge void *)pointer; return value & 1; } 

और अंत में, एक फ़ंक्शन जो एक लेबल सूचक से सभी जानकारी निकालता है। चूंकि सी एक साथ कई मूल्यों की वापसी का समर्थन नहीं करता है, इसलिए मैंने इसके लिए एक विशेष संरचना बनाई: इसमें प्रकार और मूल्य स्वयं शामिल हैं

  struct TaggedPointerComponents { unsigned long long value; unsigned type; }; 

यह फ़ंक्शन सबसे पहले, केवल विपरीत दिशा में, बहुत ही प्रकार के रूपांतरण का उपयोग करके सूचक को इंट में परिवर्तित करता है:

  static struct TaggedPointerComponents ReadTaggedPointer(id pointer) { uintptr_t value = (uintptr_t)(__bridge void *)pointer; 

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

  struct TaggedPointerComponents components = { value >> (kTagBits + kTypeBits), 

एक प्रकार प्राप्त करने के लिए, आपको न केवल बदलाव करना होगा, बल्कि एक मुखौटा भी लागू करना होगा

  (value >> kTagBits) & ((1ULL << kTypeBits) - 1) }; 

नतीजतन, सभी घटक प्राप्त होते हैं, और हम उन्हें एक संरचना के रूप में वापस करते हैं।

  return components; } 

कुछ बिंदु पर, हमें रनटाइम को बताना चाहिए कि हम एक ऐसा वर्ग है जो लेबल पॉइंटर्स पर _objc_insert_tagged_isa फ़ंक्शन को कॉल करके चलता है। इसके लिए सबसे अच्छा है + आरंभिक। सुरक्षा कारणों से, उद्देश्य-सी रनटाइम एक स्लॉट को फिर से लिखना पसंद नहीं करता है, और इसलिए आपको पहले वहां nil लिखना चाहिए, और उसके बाद ही हमारा नया वर्ग:

  + (void)initialize { if(self == [MANumber class]) { _objc_insert_tagged_isa(kSlot, nil); _objc_insert_tagged_isa(kSlot, self); } } 

अब हम लेबल पॉइंटर्स बनाने की बहुत प्रक्रिया पर आगे बढ़ सकते हैं। मैंने दो विधियाँ लिखीं: + numberWithLongLong: और + numberWithUnsignedLongLong:। ये विधियां लेबल किए गए बिंदुओं पर ऑब्जेक्ट बनाने की कोशिश करती हैं, और यदि मान बहुत बड़ा है, तो वे बस साधारण ऑब्जेक्ट बनाते हैं।

ये विधियां केवल एक निश्चित मान के लिए एक लेबल सूचक बना सकती हैं - उन्हें kLongLongBits - kTagBits - kTypeBits, या 64-बिट सिस्टम में 58 बिट्स में फिट होना चाहिए। संकेत को इंगित करने के लिए एक बिट की आवश्यकता है, कुल, अधिकतम लंबा लंबा मूल्य 57 में 2 है, न्यूनतम -57 है।

  + (id)numberWithLongLong: (long long)value { long long taggedMax = (1ULL << (kLongLongBits - kTagBits - kTypeBits - 1)) - 1; long long taggedMin = -taggedMax - 1; 

यह सबसे सरल रहता है। यदि मान सीमा से बाहर है, तो हम आवंटन / init के साथ एक नियमित नृत्य करते हैं। अन्यथा, हम दिए गए मान और वर्ग INT के साथ एक लेबल सूचक बनाते हैं:

  if(value > taggedMax || value < taggedMin) return [[self alloc] initWithLongLong: value]; else return TaggedPointer(value, INT); } 

अहस्ताक्षरित लंबी लंबी के लिए सब कुछ समान है, अनावश्यक संकेत बिट के कारण मूल्यों के सेट में वृद्धि को छोड़कर:

  + (id)numberWithUnsignedLongLong:(unsigned long long)value { unsigned long long taggedMax = (1ULL << (kLongLongBits - kTagBits - kTypeBits)) - 1; if(value > taggedMax) return [[self alloc] initWithUnsignedLongLong: value]; else return (id)TaggedPointer(value, UINT); } 

अब हमें अपने पॉइंटर्स के लिए एक प्रकार के एक्सेसर की आवश्यकता है ताकि हम बिट्स, मास्क, या कुछ और के बारे में चिंता किए बिना बस [स्वयं प्रकार] कॉल कर सकें। वह जो भी करेगा वह IsTaggedPointer फ़ंक्शन के साथ पॉइंटर की जांच करेगा, और यदि इसे लेबल किया गया है, तो ReadTaggedPointer को कॉल करें। यदि पॉइंटर सामान्य है, तो बस _type:

  - (int)type { if(IsTaggedPointer(self)) return ReadTaggedPointer(self).type; else return _type; } 

संकेत के साथ कठिनाइयों के कारण अर्थ का एक एक्सेसर कुछ अधिक जटिल होगा। पहले, आइए देखें कि क्या यह एक नियमित सूचक है:

  - (union Value)value { if(!IsTaggedPointer(self)) { return _value; } 

लेबल वाले लोगों के लिए, हमें पहले ReadTaggedPointer का उपयोग करके मान पढ़ना होगा। आउटपुट पर, हमारे पास एक अहस्ताक्षरित लंबा लंबा है, इसलिए हमें थोड़ा काम करना होगा यदि मूल्य वास्तव में एक संकेत है।

  else { unsigned long long value = ReadTaggedPointer(self).value; 

वापसी मान के लिए टाइप यूनियन मान का एक स्थानीय चर बनाएँ:

  union Value v; 

यदि यह अहस्ताक्षरित है, तो सब कुछ सरल है - हम मूल्य को v में डालते हैं, और यह है:

  int type = [self type]; if(type == UINT) { vu = value; } 

हस्ताक्षर के साथ, सब कुछ इतना सरल नहीं है। सबसे पहले, साइन बिट की जाँच करें - यह बिट संख्या 57 में छिपा है:

  else if(type == INT) { unsigned long long signBit = (1ULL << (kLongLongBits - kTagBits - kTypeBits - 1)); 

यदि बिट एक के बराबर है, तो 57 बिट्स वाले सभी बिट्स को इकाइयों से भरा जाना चाहिए, यह आवश्यक है ताकि दिए गए लंबे समय तक एक वैध 64-बिट नकारात्मक संख्या हो। इस प्रक्रिया को साइन एक्सटेंशन कहा जाता है, संक्षेप में इसका सार यह है: नकारात्मक संख्याएं लोगों से शुरू होती हैं, और पहला शून्य पहला महत्वपूर्ण बिट है। इसलिए, एक नकारात्मक संख्या का विस्तार करने के लिए, आप बस इकाइयों को बाईं ओर जोड़ते हैं:

  if(value & signBit) { unsigned long long mask = (((1ULL << kTagBits + kTypeBits) - 1) << (kLongLongBits - kTagBits - kTypeBits)); value |= mask; } 

सकारात्मक संख्याओं के साथ कुछ भी करने की आवश्यकता नहीं है - वे पहले से ही बाईं ओर शून्य से भरे हुए हैं। तो बस v भरें:

  vi = value; } 

यदि हमें कुछ अन्य प्रकार मिला है, तो चीजें खराब हैं, आपको इसे फेंकना होगा:

  else abort(); 

परिणामस्वरूप, वापसी v:

  return v; } } 

यह सब कोड लिखे जाने के बाद, हमें हमेशा की तरह नए MANumber के साथ काम करने का अवसर मिलता है, एकमात्र अंतर यह है कि हमें मूल्यों को सीधे नहीं, बल्कि accessor के तरीकों के माध्यम से एक्सेस करना होगा। हम भी लेबल की तुलना कर सकते हैं और नियमित MANumber की तुलना कर सकते हैं: और isEqual:।

निष्कर्ष

लेबल पॉइंटर्स कोको और ऑब्जेक्टिव-सी रनटाइम के लिए एक बढ़िया अतिरिक्त हैं, जो काम की गति को बढ़ा सकते हैं और एनएसएनम्बर के साथ काम करते समय मेमोरी लागत को कम कर सकते हैं।

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

(माइक ऐश से ताजा शुक्रवार क्यू एंड ए का मुफ्त अनुवाद)

अद्यतन:

जैसा कि वादा किया गया था, लेबल पॉइंटर्स का व्यावहारिक उपयोग आने में लंबा नहीं था।