Affichage des articles dont le libellé est Cocoa Touch. Afficher tous les articles
Affichage des articles dont le libellé est Cocoa Touch. Afficher tous les articles

samedi 17 mars 2012

Outlets, Cocoa Cocoa Touch vs

J'ai presque toujours suivre l'exemple d'Apple sur le cacao et les conventions Cocoa Touch. Je suppose que par le temps à l'extérieur des développeurs comme moi voir quelque chose pour la première fois, les ingénieurs d'Apple ont été vivre avec cette chose pendant de nombreux mois, alors qu'ils ont probablement obtenu une bien meilleure idée que moi sur la meilleure façon d'utiliser cette nouvelle chose.

Mais, après avoir passé du temps avec leurs trucs, parfois - pas souvent, mais parfois - je suis en désaccord avec ce qui semble être d'Apple recommande «meilleures pratiques» pour faire quelque chose. Je pense que je suis venu à la décision que le comportement IBOutlet dans iOS est l'un de ces domaines.

Si vous regardez des extraits de documentation d'Apple et des exemples de code, vous constaterez qu'ils conservent presque toujours propriétés IBOutlet, comme:

 #import <UIKit/UIKit.h>   @interface FooView : UIView  {  } @synthesize (nonatomic, retain) IBOutlet UIButton button; @synthesize (nonatomic, retain) IBOutlet UITextField textField; @synthesize (nonatomic, retain) IBOutlet UIImageView imageView; @end 


Il ya une bonne raison à cela. Dans iOS, la documentation stipule explicitement que vous devez conserver tous les points car le chargeur bundle pour iOS autoreleases tous les objets créés à la suite du chargement d'une plume.
Les objets dans le fichier nib sont créés avec un nombre de 1 conservent puis autoreleased. Comme il reconstruit la hiérarchie d'objets, cependant, UIKit rétablit les connexions entre les objets en utilisant l'setValue: forKey: méthode, qui utilise la méthode setter disponible ou conserve l'objet par défaut si aucune méthode setter est disponible. Si vous définissez des débouchés pour nib fichier des objets, vous devez toujours définir une méthode setter (ou biens déclarés) pour accéder à cette sortie. Méthodes setter de débouchés devraient conserver leurs valeurs, et les méthodes setter pour les points contenant des objets de haut niveau doivent conserver leurs valeurs pour les empêcher d'être libéré. Si vous ne stockez pas les objets de haut niveau dans les points, vous devez conserver soit le tableau renvoyé par la loadNibNamed: le propriétaire: options: méthode ou les objets à l'intérieur du tableau pour éviter ces objets d'être libérés prématurément.

Ceci est différent de cacao sur le Mac, où il n'était pas nécessaire de conserver les débouchés et les gens ont rarement fait. En fait, nous n'avons généralement pas s'embêter avec des méthodes d'accès ou de mutator pour les points (il était juste en tapant supplémentaires inutiles dans la plupart des cas), nous venons de mettre le mot-clé IBOutlet en face de la variable d'instance et le chargeur nib était heureux de joindre nos points de vente comme ça, en conservant les objets qui avaient besoin de soutènement.

Le comportement sous Cocoa / Mac n'est pas réellement de conserver tout dans la plume, mais plutôt de conserver tous les objets qui n'a pas un objet parent de le conserver. Donc, en d'autres termes, si un objet dans une plume sera retenue par autre chose, comme un SuperView, le chargeur de nib ne dérange pas de le conserver encore. Mais, si elle n'a pas, le chargeur bundle il conserve afin qu'il ne soit pas libéré.

C'est une approche logique et, en fait, était nécessaire de retour dans le 2.0 de pré-Objective-C jours parce prises à l'époque étaient juste Ivars et il n'y avait pas de moyen facile pour la classe contrôleur de conserver des objets qui devaient être conservés.

Je me demande pourquoi ils changer le comportement fondamental d'un objet de fondation comme NSBundle entre Mac OS et iOS? NSBundle ne fait pas partie du cacao ou de Cocoa Touch, ça fait partie de la Fondation, et le point entier de la Fondation est d'avoir des objets communs entre les différents systèmes d'exploitation.

J'ai écrit une petit projet pour tester si le chargeur Bundle vraiment se comporter différemment, tel que documenté, en utilisant une instance de UIView dans le bec sans SuperView. Evidemment, lorsque je n'ai pas de conserver la prise, soit je suis une EXC_BAD_ACCESS ou un objet tout à fait différent quand j'ai imprimé la prise d'NSLog (). La différence est réelle. Le chargeur de botte sur le Mac conservera points pour vous si ils ont besoin pour être conservé, ce qui vous permet de continuer à utiliser des variables d'instance, ou des propriétés avec le mot clé attribuer. Cela signifie que vous n'avez pas à communiquer vos points de vente dans dealloc et vous n'avez pas à perdre son temps avec quelque chose comme viewDidUnload sur iOS.

Le chargeur de paquet sur l'iOS, d'autre part, ne conserve rien pour vous, alors si un objet n'est pas un objet parent de le conserver, vous devez le conserver dans votre classe contrôleur ou vous allez vous retrouver avec un invalide sortie.

Je ne vois vraiment pas la valeur à changer ce comportement. Je devine que la décision a été prise pour des raisons d'efficacité de la mémoire dans les premiers jours de l'iPhone. L'idée étant que vous pouvez charger une plume avec des instances d'objets que vous ne sont pas réellement à l'aide, et avec l'ancien comportement, ceux qui prendraient la mémoire aussi longtemps que la plume a été chargé. Cela ne veut pas nécessairement ressembler à une bonne idée sur un appareil embarqué sans mémoire virtuelle et 128 Mo de RAM, ce qui est de l'iPhone original et l'iPhone 3G avait.

Malgré cela, je pense que le remède est ici pire que le mal. Si vous ne vous souvenez de libérer vos points de vente dans les viewDidUnload (qui, si je me souviens bien, nous ne pouvions même pas faire dans la version 2.0 du SDK), vos points de vente continueront à utiliser de la mémoire après la plume est déchargé, ce qui évite aucun avantage de l'lazy loading. Essentiellement, il est plus fragile car il repose sur le programmeur fait la bonne chose et il ya peu, voire aucun des situations où un programmeur aurait besoin pour ne pas faire la bonne chose.

En vertu de la chargeuse bundle ne conservant pas prises, elle exige aussi plus par cœur le code réutilisable, qui sera écrit dans chaque classe contrôleur dans chaque application iOS, mais il fonctionne aussi bien d'un risque d'utilisation de la mémoire inutile, sans doute un plus grand risque. En d'autres termes, le remède n'est pas meilleur que la maladie.

iPhones sont de plus robuste et moins de mémoire limitée avec chaque nouvel appareil qui sort. Je dirais que c'est déjà l'heure (ou, à tout le moins, sera bientôt le temps), pour amener le comportement des deux chargeurs bundle ensemble. S'ils sont réunis, ils devraient être réunis en utilisant le comportement de cacao vieille pas le comportement de nouveaux iOS. Quand vous pensez au nombre de personnes codant pour l'iOS maintenant, ces dealloc supplémentaire requis et les lignes viewDidUnload dans chaque classe unique contrôleur de chaque application iOS sont vraiment ajouter jusqu'à beaucoup d'heures d'ingénierie ont perdu sur le passe-partout.

Il ya quelques semaines, j'ai commencé à expérimenter avec l'aide de céder au lieu de le conserver pour IBOutlets sauf dans les cas où l'objet du point de vente n'a pas eu une superview ou un autre objet à son maintien. Si une prise n'est pas une vue ou un contrôle, alors j'utilise aussi conserver. En substance, je suis imitant l'ancien comportement de la plume dans la conception de mes classes de contrôleur.

Cela a conduit à une frappe beaucoup moins et moins de code à maintenir parce que 95% ou plus des points de vente que je crée sont connectés à des objets retenus par leurs superview pendant l'existence entière de la classe contrôleur.

Maintenant, je ne suis pas nécessairement dire que vous devriez faire ce que je fais. Il peut être difficile, parfois, se souvenant de laquelle les objets doivent être conservés et qu'ils peuvent être difficiles à déboguer, si vous vous trompez. Apple a fait une recommandation de bonnes raisons et je ne pense pas que vous devriez ignorer cette recommandation à la légère. Cela étant dit, si vous êtes suffisamment à l'aise avec la gestion de la mémoire en Objective-C et le chargeur bundle pour être en mesure de distinguer si un objet nib sera automatiquement retenue par autre chose, vous pourriez vous épargner un peu juste de taper dans le temps.

Normalement, je essayer de tenir compte des changements d'Apple, mais aussi dans ce cas, je ne peux pas me convaincre que c'était un bon changement. Le comportement nib anciens de conserver les seules choses qui ont besoin de retenue a été en usage depuis plus de 20 ans, qui remonte à quand les ordinateurs de bureau sont moins puissants que nos iPhones sont, et il ne semble pas être un avantage pratique pour le changement. D'autre part, nous serions tous bénéficier de revenir à l'ancien comportement de Mac OS bundle parce que nous aurions moins de rendre le travail à faire lors de la création d'une classe contrôleur. Il ya aussi peu de danger à changer ce comportement, car code qui suit les recommandations actuelles d'Apple continuerait de fonctionner correctement.

lundi 12 mars 2012

Boutons Gradient améliorée

