Quelle est l'utilité de l'atsortingbut unsafe_unretained?

unsafe_unretained n'existe que dans ARC. Cela fonctionne comme assign dans MRC. Ces propriétés ne seront pas conservées. Habituellement, vous ne voudriez pas utiliser de telles propriétés pour les delegates parce qu'ils n'ont pas besoin d'un propriétaire qui les conserve.

weak propriétés weak sont comme non unsafe_unretained mais elles fonctionnent un peu plus intelligemment. Lorsque l'object affecté à la propriété est libéré, une reference faible devient automatiquement nil pour éviter les plantages lors de l'envoi de messages à cet object (son adresse memory). Les propriétés Unsafe_unretained ne le font pas. Ils conservent toujours l'adresse memory (à less que vous ne la changiez manuellement), quel que soit l'object associé à cette adresse. Des references faibles peuvent prévenir les accidents dans un tel cas mais le résultat ne sera toujours pas comme prévu. Si votre code est bien écrit et organisé, cela ne devrait pas arriver.

Alors pourquoi utiliseriez-vous unsafe_unretained au lieu de weak ? Les references faibles ne sont disponibles que sur iOS 5 et versions ultérieures. Par conséquent, si vous unsafe_unretained une application ARC ciblant iOS 4, vous devez utiliser des propriétés non unsafe_unretained . Et encore une fois, envoyer des messages à une propriété libérée n'est pas quelque chose que vous voulez avoir dans n'importe quel code, donc si votre code est bien organisé, vous ne devriez pas avoir de problèmes avec cela.

Précédemment à ARC, on pouvait spécifier un délégué ou une autre propriété de reference à parent comme assign pour empêcher les cycles de retenue. Avec l'introduction d'ARC et des compilateurs plus récents, vous utiliserez plutôt unsafe_unretained .

Vous l'utilisez donc chaque fois que vous n'avez pas besoin de la propriété de la reference, et lorsque vous n'avez pas besoin ou ne voulez pas utiliser le nouveau type de reference weak (qui annule la reference lorsqu'elle est désallouée).

Essayez ceci: Comprendre la memory management sous ARC

Voici un cas d'utilisation spécifique pour unsafe_unretained. Dites deux classs se référent l'une l'autre, une direction étant forte et l'autre direction faible. Pendant le dealloc de la première class, la reference faible de la deuxième class sera déjà nulle, empêchant ainsi un bon nettoyage. Le rlocation de la reference faible par une reference Unsafe_unretained résoudra ce problème. Voir l'exemple de code ci-dessous:

 @class Foo; @interface Bar: NSObject //Replacing weak with unsafe_unretained prevents this property from becoming nil during Foo.dealloc @property (nonatomic, weak) Foo *foo; - (id)initWithFoo:(Foo *)foo; @end @interface Foo : NSObject @property (nonatomic, strong) Bar *bar; - (void)startObserving; - (void)endObserving; @end @implementation Bar - (id)initWithFoo:(Foo *)foo { if ((self = [super init])) { self.foo = foo; //Start observing [self.foo startObserving]; } return self; } - (void)dealloc { //Since foo is a weak property, self.foo may actually be nil at this point! See dealloc of class Foo. [self.foo endObserving]; } @end @implementation Foo - (id)init { if ((self = [super init])) { self.bar = [[Bar alloc] initWithFoo:self]; } return self; } - (void)dealloc { //This will sortinggger the deallocation of bar. However, at this point all weak references to self will return nil already! self.bar = nil; //endObserving is never called, because Bar.foo reference was already nil. } - (void)startObserving { NSLog(@"Start observing"); } - (void)endObserving { NSLog(@"End observing"); } @end