Différences entre fort et faible en Objective-C
Je suis nouveau sur Obj-C, alors ma première question est:
Quelles sont les différences entre strong et weak dans @property déclarations de pointeurs sur des objets?
De plus, que signifie nonatomic?
Une référence forte (que vous utiliserez dans la plupart des cas) signifie que vous souhaitez "posséder" l'objet que vous référencez avec cette propriété/variable. Le compilateur veillera à ce que tout objet que vous affectez à cette propriété ne soit pas détruit tant que vous le pointez avec une référence forte. L'objet n'est détruit que lorsque vous définissez la propriété sur nil (sauf si un ou plusieurs autres objets en contiennent également une référence forte).
En revanche, avec une référence faible, vous signifiez que vous ne voulez pas contrôler la durée de vie de l'objet. L'objet que vous référencez faiblement ne vit que parce qu'au moins un autre objet y fait une référence forte. Une fois que ce n'est plus le cas, l'objet est détruit et votre propriété faible sera automatiquement définie sur nil. Les cas d'utilisation les plus fréquents de références faibles sous iOS sont:
déléguer des propriétés, qui sont souvent référencées faiblement pour éviter les cycles de rétention, et
les sous-vues/contrôles de la vue principale d'un contrôleur de vue, car ces vues sont déjà fortement détenues par la vue principale.
atomic vs. nonatomic fait référence à la sécurité des threads des méthodes getter et setter que le compilateur synthétise pour la propriété. atomic (valeur par défaut) demande au compilateur de rendre les méthodes d'accès sûres pour les threads (en ajoutant un verrou avant l'accès à ivar) et nonatomic fait le contraire. L'avantage de nonatomic est une performance légèrement supérieure. Sur iOS, Apple utilise nonatomic pour presque toutes leurs propriétés. Le conseil général est donc que vous fassiez de même.
Il peut être utile de penser aux références fortes et faibles en termes de ballons.
Un ballon ne s'envolera pas tant qu'une personne au moins s'accroche à une ficelle qui y est attachée. Le nombre de personnes qui détiennent des chaînes est le nombre de retenues. Lorsque personne ne tient à une corde, le ballon s'envolera (dealloc). Beaucoup de gens peuvent avoir des liens avec le même ballon. Vous pouvez obtenir/définir des propriétés et appeler des méthodes sur l'objet référencé avec des références fortes et faibles.
Une référence forte, c'est comme tenir une ficelle à ce ballon. Tant que vous tenez une ficelle attachée au ballon, celle-ci ne s'envolera pas.
Une référence faible, c'est comme regarder le ballon. Vous pouvez le voir, accéder à ses propriétés, appeler ses méthodes, mais vous n'avez aucune chaîne pour cette bulle. Si tout le monde tient la corde, le ballon s'envole et vous ne pouvez plus y accéder.
strong: lui attribue la valeur entrante, il conservera la valeur entrante et libérera la valeur existante de la variable d'instance
faible: va lui affecter la valeur entrante sans la conserver.
La différence fondamentale réside donc dans le maintien de la nouvelle variable. Généralement, vous voulez le conserver, mais il existe des situations dans lesquelles vous ne voulez pas l'avoir, sinon vous obtiendrez un cycle de conservation et vous ne pourrez pas libérer la mémoire des objets. Par exemple. obj1 conserve obj2 et obj2 conserve obj1. Pour résoudre ce genre de situation, vous utilisez des références faibles.
Une réponse fictive: -
Je pense que l'explication est donnée dans la réponse ci-dessus, donc je vais simplement vous dire où utiliser STRONG et où utiliser WEAK:
Utilisation de Weak: - 1. Délégués 2. Prises 3. Sous-vues 4. Contrôles, etc.
Utilisation de Strong: - Restant partout sans être inclus dans WEAK.
fort et faible , ces mots clés tournent autour de Propriété des objets en Objective-C
Qu'est-ce que la propriété d'objet?
Les variables de pointeur impliquent la propriété des objets qu'elles désignent.
- Lorsqu'une méthode (ou fonction) a une variable locale qui pointe vers un objet, cette variable est dite propriétaire de l'objet pointé.
- Lorsqu'un objet a une variable d'instance qui pointe vers un autre objet, l'objet avec le pointeur est considéré comme propriétaire de l'objet pointé.
Chaque fois qu'une variable de pointeur pointe sur un objet, cet objet a un propriétaire et reste en vie. Ceci est connu comme une référence forte .
Une variable peut éventuellement ne pas s'approprier un objet qu'elle désigne. Une variable qui ne prend pas possession d'un objet s'appelle une référence faible .
Cherchez une explication détaillée ici Démystifier @ propriété et attributs
strong est la valeur par défaut. Un objet reste "vivant" tant qu’il contient un pointeur puissant.
faible spécifie une référence qui ne maintient pas l'objet référencé en vie. Une référence faible est définie sur nil lorsqu'il n'y a pas de référence forte à l'objet.
Ici, la documentation Apple a expliqué la différence entre une propriété faible et une propriété forte à l'aide de divers exemples:
Ici, dans ce blog l'auteur a rassemblé toutes les propriétés au même endroit. Cela aidera à comparer les caractéristiques des propriétés:
http://rdcworld-iphone.blogspot.in/2012/12/variable-property-attributes-or.html
Pour comprendre les références forte et faible, considérons l'exemple ci-dessous, supposons que nous ayons une méthode nommée displayLocalVariable.
-(void)displayLocalVariable
{
UIView* myView = [[UIView alloc] init];
NSLog(@"myView tag is = %ld", myView.tag);
}
Dans la méthode ci-dessus, la portée de la variable myView est limitée à la méthode displayLocalVariable. Une fois que la méthode est terminée, la variable myView contenant l'objet UIView est libérée de la mémoire.
Et maintenant, si nous voulons conserver la variable myView tout au long du cycle de vie de notre contrôleur de vue. Pour cela, nous pouvons créer la propriété nommée usernameView qui aura une référence forte à la variable myView (voir @property(nonatomic,strong) UIView* usernameView; et self.usernameView = myView; dans le code ci-dessous), comme ci-dessous,
@interface LoginViewController ()
@property(nonatomic,strong) UIView* usernameView;
@property(nonatomic,weak) UIView* dummyNameView;
- (void)displayLocalVariable;
@end
@implementation LoginViewController
- (void)viewDidLoad
{
[super viewDidLoad];
}
-(void)viewWillAppear:(BOOL)animated
{
[self displayLocalVariable];
}
- (void)displayLocalVariable
{
UIView* myView = [[UIView alloc] init];
NSLog(@"myView tag is = %ld", myView.tag);
self.usernameView = myView;
}
- (void)didReceiveMemoryWarning
{
[super didReceiveMemoryWarning];
}
@end
Maintenant, dans le code ci-dessus, vous pouvez voir que myView a été assigné à self.usernameView et que self.usernameView a une référence forte (comme nous l'avons déclaré dans l'interface à l'aide de @property) à myView. Par conséquent, myView ne sera pas désalloué de la mémoire tant que self.usernameView ne sera pas actif.
- Référence faible
Maintenant, envisagez d'affecter myName à dummyNameView, qui est une référence faible, self.dummyNameView = myView; contrairement à la référence forte. Faible tiendra la vue uniquement jusqu'à ce qu'il y ait une référence forte à la vue. Voir ci-dessous le code pour comprendre la référence faible,
-(void)displayLocalVariable
{
UIView* myView = [[UIView alloc] init];
NSLog(@"myView tag is = %ld", myView.tag);
self.dummyNameView = myView;
}
Dans le code ci-dessus, il y a référence faible à myView (c'est-à-dire que self.dummyNameView a une référence faible à myView) mais il n'y a pas de référence forte à myView, par conséquent self.dummyNameView ne pourra pas contenir la valeur myView.
Maintenant, considérez à nouveau le code ci-dessous,
-(void)displayLocalVariable
{
UIView* myView = [[UIView alloc] init];
NSLog(@"myView tag is = %ld", myView.tag);
self.usernameView = myView;
self.dummyNameView = myView;
}
Dans le code ci-dessus, self.usernameView a une référence forte à myView. C'est pourquoi self.dummyNameView aura désormais la valeur myView même après la fin de la méthode, car myView est associé à une référence Strong.
Désormais, chaque fois que nous faisons une référence forte à une variable, son nombre de conservation est augmenté de un et la variable ne sera pas désallouée tant que son nombre de conservation n'a pas atteint 0.
J'espère que cela t'aides.
Strong: essentiellement utilisé avec les propriétés utilisées pour obtenir ou envoyer des données à partir de/dans d'autres classes. faible: généralement toutes les prises, les connexions sont de type faible à partir de l'interface.
Nonatomic: Ce type de propriétés est utilisé lorsque nous ne voulons pas partager notre sortie ou notre objet dans différents threads simultanés. En d'autres termes, l'instance non-atomique fait que nos propriétés traitent un thread à la fois. J'espère que cela vous sera utile.