Automatic Reference Counting (ARC)
Ontdek hoe ARC geheugenbeheer vereenvoudigt en welke gevolgen dit heeft voor Objective-C-ontwikkeling en legacycode.
Automatic Reference Counting (ARC) is een gratis Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps bevat in totaal 4 lessen.
Welkom bij ARC
Geheugenbeheer is cruciaal bij programmeren. In Objective-C moest je geheugen vroeger handmatig beheren, wat kon leiden tot fouten zoals geheugenlekken of crashes.
Automatic Reference Counting (ARC) veranderde dit door veel van het werk voor je te automatiseren. Het is een functie van de compiler, geen garbagecollector tijdens runtime.
ARC: magie van de compiler
Met ARC voegt de Xcode-compiler tijdens het compileren automatisch de benodigde code voor geheugenbeheer (zoals aanroepen van retain, release en autorelease) toe aan je app.
Dat betekent dat je deze aanroepen niet meer zelf schrijft. De compiler zorgt ervoor dat objecten in leven blijven zolang dat nodig is en worden vrijgegeven wanneer dat niet meer nodig is.
Je eerste ARC-object
Laten we ARC in actie bekijken. Wanneer je een Objective-C-object maakt, beheert ARC automatisch het bijbehorende geheugen. Je hoeft release niet aan te roepen.
In dit eenvoudige voorbeeld wordt een NSString gemaakt. ARC handelt de deallocatie af zodra er niet langer naar wordt verwezen.
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
// Create an NSString object
NSString *greeting = @"Hello, CoddyKit!";
NSLog(@"%@", greeting);
// ARC automatically manages the memory for 'greeting'.
// No explicit [greeting release] is needed here.
}
return 0;
}Properties en sterke referenties
Wanneer je properties voor je objecten declareert, gebruikt ARC standaard sterke referenties voor Objective-C-objecten. Een sterke referentie betekent dat het object in eigendom is en niet wordt gedealloceerd zolang er ten minste één sterke referentie naar bestaat.
Voor primitieve typen (zoals int en float) gebruik je assign.
#import <Foundation/Foundation.h>
@interface MyObject : NSObject
@property (strong, nonatomic) NSString *name;
- (void)sayHello;
@end
@implementation MyObject
- (void)sayHello {
NSLog(@"Hello, my name is %@", self.name);
}
// dealloc is called automatically when strong refs are gone
- (void)dealloc {
NSLog(@"MyObject %@ is deallocated.", self.name);
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
MyObject *obj = [[MyObject alloc] init];
obj.name = @"Coddy"; // 'name' is a strong property
[obj sayHello];
// 'obj' goes out of scope, ARC releases it, dealloc is called.
}
return 0;
}Aangepast opruimen met `dealloc`
Onder ARC roep je niet [super dealloc] aan en geef je geen objecten vrij met release binnen je dealloc-methode. De compiler handelt alle releases van Objective-C-objecten af.
Je gebruikt dealloc nog steeds om resources op te ruimen die geen Objective-C-objecten zijn, zoals Core Foundation-objecten, C++-objecten of bestandshandles.
#import <Foundation/Foundation.h>
@interface MyResourceHolder : NSObject
@property (strong, nonatomic) NSString *identifier;
@end
@implementation MyResourceHolder
- (instancetype)init {
self = [super init];
if (self) {
_identifier = @"My Unique ID";
NSLog(@"MyResourceHolder %@ created.", _identifier);
// Imagine opening a C file handle or allocating C memory here.
}
return self;
}
// ARC handles Objective-C objects. Use dealloc for other resources.
- (void)dealloc {
NSLog(@"MyResourceHolder %@ deallocated. (Closing C file handle, etc.)", _identifier);
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
MyResourceHolder *holder = [[MyResourceHolder alloc] init];
// holder goes out of scope, ARC deallocates it.
}
return 0;
}Migreren van verouderde projecten
Veel oudere Objective-C-projecten zijn geschreven met Manual Retain-Release (MRR). Xcode biedt een hulpmiddel om deze projecten naar ARC te migreren.
Ga naar Edit > Refactor > Convert to Objective-C ARC.... Hiermee wordt een groot deel van de conversie geautomatiseerd, maar handmatige aanpassingen kunnen nog steeds nodig zijn, vooral bij complexe projecten of codebases met verschillende geheugenbeheermodellen.
Codebases met gemengde geheugenbeheermodellen
Soms moet je bestanden zonder ARC gebruiken binnen een ARC-project (bijvoorbeeld bibliotheken van derden). Xcode staat dit toe.
Je kunt de compiler opdracht geven om specifieke bestanden zonder ARC te compileren door voor die bestanden de compilerflag -fno-objc-arc in te stellen bij de Build Phases-instellingen van je project.
ARC en Core Foundation
ARC beheert alleen Objective-C-objecten. Het beheert geen Core Foundation-objecten (zoals CFStringRef en CFArrayRef), omdat die op C zijn gebaseerd.
Om te converteren tussen Objective-C- en Core Foundation-typen gebruik je bridging-casts: __bridge, __bridge_transfer en __bridge_retained. Deze geven ARC aan hoe het eigendom moet worden verwerkt.
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSString *ocString = @"Hello ARC!";
// __bridge_retained: transfer ownership from ARC to Core Foundation.
// CFRelease must be called manually later.
CFStringRef cfString = (__bridge_retained CFStringRef)ocString;
NSLog(@"Objective-C String: %@", ocString);
NSLog(@"Core Foundation String: %@", (__bridge NSString *)cfString);
// Manual release required for Core Foundation objects obtained via __bridge_retained
CFRelease(cfString);
}
return 0;
}Beperkingen en valkuilen van ARC
Hoewel ARC geheugenbeheer eenvoudiger maakt, lost het niet alle problemen op. Het kan retain-cycli niet voorkomen: situaties waarin twee objecten sterk naar elkaar verwijzen, waardoor geen van beide wordt gedealloceerd.
Daar komen zwakke referenties van pas; die behandelen we in de volgende les. Let ook op geheugenbeheer in C-stijl (malloc/free), want dat wordt niet door ARC beheerd.
Controle van je ARC-kennis
ARC heeft de manier waarop we geheugen beheren in Objective-C aanzienlijk veranderd.
Wat is een belangrijk voordeel van het gebruik van Automatic Reference Counting (ARC) bij de ontwikkeling van Objective-C?
Samenvatting van ARC en wat hierna komt
Je hebt geleerd dat ARC het geheugenbeheer automatiseert door tijdens het compileren aanroepen van retain en release in te voegen. Dit maakt ontwikkelen veel eenvoudiger en vermindert veelvoorkomende geheugenfouten.
We hebben ook kort gekeken naar het beheren van Core Foundation-objecten en naar het belang van dealloc voor het opruimen van resources die geen Objective-C-resources zijn.
Hierna gaan we dieper in op zwakke versus sterke referenties om te begrijpen hoe je retain-cycli voorkomt — een belangrijk concept, ook bij ARC.
Leer Objective-C met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Automatic Reference Counting (ARC)” gratis?
Ja — de volledige tekst van “Automatic Reference Counting (ARC)” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps bevat in totaal 4 lessen.
Wat leer ik in “Automatic Reference Counting (ARC)”?
Ontdek hoe ARC geheugenbeheer vereenvoudigt en welke gevolgen dit heeft voor Objective-C-ontwikkeling en legacycode. Je oefent met Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps te beginnen?
Ervaring vooraf is niet nodig. Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Automatic Reference Counting (ARC)”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps?
Ja. Elke les over Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- De basis van handmatig retain-releasebeheer (MRR)
- Automatic Reference Counting (ARC)
- Zwakke versus sterke referenties
- Retain-cycli in blocks doorbreken