J'ai joué un peu, améliorer mes sans image classe de bouton de gradient. La nouvelle version vous permet de spécifier le gradient pour l'état normal et mis en évidence par peuplant deux tableaux, l'un avec les couleurs qui composent les gradients et l'autre avec la position relative de chaque couleur. J'ai réussi à se débarrasser de la classe parente abstraite et les classes de chaque enfant et de toutes les fonctionnalités est désormais contenu dans une seule classe.

Screen shot 2010-05-19 at 11.48.50 PM.png
Il ya cinq styles intégrés qui peuvent être vus dans l'image ci-dessus, ou vous pouvez définir manuellement le gradient de la valeur que vous souhaitez. Vous pouvez télécharger le code source de la Google code de la page. Il n'ya aucune restriction ou limitation quant à son utilisation.

La meilleure façon d'utiliser ces moyens consiste à ajouter une instance UIButton à votre vue dans Interface Builder, puis changez la classe sous-jacente à partir d'UIButton GradientButton. Parce qu'il n'y a aucun moyen de créer des palettes pour les classes IB iPhone, vous aurez également à mettre en œuvre viewDidLoad et régler le dégradé ou utiliser les méthodes existantes là.

lundi 5 mars 2012

Accessorizer 1.5

J'ai posté au sujet Accessorizer avant. Il vient d'être mis à jour pour la version 1.5, intégrant une nouvelle fonctionnalité qui sauta d'une demande de fonctionnalité qui a été faite par votre serviteur. En fait, il s'agissait davantage d'un commentaire hors-la main, puis une demande de fonctionnalité, mais Kevin Callahan, le cerveau derrière Accessorizer aimé la demande et a sauté sur elle avec enthousiasme.

La nouvelle fonctionnalité? Accessorizer a maintenant la capacité de détecter automatiquement les classes qui sont couramment utilisés comme points de vente et, si vous le souhaitez, vous ajoutez le mot-clé IBOutlet automatiquement les déclarations de propriété produites. J'ai été beta test de cette nouvelle fonctionnalité, et fonctionne très bien.

Si vous n'avez aucune quantité importante de la programmation Objective-C et n'ont pas essayé Accessorizer, je serais vraiment suggérer de donner un essai. Dans l'application que j'ai écrit aujourd'hui pour Plus l'iPhone 3 de développement, Je dirais que Accessorizer m'a sauvé au moins cinq minutes de la dactylographie (pour ne pas mentionner considérablement réduit les chances d'erreurs et de fautes de frappe). J'ai tapé seulement mes variables d'instance, puis quelques touches courtes et une vingtaine de secondes plus tard, j'ai eu mes déclarations de propriété complet avec mot-clé IBOutlet en cas de besoin, les déclarations de synthétiser @, et les deux méthodes NSCoding. Vous n'avez pas à écrire des classes trop nombreuses pour elle de payer pour elle-même si vous faites cela pour vivre. Si vous êtes un amateur, puis, en quelque sorte, votre temps est encore plus précieux.

Et si vous n'êtes pas sûr de savoir comment l'utiliser, ou pourquoi vous l'utilisez, consultez les vidéos Accessorizer dans la partie inférieure droite de la page d'accueil.

Accessorizer 1.5

J'ai posté au sujet Accessorizer avant. Il vient d'être mis à jour pour la version 1.5, intégrant une nouvelle fonctionnalité qui sauta d'une demande de fonctionnalité qui a été faite par votre serviteur. En fait, il s'agissait davantage d'un commentaire hors-la main, puis une demande de fonctionnalité, mais Kevin Callahan, le cerveau derrière Accessorizer aimé la demande et a sauté sur elle avec enthousiasme.

La nouvelle fonctionnalité? Accessorizer a maintenant la capacité de détecter automatiquement les classes qui sont couramment utilisés comme points de vente et, si vous le souhaitez, vous ajoutez le mot-clé IBOutlet automatiquement les déclarations de propriété produites. J'ai été beta test de cette nouvelle fonctionnalité, et fonctionne très bien.

Si vous n'avez aucune quantité importante de la programmation Objective-C et n'ont pas essayé Accessorizer, je serais vraiment suggérer de donner un essai. Dans l'application que j'ai écrit aujourd'hui pour Plus l'iPhone 3 de développement, Je dirais que Accessorizer m'a sauvé au moins cinq minutes de la dactylographie (pour ne pas mentionner considérablement réduit les chances d'erreurs et de fautes de frappe). J'ai tapé seulement mes variables d'instance, puis quelques touches courtes et une vingtaine de secondes plus tard, j'ai eu mes déclarations de propriété complet avec mot-clé IBOutlet en cas de besoin, les déclarations de synthétiser @, et les deux méthodes NSCoding. Vous n'avez pas à écrire des classes trop nombreuses pour elle de payer pour elle-même si vous faites cela pour vivre. Si vous êtes un amateur, puis, en quelque sorte, votre temps est encore plus précieux.

Et si vous n'êtes pas sûr de savoir comment l'utiliser, ou pourquoi vous l'utilisez, consultez les vidéos Accessorizer dans la partie inférieure droite de la page d'accueil.

dimanche 19 février 2012

Une catégorie sur NSDate

Voici une catégorie sur NSDate qui fait quelques tâches peu communes qui nécessitent plusieurs lignes de code et les transforme en une seule méthode tout. Parmi ces méthodes sont celle qui prend un jour avec une valeur datetime et le transforme en une date sans temps, une méthode qui calcule une nouvelle date qui est un certain nombre de jours après la date, et une méthode qui calcule la différence entre deux dates donnée en jours.

Rien fracassantes, mais il peut vous faire économiser quelques lignes de code ici et là.

NSDate-Misc.h
#import <Foundation/Foundation.h>
@interface NSDate(Misc)
+ (NSDate *)dateWithoutTime;
- (NSDate *)dateByAddingDays:(NSInteger)numDays;
- (NSDate *)dateAsDateWithoutTime;
- (int)differenceInDaysTo:(NSDate *)toDate;
- (NSString *)formattedDateString;
- (NSString *)formattedStringUsingFormat:(NSString *)dateFormat;
@end


NSDate-Misc.m
#import "NSDate-Misc.h"

@implementation NSDate(Misc)
+ (NSDate *)dateWithoutTime
{
return [[NSDate date] dateAsDateWithoutTime];
}

-(NSDate *)dateByAddingDays:(NSInteger)numDays
{
NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];

NSDateComponents *comps = [[NSDateComponents alloc] init];
[comps setDay:numDays];

NSDate *date = [gregorian dateByAddingComponents:comps toDate:self options:0];
[comps release];
[gregorian release];
return date;
}

- (NSDate *)dateAsDateWithoutTime
{
NSString *formattedString = [self formattedDateString];
NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
[formatter setDateFormat:@"MMM dd, yyyy"];
NSDate *ret = [formatter dateFromString:formattedString];
[formatter release];
return ret;
}

- (int)differenceInDaysTo:(NSDate *)toDate
{
NSCalendar *gregorian = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];

NSDateComponents *components = [gregorian components:NSDayCalendarUnit
fromDate:self
toDate:toDate
options:0
]
;
NSInteger days = [components day];
[gregorian release];
return days;
}

- (NSString *)formattedDateString
{
return [self formattedStringUsingFormat:@"MMM dd, yyyy"];
}

- (NSString *)formattedStringUsingFormat:(NSString *)dateFormat
{
NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
[formatter setDateFormat:dateFormat];
NSString *ret = [formatter stringFromDate:self];
[formatter release];
return ret;
}

@end


samedi 18 février 2012

Qu'est-ce, apprends-moi?

Oui, croyez-le ou non, il semble que je vais enseigner.

J'ai accepté d'être l'instructeur pour un jour de trois Boot Camp Atelier iPhone NYC qui fonctionne à partir d'août 14-16. Les prochains ateliers (à la fois à New York et autres lieux) sont une possibilité si je n'ai pas inciter à une émeute ou faire un travail vraiment horrible d'enseignement celui-ci.

