Pourquoi ne NSError besoin de double indirection? (pointeur vers un pointeur)

La NSError** modèle est utilisé lorsque la méthode renvoie normalement une certaine valeur, mais plutôt peut-être besoin de retourner un objet d'erreur (de type NSError*) en cas d'échec. En Objective-C, une méthode ne peut retourner un type d'objet, mais c'est un cas où vous voulez retourner deux. C-comme langues lorsque vous avez besoin de retourner une valeur supplémentaire que vous demandez pour un pointeur vers une valeur de ce type, de sorte que le retour d'un NSError* vous avez besoin d'un NSError** paramètre. De façon plus réaliste exemple serait celui-ci:

//The method should return something, because otherwise it could just return
//NSError* directly and the error argument wouldn't be necessary
- (NSArray *)doStuffWithObject:(id)obj error:(NSError **)error
{
  NSArray *result = ...;  //Do some work that might fail
  if (result != nil) {
    return result;
  } else {
    //Something went bad!
    //The caller might pass NULL for `error` if they don't care about
    //the result, so check for NULL before dereferencing it
    if (error != NULL) {
      *error = [NSError errorWithDomain:...];
    }
    return nil;  //The caller knows to check error if I return nil
  }
}

Si vous n'aviez qu'un NSError* paramètre au lieu d'un NSError** puis doStuff ne serait jamais en mesure de passer à l'erreur de l'objet appelant.

Une vieille question, mais je pense que sa vaut le coup d'investir ici -

Le véritable coupable est NSError. Si vous regardez à sa classe de référence, il n'existe pas de setter pour un de ses attributs, c'est à dire de domaine, un code ou userInfo. Donc, il n'y a aucun moyen, il vous suffit d'allocation et initialisation d'un NSError, le passer à la méthode, puis de renseigner les informations sur le passé NSError objet. (S'il y avait eu une méthode de définition, nous pourrions avoir passé juste une NSError * et fait quelque chose comme erreur.code = 1 dans la méthode.)

Donc, dans le cas où il y a une erreur, vous devez générer un nouveau NSError objet dans la méthode, et si vous faites ainsi, la seule façon de le transmettre à l'appelant, c'est d'avoir un NSError ** argument. (Pour la raison expliquée dans les réponses ci-dessus.)

Je n'ai toujours pas obtenir l'image complète en lisant toutes les réponses ci-dessus. Le profane exercice je l'ai fait ci-dessous, enfin m'a aidé à comprendre ce qui se passe. Il suffit de le mettre là au cas où il aide les débutants à d'autres.

Supposons que vous avez

@interface Class X
-(void) methodX:(NSMutableArray *)array;
@end

Dans une autre partie du code, vous avez la séquence suivante

ClassX *objectX = [[ClassX alloc] init];
NSMutableArray *arrayXX = [@[@(1), @(2)] mutableCopy]; 
//What is stored in arrayXX is the address in the heap at which the NSMutableArray object starts, lets call this address ZZZ
//array starting at address ZZZ in the heap now contains NSNUmbers @1,@2
[objectX methodX:array]

Lorsque vous appelez [objectX methodX:array], ce qui est reçu par la méthode est un copie de array. Depuis le tableau contient une adresse (j'.e est un pointeur), le copie est de spécial que ce qui est reçu est une autre variable avec l'adresse ZZZ en elle.

Donc, si methodX ne [array removeObjectAtIndex:0], puis l'objet commençant à l'adresse ZZZ est affecté (maintenant ne contient qu'un seul NSNUmber @(2)). Ainsi, lorsque le retour de la méthode, le tableau d'origine également en soit affectée.

Suppose au contraire methodX ne array = [@[@(2)] mutableCopy]; puis tableau d'origine ne soit pas affectée. C'est parce que vous ne vont pas dans l'adresse ZZZ et changer quelque chose. Au lieu de cela vous a remplacé le ZZZ dans la copie reçu par la méthode à une adresse différente de YYY. YYY adresse est le début d'un NSMUtableArray objet avec un élément NSNUmber @(2). L'original ZZZ adresse contient toujours un NSMUtableArray avec deux éléments. @(1) et @(2). Donc, si la méthode retourne, le tableau d'origine est intact.