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

Question

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

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

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

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

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

Comments

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

— NJones

@NJones रहे हैं दो संपत्ति विशेषताएं ( weakऔर strong) और 4 चर जीवन क्वालिफायर ( __strong, __weak, __unsafe_unretained, __autoreleasing)। नीचे एआरसी नोट्स देखें।

— स्नोक्रैश

@SnowCrash Xcode का एक संस्करण था, संभवतः एक डेवलपर पूर्वावलोकन, जिसमें assignARC के साथ संकलन करते समय एक त्रुटि हुई थी। इस बारे में कई हटाए गए उत्तर हैं। ऐसा लगता है कि अंतिम रिलीज़ से पहले इसे बदल दिया गया था। unsafe_unretainedहममें से बहुत से शुरुआती लोगों के लिए पसंदीदा विशेषता है। प्रमाण के लिए जो कि unsafe_unretainedएक मान्य विशेषता है, ऐप्पल के "प्रोग्रामिंग विथ ऑब्जेक्टिव-सी" को सेक्शन "एनकैप्सुलेटिंग डेटा" के तहत सबहडिंग के तहत "कुछ वर्गों के लिए असुरक्षित असुरक्षित संदर्भ का उपयोग करें"। जो कहता है: "एक संपत्ति के लिए, इसका मतलब असुरक्षित_सुविधा प्राप्त विशेषता का उपयोग कर रहा है:"

— NJones

Answer 1

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

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

@property(strong) MyClass *myObject;

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

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

Comments

वास्तव में, एआरसी के तहत यह assignएक वस्तु के लिए उपयोग करने के लिए एक संकलन त्रुटि है । यदि आप संपत्ति को बनाए रखना नहीं चाहते हैं, तो आपको weakया तो unsafe_unretained(जो असुरक्षित है, जाहिर है) का उपयोग करना होगा।

— कोबाल

assignARC परियोजनाओं में तैनाती लक्ष्य 4.0 के साथ मेरे लिए बस ठीक संकलन करता है।

— पास्कल

@ पास्कल: तैनाती के लक्ष्यों में कमजोर संदर्भों की अनुमति नहीं है जहां ओएस 5.0 या उच्चतर नहीं है। तो पुराने प्रोजेक्ट्स के लिए आप अभी भी असाइनमेंट का उपयोग कर सकते हैं, लेकिन यदि आप नए संस्करणों में जाते हैं, तो आपको कमजोर स्विच करना होगा

— मैटिया

Xcode 4 जैसा दिखता है (ARC के साथ) बनाम का उपयोग करके NSManagedObject उप-वर्ग उत्पन्न करता है । मुझे लगता है कि यह ज्यादातर हानिरहित है, लेकिन मुझे लगता है कि यह स्थिरता के लिए होना चाहिए ... या शायद यह कोई फर्क नहीं पड़ता। stackoverflow.com/questions/7796476/…retainstrongstrong

— जो

@JeremyP हां, आपका जवाब हाजिर है। मैं @ मटिया पर प्रतिक्रिया दे रहा था। मैं इंगित कर रहा था कि assignकुछ मामलों में अभी भी मान्य है।

— स्टीवन ऑक्सले

Answer 2

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

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

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

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

1. स्ट्रोंग (iOS4 = रिटेन)

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

उदाहरण:

@property (strong, nonatomic) ViewController *viewController;

@synthesize viewController;

2. कमजोर -

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

उदाहरण :

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

@synthesize myButton;

मजबूत और कमजोर व्याख्या, बीजे होमर को धन्यवाद :

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

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

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

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

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

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

३.श्रुत = मजबूत

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

उदाहरण:

@property (nonatomic, retain) NSString *name;

@synthesize name;

4.assign

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

उदाहरण:

@property (nonatomic, assign) NSString *address;

@synthesize address;

Comments

2. "एक कमजोर संदर्भ एक संदर्भ है जो एक संग्रहकर्ता द्वारा संग्रह से संदर्भित ऑब्जेक्ट की रक्षा नहीं करता है" - उद्देश्य सी में कोई ऐसी चीज नहीं है जैसे कचरा कलेक्टर;

— बुचरलैंड

