web-dev-qa-db-fra.com

Attributs de propriété faibles et forts dans Objective-C

Quelle est la différence entre les attributs de définition de propriété faibles et forts dans Objective-C?

@property(retain, [weak/strong]) __attribute__((NSObject)) CFDictionaryRef myDictionary;

Quel est l'impact et l'avantage?

J'ai entendu dire que faible n'est pas disponible sur iOS 4 et que nous devons utiliser assign.

Est-ce que faible est similaire à assigner?

iphoneiosobjective-cautomatic-ref-counting
93
kkurni

ARC est activé ou désactivé pour un fichier particulier. Si c'est le cas, vous ne pouvez pas utiliser retainreleaseautorelease etc ... à la place, vous utilisez strongweak pour les propriétés ou __strong__weak Pour les variables (la valeur par défaut est __strong). Strong est l’équivalent à conserver, mais ARC gérera la version pour vous.

Si vous voulez éviter les cycles de rétention (par exemple, le parent conserve l’enfant et l’enfant le conserve pour qu’il ne soit jamais relâché).

La partie "pontage sans frais" (passer de NS à CF) est un peu délicate. Vous devez toujours gérer manuellement CFRelease() et CFRetain() pour les objets CF. Lorsque vous les reconvertissez en objets NS, vous devez informer le compilateur du nombre de conservations afin qu'il sache ce que vous avez fait.

C'est tout ici .

102
Robert

Voici des informations sur ce que je sais des propriétés de variable

  1. atomique // par défaut
  2. non atomique
  3. fort = conserver // par défaut
  4. faible
  5. conserver
  6. assign // valeur par défaut
  7. unsafe_unretained
  8. copie
  9. lecture seulement
  10. readwrite // par défaut

donc ci-dessous est le lien détaillé de l'article où vous pouvez trouver tous les attributs mentionnés ci-dessus, qui vont certainement vous aider. Un grand merci à toutes les personnes qui donnent les meilleures réponses ici !!

Attributs de propriété de variable ou modificateurs sous iOS

01. fort (iOS4 = conserver) - il est indiqué "conservez-le dans le tas jusqu'à ce que je ne pointe plus dessus" - en d'autres termes " Je suis le propriétaire, vous ne pouvez pas traiter cela avant de viser avec "" - Vous utilisez fort uniquement si vous devez conserver l'objet. - Par défaut, toutes les variables d'instance et les variables locales sont des indicateurs puissants. - Nous utilisons généralement fort pour UIViewControllers (parents de l'élément d'interface utilisateur) - strong est utilisé avec ARC et vous aide fondamentalement à ne pas avoir à vous soucier du nombre de rétentions d'un objet. ARC le publie automatiquement pour vous lorsque vous avez terminé. Le mot-clé strong signifie que vous êtes propriétaire de l'objet.

Exemple:

@property (strong, nonatomic) ViewController *viewController;

@synthesize viewController;

02. faible (iOS4 = unsafe_unretained) - il est indiqué "conservez-le tant que quelqu'un pointe du doigt dessus" - la même chose que assign, non retenue ou relâche - une référence "faible" est une référence que vous ne conservez pas. - Nous utilisons généralement faible pour IBOutlets (UIViewController's Childs). Cela fonctionne car l'objet enfant n'a besoin d'exister que tant que l'objet parent existe. - une référence faible est une référence qui ne protège pas l'objet référencé de la collecte par un ramasse-miettes. - Faible est essentiellement assigner, une propriété non conservée. Sauf que lorsque l'objet est désalloué, le pointeur faible est automatiquement défini sur nil

Exemple :

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

@synthesize myButton;

Expliquez : Merci à BJ Homer

Imaginez que notre objet soit un chien et que celui-ci veuille fuir (être désalloué). Les pointeurs forts sont comme une laisse sur le chien. Tant que vous avez la laisse attachée au chien, celui-ci ne s'enfuira pas. Si cinq personnes attachent leur laisse à un chien (cinq pointeurs puissants à un objet), le chien ne s'enfuira pas tant que les cinq laisses ne sont pas détachées. Les pointeurs faibles, par contre, sont comme des petits enfants qui pointent le chien et disent "Regarde! Un chien!" Tant que le chien est toujours en laisse, les petits enfants peuvent toujours le voir et ils le montrent du doigt. Dès que toutes les laisses sont détachées, cependant, le chien s'enfuit, peu importe le nombre de petits enfants qui le désignent. Dès que le dernier pointeur fort (leash) ne pointe plus vers un objet, celui-ci est désalloué et tous les pointeurs faibles sont mis à zéro. Quand on utilise faible? Si vous voulez éviter les cycles de rétention (par exemple, le parent conserve l’enfant et l’enfant le conserve pour qu’il ne soit jamais relâché).

119
swiftBoy

Pour appeler les parties de la documentation référencées par Robert qui répondent explicitement à vos deux dernières questions:

// The following declaration is similar to "@property(assign) MyClass *myObject;"
// except that if the MyClass instance is deallocated,
// the property value is set to nil instead of remaining as a dangling pointer.
@property(weak) MyClass *myObject;

Ceci est appelé une référence de réduction à zéro. Vous pouvez créer des références faibles qui ne remettent pas à zéro les références faibles à l'aide de __unsafe_unretained, mais comme son nom l'indique, cela n'est généralement pas recommandé.

Aussi dans la documentation:

Weak references are not supported in Mac OS X v10.6 and iOS 4.
2
rimsky

L’utilisation limpide de la propriété WEAK est la suivante:

Any control whose properties we need to change(eg:text of a label) is declared weak and as below:

@property(nonatomic,weak) IBOutlet Type *name;
Eg: @property(nonatomic,weak) IBOutlet UILabel *myLabel;
2
Alen Alexander

prenons un exemple pour élaborer davantage (la réponse ci-dessus est déjà excellente), cet exemple peut aider un peu plus

laissons nous avoir deux classes A et B

//A.h

#import <Foundation/Foundation.h>
#import "B.h"

@interface A : NSObject

@property (nonatomic, strong) B *objB;

@end

@implementation A
//

@end

//B.h

    #import <Foundation/Foundation.h>
    #import "A.h"


    @interface B : NSObject

    @property strong text(nonatomic, strong) A *objA;

    @end

    @implementation B
    //

    @end

    and in main

    #import "B.h"
    #import "A.h"

    {
    A *obja =[[A alloc]init];
    B *objb =[[B alloc]init];
    A.objB=objb;
    B.objA=obja;
   }

le code ci-dessus générera un cycle de conservation car les deux sont du type fort a --------> b ---------> a

aussi, pour l’éviter, vous devez utiliser la propriété week de l’une de ces propriétés afin qu’il se réfère chaque semaine à l’objet sans augmenter le nombre de références.

0
Anurag Bhakuni