Comment dois-je appeler +les méthodes de la classe en Objective-C sans faire référence à la classe?

J'ai une série de "politique" des objets qui j'ai pensé que cela pourrait être pratique de mettre en œuvre les méthodes de la classe sur un ensemble de classes. J'ai spécifié un protocole pour cela, et créé des classes pour les rendre conformes à (juste celui qui est illustré ci-dessous)

@protocol Counter   
+(NSInteger) countFor: (Model *)model;
@end

@interface CurrentListCounter : NSObject <Counter> 
+(NSInteger) countFor: (Model *)model;
@end

J'ai ensuite un tableau des classes qui sont conformes à ce protocole (comme CurrentListCounter ne)

+(NSArray *) availableCounters {
return [[[NSArray alloc] initWithObjects: [CurrentListCounter class], [AllListsCounter class], nil] autorelease];
}

Avis comment je suis en utilisant les classes comme des objets (et ce pourrait être mon problème en Smalltalk les classes sont des objets comme tout le reste - je ne suis pas sûr si elles sont dans l'Objective-C?)

Mon problème est lorsque je veux appeler la méthode lorsque je prends un des objets de stratégie de sortie de la matrice:

id<Counter> counter = [[MyModel availableCounters] objectAtIndex: self.index];
return [counter countFor: self];

Je reçois un avertissement sur l'instruction return - il dit -countFor: n'est pas trouvé dans le protocole (donc sa en supposant que c'est une méthode d'instance où je veux appeler une méthode de classe). Cependant, comme les objets de mon tableau sont des instances de la classe, ils sont maintenant comme des méthodes d'instance (ou sur le plan conceptuel qu'ils devraient être).

Est-il une solution magique pour appeler les méthodes de la classe? Ou est-ce juste une mauvaise idée, et je viens de créer des instances de mes objets de stratégie (et ne pas utiliser les méthodes de la classe)?

Compteur de pas à l'encontre de

OriginalL'auteur TimM | 2009-05-31

  1. 20

    Ce 

    id <Counter> counter = [[Model availableCounters] objectAtIndex:0];
return ( [counter countFor: nil] );

    Devrait être

    Class <Counter> counter = [[Model availableCounters] objectAtIndex:0];
return ( [counter countFor: nil] );

    Dans le premier, vous disposez d'une instance qui est conforme à <Counter>. Dans le deuxième, vous avez une classe qui est conforme à <Counter>. L'avertissement du compilateur est correct parce que les instances qui sont conformes à <Counter> ne pas répondre à countFor:, seules les classes ne.

    Je suis d'accord aussi qu'il se sent mieux d'utiliser des instances de classes ici.
    Cette réponse est correcte - au début, je n'avais pas remarqué la subtilité de la Classe<Compteur> vs id<Compteur> - qui répond réellement à l'origine du titre de mon post.

    OriginalL'auteur Jon Hess

  2. 5

    Une classe Objective-C fonctionne comme une instance -- le principal sous-jacent différence est que retenir de comptage ne fait rien sur eux. Cependant, ce que vous allez stocker dans l'-availableCounters tableau ne sont pas des instances (le id type), mais les classes qui ont un type de Class. Par conséquent, avec l'-availableCounters définition que vous avez spécifié ci-dessus, ce que vous avez besoin est cela:

    Class counterClass = [[MyModel availableCounters] objectAtIndex: self.index];
return ( [counterClass countFor: self] );

    Cependant, il serait probablement sémantiquement mieux si vous avez utilisé les instances plutôt que de classes. Dans ce cas, vous pourriez faire quelque chose comme ce qui suit:

    @protocol Counter
- (NSUInteger) countFor: (Model *) model;
@end

@interface CurrentListCounter : NSObject<Counter>
@end

@interface SomeOtherCounter : NSObject<Counter>
@end

    Alors votre modèle de classe peut implémenter les suivantes:

    static NSArray * globalCounterList = nil;

+ (void) initialize
{
    if ( self != [Model class] )
        return;

    globalCounterList = [[NSArray alloc] initWithObjects: [[[CurrentListCounter alloc] init] autorelease], [[[SomeOtherCounter alloc] init] autorelease], nil];
}

+ (NSArray *) availableCounters
{
    return ( globalCounterList );
}

    Votre utilisation de ce serait exactement comme vous l'avez indiqué ci-dessus:

    id<Counter> counter = [[Model availableCounters] objectAtIndex: self.index];
return ( [counter countFor: self] );
    Merci Jim - je voulais voir jusqu'où vous pouvez pousser Objective-C. Il ressemble quand vous frappez les classes c'est là qu'il commence à agir un peu différemment (même si elle n'travail - les classes sont toujours des objets, ce qui est agréable) - donc c'est peut-être préférable de s'en tenir à des instances. Une chose dans votre début de commentaire - "Classe counterClass" est en évitant le protocole, alors que mes cours soient aussi conformes à des "Contre". Je suppose que ce manque est d'être en mesure de bien spécifier les protocoles pour les classes (sur le côté de classe) - quelque chose comme: @interface CurrentListCounter : NSObject <+Compteur>
    Vous pourriez être en mesure d'utiliser la Classe<Compteur> counterClass. Je ne suis pas sûr. Mais ce n'est vraiment limite les messages du compilateur de ne pas avertir sur — ObjC type de vérification est vraiment seulement consultatif. Et les protocoles pouvez spécifier les méthodes de la classe, de sorte que vous n'avez besoin d'aucune sorte de <+Compteur> syntaxe particulière (regardez la NSObject protocole, par exemple).
    Cool, c'est la solution: Classe<Compteur> compteur = [[Modèle availableCounters].... C'est dit au compilateur que j'ai une instance d'une classe qui est conforme à ce protocole. Elle est toujours une question de goût si l'utilisation de classes d'objets est souhaitable en Obj-c (le consensus semble pas)

    OriginalL'auteur Jim Dovey

  3. 0

    Il s'avère qu'il est vraiment en train de travailler, et que l'avertissement est incorrect.

    Donc, la question demeure de savoir si ses une chose raisonnable à faire (utiliser les méthodes de la classe s'ils n'ont pas besoin de tout état)?

    Et la meilleure façon de gérer l'avertissement (j'aime courir avertissement gratuit)?

    Ma seule solution était d'avoir un deuxième protocole (essentiellement la même que la première mais la déclarer sur l'instance de côté):

    @protocol CounterInstance
-(NSInteger) countFor: (Model *)model;
@end

    Et où ai-je accès à des compteurs de l'utiliser à la place (pour tromper le compilateur):

    id<CounterInstance> counter = [[MyModel availableCounters] objectAtIndex: self.index];
return [counter countFor: self];

    Son un peu maladroit mais ne fonctionne pas. Suis intéressé par les vues des autres?

    L'avertissement n'est pas incorrect. La nature dynamique de l'Objective-C signifie que le message est envoyé à l'objet, de toute façon. Le compilateur est la collecte de l'avertissement que vous sachiez que c'est vraiment attend à une méthode d'instance. Comme pour votre solution, je pense que c'est laid. Fais juste ce que Jim a dit.

    OriginalL'auteur TimM