Je suis en fait très excitée sur cette opération. Le programme Boot Camp iPhone est un excellent programme et je suis impatient d'être une partie de celui-ci. L'encre est encore fraîche sur la face (je ne suis même pas mentionnés en tant qu'instructeur sur leur page web encore), donc je n'ai pas beaucoup de détails en ce moment, mais je peux vous dire que cet atelier est particulièrement destiné aux nouveaux iPhone les développeurs qui ont quelques connaissances en programmation de base (ou, essentiellement, les mêmes personnes que notre livre est destiné aux). Donc, si vous vivez dans ou près de la région métropolitaine de New York et êtes intéressé à devenir un développeur iPhone, je serais ravi de vous avoir dans mon atelier.

Si tout se passe bien, je suis l'espoir de les convaincre d'offrir un atelier plus avancé ou peut-être même un atelier d'OpenGL / Gaming dans le futur. Faites moi savoir si vous êtes intéressé à l'autre de ces sujets et, si oui, où vous habitez.

A propos de la seule autre chose que je sais à ce stade est que je serai peaufiner le programme qui est sur leur site un peu mettre à jour pour 3.0 et pour correspondre à mon style d'enseignement. Autre que cela, les détails seront à venir une fois que je les connais.

Données de base - Déterminer si un objet géré est nouveau

Désolé pour le manque de messages OpenGL ES. Les choses sont assez mouvementée aujourd'hui avec l'écriture de développement Plus pour iPhone, et je ne suis même pas totalement rattrapé de la semaine passée à la WWDC. Ainsi, il peut être un peu de temps avant que je sois en mesure d'obtenir un autre poste de fond hors comme un autre tutoriel OpenGL ES.

Quiconque travaille avec Core Data peut apprécier cette catégorie que j'ai écrit, avec l'aide de Jim Dovey. Curieusement, les objets gérés ne sais pas si elles sont nouvelles ou non. C'est-à-dire si elles ont été ajoutés au contexte depuis la dernière charge ou l'enregistrer. J'ai trouvé ceci pour être un élément d'information que j'ai eu besoin de beaucoup, tellement absorbé par le chèque dans une catégorie.

NSManagedObject-isNew.h

//
// NSManagedObject-IsNew.h

#import <Foundation/Foundation.h>


@interface NSManagedObject(IsNew)
/*!
@method isNew
@abstract Returns YES if this managed object is new and has not yet been saved yet into the persistent store.
*/

-(BOOL)isNew;
@end



NSManagedObject-isNew.m

//
// NSManagedObject-IsNew.m
//

#import "NSManagedObject-IsNew.h"


@implementation NSManagedObject(IsNew)
-(BOOL)isNew
{
NSDictionary *vals = [self committedValuesForKeys:nil];
return [vals count] == 0;
}

@end



Ensuite, vous pouvez simplement ajouter ces fichiers à votre projet, # importer le fichier en-tête, et puis vous pouvez demander à n'importe quel objet géré si c'est nouveau en lui envoyant un message isNew.

vendredi 17 février 2012

Runtime Madness

Il y avait une discussion passionnante sur Twitter ce matin concernant les runtimes modernes vedette sur 64-bits sur Mac et sur l'iPhone. Une des caractéristiques du moteur d'exécution nouvelle création automatique de variables d'instance pour vos propriétés. Ainsi, par exemple, c'est une classe tout à fait valable pour Mac programmes 64-bit:

#import <Cocoa/Cocoa.h>

@interface TestController : NSObject {

}

@property (retain) NSString *testString;
@end


Notez qu'il n'y a pas de déclaration variable d'instance pour testString, ce n'est pas nécessaire. Maintenant que le fragiles problème de classe de base a été éliminée dans le modernes ABI, Le runtime est capable de faire ce travail pour nous.

Cela fonctionne sur l'iPhone aussi. Malheureusement, le simulateur d'iPhone est une application 32-bits Mac, ce qui signifie les programmes exécutés dans le simulateur cannot profiter de cette fonctionnalité. En d'autres termes, la classe suivante est une classe tout à fait valable lorsqu'il est compilé pour l'appareil iPhone, mais échouera avec des erreurs lorsqu'il est compilé avec le simulateur:

#import <UIKit/UIKit.h>

@interface HeroEditViewController : UITableViewController {
}

@property (nonatomic, retain) NSManagedObject *myObject;
@end


Vous pourriez utiliser cette fonctionnalité sur l'iPhone, mais pas sur le simulateur en faisant ceci:

#import <UIKit/UIKit.h>

@interface HeroEditViewController : UITableViewController {
#if TARGET_IPHONE_SIMULATOR
NSManagedObject *myObject;
#endif
}

@property (nonatomic, retain) NSManagedObject *myObject;
@end



Mais, il ya un hic. L'ABI modernes ne permettent pas l'accès à @ variables d'instance privées, et les variables d'instance créé pour vous par le runtime sont @ private. Cela signifie que vous ne pouvez pas accéder au sous-jacente, variable d'instance non déclarés à partir de votre propre classe. Vous devez utiliser la méthode d'accès partout.

Alors, quel est l'avantage de ne pas déclarer la variable d'instance sous-jacente? Si vous écrivez une application 64-bits Mac, il peut vous faire économiser un peu juste de taper. Sur l'iPhone, il ne vous épargner toute tapant du tout, en fait, il ajoute deux lignes de code à moins que vous ne jamais, jamais utiliser le simulateur. Cela signifie que pour les développeurs iPhone plupart, il n'ya vraiment aucun avantage à utiliser fonction dès maintenant. Dans l'avenir, il est possible, et peut-être même probable qu'il y aura les optimisations du compilateur qui peut se produire que si vous avez que vous avez laissé le runtime créer vos variables d'instance pour vous, cependant.

Craig Hockenberry a ouvert un rapport de bogue pour demander que le simulateur d'iPhone être changé pour utiliser un moteur d'exécution modernes (sans changer la taille des types de données à 64 bits tailles, bien sûr). Si vous souhaitez être en mesure d'avoir votre variables d'instance de synthèse, vous pourriez vouloir duper son rapport. Les développeurs plus qui déclarent un bug spécifique ou demande de fonctionnalité, les plus susceptibles d'Apple est de chercher à mettre en œuvre le correctif demandé ou fonction.

Si vous vous demandez si vous devriez utiliser cette nouvelle fonctionnalité dans vos applications iPhone, il n'ya vraiment pas de réponse unique. Il n'ya absolument aucune garantie qu'il n'y aura jamais aucun avantage à utiliser ce sur l'iPhone. Sauf si vous n'utilisez pas le simulateur du tout, vous avez encore de déclarer les variables d'instance lors de la compilation pour le simulateur, afin de ne pas vous faire économiser de toute frappe. C'est un pari, donc n'hésitez pas à utiliser que vous voulez, mais il n'y a certainement aucune raison impérieuse de les utiliser encore.

Je voudrais, cependant, commencer à se déplacer loin de l'accès variable d'instance lors de l'utilisation directe des propriétés. À un certain point, il sera probablement judicieux d'utiliser cette fonction, et vous serez coincé à jour une grande quantité de code si vous accéder directement à vos variables d'instance.

Merci à @bbum, @borkware, @chockenberry et le reste des geeks de cacao qui ont participé à la discussion éducatif!

Note: Si vous voulez expérimenter avec ce sur un programme Mac, voici les options de configuration de projet Xcode, vous aurez besoin de changer de sorte que vous n'êtes pas aussi la construction d'une version 32-bit (pour lequel les variables d'instance ne peuvent pas être synthétisés ) - cliquez pour agrandir les versions (il ya deux photos):




lundi 13 février 2012

OpenGL ES à partir de zéro, Partie 1: Concepts de base

J'ai fait un certain nombre d'affichages sur la programmation OpenGL ES pour l'iPhone, mais la plupart des messages que j'ai fait ont été ciblées sur les personnes qui connaissent déjà au moins un peu plus sur la programmation 3D.

Si vous n'avez pas déjà fait, prenez une copie de mon modèle d'OpenGL Empty project Xcode. Nous allons utiliser ce modèle comme point de départ plutôt que celui fourni d'Apple. Vous pouvez l'installer en copiant le dossier décompressé à cet endroit:
/Developer/Platforms/iPhoneOS.platform/Developer/Library/Xcode/Project Templates/Application/
Il ya un certain nombre de bons tutoriaux et livres sur OpenGL. Malheureusement, il ne sont pas très nombreuses sur OpenGL ES, et aucune (au moins pendant que j'écris ceci) qui sont spécifiquement conçus pour l'apprentissage de la programmation 3D sur l'iPhone. Parce que la plupart des matériels disponibles pour l'apprentissage OpenGL commence enseignement en utilisant ce qu'on appelle mode direct, Qui fait partie de la fonctionnalité d'OpenGL qui n'est pas dans OpenGL ES, il peut être vraiment difficile pour un dev iPhone sans expérience 3D pour se lever et courir à l'aide des livres existants et des tutoriels. J'ai eu un certain nombre de personnes en font la demande, donc j'ai décidé de commencer une série de messages de blog conçu pour le débutant absolu en 3D. C'est la première fois dans cette série. Si vous avez lu et compris mon précédent affichages OpenGL, vous trouverez probablement cette série à être un peu trop basique.

Types de données OpenGL


La première chose que nous allons parler sont les types de données d'OpenGL. Parce que OpenGL est une API multi-plateforme, et la taille des types de données peuvent varier en fonction du langage de programmation utilisé ainsi que le processeur sous-jacent (64 bits vs 32 bits vs 16 bits), OpenGL déclare ses propres types de données personnalisés . Lors du passage de valeurs dans OpenGL, vous devez toujours utiliser ces types de données OpenGL pour s'assurer que vous êtes de passage des valeurs de la bonne taille ou de précision. Ne pas le faire pourrait provoquer des résultats inattendus ou des ralentissements causés par la conversion des données à l'exécution. Chaque mise en œuvre de l'OpenGL, indépendamment de la plateforme ou du langage, déclare les types de données standard OpenGL de telle manière qu'ils seront de la même taille sur toutes les plateformes, ce qui rend le portage OpenGL de code d'une plateforme à une autre plus facile.

Voici les types de données OpenGL ES:
  • GLenum: Un entier non signé utilisé pour GL spécifiques énumérations. Les plus couramment utilisés pour raconter OpenGL, le type de données stockées dans un tableau transmis par le pointeur (par exemple GL_FLOAT) pour indiquer que le tableau est constitué de GLfloats.
  • GLboolean: Utilisé pour tenir une seule des valeurs booléennes. OpenGL ES déclare également ses propres valeurs vrai et faux (et GL_TRUE GL_FALSE) pour éviter les différences plateforme et du langage. Lors du passage booléens dans OpenGL, utilisez ces plutôt que OUI ou NON (bien qu'il ne fera pas mal si vous utilisez accidentellement OUI ou TRUE, car ils sont réellement défini les mêmes. Mais, il est de bon ton d'utiliser les valeurs définies par GL.
  • GLbitfield: Ce sont des entiers sur quatre octets utilisés pour emballer les multiples valeurs booléennes (jusqu'à 32) en une seule variable en utilisant des opérateurs bit à bit. Nous allons discuter de cela plus la première fois que nous utilisons une variable bitfield, mais vous pouvez lire sur l'idée de base plus sur Wikipedia
  • GLbyte: A signé un octet entier capable de contenir une valeur de -128 à 127
  • GLshort: A signé de deux octets entiers capable de contenir une valeur comprise entre -32768 à 32767
  • GLint: A signé quatre octets capable de contenir une valeur comprise entre -2147483648 et 2147483647
  • GLsizei: A signé, quatre octets utilisés pour représenter la taille (en octets) de données, similaire à size_t en C.
  • GLubyte: Un non signé, un octet entier capable de contenir une valeur comprise entre 0 et 255.
  • GLushort: Un non signé, de deux octets entiers capable de contenir une valeur comprise entre 0 et 65535
  • GLuint: Un non signé, quatre octets capable de contenir une valeur comprise entre 0 et 4294967295
  • GLfloat: Une précision de quatre octets IEEE 754-1985 flottantes variable en virgule.
  • GLclampf: Ceci est aussi une variable à quatre octets de précision en virgule flottante, mais quand OpenGL utilise GLclampf, il est ce qui indique que la valeur de cette variable particulière doit toujours être compris entre 0,0 et 1,0.
  • GLvoid: Une valeur nulle utilisée pour indiquer qu'une fonction ne retourne aucune valeur, ou ne prend aucun argument.
  • GLfixed: Nombres à virgule fixe sont un moyen de stocker des nombres réels en utilisant des nombres entiers. Ce fut une optimisation courante dans les systèmes 3D utilisés car la plupart des processeurs d'ordinateur sont beaucoup plus rapides à faire des maths avec des entiers qu'avec variables à virgule flottante. Parce que l'iPhone a des processeurs vectoriels qui utilise OpenGL pour faire vite mathématiques à virgule flottante, nous ne serons pas discuter arithmétique en virgule fixe ou le type de données GLfixed.
  • GLclampx: Une autre variable en virgule fixe, utilisé pour représenter des nombres réels compris entre 0,0 et 1,0 en utilisant l'arithmétique virgule fixe. Comme GLfixed, nous ne serons pas d'utiliser ou de discuter de ce type de données.

OpenGL ES (au moins la version utilisée sur l'iPhone) ne supporte aucune de 8 octets (64 bits) des types de données tels que long ou double. OpenGL ne sont plus ces types de données, mais étant donné la taille de l'écran la plupart des périphériques embarqués, et les types d'applications que vous êtes susceptibles d'être écrit pour eux, la décision a été prise de les exclure de l'OpenGL ES sous l'hypothèse qu'il y aurait besoin de peu pour eux, et que leur utilisation pourrait avoir un effet néfaste sur la performance.

Le point ou un sommet


L'unité atomique dans le graphisme 3D est appelé le point or vertex. Celles-ci représentent un seul point dans un espace tridimensionnel et sont utilisés pour construire des objets plus complexes. Les polygones sont construits à partir de ces points, et les objets sont construits en plusieurs polygones. Bien OpenGL régulière supporte de nombreux types de polygones, OpenGL ES ne supporte que l'utilisation de trois faces de polygones (triangles aka).

Si vous vous souvenez de retour à l'école secondaire la géométrie, vous vous souvenez probablement quelque chose qui s'appelle Coordonnées cartésiennes. L'idée de base est que vous sélectionnez un point arbitraire dans l'espace et l'appellent le origin. Vous pouvez ensuite désigner n'importe quel point dans l'espace en référençant l'origine et l'aide de trois nombres, un pour chacune des trois dimensions, qui sont représentés par trois lignes imaginaires qui traversent l'origine. La ligne imaginaire allant de gauche à droite est appelé l'axe des x. Voyager le long de l'axe x, comme vous allez à la droite le long de l'axe des x, la valeur est plus élevée et que vous allez vers la gauche, ils obtiennent plus bas. Gauche de l'origine sont des valeurs de x négatives, et à droite sont les valeurs de x positives. Les deux autres axes de travail exactement de la même manière. En remontant le long de l'axe Y, la valeur de y augmente, et de descendre, il diminue. Les valeurs supérieures à l'origine ont une valeur y positifs, et ceux ci-dessous l'origine ont une valeur y négatifs. Avec Z, comme des objets s'éloigner du spectateur, la valeur est faible, et comme ils se déplacent vers le spectateur (ou continuer derrière le spectateur), les valeurs deviennent plus importants. Les points qui sont en face de l'origine ont une valeur positive z, et ceux qui sont derrière l'origine ont une valeur négative z. L'illustration suivante pourrait rendre l'aide ces mots un sens un peu plus:
cartesian.png

Note: Core Graphics, qui est un autre cadre pour faire des images sur l'iPhone utilise un système de coordonnées légèrement différentes dans ce que l'axe Y diminue car il passe de l'origine, et augmente comme il va vers le bas.


La valeur qui augmente ou diminue le long de ces axes sont dans une échelle arbitraire - ils ne représentent aucune mesure réelle, comme les pieds, pouces ou mètres. Vous pouvez sélectionner n'importe quelle échelle qui fait sens pour vos propres programmes. Si vous souhaitez concevoir un jeu où chaque unité est un pied, vous pouvez le faire. si vous voulez faire de chaque unité d'un micron, vous pouvez le faire aussi bien. OpenGL ne prend pas garde à ce qu'ils représentent pour l'utilisateur final, qu'il estime juste d'entre eux comme des unités, et s'assurer qu'ils sont tous des distances égales.

Depuis l'emplacement d'un objet dans l'espace tridimensionnel peut être représenté par trois valeurs, la position d'un objet est généralement représentée en OpenGL par l'utilisation de trois variables GLfloat, généralement en utilisant un tableau de trois flotteurs, là où le premier élément du tableau (indice 0 ) est la position x, la seconde (indice 1) est la position y, et le troisième (index 2) est la position z. Voici un exemple très simple de créer un sommet pour une utilisation en OpenGL ES:

    GLfloat vertex[3];
vertex[0] = 10.0; // x
vertex[1] = 23.75; // y
vertex[2] = -12.532; // z


En OpenGL ES, vous devez généralement soumettre tous les sommets qui composent une partie ou l'ensemble des objets dans votre scène comme un Vertex Array. Un large vertex est tout simplement un tableau de valeurs (généralement GLfloats) qui contient les données de vertex pour certains ou de tous les objets dans le monde. Nous allons voir comment ce processus fonctionne dans le prochain post de cette série, mais la seule chose à retenir à propos des Vertex Arrays, c'est que leur taille est basée sur le nombre de sommets d'être soumis soit multiplié par trois (pour le dessin en trois dimensions d'espace) ou deux (pour le dessin en deux dimensions d'espace). Ainsi, un tableau de vertex qui détient six triangles dans l'espace tridimensionnel serait composé d'un tableau de 54 GLfloats, parce que chaque triangle a trois sommets, et chaque sommet a trois coordonnées et 6 x 3 x 3 = 54.

Faire face à toutes ces GLfloats peut être une douleur, cependant, parce que vous êtes constamment avoir à multiplier les choses dans votre tête et essayez de penser à ces tableaux en termes de sommets et de polygones qu'ils représentent. Heureusement, il existe un moyen plus facile. Nous pouvons définir une structure de données pour organiser un seul sommet, comme ceci:

typedef struct {
GLfloat x;
GLfloat y;
GLfloat z;
}
Vertex3D;

En faisant cela, notre code devient plus lisible:

Vertex3D vertex;
vertex.x = 10.0;
vertex.y = 23.75;
vertex.z = -12.532;

Maintenant, parce que notre structure Vertex3D est composé de trois GLfloats, en passant un pointeur sur une Vertex3D est exactement le même que le passage d'un pointeur vers un tableau de trois GLfloats. Il n'y a aucune différence pour l'ordinateur, les deux ont la même taille et le même nombre d'octets dans le même ordre que OpenGL attend d'eux. Le regroupement des données dans ces structures de données rend juste plus facile pour nous en tant que programmeur de visualiser et de traiter les données. Si vous téléchargez mon template Xcode depuis le début de cet article, cette structure de données et les fonctions de soutien, je vais discuter la prochaine ont déjà été définis dans le fichier nommé OpenGLCommon.h. Il ya aussi une fonction inline pour la création de sommets unique:

static inline Vertex3D Vertex3DMake(CGFloat inX, CGFloat inY, CGFloat inZ)
{
Vertex3D ret;
ret.x = inX;
ret.y = inY;
ret.z = inZ;
return ret;
}


Si vous vous souvenez de retour à la géométrie (ou peut-être vous n'avez pas, ce qui est correct), la distance entre deux points sur un plan est calculé en utilisant cette formule:

distance formula.png


Nous pouvons appliquer cette formule pour calculer la distance en ligne droite entre deux points quelconques dans un espace tridimensionnel avec cette fonction inline simple:

static inline GLfloat Vertex3DCalculateDistanceBetweenVertices (Vertex3D first, Vertex3D second)
{
GLfloat deltaX = second.x - first.x;
GLfloat deltaY = second.y - first.y;
GLfloat deltaZ = second.z - first.z;
return sqrtf(deltaX*deltaX + deltaY*deltaY + deltaZ*deltaZ );
}
;


Triangles


Depuis OpenGL ES ne supporte que les triangles, on peut également créer une structure de données pour le groupe trois sommets en un objet unique triangle.

typedef struct {
Vertex3D v1;
Vertex3D v2;
Vertex3D v3;
}
Triangle3D;


Encore une fois, une seule Triangle3D est exactement le même comme un tableau de neuf GLfloats, c'est juste plus facile pour nous de traiter avec elle dans notre code, car nous pouvons construire des objets hors de sommets et de triangles plutôt que sur des tableaux de GLfloats.

Il ya un peu plus de choses que vous devez savoir sur les triangles, cependant. En OpenGL, il s'agit d'un concept connu sous le nom winding, Ce qui signifie simplement que l'ordre dans lequel les sommets sont dessinés questions. Contrairement aux objets dans le monde réel, les polygones en OpenGL n'ont généralement pas les deux faces d'eux. Ils ont un côté, ce qui est considéré comme le face avant, Et d'un triangle ne peut être vu si sa face avant qui fait face au spectateur. Alors qu'il est possible de configurer OpenGL pour traiter les polygones comme deux faces, par défaut, les triangles ont un seul côté visible. En sachant ce qui est la face avant ou visible du polygone, OpenGL est capable de faire la moitié de la quantité de calculs par polygone qu'il aurait à faire si les deux parties étaient visibles.

Bien qu'il existe des moments où un polygone voler de ses propres, et vous pourriez très bien vouloir le dos tirées, généralement un triangle fait partie d'un objet plus grand, et l'un des côtés du polygone sera face à l'intérieur de l'objet et ne sera jamais être vu. Le côté qui n'est pas établi est appelé un backface, Et détermine OpenGL qui est la face avant d'être tiré et qui est la contreface en regardant l'ordre de dessin des sommets. La face avant est celle qui serait établie en suivant les sommets dans le sens antihoraire de commande (par défaut, il peut être changé). Depuis OpenGL peut déterminer facilement quels triangles sont visibles pour l'utilisateur, il peut utiliser un processus appelé Contreface Culling pour éviter de faire le travail pour les polygones qui ne sont pas face à l'avant de la fenêtre et, par conséquent, ne peut pas être vu. Nous allons discuter de la fenêtre dans la prochaine affectation, mais vous pouvez penser que c'est la caméra virtuelle, ou une fenêtre virtuelle à la recherche dans le monde OpenGL.

winding.png


Dans l'illustration ci-dessus, le triangle cyan sur la gauche est une contreface et ne seront pas tirés parce que l'ordre que les sommets seraient établis en relation avec le spectateur est dans le sens horaire. D'autre part, le triangle sur la droite est un FrontFace qui sera tiré parce que l'ordre des sommets est anti-horaire par rapport au spectateur.

Dans la prochaine affectation de cette série, nous allons examiner la mise en place dans le monde virtuel en OpenGL et faire un peu de dessin simple à l'aide Vertex3D et Triangle3D. Dans le poste après cela, nous allons examiner transformations qui sont une façon d'utiliser l'algèbre linéaire pour déplacer des objets autour dans le monde virtuel.

dimanche 12 février 2012

Clark Cox sur VLA

Clark S. Cox, III, Un développeur et contributeur de cacao assez fréquent à la liste de diffusion de cacao-dev, Souligne un défaut majeur dans les tableaux de C99 de longueur variable (VLA) sur son blog aujourd'hui. Bien qu'il soit agréable d'être en mesure d'allouer des tableaux sur la pile, je suis avec Clark sur celui-ci: l'utilisation de malloc () (ou un de ses frères comme calloc ()) suivie par free () pour tout les tableaux potentiellement important pour vous n'avez pas à vous soucier de comportement indéfini lorsque votre tableau est trop gros pour tenir sur la pile.

Maintenant, excusez-moi, j'ai un peu de code pour vérifier où je pense que j'ai utilisé VLA pour les tableaux potentiellement important.

samedi 11 février 2012

Les différences dans la délégation

Cacao et tactile ont évidemment beaucoup de choses en commun. Ils utilisent le même langage sous-jacente, elles utilisent toutes deux classes de la Fondation, et ils ont tous deux suivi de nombreux modèles de conception identique. Le fait qu'ils sont conçus pour fonctionner à différents types de matériel physique et le fait que Cocoa Touch a été créé près de vingt ans après le cacao (n'ee NexSTEP), signifie qu'il ya certains domaines qui sont très différents. Ces différences peuvent vous jeter, car beaucoup de choses entre les deux est le même.

La plus évidente de ces différences est que le concept de classes de contrôleur générique de vue est «cuit dans" à Cocoa Touch, mais ont été ajoutés au cacao, après qu'il a été autour depuis des années. Mais c'est un sujet pour un blog affichage distinct. Aujourd'hui, je veux parler de l'autre, la différence un peu plus subtile, qui est que le Touch Cacao et mettre en œuvre les délégués de manières complètement différentes. Regardons les objets déléguer plus couramment utilisées: les délégués d'application. Les deux cadres d'application des délégués-UIApplicationDelegate et NSApplicationDelegate-servir le même but, mais sont mises en oeuvre différemment.

Delegation n'est pas unique à l'Objective-C. C'est un modèle reconnu qui est utilisé dans de nombreuses langues, mais avec parcimonie dans la plupart des. En raison de l'Objective-C dynamique, la nature faiblement typé, la pomme et des ingénieurs de NeXT a réalisé très tôt que la délégation a souvent été un meilleur choix que l'héritage, ce qui explique pourquoi la hiérarchie de classes pour le cacao et Cocoa Touch est généralement plus plat que les hiérarchies de l'orienté objet cadres d'application intégré dans d'autres langues. Si vous venez à Objective-C récemment d'un autre langage OO, chaque fois que votre premier réflexe est de sous-classe, prendre du recul et demandez-vous si un autre modèle de conception, comme la délégation ou d'une catégorie, ne rentrent plus facilement dans la lumière de la langue que vous utilisez.

Mais revenons aux délégués d'application. La grande différence entre UIApplicationDelegate et NSApplicationDelegate est en ce qu'ils sont. NSApplicationDelegate est un protocole informel, Ce qui signifie que c'est simplement une catégorie sur NSObject. Ci-dessous, vous pouvez voir ce NSApplicationDelegate ressemble dans Leopard. J'ai pris des commentaires et des macros pré-compilateur et reformaté pour le rendre plus facile à lire. Vous pouvez trouver l'original dans :

@interface NSObject(NSApplicationDelegate)
- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender;
- (BOOL)application:(NSApplication *)sender openFile:(NSString *)filename;
- (void)application:(NSApplication *)sender openFiles:(NSArray *)filenames;
- (BOOL)application:(NSApplication *)sender openTempFile:(NSString *)filename;
- (BOOL)applicationShouldOpenUntitledFile:(NSApplication *)sender;
- (BOOL)applicationOpenUntitledFile:(NSApplication *)sender;
- (BOOL)application:(id)sender openFileWithoutUI:(NSString *)filename;
- (BOOL)application:(NSApplication *)sender printFile:(NSString *)filename;
- (NSApplicationPrintReply)application:(NSApplication *)application
printFiles:(NSArray *)fileNames
withSettings:(NSDictionary *)printSettings
showPrintPanels:(BOOL)showPrintPanels;

- (void)application:(NSApplication *)sender printFiles:(NSArray *)filenames;
- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)sender;
- (BOOL)applicationShouldHandleReopen:(NSApplication *)sender hasVisibleWindows:(BOOL)flag;
- (NSMenu *)applicationDockMenu:(NSApplication *)sender;
- (NSError *)application:(NSApplication *)application willPresentError:(NSError *)error;
@end

Cela peut sembler un peu étrange. Pourquoi devrions-nous déclarer une catégorie sur NSObject pour les méthodes de délégué? En fonction de vos antécédents linguistiques, vous pourriez vous demander pourquoi ce n'est pas un protocole ou d'interface. La réponse est simple, vraiment. En Objective-C antérieure à 2.0, les protocoles (parfois dénommé "protocole officiel") ne permet pas des méthodes facultatives. Si vous conformer à un protocole, vous avez eu à mettre en œuvre toutes les méthodes de ce protocole. Cela n'aurait pas fonctionné très bien, les ingénieurs d'Apple et de NeXT ne voulait pas forcer les programmeurs à répondre à toutes les méthodes concevables tout délégué application serait jamais besoin de leurs propres délégués. Plutôt, ils ont voulu laisser les programmeurs en œuvre que les méthodes qu'ils avaient besoin de déléguer. En le déclarant comme une catégorie et créer ce que nous appelons un «protocole informel", le compilateur et le programmateur nous dit quelles sont les méthodes par ce délégué peut répondre, mais aucune obligation n'est imposée au programmeur d'implémenter une méthode particulière. Il est parfaitement valide (stupide) d'un délégué à répondre à aucune des méthodes de délégué.

Dans l'approche de cacao aux délégués, la méthode mutateur pour un délégué ressemble généralement à ceci:

- (void)setDelegate:(id)anObject;

En d'autres termes, une instance de n'importe quelle classe peut être définie comme le délégué. Si ce délégué met en œuvre une méthode déléguée particulier, cette méthode sera appelée au moment approprié. Si ce n'est pas l'appliquer, NSApplication va simplement sauter l'appel et continuer l'exécution du programme. C'est une approche très laissez-faire qui met beaucoup de confiance dans le programmateur. C'est cacao en un mot, vraiment. Objective-C ne donne pas les mécanismes de programmeur de complètement verrouiller d'autres programmeurs la manière, disons, Java, C + + et C # ne. Il n'y a pas des classes finales, et les choses en déclarant @ private est vraiment plus d'une suggestion. La nature de la langue conduit à une approche différente de beaucoup de choses. Il peut sembler étrange - même mal - si vous venez d'une des nombreuses langues qui tirent leur modèle objet de l'extrême-Simula moins confiance, mais lui donner le temps. Correctement utilisé, il est très élégant.

D'un autre côté. UIApplicationDelegate, délégué application de l'iPhone, n'est pas implémentée en utilisant une catégorie, il est mis en œuvre en utilisant un protocole formel. Depuis l'iPhone a été développé après l'Objective-C 2.0 a été publié, Apple avait la possibilité d'utiliser des méthodes formelles dans les protocoles facultatifs, ainsi en Cocoa Touch plupart (je pense que tous) les délégués sont définies comme des protocoles formels. C'est ce que le délégué application ressemble à Cocoa Touch. Encore une fois, j'ai reformaté et supprimé des commentaires à faire lire plus facile dans ce contexte:

@protocol UIApplicationDelegate<NSObject>
@optional
- (void)applicationDidFinishLaunching:(UIApplication *)application;
- (void)applicationDidBecomeActive:(UIApplication *)application;
- (void)applicationWillResignActive:(UIApplication *)application;
- (BOOL)application:(UIApplication *)application handleOpenURL:(NSURL *)url;
- (void)applicationDidReceiveMemoryWarning:(UIApplication *)application;
- (void)applicationWillTerminate:(UIApplication *)application;
- (void)applicationSignificantTimeChange:(UIApplication *)application;
- (void)application:(UIApplication *)application
willChangeStatusBarOrientation:(UIInterfaceOrientation)newStatusBarOrientation
duration:(NSTimeInterval)duration;

- (void)application:(UIApplication *)application
didChangeStatusBarOrientation:(UIInterfaceOrientation)oldStatusBarOrientation;

- (void)application:(UIApplication *)application
willChangeStatusBarFrame:(CGRect)newStatusBarFrame;

- (void)application:(UIApplication *)application
didChangeStatusBarFrame:(CGRect)oldStatusBarFrame;

@end


C'est vraiment pas si différent. Bien sûr, les méthodes délégué ne sont pas exactement les mêmes en raison de la nature différente des dispositifs pour lesquels le cacao et le Cocoa Touch ont été conçus, mais ce protocole dit essentiellement la même que notre protocole antérieur informelle dit: que tout objet peut être un délégué, et depuis il déclare toutes les méthodes que @ option, le délégué a seulement besoin de mettre en œuvre ces méthodes, il se soucie. La méthode mutateur pour un délégué de Cocoa Touch ressemble à celle de cacao, mais avec deux différences. Tout d'abord, UIApplication utilise les propriétés d'Objective-C 2.0 's et synthétise les mutator plutôt que de déclarer un mutator manuellement. Deuxièmement, et plus important, mais il accepte toujours id (ce qui signifie tout autre objet), il demande que l'objet étant désigné comme le délégué conformes au protocole UIApplicationDelegate:

@property(nonatomic,assign) id<UIApplicationDelegate> delegate;

Ceci étant Objective-C, vous pouvez assigner n'importe quelle réalité l'objet à la déléguée, même celui qui ne se conforment pas au protocole, mais si la classe de l'objet assigné ne fait pas explicitement conforme à UIApplicationDelegate, vous obtiendrez un avertissement à la compilation . Heureusement, tous les modèles d'application pour iPhone vous donne votre délégué application, et la classe le délégué fourni est conforme déjà à cette propriété, de sorte que vous rarement besoin de faire cette étape pour le délégué d'application, mais quand il vient aux délégués d'innombrables autres Cocoa Touch , vous devrez explicitement conformes votre classe au protocole de délégué.

Que cacao passeront à l'utilisation des protocoles officiels sont, dès maintenant, une question sans réponse. Jusqu'ici, je n'ai vu aucune indication d'Apple ce changement. Comme de Leopard, chaque délégué, je peux penser à est implémenté comme une catégorie sur NSObject, mais je ne dispose pas de plus information sur ce qui se passe dans l'intérieur de la boucle que la plupart d'entre vous font et ne savent pas si elles ont des plans pour changer cette situation. Ils pourraient. Ils ne pourraient pas.

Ce que je sais est que pas tout le monde convient que la nouvelle façon de faire des délégués est le meilleur. J'ai parlé à un certain nombre de vieux temps de cacao / Mac programmeurs qui considèrent la nouvelle approche que moins élégant et le voir comme un changement inutile. Je n'ai pas vraiment avoir beaucoup d'avis, pour être honnête. En pratique, il n'ya pas beaucoup de différence dans la façon dont nous utilisons les délégués des deux approches. Autre que pour se conformer à l'une de nos classes de protocole, à peu près tout fonctionne de la même.

La nouvelle approche est un compromis. Il ajoute quelques vérifications compilateur temps qui ne sont pas disponibles avec les protocoles informels, mais elle a aussi des conséquences imprévues. Par exemple, lorsque vous avez sous-classes de classes avec les délégués, vous pouvez avoir des situations où un délégué doit se conformer à un protocole pour un objet pour lequel ce n'est pas le délégué. Vous pouvez voir un exemple de cela dans Début de développement iPhone au chapitre 16. À la page 467, nous nous conformons aux CameraViewController UINavigationControllerDelegate, même si nous ne sommes pas un délégué d'un UINavigationController. Pourquoi? Parce UIImagePickerController est une sous-classe de UINavigationController. Parce que ces deux classes ont délégués et de leurs délégués nécessitent des protocoles différents. En conséquence, le compilateur nous force à se conformer aux deux protocoles. C'est un inconvénient plutôt mineur - il faut taper un nom de classe unique - mais cela semble se frotter certains développeurs Cocoa qui j'ai parlé comme étant très «anti-Cacao-like» et inélégant.

Voyons finir avec un dernier importante d'informations sur les délégués qui s'applique à la fois de cacao et Cocoa Touch: en règle générale, les objets ne pas envoyer une message à retenir, leur délégué. Il ya quelques exceptions à cela, mais à moins d'une classe est spécifiquement documentées comme conservant son délégué, supposer qu'ils n'en ont pas. Si votre délégué sera désallouée avant la classe, il est un délégué pour, vous devez vous assurer de mettre en déléguer la classe »à zéro avant votre classe est libérée pour éviter les problèmes.

WWDC a été annoncé - Juin 8 - 12

Exécuter, ne marchez pas au sur le site d'Apple WWDC pour obtenir vos billets. Ils ont vendu l'an dernier, je m'attends à ce qu'ils peuvent le faire encore cette année. Plus il est moins cher si vous achetez tôt.

lundi 6 février 2012

Itinéraire de cartographie à partir de votre app

Si vous voulez donner à vos utilisateurs un itinéraire en lançant l'application Maps, c'est en fait assez facile. Vous créez simplement un URL Google Maps régulière et l'utilisation UIApplication de l'ouvrir; Votre téléphone reconnaît que l'URL est pour les directions et sera ouverte Maps.app plutôt que Safari.app automatiquement.

Le format d'URL est très facile pour les directions:

http://maps.google.com/maps?saddr = [adresse de la source ou les coordonnées] & daddr = [adresse de destination ou de coordonnées]

Voici un exemple de prendre les coordonnées extraites de Core Location, et s'en servir comme point de départ pour les directions:

    NSString *destinationString = @"Cupertino,California";
NSString *url = [NSString stringWithFormat: @"http://maps.google.com/maps?saddr=%f,%f&daddr=%@", newLocation.coordinate.latitude, newLocation.coordinate.longitude, destinationString];
[[UIApplication sharedApplication] openURL:[NSURL URLWithString:url]];

Bien sûr, ce faisant cela s'arrête et lance votre application Maps.app, alors assurez-vous que vous avez tout sauvegardé avant de le faire.

Il ya un gotcha si vous utilisez des termes de recherche ou d'une adresse physique au lieu de coordonnées. Maps.app n'aime pas les espaces. Contrairement à Safari, Maps.app ne convertira pas automatiquement les espaces à 20% pour vous. D'autre part, vous ne voulez pas utiliser stringByAddingPercentEscapesUsingEncoding NSString: soit, parce que cette méthode permet de convertir les virgules, tirets, et certains autres personnages, qui peuvent causer des problèmes lorsque Maps.app lancement (et le sera probablement - les virgules sont importants! ).

Dans la plupart des cas, vous pouvez simplement supprimer les espaces en faisant ceci:

    NSString *newAddressPartOfURL = [addressPartOfURL stringByReplacingOccurrencesOfString:@" " withString:@""]

Techniquement parlant, nous sommes tricherie. Nous devrions être en mesure d'URL-encoder toute l'adresse sans problème, et cela devrait fonctionner. Mais ... elle n'existe pas. C'est l'une de ces situations où vous avez besoin de tricher un peu pour que les choses fonctionnent correctement. Je peux vous dire de première main l'expérience que si vous URL-encoder les virgules dans votre adresse, vous obtiendrez un message qui n'a pas pu trouver Maps.app l'adresse indiquée.

vendredi 3 février 2012

Les tableaux jumelés à Cocoa et Cocoa Touch

Le concept de «tableaux jumelés" est vraiment un puissant. L'idée de base est-ce - que vous avez NSArrays multiples ou NSMutableArrays, et ils détiennent des valeurs correspondant à la même chose. Par exemple, vous pourriez avoir un tableau de clés et l'une des valeurs. C'est un simple exemple, et celui où vous n'auriez probablement juste utiliser une NSDictionary, mais c'est un bon exemple pour montrer ce qu'ils sont utilisés pour. Maintenant, le premier élément dans un tableau correspond à l'élément premier dans l'autre tableau. Cela vous donne plus de souplesse que d'utiliser une NSDictionary parce que vous avez un accès rapide à chaque liste et peuvent également avoir plus de deux tableaux appariés, vous n'êtes donc pas restreinte à clé et la valeur, vous pourriez avoir trois valeurs clés et par exemple, sans avoir à déranger avec des dictionnaires à l'intérieur des dictionnaires.

J'utilise cette technique beaucoup avec SQLitePersistentObjects sur l'iPhone pour éviter de charger des objets en mémoire juste pour afficher une ou deux valeurs à partir d'un objet, par exemple, à mettre dans un tableau. Lorsque vous avez des objets qui contiennent UIImages ou NSDatas, en faisant cela peut vraiment garder votre chemin empreinte mémoire vers le bas, qui est une très bonne chose sur un dispositif de ressources limitées. Sur l'iPhone, je suis un grand fan de tableaux appariés. Je ne les utilisez pas tellement sur le Mac, mais ils ont certainement leurs utilisations.

Mais, il ya une chose vraiment gênant sur les tableaux appariés: les triant. C'est juste pas drôle. NSMutableArray est mis en place pour trier en fonction des valeurs de son propre réseau, et non sur les valeurs dans un autre tableau. Donc, si vous voulez trier la fois la clé et les tableaux de valeur fondée sur les valeurs dans le tableau de clés, comment voulez-vous faire? Il n'ya pas facile, moyen intégré.

Eh bien, si vous avez suivi ce blog, pour toute longueur de temps, vous savez que j'ai vraiment, vraiment, comme l'Objective-C les catégories. Voici une nouvelle - il vous permet de trier des tableaux multiples basées sur les valeurs dans un tableau. Il utilise exactement l'algorithme de tri même que NSMutableArray je crois - une sorte coquille. Je ne travaille pas pour Apple et n'ont pas accès à leur code, donc je ne sais pas pour sûr qu'ils ont encore le faire de cette façon, mais l'ancien NeXTStep / OpenStep tri a été fait de cette façon, et le genre GNUStep est toujours fait de cette façon, donc je suppose que Apple Foundation Kit version de NSMutableArray fonctionne toujours de cette façon, si je ne suis certainement ouvert à d'autres algorithmes de tri optimisé, si vous voulez modifier.

Voici un exemple d'utilisation de cette catégorie, en utilisant trois tableaux jumelés, l'un avec des chiffres, et deux autres avec ces chiffres énoncés dans des langues différentes, et le tri des trois valeurs basées sur les chiffres.

    NSMutableArray *array1 = [NSMutableArray arrayWithObjects:[NSNumber numberWithInt:5], [NSNumber numberWithInt:3], [NSNumber numberWithInt:1], [NSNumber numberWithInt:2], [NSNumber numberWithInt:4], [NSNumber numberWithInt:6], nil];
NSMutableArray *array2 = [NSMutableArray arrayWithObjects:@"Five", @"Three", @"One", @"Two", @"Four", @"Six", nil];
NSMutableArray *array3 = [NSMutableArray arrayWithObjects:@"Cinq", @"Trois", @"Un", @"Deux", @"Quatre", @"Six", nil];

[array1 sortArrayUsingSelector:@selector(compare:) withPairedMutableArrays:array2, array3, nil];

Après l'appel à sortArrayUsingSelector: withPairedArrays: les trois tableaux seront tous dans l'ordre numérique, de sorte array2 ressemblera à ceci:
One, Two, Three, Four, Five, Six
et tableau3 ressemblera à ceci:
Un, Deux, Trois, Quatre, Cinq, Six
Plutôt cool, hein? Voici le code:

NSMutableArray-MultipleSort.h
//
// NSMutableArray-MultipleSort.h
// iContractor
//
// Created by Jeff LaMarche on 1/16/09.
// Copyright 2009 Jeff LaMarche. All rights reserved.
//

// This category on NSMutableArray implements a shell sort based on the old NeXT example
// SortingInAction. It is functionally identical to sortArrayUsingSelector: except that
// it will sort other paired arrays based on the comparison values of the original array
// this is for use in paired array situations, such as when you use one array to store
// keys and another array to store values. This is a variadic method, so you can sort
// as many paired arrays as you have.

// This source may be used, free of charge, for any purposes. commercial or non-
// commercial. There is no attribution requirement, nor any need to distribute
// your source code. If you do redistribute the source code, you must
// leave the original header comments, but you may add additional ones.


// Stride factor defines the size of the shell sort loop's stride. It can be tweaked
// for performance, though 3 seems to be a good general purpose value
#define STRIDE_FACTOR 3

#import <Foundation/Foundation.h>

// This compare method was taken from the GNUStep project. GNUStep is
// licensed under the LGPL, which allows such use.
static inline NSComparisonResult compare(id elem1, id elem2, void* context)
{
NSComparisonResult (*imp)(id, SEL, id);

if (context == 0)
{
[NSException raise: NSInvalidArgumentException
format: @"compare null selector given"
]
;
}

imp = (NSComparisonResult (*)(id, SEL, id))
[elem1 methodForSelector: context];

if (imp == NULL)
{
[NSException raise: NSGenericException
format: @"invalid selector passed to compare"
]
;
}

return (*imp)(elem1, context, elem2);
}

@interface NSMutableArray(MultipleSort)
// Takes a comparator and a nil-terminated list of paired arrays
- (void)sortArrayUsingSelector:(SEL)comparator withPairedMutableArrays:(NSMutableArray *)array1, ...;
@end



NSMutableArray-MultipleSort.m
//
// NSMutableArray-MultipleSort.m
// iContractor
//
// Created by Jeff LaMarche on 1/16/09.
// Copyright 2009 Jeff LaMarche Consulting. All rights reserved.
//
// This source may be used, free of charge, for any purposes. commercial or non-
// commercial. There is no attribution requirement, nor any need to distribute
// your source code. If you do redistribute the source code, you must
// leave the original header comments, but you may add additional ones.

#import "NSMutableArray-MultipleSort.h"

@implementation NSMutableArray(MultipleSort)
- (void)sortArrayUsingSelector:(SEL)comparator withPairedMutableArrays:(NSMutableArray *)array1, ...
{
unsigned int stride = 1;
BOOL found = NO;
unsigned int count = [self count];
unsigned int d;

while (stride <= count)
stride = stride * STRIDE_FACTOR + 1;

while (stride > (STRIDE_FACTOR - 1))
{
stride = stride / STRIDE_FACTOR;
for (unsigned int c = stride; c < count; c++)
{
found = NO;
if (stride > c)
break;

d = c - stride;
while (!found)
{
id a = [self objectAtIndex: d + stride];
id b = [self objectAtIndex: d];

NSComparisonResult result = (*compare)(a, b, (void *)comparator);

if (result < 0)
{
[a retain];
[self replaceObjectAtIndex: d + stride withObject: b];
[self replaceObjectAtIndex: d withObject: a];

id eachObject;
va_list argumentList;
if (array1)
{
id a1 = [array1 objectAtIndex:d+stride];
id b1 = [array1 objectAtIndex:d];
[a1 retain];
[array1 replaceObjectAtIndex: d + stride withObject:b1];
[array1 replaceObjectAtIndex: d withObject: a1];
[a1 release];
va_start(argumentList, array1);
while (eachObject = va_arg(argumentList, id))
{
id ax = [eachObject objectAtIndex:d+stride];
id bx = [eachObject objectAtIndex:d];
[ax retain];
[eachObject replaceObjectAtIndex: d + stride withObject:bx];
[eachObject replaceObjectAtIndex: d withObject: ax];
[ax release];
}
va_end(argumentList);
}

[a release];

if (stride > d)
break;

d -= stride;
}
else
found = YES;
}
}
}
}
@end



jeudi 2 février 2012

Outlets - variable de propriété vs instance

Lorsque nous avons écrit notre livre de programmation iPhone, Tous les exemples de code et de documentation d'Apple a utilisé le mot-clé IBOutlet exactement comment nous avions toujours utilisé en Cocoa pour Mac OS X, placé en face de la déclaration de variable, par exemple, comme tant
#import 

@interface MyViewController : UIViewController {
IBOutlet UILabel *myLabel;

}
@property (nonatomic, retain) UILabel *myLabel;
@end

Quelque part le long de la ligne, je ne sais pas exactement quand, ils ont commencé à mettre le modificateur IBOutlet dans la déclaration des biens au lieu, comme ceci:
#import 

@interface MyViewController : UIViewController {
UILabel *myLabel;

}
@property (nonatomic, retain) IBOutlet UILabel *myLabel;
@end

Or, en pratique, il n'y a absolument aucune différence dans la manière dont les fonctions d'un contrôleur de classe basée sur l'endroit où vous placez le mot-clé IBOutlet. J'ai utilisé les deux approches, même mêlés dans la même classe, et j'ai remarqué aucune différence. Ce n'était pas assez pour moi, bien, je voulais savoir s'il y avait une différence fondamentale entre les deux - une différence dans la manière dont les connexions ont été faites.

Vous voyez, dès le début, sur le temps de SDK2, je me souviens que quelqu'un en disant qu'ils avaient testé et les mutateurs pour leurs IBOutlets n'obtenaient pas appelée lorsque la sortie de connexions ont été faites. Ce fut une surprise car le code source échantillon a été en utilisant les propriétés de tous les IBOutlets, même si ce n'était pas la façon dont il avait été fait en Cocoa sur Mac, et si les manipulateurs ne sont pas s'habituer, il ne serait pas aucune raison de déclarer une propriété pour les points de vente.

Cela m'a fait demander si, peut-être, Interface Builder seulement utilisé la mutator si vous mettez le mot clé IBOutlet sur la ligne de déclaration de propriété, mais pas si vous mettez le précédant la déclaration de variable par exemple. Il semblait y avoir une logique à cela, étant donné le changement d'Apple dans le placement préféré des mots clés à partir IBOutlet la variable d'instance à la propriété. Si c'est le cas, alors il serait important de savoir, parce que vous pourriez obtenir de légères différences dans le comportement dans certaines circonstances rares sur la base duquel vous avez utilisé.

Vous vous demandez devrait conduire à l'exploration, alors j'ai décidé de le découvrir. Il est assez facile de tester - J'ai créé un projet d'application iPhone avec deux étiquettes sur une vue, et deux sorties d'être connecté à ces deux étiquettes. L'un des points a été donné le mot-clé IBOutlet précédant la déclaration de variable d'instance, l'autre a été donné la déclaration IBOutlet dans le cadre de la propriété. Dans les deux cas, j'ai mis en œuvre les méthodes mutator manuellement afin qu'ils imprimer un relevé dans le journal à chaque fois qu'ils ont été appelés en outre à faire l'affectation.

Et le résultat?

Il apparaît que lorsque vous placez le mot-clé IBOutlet, sur toutes les versions actuelles du SDK (2.0, 2.1, 2.2), est purement stylistique et n'a aucun impact sur ce qui se passe sous le capot. Pour les deux sorties, le mutator a été appelée lorsque les points de vente ont été connectés au cours du démarrage d'application.

Ainsi, il semble que vous pouvez utiliser n'importe quelle clé de placement que vous préférez, même si Apple semble bien se passer de placer l'IBOutlet dans la déclaration de propriété pour tous leurs exemples de code et de nouvelles listes de code de la documentation, de sorte que si vous croyez fermement qu'il devrait être mis sur la variable d'instance, c'est probablement le meilleur endroit pour le mettre, et probablement là où nous allons le mettre si jamais on fait une seconde édition.

Outlets - variable de propriété vs instance

Lorsque nous avons écrit notre livre de programmation iPhone, Tous les exemples de code et de documentation d'Apple a utilisé le mot-clé IBOutlet exactement comment nous avions toujours utilisé en Cocoa pour Mac OS X, placé en face de la déclaration de variable, par exemple, comme tant
#import 

@interface MyViewController : UIViewController {
IBOutlet UILabel *myLabel;

}
@property (nonatomic, retain) UILabel *myLabel;
@end

Quelque part le long de la ligne, je ne sais pas exactement quand, ils ont commencé à mettre le modificateur IBOutlet dans la déclaration des biens au lieu, comme ceci:
#import 

@interface MyViewController : UIViewController {
UILabel *myLabel;

}
@property (nonatomic, retain) IBOutlet UILabel *myLabel;
@end

Or, en pratique, il n'y a absolument aucune différence dans la manière dont les fonctions d'un contrôleur de classe basée sur l'endroit où vous placez le mot-clé IBOutlet. J'ai utilisé les deux approches, même mêlés dans la même classe, et j'ai remarqué aucune différence. Ce n'était pas assez pour moi, bien, je voulais savoir s'il y avait une différence fondamentale entre les deux - une différence dans la manière dont les connexions ont été faites.

Vous voyez, dès le début, sur le temps de SDK2, je me souviens que quelqu'un en disant qu'ils avaient testé et les mutateurs pour leurs IBOutlets n'obtenaient pas appelée lorsque la sortie de connexions ont été faites. Ce fut une surprise car le code source échantillon a été en utilisant les propriétés de tous les IBOutlets, même si ce n'était pas la façon dont il avait été fait en Cocoa sur Mac, et si les manipulateurs ne sont pas s'habituer, il ne serait pas aucune raison de déclarer une propriété pour les points de vente.

Cela m'a fait demander si, peut-être, Interface Builder seulement utilisé la mutator si vous mettez le mot clé IBOutlet sur la ligne de déclaration de propriété, mais pas si vous mettez le précédant la déclaration de variable par exemple. Il semblait y avoir une logique à cela, étant donné le changement d'Apple dans le placement préféré des mots clés à partir IBOutlet la variable d'instance à la propriété. Si c'est le cas, alors il serait important de savoir, parce que vous pourriez obtenir de légères différences dans le comportement dans certaines circonstances rares sur la base duquel vous avez utilisé.

Vous vous demandez devrait conduire à l'exploration, alors j'ai décidé de le découvrir. Il est assez facile de tester - J'ai créé un projet d'application iPhone avec deux étiquettes sur une vue, et deux sorties d'être connecté à ces deux étiquettes. L'un des points a été donné le mot-clé IBOutlet précédant la déclaration de variable d'instance, l'autre a été donné la déclaration IBOutlet dans le cadre de la propriété. Dans les deux cas, j'ai mis en œuvre les méthodes mutator manuellement afin qu'ils imprimer un relevé dans le journal à chaque fois qu'ils ont été appelés en outre à faire l'affectation.

Et le résultat?

Il apparaît que lorsque vous placez le mot-clé IBOutlet, sur toutes les versions actuelles du SDK (2.0, 2.1, 2.2), est purement stylistique et n'a aucun impact sur ce qui se passe sous le capot. Pour les deux sorties, le mutator a été appelée lorsque les points de vente ont été connectés au cours du démarrage d'application.

Ainsi, il semble que vous pouvez utiliser n'importe quelle clé de placement que vous préférez, même si Apple semble bien se passer de placer l'IBOutlet dans la déclaration de propriété pour tous leurs exemples de code et de nouvelles listes de code de la documentation, de sorte que si vous croyez fermement qu'il devrait être mis sur la variable d'instance, c'est probablement le meilleur endroit pour le mettre, et probablement là où nous allons le mettre si jamais on fait une seconde édition.

Outlets - variable de propriété vs instance

Lorsque nous avons écrit notre livre de programmation iPhone, Tous les exemples de code et de documentation d'Apple a utilisé le mot-clé IBOutlet exactement comment nous avions toujours utilisé en Cocoa pour Mac OS X, placé en face de la déclaration de variable, par exemple, comme tant
#import 

@interface MyViewController : UIViewController {
IBOutlet UILabel *myLabel;

}
@property (nonatomic, retain) UILabel *myLabel;
@end

Quelque part le long de la ligne, je ne sais pas exactement quand, ils ont commencé à mettre le modificateur IBOutlet dans la déclaration des biens au lieu, comme ceci:
#import 

@interface MyViewController : UIViewController {
UILabel *myLabel;

}
@property (nonatomic, retain) IBOutlet UILabel *myLabel;
@end

Or, en pratique, il n'y a absolument aucune différence dans la manière dont les fonctions d'un contrôleur de classe basée sur l'endroit où vous placez le mot-clé IBOutlet. J'ai utilisé les deux approches, même mêlés dans la même classe, et j'ai remarqué aucune différence. Ce n'était pas assez pour moi, bien, je voulais savoir s'il y avait une différence fondamentale entre les deux - une différence dans la manière dont les connexions ont été faites.

Vous voyez, dès le début, sur le temps de SDK2, je me souviens que quelqu'un en disant qu'ils avaient testé et les mutateurs pour leurs IBOutlets n'obtenaient pas appelée lorsque la sortie de connexions ont été faites. Ce fut une surprise car le code source échantillon a été en utilisant les propriétés de tous les IBOutlets, même si ce n'était pas la façon dont il avait été fait en Cocoa sur Mac, et si les manipulateurs ne sont pas s'habituer, il ne serait pas aucune raison de déclarer une propriété pour les points de vente.

Cela m'a fait demander si, peut-être, Interface Builder seulement utilisé la mutator si vous mettez le mot clé IBOutlet sur la ligne de déclaration de propriété, mais pas si vous mettez le précédant la déclaration de variable par exemple. Il semblait y avoir une logique à cela, étant donné le changement d'Apple dans le placement préféré des mots clés à partir IBOutlet la variable d'instance à la propriété. Si c'est le cas, alors il serait important de savoir, parce que vous pourriez obtenir de légères différences dans le comportement dans certaines circonstances rares sur la base duquel vous avez utilisé.

Vous vous demandez devrait conduire à l'exploration, alors j'ai décidé de le découvrir. Il est assez facile de tester - J'ai créé un projet d'application iPhone avec deux étiquettes sur une vue, et deux sorties d'être connecté à ces deux étiquettes. L'un des points a été donné le mot-clé IBOutlet précédant la déclaration de variable d'instance, l'autre a été donné la déclaration IBOutlet dans le cadre de la propriété. Dans les deux cas, j'ai mis en œuvre les méthodes mutator manuellement afin qu'ils imprimer un relevé dans le journal à chaque fois qu'ils ont été appelés en outre à faire l'affectation.

Et le résultat?

Il apparaît que lorsque vous placez le mot-clé IBOutlet, sur toutes les versions actuelles du SDK (2.0, 2.1, 2.2), est purement stylistique et n'a aucun impact sur ce qui se passe sous le capot. Pour les deux sorties, le mutator a été appelée lorsque les points de vente ont été connectés au cours du démarrage d'application.

Ainsi, il semble que vous pouvez utiliser n'importe quelle clé de placement que vous préférez, même si Apple semble bien se passer de placer l'IBOutlet dans la déclaration de propriété pour tous leurs exemples de code et de nouvelles listes de code de la documentation, de sorte que si vous croyez fermement qu'il devrait être mis sur la variable d'instance, c'est probablement le meilleur endroit pour le mettre, et probablement là où nous allons le mettre si jamais on fait une seconde édition.