विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास · पाठ

कमज़ोर बनाम मज़बूत संदर्भ

retain चक्रों को रोकने और ऑब्जेक्ट के जीवनकाल को प्रभावी ढंग से प्रबंधित करने के लिए मज़बूत और कमज़ोर संदर्भों में अंतर करें।

पाठ 3, कुल 4 में से11 चरण

कमज़ोर बनाम मज़बूत संदर्भ, CoddyKit पर विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

ऑब्जेक्ट के जीवनकाल को समझना

Objective-C में किसी ऑब्जेक्ट के जीवनकाल का प्रबंधन करना अत्यंत महत्वपूर्ण है। इसका अर्थ है तय करना कि ऑब्जेक्ट को मेमोरी में कब मौजूद रहना चाहिए और कब उसे सुरक्षित रूप से हटाया जा सकता है।

रेफ़रेंस के माध्यम से हम सिस्टम को बताते हैं कि हमें किसी ऑब्जेक्ट की 'परवाह' है और हम चाहते हैं कि वह सक्रिय रहे। इसके दो मुख्य प्रकार हैं: strong और weak।

Strong रेफ़रेंस: डिफ़ॉल्ट

ARC (Automatic Reference Counting) का उपयोग करते समय Objective-C में प्रॉपर्टी और वेरिएबल के लिए strong रेफ़रेंस डिफ़ॉल्ट प्रकार होता है।

यह किसी ऑब्जेक्ट का 'स्वामित्व' दर्शाता है।
जब किसी ऑब्जेक्ट का कम-से-कम एक strong रेफ़रेंस होता है, तो उसे deallocate नहीं किया जा सकता।
यह ऑब्जेक्ट का retain count बढ़ाता है और उसे मेमोरी में बनाए रखता है।

इसे किसी चीज़ को कसकर पकड़े रहने जैसा समझें; जब तक आप उसे पकड़े रहते हैं, वह गायब नहीं होगी।

Strong रेफ़रेंस का उदाहरण

आइए strong रेफ़रेंस को कार्य करते हुए देखें। person1 वेरिएबल हमारे Person ऑब्जेक्ट का strong रेफ़रेंस रखता है। ध्यान दें कि जब ऑब्जेक्ट को strong रूप से रेफ़रेंस नहीं किया जाता, तब dealloc विधि कॉल होती है।

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property (strong, nonatomic) NSString *name;
- (void)sayHello;
@end

@implementation Person
- (void)sayHello {
    NSLog(@"Hello, my name is %@", self.name);
}
- (void)dealloc {
    NSLog(@"Person %@ is being deallocated.", self.name);
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *person1 = [[Person alloc] init];
        person1.name = @"Alice";
        NSLog(@"Person '%@' created.", person1.name);
        [person1 sayHello];
        // person1 goes out of scope at the end of @autoreleasepool
        // The Person object will be deallocated.
    }
    return 0;
}

समस्या: Retain Cycle

हालाँकि strong रेफ़रेंस आवश्यक होते हैं, लेकिन वे मेमोरी प्रबंधन की एक सामान्य समस्या पैदा कर सकते हैं, जिसे retain cycle (या strong रेफ़रेंस cycle) कहा जाता है।

ऐसा तब होता है जब दो या अधिक ऑब्जेक्ट एक-दूसरे को strong रूप से रेफ़रेंस करते हैं और एक बंद चक्र बनाते हैं। चूँकि cycle में प्रत्येक ऑब्जेक्ट को कोई दूसरा ऑब्जेक्ट strong रूप से रेफ़रेंस करता है, इसलिए उनका retain count कभी शून्य नहीं होता और वे कभी deallocate नहीं होते।

Retain Cycle का चित्रण

कल्पना कीजिए कि कोई Parent ऑब्जेक्ट किसी Child ऑब्जेक्ट को strong रूप से रेफ़रेंस करता है और वह Child ऑब्जेक्ट भी अपने Parent को strong रूप से रेफ़रेंस करता है।

Parent कहता है: "मेरे पास Child का स्वामित्व है।"
Child कहता है: "मेरे पास Parent का स्वामित्व है।"

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

Weak रेफ़रेंस का परिचय

Weak रेफ़रेंस (__weak या weak प्रॉपर्टी एट्रिब्यूट से घोषित) retain cycle को तोड़ने के लिए बनाए गए हैं।

ये ऑब्जेक्ट का retain count नहीं बढ़ाते।
ये स्वामित्व नहीं दर्शाते।
महत्वपूर्ण रूप से, जिस ऑब्जेक्ट की ओर weak रेफ़रेंस संकेत करता है, उसके deallocate होते ही weak रेफ़रेंस अपने-आप nil हो जाता है।

'nil कर देने' का यह व्यवहार बहुत सुरक्षित है और लटके हुए पॉइंटर को रोकता है।

Weak रेफ़रेंस का व्यवहार

ध्यान दें कि weak रेफ़रेंस कैसे व्यवहार करता है। जब किसी ऑब्जेक्ट का अंतिम strong रेफ़रेंस रिलीज़ हो जाता है, तो ऑब्जेक्ट deallocate हो जाता है और उसकी ओर संकेत करने वाले सभी weak रेफ़रेंस अपने-आप nil हो जाते हैं।

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property (strong, nonatomic) NSString *name;
- (void)dealloc;
@end

