objective-c par défaut de la méthode init de la classe?

J'ai deux différentes méthodes pour initialiser mon objectif c de classe. L'une est la valeur par défaut, et l'on prend un paramètre de configuration. Maintenant, je suis assez vert quand il s'agit de objective-c, mais j'ai mis en œuvre ces méthodes et je me demandais si il y a une meilleure (plus correct/bon style) pour gérer l'initialisation de la façon dont je l'ai fait. Sens, ai-je écrire ces initialisation des fonctions en conformité avec les normes et bon style? Il n'a tout simplement pas se sentir le droit de vérifier l'existence de selfPtr et revenir ensuite sur cette base.

Ci-dessous sont les élèves de ma classe d'en-tête et les fichiers de mise en œuvre. Aussi, si vous repérez quelque chose d'autre qui est le bien et le mal, s'il vous plaît laissez-moi savoir. Je suis une C++/développeur Javascript qui est d'apprendre objective-c comme passe-temps et apprécie les conseils que vous pourriez offrir.

#import <Cocoa/Cocoa.h>

//class for raising events and parsing returned directives

@interface awesome : NSObject {
 //silence is golden. Actually properties are golden. Hence this emptiness.
}

//properties
@property (retain) SBJsonParser* parser;
@property (retain) NSString* eventDomain;
@property (retain) NSString* appid

//constructors
-(id) init;
-(id) initWithAppId:(id) input;

//destructor
-(void) dealloc;


@end

#import "awesome.h"
#import "JSON.h"


@implementation awesome



- (id) init {
 if (self = [super init]) {
  //if init is called directly, just pass nil to AppId contructor variant
  id selfPtr = [self initWithAppId:nil];
 }

 if (selfPtr) {
  return selfPtr;
 } else {
  return self;
 }
}

- (id) initWithAppId:(id) input {
 if (self = [super init]) {
  if (input = nil) {
   input = [[NSString alloc] initWithString:@"a369x123"];
  }
  [self setAppid:input];
  [self setEventDomain:[[NSString alloc] initWithString:@"desktop"]];
 }
 return self;
}

//property synthesis
@synthesize parser;
@synthesize appid;
@synthesize eventDomain;

//destructor
- (void) dealloc {
 self.parser = nil;
 self.appid = nil;
 self.eventDomain = nil;
 [super dealloc];
}

@end

Merci!

Un des problème particulier que je vois, c'est que si init est utilisé, alors [super init] est appelée deux fois.
Vous êtes également les fuites de la eventDomain bien, parce que vous créez un objet à +1 propriété comte, et le donner à une méthode qui augmente la propriété count +2, votre méthode dealloc seulement le ramène vers +1. Il devrait être 0 par rapport à votre awesome objet.
Aussi, le Cocoa/Cocoa.h est pour Mac OS X, pas pour iOS.
Aussi, le Cacao utilise traditionnellement capital chameau cas (ou le haut du dos de chameau cas) pour les noms de classe, comme Awesome ou MoreAwesome, ou TheMostAwesome etc.
Attendez, qui a ajouté le ios tag? Il n'y avait rien dans cette question de suggérer ce fut ios, en fait, comme @jer points, inclus l'en-tête indique que c'est Mac OS X, pas iOS.

OriginalL'auteur Alex | 2010-12-27

14

Quand un initialiseur simplement exécute le plus complexe de l'initialiseur certains paramètres par défaut, appelez ça comme tels:
```
-(id)init {
  return [self initWithAppID:nil];
}

-(id)initWithAppID:(id)input {
  if (self = [super init]) {
    /* perform your post-initialization logic here */
  }
  return self;
}
```
Généralement, vous essayez de faire les initialiseurs de la "désigné initialiseur", ce qui signifie qu'il est celui qui obtient toujours invoqué. Dans ce cas, c'est -initWithAppID:.

OriginalL'auteur d11wtq
1

Votre méthode init doit appeler le préféré de l'initialiseur, initWithAppId:, au lieu de la super mise en œuvre. Puis le initWithAppId appelle la super mise en œuvre, comme il le fait. Aussi, dans initWithAppId:, vous avez si(entrée = nil), qui sera toujours la valeur d'entrée à néant et évaluer OUI. Voici la bonne mise en œuvre.
```
- (id)init {
    return [self initWithAppId:nil];
}
- (id)initWithAppId:(id)input {
    if((self = [super init])) {
        if(input == nil) input = @"a369x123";
        self.appid = input;
        self.eventDomain = @"desktop";
    }
    return self;
}
```
OriginalL'auteur ughoavgfhw
0

Pour être honnête, je vois cela comme un point discutable. Votre deuxième méthode d'initialisation n'a pas de sens lors de la réception d'un nul argument (en plus vous avez un problème de logique dans votre conditionnelle de vérifier si l'entrée est nul). Ce que je ferais dans ce cas, est de fournir une méthode d'initialisation, et deux d'usine, les méthodes de la classe qui agissent de la manière habituelle: Retour autoreleased de cas, et dans l'un d'eux, de donner votre valeur par défaut.

Par exemple, déclarer une méthode de classe:
```
+ (awesome*)awesome;
+ (awesome*)awesomeWithAppId:(id)foo;
```
et de la mise en œuvre de +awesome par exemple, de l'écrire comme ceci:
```
+ (awesome*)awesome
{
    return [[[awesome alloc] initWithAppId:@"a369x123"] autorelease];
}
```
Et de la même manière, dans votre awesomeWithAppId: quelque chose comme ceci:
```
+ (awesome*)awesomeWithAppId:(id)foo
{
    return [[[awesome alloc] initWithAppId:foo] autorelease];
}
```
Puis de nouveau, ce n'est peut-être moi.

OriginalL'auteur jer
0

La default sera celle que vous choisissez d'appel,
```
[awesome alloc] init];
[awesome alloc] initWithAppId:ID];
```
OriginalL'auteur WrightsCS

Vous devez vous connecter pour publier un commentaire.