ios - उद्देश्य-सी एआरसी: मजबूत बनाम बनाए रखें और कमजोर बनाम बनाम




objective-c ios5 (5)

एआरसी, strong और weak द्वारा पेश की गई संपत्तियों के लिए दो नए मेमोरी प्रबंधन विशेषताएं हैं।

copy अलावा, जो स्पष्ट रूप से कुछ अलग है, क्या strong बनाम retain और weak बनाम assign बीच कोई अंतर है?

मेरी समझ से, यहां केवल अंतर यह है कि weak पॉइंटर को nil सौंपेगा, जबकि assign नहीं किया जाएगा, जिसका अर्थ यह है कि जब प्रोग्राम जारी होने के बाद पॉइंटर को संदेश भेजता है तो प्रोग्राम क्रैश हो जाएगा। लेकिन अगर मैं weak उपयोग करता हूं, तो यह कभी नहीं होगा, क्योंकि संदेश nil को भेजता है, कुछ भी नहीं करेगा।

मैं strong और retain बीच किसी भी अंतर के बारे में नहीं जानता।

क्या कोई कारण है कि मुझे नई परियोजनाओं में assign और retain उपयोग क्यों करना चाहिए, या किस तरह से बहिष्कृत किया जा रहा है?


बलवान:

  • संपत्ति नष्ट नहीं होगी, लेकिन केवल एक बार जब आप संपत्ति को शून्य पर सेट करेंगे तो वस्तु नष्ट हो जाएगी
  • डिफ़ॉल्ट रूप से सभी इंस्टेंस चर और स्थानीय चर मजबूत पॉइंटर्स होते हैं।
  • यदि आप ऑब्जेक्ट को बनाए रखने की आवश्यकता रखते हैं तो आप केवल तभी मजबूत उपयोग करते हैं।
  • हम आमतौर पर UIViewControllers (UI आइटम के माता-पिता) के लिए मजबूत उपयोग करते हैं
  • आईओएस 4 (गैर-एआरसी) हम कुंजीपटल बनाए रखने का उपयोग कर सकते हैं
  • आईओएस 5 (एआरसी) हम मजबूत कीवर्ड का उपयोग कर सकते हैं

उदाहरण: @property (मजबूत, nonatomic) ViewController * दृश्य नियंत्रक;

@ सिंथेसाइज व्यू कंट्रोलर;

कमज़ोर

डिफ़ॉल्ट रूप से स्वचालित रूप से मिलता है और शून्य पर सेट

  • हम आम तौर पर आईबीओटलेट्स (यूआईवीव कंट्रोलर चाइल्ड्स) और प्रतिनिधि के लिए कमजोर उपयोग करते हैं
  • असाइन करने के समान ही, कोई रखरखाव या रिलीज नहीं

उदाहरण: @property (कमजोर, nonatomic) IBOutlet UIButton * myButton;

@bynthesize myButton;


nonatomic / परमाणु

  • nonatomic परमाणु से बहुत तेज है
  • हमेशा nonatomic का उपयोग करें जब तक कि आप परमाणु के लिए एक बहुत ही विशिष्ट आवश्यकता नहीं है, जो दुर्लभ होना चाहिए (परमाणु थ्रेड सुरक्षा की गारंटी नहीं देता है - केवल संपत्ति को एक्सेस करने पर स्टालों को रोकता है जब इसे एक साथ अन्य धागे द्वारा सेट किया जा रहा है)

मजबूत / कमजोर / असाइन

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

(वैकल्पिक)

प्रतिलिपि

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

सिफ़ पढ़िये

  • संपत्ति की सेटिंग को अक्षम करने के लिए इसका उपयोग करें (यदि कोई अवरोध है तो संकलन से कोड रोकता है)
  • आप अपने आवृत्ति चर के माध्यम से या गेटटर विधि के भीतर सीधे वैरिएबल को बदलकर गेटटर द्वारा जो भी वितरित कर सकते हैं उसे बदल सकते हैं

परिवर्तनीय संपत्ति विशेषताओं की जांच करने के लिए इतने सारे लेख स्टैक ओवरफ्लो पोस्ट और डेमो अनुप्रयोगों को पढ़ने के बाद, मैंने सभी विशेषताओं को एक साथ जानकारी देने का निर्णय लिया:

  1. परमाणु // डिफ़ॉल्ट
  2. nonatomic
  3. मजबूत = // डिफ़ॉल्ट बनाए रखें
  4. कमज़ोर
  5. बनाए रखने के
  6. // डिफ़ॉल्ट असाइन करें
  7. unsafe_unretained
  8. प्रतिलिपि
  9. सिफ़ पढ़िये
  10. readwrite // डिफ़ॉल्ट

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

आईओएस में परिवर्तनीय संपत्ति विशेषताओं या संशोधक

