Comment effacer un NSMutableArray d'objets personnalisés sans créer de fuites de mémoire?

Si j'ai un NSMutableArray d'objets personnalisés, comment puis-je doit facilement effacer le tableau sans causer des problèmes de mémoire? Supposons que l'objet personnalisé de classe a une méthode dealloc dans lequel correctement publié une instance de variables etc.

Par exemple, est-il possible d'utiliser le NSArray "removeAllObjects" méthode?

  • Si oui, comment cela fonctionne - t "removeAllObjects" appel "dealloc" méthode sur chaque objet en tant qu'il supprime
  • Si aucun - quelle serait l'approche la plus facile à utiliser?

EDIT (après 4 réponses) - Une dernière question de clarification après le grand les réponses - je ne suis pas encore tout à fait sûr sur les variables d'instance/propriétés dans mon objet personnalisé que j'ai mis à retenir? Ceux-ci semblent être libéré par le "dealloc" de la méthode dans mon objet personnalisé de classe, où nous le faire manuellement avec [super release].

Donc, si, ré compensation d'un tableau, si je fais un removeAllObjects, puis NSArray questions à "libérer" de mes objets personnalisés, mais ne l'appelez pas "dealloc", alors comment faire mon variables d'instance sortir?

source d'informationauteur Greg

  1. 31

    removeAllObjects de supprimer l'objet de la matrice. Ce processus permettra d'envoyer un message de libération de l'objet et cela va faire diminuer son nombre de références. Lorsque le compteur de référence atteint zéro, l'objet sera libéré.

    ne pas faire comme cela, car il sera de fuite.

    NSObject *object = [[NSObject alloc] init];       + 1
[array addObject:object];                         + 1
[array removeAllObjects];                         - 1
                                                =======
                                                = + 1 -> Leak

    c'est la façon correcte:

    NSObject *object = [[[NSObject alloc] init] autorelease]; + 1 (from alloc) - 1 (from autorelease)
[array addObject:object];                         + 1
[array removeAllObjects];                         - 1
                                                =======
                                                =   0 -> Object will be deallocated

    Au lieu de l'appeler removeAllObjects vous pouviez juste de libérer le tableau. Si un tableau est libéré de tout ce qui est à l'intérieur de, il est libéré et si il n'y a pas d'autre référence à l'objet, il sera libéré.

  2. 3

    Yep, il suffit d'appeler removeAllObjects. Juste pour être sûr, vous n'appelez pas retain lorsque vous ajoutez un objet à un tableau ou lorsque vous créez un tableau avec les objets. C'est fait automatiquement pour vous.

    Concernant deallocde nouveau qui sera fait automatiquement, et vous ne pouvez pas prédire quand.

    La seule chose que vous devez avoir dans le dealloc est la matrice de l'objet lui-même. C'est, en supposant que c'est une variable d'instance ou ivar?

    Afin de vérifier que tout est bon, exécutez l'Analyseur à l'aide de Produit -> Analyser. Et puis donner de l'application d'un profil dans les Instruments à l'aide de la les Fuites instrument pour vérifier qu'aucune partie de votre code à l'origine de toutes les fuites de mémoire.

  3. 1

    Fondamentalement removeAllObjects méthode envoie release message à tous les objets. Le libération méthode décrémente les objets de comptage de référence. Et si le compteur de référence d'un objet atteint 0 puis le dealloc message sera envoyé à l'objet.

    La réponse à votre question appelle [array removeAllObjects] est complètement sûr. Par ailleurs, si vous ne voulez pas le tableau plus que vous pouvez appeler directement [array release] qui libère tous ses objets ainsi que dans le tableau.

  4. 1

    La dealloc méthode n'est jamais appelé directement. Tout est fait à travers le retain/release mécanisme (et le comptage de référence principe). C'est donc le release méthode qui est appelée, pas la dealloc directement. Le dealloc méthode n'est appelée par le moteur d'exécution si le dernier release appel provoque le comptage de référence (retainCount) de l'objet atteint zéro, ce qui signifie que l'objet est vraiment libéré de la mémoire que personne ne s'en sert plus.

    NSArray et toutes les classes de conteneurs dans le Cacao (NSDictionaryNSSet...) ne conservent leurs valeurs. Ainsi, lorsque vous ajoutez un objet, d'un conteneur comme NSArrayil retain cette valeur. Et lorsque vous supprimez cette valeur (y compris lorsque vous appelez removeAllObjects")release.

    Mémoire Mgmt règles sont faciles à suivre: mais la seule règle qui compte, il vous suffit d'appeler release ou autorelease si vous l'avez appelé allocretain ou copy méthodes. C'est toujours de la responsabilité de l'objet qui a le alloc/retain/copy d'appeler le release/autorelease. Ne laissez jamais un alloc/retain/copy sans attente release/autorelease appel à l'équilibre (ou vous avez des fuites), mais d'un autre côté il ne faut jamais appeler release/autorelease si vous n'avez pas le alloc/retain/copy appeler vous-même.

    Bon exemple 1:

    MyClass* obj = [[MyClass alloc] init]; //here you do an alloc
[myArray addObject:obj]; //the NSArray "myArray" retains the object obj
//so now you can release it, the array has the responsability of the object while it is held in the array
[obj release]; //this release balance the "alloc" on the first line, so that's good

[myArray removeAllObjects]; //there the object held by the array receive a release while being removed from the array. As nobody retains it anymore, its dealloc method will be called automatically.

    Bon exemple 2:

    MyClass* obj = [[MyClass alloc] init]; //here you do an alloc
[myArray addObject:obj]; //the NSArray "myArray" retains the object obj
//so now you can release it, the array has the responsability of the object while it is held in the array
[myArray removeAllObjects]; //there the object held by the array receive a release while being removed from the array. But your own code still retains a reference to it (because of the "alloc" on first line) so it won't be removed from memory right now
[obj release]; //this release balance the "alloc" on the first line, and as nobody retains the object anymore, its dealloc method will be called and it will be deallocated from memory

    Bon exemple 3:

    MyClass* obj = [self getSomeObjectFromAnotherMethod]; //here you don't have an "alloc" on this line
[myArray addObject:obj]; //the array retains the object
[myArray removeAllObjects]; //the array release the object while it removes it from the array
//no need to call "release" here as there is no "alloc" done in the scope of this code

    Mauvais exemple:

    MyClass* obj = [self getSomeObjectFromAnotherMethod]; //here you don't have an "alloc" on this line
[myArray addObject:obj]; //the array retains the object
[myArray removeAllObjects]; //the array release the object while it removes it from the array
[obj release]; //Crash here! obj does not exists anymore and has been deallocated from memory before this line!