Qu'est-ce qui augmente le nombre de retenues d'un objet?

Voici le code que je fais référence.

//Person.h

@interface Person : NSObject {
    NSString *firstName;
    NSString *lastName;
}
@end

//Person.m

@implementation Person
- (id)init {
    if (![super init]) return nil;
    firstName = @"John";
    lastName = @"Doe";
}
@end

//MyClass.m

@implementation MyClass
    .....
- (NSArray *)getPeople {
    NSMutableArray *array = [[NSMutableArray alloc] init];

    int i;
    for (i = 0; i < 10; i++) {
        Person *p = [[Person alloc] init];
        [array addObject:p];
    }

    return array;
}
    .....
@end

Maintenant, je sais il n'y a pas de gestion de la mémoire en cours dans cet exemple de code. Ce qui serait nécessaire?

Dans le getPeople boucle, je suis alloc avec une Personne (retainCount 1), puis l'ajouter à la matrice. L'conserver le comte est maintenant de 2, non? Si c'est deux, je devrais être [p de presse]'ing après l'ajout au tableau, portant le retainCount redescendre à 1?

Je crois que c'est l'appelant responsabilité de libérer le tableau retourné par la méthode? (Ce qui permettrait également de libérer de la mémoire de la Personne, et de leurs variables d'instance, en supposant que leur compte sont à 1).

J'ai lu d'Apple de gestion de la mémoire document, mais je crois que je suis plus claire sur, est ce qui augmente la une les objets conservent le comte? Je pense que je saisir l'idée de qui est responsable de la libération, bien que. C'est la règle fondamentale, selon Apple:

Vous prenez possession d'un objet, si vous créez à l'aide d'une méthode dont le nom commence par “alloc” ou “nouveau” ou contient “copie” (par exemple, alloc, newObject, ou mutableCopy), ou si vous l'envoyez un conserver message. Vous êtes responsable de renoncer à la propriété des objets que vous possédez à l'aide de la libération ou de la autorelease. Chaque fois que vous recevez un objet, vous devez ne pas le publier.

bobDevil la phrase "seulement s'inquiéter de conserver compte que vous ajoutez à l'élément explicitement" fait cliquez sur pour moi. Après la lecture de la politique sur la Propriété d'Apple, pour l'essentiel, l'objet, de méthode, qui a créé le nouvel objet, est le seul responsable de la libération /c'est/intérêt. Est-ce correct?

Maintenant, disons que j'ai une méthode, qui reçoit un objet, et l'affecte à une variable d'instance. J'ai besoin de conserver le reçu objet de corriger, car j'ai encore un intérêt?

Si tout cela est incorrect, laissez-moi savoir.

source d'informationauteur Thomas R

18

Il est exact que l'conserver le comte est de 2 après l'ajouter à un tableau. Cependant, vous ne devez vous soucier de les conserver compte que vous ajoutez à l'élément explicitement.

La conservation d'un objet est un contrat qui dit "je ne suis pas fait avec vous, ne pas aller loin." Une règle de base (il y a des exceptions, mais elles sont généralement documentés), c'est que vous propre de l'objet lorsque vous alloue un objet, ou d'en créer une copie. Cela signifie que vous êtes compte tenu de l'objet à conserver un nombre de 1(pas autoreleased). Dans ces deux cas, vous devez le libérer lorsque vous avez terminé. En outre, si vous jamais explicitement conserver un objet, vous devez le libérer.

Donc, être spécifique à votre exemple, lorsque vous créez la Personne, vous en avez un à conserver vous pouvez compter sur elle. Vous l'ajouter à un tableau (ce qui ne veut que ce soit avec elle, vous n'avez pas de soins) et puis vous avez terminé avec la Personne, donc vous libérer:
```
Person *p = [[Person alloc] init]; //retain 1, for you
[array addObject:p]; //array deals with p however it wants
[p release]; //you're done, so release it
```
Aussi, comme je l'ai dit ci-dessus, vous ne possédez que l'objet lors de l'allocation ou de la copie en général, de façon à être cohérent avec celui de l'autre côté des choses, vous devez retourner le tableau autoreleased, de sorte que l'appelant de la getPeople méthode n'est pas propre.
```
return [array autorelease];
```
Edit:
Corriger, si vous le créez, vous devez le libérer. Si vous investissez un intérêt (par le biais de conserver), vous devez le libérer.
4

Conserver les comptages sont augmentés lorsque vous appelez alloc spécifiquement, de sorte que vous aurez besoin de libérer explicitement.

usine méthodes généralement vous donner une autoreleased objet (comme [NSMutableArray tableau] -- vous aurait précisément pour conserver ce de le garder pour toute longueur de temps.).

Autant que NSArray et NSMutableArray addObject:, quelqu'un d'autre aura à se prononcer. Je crois que vous traiter les classes comme des boîtes noires en termes de la façon dont ils gèrent leur propre gestion de la mémoire en tant que motif de conception, de sorte que vous ne serait jamais libérer explicitement quelque chose que vous avez passé dans NSArray. Lorsqu'il est détruit, ses censé s'occuper de la décrémentation de la conserver le comte lui-même.

Vous pouvez également obtenir un peu implicite à retenir si vous déclarez votre ivars comme des propriétés comme @property (conserver) suchAndSuchIvar, et d'utiliser @synthétiser de la mise en œuvre. Synthétiser fondamentalement crée les setters et getters pour vous, et si vous appelez (à conserver) plus précisément, le poseur va conserver l'objet passé en. Ce n'est pas toujours évident, parce que les opérateurs peuvent être structurée comme suit:
```
Person fart = [[Person alloc] init];
fart.firstName = @"Josh"; //this is actually a setter, not accessing the ivar
                          //equivalent to [fart setFirstName: @"Josh"], such that
                          //retainCount++
```
Edit:

Et aussi loin que la gestion de la mémoire, dès que vous ajoutez l'objet du tableau, vous en avez fini avec elle... alors:
```
   for (i = 0; i < 10; i++) {
       Person *p = [[Person alloc] init];
       [array addObject:p];
       [p release];
   }
```
Josh
2

Vous devriez /ne pas/être inquiet au sujet de la conserver comte. C'est à l'interne mis en œuvre. Vous devez seulement savoir si vous avez envie de "posséder" un objet en la retenant. Dans le code ci-dessus, le tableau doit posséder l'objet, pas vous (en dehors de la boucle que vous n'avez même pas référence à lui, sauf par le biais de la matrice). Parce que vous êtes propriétaire [[Person alloc] init]vous avez alors de le libérer.

Ainsi
```
Person *p = [[Person alloc] init];
[array addObject:p];
[p release];
```
Aussi, l'appelant "getPeople" ne devraient pas posséder de la matrice. C'est la convention. Vous devriez autorelease en premier.
```
NSMutableArray *array = [[[NSMutableArray alloc] init] autorelease];
```
Vous aurez envie de lire la documentation d'Apple sur la gestion de la mémoire: http://developer.apple.com/documentation/Cocoa/Conceptual/MemoryMgmt/MemoryMgmt.html

Vous devez vous connecter pour publier un commentaire.