और यह पदानुक्रम iOS द्वारा स्वचालित रूप से प्रबंधित किया जाता है। MVC अवधारणा के बारे में पढ़ें। मेरा मतलब है जब ViewContorller को आईओएस लोड किया जा रहा है, तो यह स्क्रीन पर पदानुक्रम देख रहा है (लापता दृश्य बना रहा है)। जब अन्य ViewController प्रस्तुत किया जाता है, तो विचारों का यह पहला पदानुक्रम निपटाया जाता है। यदि आपके पास ViewController में 'मजबूत' है, तो यह दृश्य डील-डौल नहीं किया जा सकता है, जब यह ऑफ स्क्रीन है। जो कि डिवाइस की मेमोरी और ऐप के धीमे होने का कारण हो सकता है। (बेशक डिवाइस में बहुत अधिक मेमोरी है और आप 5-10 स्क्रीन ऐप पर निश्चित रूप से ठीक होंगे, लेकिन भारी ऐप में आप मुश्किल में पड़

— जाएंगे

जब हम कमजोर का उपयोग करते हैं? 1. यूआई वस्तुओं के लिए, 2. प्रतिनिधि, 3. मेमोरी चक्र से बचने के लिए स्वयं के बजाय कमजोर (ब्लॉक का उपयोग किया जाना चाहिए) (जैसा कि ऊपर उल्लेख किया गया था)

— बुचरलैंड 12

इस महान उत्तर में एक गलती है - मजबूत - "एआरसी स्वचालित रूप से आपके लिए इसे जारी करता है जब आपके साथ किया जाता है", यह सही नहीं है। एआरसी स्वचालित रूप से कमजोर वस्तुओं को छोड़ देगा जब कोई संकेत नहीं होते हैं। मजबूत - बनाए रखने के लिए पर्यायवाची है, इसलिए वस्तु को बनाए रखा जाता है और यह हमारी जिम्मेदारी है कि हम वस्तु को बनाए रखें

— अश्विन जी

@ आरडीसी, क्या defaultमतलब है? अगर मैं इसका उपयोग @property (nonatomic) NSString *stringकरता हूं strong? या assign? क्योंकि दोनों ही डिफॉल्ट हैं।

— इयूलियन ओनोफ्रेई

Answer 3

nonatomic / परमाणु

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

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

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

(वैकल्पिक)

प्रतिलिपि

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

सिफ़ पढ़िये

• प्रॉपर्टी की सेटिंग को डिसेबल करने के लिए इसका इस्तेमाल करें (यदि कोई इंफ़ेक्शन होने पर कोड को कंपाइल करने से रोकता है)
• आप अपने उदाहरण चर के माध्यम से सीधे चर को बदलकर, या अपने आप ही प्राप्त करने वाले विधि के द्वारा अपने द्वारा प्राप्त किए गए परिवर्तन को बदल सकते हैं

Comments

@ शाकिमुथैया सही हैं, आपको अपना उत्तर सही करना होगा।

— एडेला टोडेरिसी

@Sakthimuthiah गलत है (और जो कोई भी यह कहता है)। परमाणु इसे थ्रेड को सुरक्षित नहीं बनाता है, हालांकि इसके व्यवहार के कारण इसे आसानी से गलत किया जा सकता है। कृपया पढ़ें: stackoverflow.com/questions/12347236/…

— क्रिस जे

Answer 4

जहां तक ​​मुझे पता है, strongऔर retainसमानार्थक शब्द हैं, इसलिए वे बिल्कुल वैसा ही करते हैं ।

फिर weakलगभग समान है assign, लेकिन स्वचालित रूप से ऑब्जेक्ट के बाद शून्य पर सेट होता है, यह इंगित करता है, डीलॉक्ड है।

इसका मतलब है, आप बस उन्हें बदल सकते हैं।

हालाँकि , एक विशेष मामला है जिसका मैंने सामना किया है, जहाँ मुझे इसके assignबजाय उपयोग करना था weak। मान लीजिए कि हम दो गुण होते हैं चलो delegateAssignऔर delegateWeak। दोनों में हमारे प्रतिनिधि को संग्रहीत किया गया है, जो कि एकमात्र मजबूत संदर्भ होने के कारण हमारा मालिक है। प्रतिनिधि का व्यवहार होता है, इसलिए हमारी -deallocपद्धति को भी कहा जाता है।

// Our delegate is deallocating and there is no other strong ref.
- (void)dealloc {
    [delegateWeak doSomething];
    [delegateAssign doSomething];
}

प्रतिनिधिमंडल पहले से ही डीलक्लोकेशन प्रक्रिया में है, लेकिन फिर भी पूरी तरह से नहीं किया गया है। समस्या यह है कि weakउसके संदर्भ पहले से ही अशक्त हैं! संपत्ति delegateWeakमें शून्य होता है, लेकिन delegateAssignइसमें मान्य ऑब्जेक्ट होता है (पहले से जारी और अशक्त सभी संपत्तियों के साथ, लेकिन अभी भी वैध है)।

// Our delegate is deallocating and there is no other strong ref.
- (void)dealloc {
    [delegateWeak doSomething]; // Does nothing, already nil.
    [delegateAssign doSomething]; // Successful call.
}

यह काफी विशेष मामला है, लेकिन इससे हमें पता चलता है कि वे weakचर कैसे काम करते हैं और जब वे अशक्त होते हैं।

Comments

stackoverflow.com/questions/9428500/…

— sleepwalkerfx

Answer 5

ऑब्जेक्टिव-सी ऑटोमैटिक रेफरेंस काउंटिंग (ARC) पर क्लैंग का दस्तावेज स्पष्ट रूप से मालिकाना योग्यता और संशोधन को स्पष्ट करता है:

चार स्वामित्व वाले क्वालीफायर हैं:

• __ ऑटोरेलिज़िंग
• __ मजबूत
• __ * unsafe_unretained *
• __ कमजोर

यदि यह __ ऑटोरेलिज़िंग , __ मजबूत , या __ कमजोर के साथ योग्य है तो एक प्रकार का स्वामित्व-योग्य है ।

फिर घोषित संपत्ति के लिए छह स्वामित्व वाले संशोधक हैं:

• असाइन तात्पर्य __ * unsafe_unretained * स्वामित्व।
• कॉपी से तात्पर्य __ मजबूत स्वामित्व से है, साथ ही सेटर पर कॉपी शब्दार्थ के सामान्य व्यवहार से भी है।
• बनाए रखने __ तात्पर्य मजबूत स्वामित्व।
• मजबूत का मतलब है __ मजबूत स्वामित्व।
• * unsafe_unretain * का अर्थ है __ * unsafe_unretain * स्वामित्व।
• कमजोर का मतलब है __ कमजोर स्वामित्व।

कमजोर के अपवाद के साथ , ये संशोधक गैर-एआरसी मोड में उपलब्ध हैं।

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

असाइनमेंट ऑपरेटर का मूल्यांकन करते समय असाइनमेंट होता है। योग्यता के आधार पर शब्दार्थ भिन्न होते हैं:

• __ मजबूत वस्तुओं के लिए, नई पॉइन्ट्री को पहले रखा जाता है; दूसरा, लैवल्यू आदिम शब्दार्थ से भरा हुआ है; तीसरा, नई पॉइंटी को आदिम शब्दार्थ के साथ अंतराल में संग्रहीत किया जाता है; और अंत में, पुराने पॉइंटर को जारी किया जाता है। यह परमाणु प्रदर्शन नहीं किया जाता है; समवर्ती भार और दुकानों के सामने इसे सुरक्षित बनाने के लिए बाहरी सिंक्रनाइज़ेशन का उपयोग किया जाना चाहिए।
• __ कमजोर वस्तुओं के लिए, लैवल्यू को नई पॉइन्टी की ओर इंगित करने के लिए अपडेट किया जाता है, जब तक कि नई पॉइंटी वर्तमान में डीललैक्टेशन से गुजरने वाली वस्तु नहीं है, इस स्थिति में लैवल्यू को शून्य पॉइंटर में अपडेट किया जाता है। यह ऑब्जेक्ट से अन्य असाइनमेंट के संबंध में, ऑब्जेक्ट से रीड करने के लिए, और नए पॉइंटर के अंतिम रिलीज के संबंध में परमाणु रूप से निष्पादित होना चाहिए।
• __ * असुरक्षित_अनुरक्षित * वस्तुओं के लिए, नई सूचक को आदिम शब्दार्थ का उपयोग करके अंतराल में संग्रहीत किया जाता है।
• __ के लिए autoreleasing वस्तुओं, नई pointee को बनाए रखा, autoreleased, और lvalue आदिम अर्थ विज्ञान का उपयोग कर में संग्रहित है।

रीडिंग, इनिट, डिस्ट्रक्शन और मूविंग में अन्य अंतर, दस्तावेज़ में धारा 4.2 शब्दार्थ को देखें ।

Answer 6

मजबूत और कमजोर संदर्भ को समझने के लिए नीचे दिए गए उदाहरण पर विचार करें, मान लीजिए कि हमारे पास प्रदर्शन विधि के रूप में नामित विधि है।

 -(void)displayLocalVariable
  {
     NSString myName = @"ABC";
     NSLog(@"My name is = %@", myName);
  }

उपरोक्त विधि में myName वैरिएबल का दायरा DisplayLocalVariable विधि तक सीमित है, एक बार विधि समाप्त होने पर myName वैरिएबल जो स्ट्रिंग "एबीसी" को पकड़े हुए है मेमोरी से डीललोकेट हो जाएगा।

अब क्या होगा अगर हम अपने व्यू कंट्रोलर जीवन चक्र के दौरान myName वैरिएबल वैल्यू को पकड़ना चाहते हैं। इसके लिए हम उपयोक्तानाम के रूप में नामित संपत्ति बना सकते हैं, जिसमें चर myName ( self.username = myName;नीचे कोड में देखें) के रूप में नीचे के रूप में मजबूत संदर्भ होगा ,

@interface LoginViewController ()

@property(nonatomic,strong) NSString* username;
@property(nonatomic,weak) NSString* dummyName;

- (void)displayLocalVariable;

@end

@implementation LoginViewController

- (void)viewDidLoad
{
    [super viewDidLoad];

}

-(void)viewWillAppear:(BOOL)animated
{
     [self displayLocalVariable];
}

- (void)displayLocalVariable
{
   NSString myName = @"ABC";
   NSLog(@"My name is = %@", myName);
   self.username = myName;
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
}


@end

अब उपरोक्त कोड में आप देख सकते हैं कि myName को self.username और self.username को सौंपा गया है। एक मजबूत संदर्भ (जैसा कि हमने इंटरफ़ेस में @property का उपयोग करके घोषित किया है) myName को दिया गया है (अप्रत्यक्ष रूप से यह "ABC" स्ट्रिंग के लिए मजबूत संदर्भ है)। इसलिए स्ट्रिंग myName को स्मृति से तब तक नहीं हटाया जाएगा जब तक कि स्वनाम का नाम जीवित न हो।

• कमजोर संदर्भ

अब dameName को अपना नाम निर्दिष्ट करने पर विचार करें जो कि एक कमजोर संदर्भ है, self.dummyName = myName; मजबूत संदर्भ के विपरीत कमजोर मेरा नाम तभी तक रखेगा जब तक कि मेरे नाम का मजबूत संदर्भ न हो। कमजोर संदर्भ समझने के लिए नीचे कोड देखें,

-(void)displayLocalVariable
  {
     NSString myName = @"ABC";
     NSLog(@"My name is = %@", myName);
     self.dummyName = myName;
  }

उपरोक्त कोड में myName के लिए कमजोर संदर्भ है (यानी self.dummyName, MyName का कमजोर संदर्भ है) लेकिन myName का कोई मजबूत संदर्भ नहीं है, इसलिए self.dummyName myName मान को रोक नहीं पाएगा।

अब फिर से नीचे दिए गए कोड पर विचार करें,

-(void)displayLocalVariable
      {
         NSString myName = @"ABC";
         NSLog(@"My name is = %@", myName);
         self.username = myName;
         self.dummyName = myName;
      } 

उपरोक्त कोड में self.username में myName का एक मजबूत संदर्भ है, इसलिए self.dummyName का अब myName का मान होगा क्योंकि विधि समाप्त होने के बाद भी myName का एक मजबूत संदर्भ होता है।

अब जब भी हम किसी वैरिएबल के लिए एक मजबूत संदर्भ बनाते हैं तो यह बरकरार रहता है कि गिनती एक से बढ़ जाती है और वैरिएबल को डीलक्लॉक नहीं किया जाएगा रिटेन काउंट 0 तक पहुंच जाता है।

उम्मीद है की यह मदद करेगा।

Answer 7

बलवान:

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

उदाहरण: @property (मजबूत, गैर-परमाणु) ViewController * viewController;

@ सायन्ससाइज़ व्यूकंट्रोलर;

कमज़ोर

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

• हम आम तौर पर IBOutlets (UIViewController's Childs) और प्रतिनिधि के लिए कमजोर का उपयोग करते हैं
• असाइनमेंट, नो रिटेन या रिलीज़ जैसी ही चीज़

उदाहरण: @property (कमजोर, गैर-परमाणु) IBOutlet UIButton * myButton;

@ साइनयूटीज़ माय बट्टन;

Answer 8

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

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

---

कमजोर और असाइन किए गए अंतर:

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