1.स्ट्रांग (आईओएस 4 = बनाए रखें)

  • यह कहता है "जब तक मैं इसे इंगित नहीं करता तब तक इसे ढेर में रखें"
  • दूसरे शब्दों में, "मैं मालिक हूं, आप इसे ठीक से बनाए रखने के पहले इसे ठीक से पहले नहीं हटा सकते हैं"
  • यदि आप ऑब्जेक्ट को बनाए रखने की आवश्यकता रखते हैं तो आप केवल तभी मजबूत उपयोग करते हैं।
  • डिफ़ॉल्ट रूप से सभी इंस्टेंस चर और स्थानीय चर मजबूत पॉइंटर्स होते हैं।
  • हम आमतौर पर UIViewControllers (UI आइटम के माता-पिता) के लिए मजबूत उपयोग करते हैं
  • मजबूत एआरसी के साथ प्रयोग किया जाता है और यह मूल रूप से आपकी वस्तु की बरकरार गिनती के बारे में चिंता न करने में आपकी सहायता करता है। जब आप इसके साथ काम करते हैं तो एआरसी स्वचालित रूप से आपके लिए इसे रिलीज़ करता है। कीवर्ड का उपयोग करने का मतलब है कि आप ऑब्जेक्ट के स्वामी हैं।

उदाहरण:

@property (strong, nonatomic) ViewController *viewController;

@synthesize viewController;

2.weak -

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

उदाहरण :

@property (weak, nonatomic) IBOutlet UIButton *myButton;

@synthesize myButton;

मजबूत और कमजोर स्पष्टीकरण, बीजे होमर के लिए धन्यवाद :

कल्पना करें कि हमारी वस्तु एक कुत्ता है, और कुत्ता भागना चाहता है (हटाया जाना चाहिए)।

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

दूसरी ओर, कमजोर पॉइंटर्स कुत्ते पर इशारा करते हुए छोटे बच्चों की तरह हैं और कह रहे हैं "देखो! एक कुत्ता!" जब तक कुत्ता अभी भी पट्टा पर है, छोटे बच्चे अभी भी कुत्ते को देख सकते हैं, और वे अभी भी इसे इंगित करेंगे। जैसे ही सभी लीश अलग हो जाते हैं, हालांकि, कुत्ता दूर चला जाता है इससे कोई फर्क नहीं पड़ता कि कितने छोटे बच्चे इसे इंगित कर रहे हैं।

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

जब हम कमज़ोर का उपयोग करते हैं?

एकमात्र समय जब आप कमजोर उपयोग करना चाहते हैं, तो यह है कि यदि आप चक्र बनाए रखने से बचना चाहते हैं (उदाहरण के लिए अभिभावक बच्चे को बरकरार रखता है और बच्चा माता-पिता को बरकरार रखता है तो न तो कभी जारी किया जाता है)।

3. मजबूत = मजबूत

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

उदाहरण:

@property (nonatomic, retain) NSString *name;

@synthesize name;

4.assign

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

उदाहरण:

@property (nonatomic, assign) NSString *address;

@synthesize address;

मजबूत और बनाए रखने के बीच मतभेद:

  • आईओएस 4 में, मजबूत बनाए रखने के बराबर है
  • इसका मतलब यह है कि आप ऑब्जेक्ट के मालिक हैं और इसे ढेर में रखते हैं जब तक कि अब इसे इंगित न करें
  • यदि आप बनाए रखते हैं तो यह स्वचालित रूप से मजबूत की तरह काम करेगा

कमजोर और असाइन के बीच मतभेद:

  • एक "कमजोर" संदर्भ एक संदर्भ है जिसे आप बनाए नहीं रखते हैं और आप इसे तब तक रखते हैं जब तक कोई अन्य दृढ़ता से इंगित करता है
  • जब वस्तु "deallocated" है, कमजोर सूचक स्वचालित रूप से शून्य पर सेट हो जाता है
  • एक "असाइन" संपत्ति विशेषता संकलक को बताती है कि संपत्ति के सेटटर कार्यान्वयन को कैसे संश्लेषित किया जाए

संक्रमण से एआरसी रिलीज नोट्स (संपत्ति विशेषताओं पर अनुभाग में उदाहरण) से।

// The following declaration is a synonym for: @property(retain) MyClass *myObject;

@property(strong) MyClass *myObject;

एक संपत्ति घोषणा में retain के समान ही strong है।

एआरसी परियोजनाओं के लिए मैं retain बजाय strong उपयोग करता हूं, मैं सी आदिम गुणों के लिए असाइनमेंट का उपयोग करता हूं और उद्देश्य-सी वस्तुओं के कमजोर संदर्भों के लिए कमजोर होता।





automatic-ref-counting