@implementation Person
- (void)dealloc {
    NSLog(@"Person %@ is being deallocated.", self.name);
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *strongPerson = [[Person alloc] init];
        strongPerson.name = @"Bob";
        
        __weak Person *weakPerson = strongPerson;
        
        NSLog(@"Before nil: strongPerson = %@, weakPerson = %@", strongPerson.name, weakPerson.name);
        
        strongPerson = nil; // Release the strong reference
        NSLog(@"Strong reference set to nil.");
        
        if (weakPerson) {
            NSLog(@"Weak Person still exists: %@", weakPerson.name);
        } else {
            NSLog(@"Weak Person is now nil.");
        }
    }
    return 0;
}

Retain Cycle को तोड़ना

Retain cycle को तोड़ने के लिए cycle में मौजूद किसी एक रेफ़रेंस को weak होना चाहिए। हमारे Parent-Child उदाहरण में, आम तौर पर 'child' का अपने 'parent' के लिए weak रेफ़रेंस रखना उचित होता है।

इस तरह parent के पास child का स्वामित्व रहता है, लेकिन child के पास parent का स्वामित्व नहीं रहता, जिससे दोनों सही ढंग से deallocate हो सकते हैं।

#import <Foundation/Foundation.h>

@interface Parent : NSObject
@property (strong, nonatomic) NSString *name;
@property (strong, nonatomic) id child; // Strong ref to child
- (void)dealloc;
@end

@interface Child : NSObject
@property (strong, nonatomic) NSString *name;
@property (weak, nonatomic) Parent *parent; // Weak ref to parent
- (void)dealloc;
@end

@implementation Parent
- (void)dealloc {
    NSLog(@"Parent %@ is being deallocated.", self.name);
}
@end

@implementation Child
- (void)dealloc {
    NSLog(@"Child %@ is being deallocated.", self.name);
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Parent *myParent = [[Parent alloc] init];
        myParent.name = @"Mom";
        
        Child *myChild = [[Child alloc] init];
        myChild.name = @"Alice";
        
        myParent.child = myChild; // Parent strongly references Child
        myChild.parent = myParent; // Child weakly references Parent
        
        NSLog(@"Parent and Child created. Releasing strong variables...");
        // Both objects will be deallocated as strong references from outside
        // the objects are released and the weak link doesn't prevent deallocation.
    }
    return 0;
}

`weak` बनाम `unsafe_unretained`

आपको __unsafe_unretained नामक एक अन्य गैर-स्वामित्व वाले रेफ़रेंस प्रकार का सामना हो सकता है। फिर भी, हमेशा __weak को प्राथमिकता दें।

__weak: ऑब्जेक्ट के deallocate होने पर अपने-आप nil हो जाता है और क्रैश को रोकता है।
__unsafe_unretained: nil नहीं होता। ऑब्जेक्ट के deallocate होने पर रेफ़रेंस एक लटका हुआ पॉइंटर बन जाता है और उस तक पहुँचने का प्रयास करने पर क्रैश हो सकता है।

आधुनिक Objective-C में ARC के साथ __weak अधिक सुरक्षित और मानक विकल्प है।

अपने ज्ञान की जाँच करें

ARC के साथ Objective-C में weak रेफ़रेंस के प्राथमिक उद्देश्य का सबसे अच्छा वर्णन कौन-सा कथन करता है?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: Strong बनाम Weak

हमने strong और weak रेफ़रेंस के बीच महत्वपूर्ण अंतर समझा है:

Strong रेफ़रेंस: डिफ़ॉल्ट होते हैं, स्वामित्व दर्शाते हैं, retain count बढ़ाते हैं और ऑब्जेक्ट को सक्रिय रखते हैं।
Weak रेफ़रेंस: स्वामित्व नहीं दर्शाते, retain count नहीं बढ़ाते, अपने-आप nil हो जाते हैं और retain cycle तोड़ने के लिए आवश्यक होते हैं।

मेमोरी लीक रोकने और भरोसेमंद Objective-C कोड लिखने के लिए यह समझना महत्वपूर्ण है कि प्रत्येक का उपयोग कब करना चाहिए।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Objective-C सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “कमज़ोर बनाम मज़बूत संदर्भ” पाठ निःशुल्क है?

हाँ—“कमज़ोर बनाम मज़बूत संदर्भ” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“कमज़ोर बनाम मज़बूत संदर्भ” में मैं क्या सीखूँगा?

retain चक्रों को रोकने और ऑब्जेक्ट के जीवनकाल को प्रभावी ढंग से प्रबंधित करने के लिए मज़बूत और कमज़ोर संदर्भों में अंतर करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“कमज़ोर बनाम मज़बूत संदर्भ” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

मैनुअल Retain-Release (MRR) की मूल बातें
स्वचालित संदर्भ गणना (ARC)
कमज़ोर बनाम मज़बूत संदर्भ
Blocks में रिटेन चक्र तोड़ना

← विरासत और एंटरप्राइज़ ऐप्स के लिए Objective-C iOS विकास पर वापस जाएँ