Objective-C pour le développeur avancé

Avec le succès de l’iPhone et de l’iPad, la maîtrise d’Objective-C, langage natif des systèmes Apple Mac OS X et
iPhone/iPad, devient un passage obligé pour les professionnels de la programmation – alors même qu’il ne fait pas
partie de la formation classique des développeurs.
Adressé au développeur qui connaît déjà d’autres langages objet, cet ouvrage éclaire toutes les subtilités
d’Objective-C en le comparant avec les principaux langages que sont C++, Java, C# : syntaxe et concepts objet
(classes, héritage, instanciation), gestion de la mémoire, chaînes de caractères, exceptions, multithreading, concept
des propriétés, mécanismes de modifications à l’exécution… sans oublier les nouveautés d’Objective-C 2.0.
Au sommaire
De C#, Java, C++/QT à Objective-C • Du C au modèle objet • Objective-C et ses API (Cocoa…) • Racines non Unix •
Bibliothèque runtime • Compilation et linkage • 32/64 bits • Syntaxe • Vrais et faux mots-clefs • Syntaxe du C sousjacent • Commentaires • Code/déclarations • Boucle for • Nouveaux types et valeurs • Organisation du code : fichiers
.h, fichiers .m et inclusion • Fonctions et méthodes : une similarité trompeuse • Classes et objets • Classe racine, type
id, valeurs nil et Nil • Déclaration • Attributs et méthodes • Déclarations anticipées (forward) : @class, @protocol
• Visibilité public, protected, private • Messages et fonctions • Prototype et appel, méthodes d’instance, méthodes
de classe • Cibles self et super • Identifiant et signature • Surcharge • Callbacks • Modificateurs de prototype •
Messages et transmission • Délégation de message • Forwarding • Manipulations au runtime • Formes d’héritage •
Héritage simple et multiple • Downcasting • Méthodes virtuelles • Redéfinition et surcharge • Méthodes virtuelles
pures • Extension de classe (sans héritage) : les catégories • Classes abstraites • Protocoles formels et informels
• Design-pattern Class-cluster • Instanciation, destruction et copie • Variable objet et pointeur d’objets • Forme de
Coplien • Constructeurs, initialisateurs • alloc et init • self = [super init…] • Listes d’initialisation • Constructeur
virtuel • Constructeur de classe • Destructeurs • Clonage classique et pseudo-clonage • Comparaison d’objets • ==
et operator<() en C++ • Hash • Gestion de la mémoire et ramasse-miettes • new et delete • Compteur de références
(retain, release) • Autorelease et bassin d’autorelease • Garbage collector • Finalize • Liens faibles et forts • Singleton
• Chaînes de caractères • NSString • Encodages • Chaîne C • Extension de format %@ • Description d’objet • Expressions régulières • Exceptions • @try, @throw, @catch • @finally • Filtres d’exception • Bassin d’autorelease local
• Exceptions C++ • Spécificités 64 bits • Multithreading • @synchronized • Volatile • Utilitaires Cocoa et système •
API de répartition de charge • Boucle événementielle • Code implicite et propriétés • Key-value coding • Interception
• Accès aux propriétés • Différence entre « -> » et « . » • Dynamisme et runtime • RTTI du C++ • Introspection •
Typage fort ou faible • Méthode et fonction d’implémentation • Chargement au runtime • Enrichissement conditionnel •
Swizzling • Binaire Objective-C et outils de consultation • La STL et Cocoa • Conteneurs • Gestion mémoire • Itérateurs
• Énumération rapide • Foncteurs (objets-fonctions) • Mise en cache d’un appel de méthode • Fonctions de rappels
(callbacks) par blocs • Évolutions d’Objective C • Migration vers le 64 bits • Objective-C 2.0 • Objective C++ • Blocks
• Closure (fermeture) • Annexes • Fonctionnalités propres au C++ • Références • Inlining • Templates • Surcharge
d’opérateurs • Friends • Méthodes const • Namespace (espaces de noms) • C++/Objective-C.
À qui s’adresse cet ouvrage ?
– Développeurs expérimentés C++, Java, C#, Python et PHP 5 qui veulent développer pour iPhone ou Mac OS X
– Professionnels du développement web et mobile
– Fans d’iPhone qui souhaitent développer pour iPhone et Mac OS X
32 €
P. Y. Chatelier
Conception : Nord Compo
Objective-C, langage objet indispensable pour développer en natif
sous Mac OS X et pour l’iPhone et l’iPad
Pierre Y. Chatelier
développe pour Mac OS X
par passion depuis
qu’il a découvert cette
plate-forme en 2002,
et est maintenant l’auteur
de plusieurs logiciels pour
Mac OS et iPhone.
Après avoir fait ses classes
d’ingénieur à l’Isima
de Clermont-Ferrand et
obtenu un doctorat,
il occupe maintenant
un poste en recherche
& développement
en Bourgogne et souhaite
promouvoir le langage
Objective-C, peu enseigné
malgré ses nombreuses
qualités.
9 7 8221 2 1 27 5 1 5
Face à un C++ puissant, efficace et maîtrisé, Objective-C surprend par sa richesse et sa souplesse.
Adressé au développeur confirmé, ce livre dense et érudit guidera les amoureux de la programmation
iPhone/iPad et Mac OS X à travers toutes les subtilités de ce langage.
P. Y. Chatelier
Code éditeur : G12751
ISBN : 978-2-212-12751-5
pour le développeur avancé
Objective-C
pour le développeur avancé
Le langage iPhone/iPad et Mac OS X
pour les développeurs C++/Java/C#
Objective-C
Objective-C
P i e r r e Y. C h a t e l i e r
Face à un C++ puissant, efficace et maîtrisé, Objective-C surprend par sa richesse et sa souplesse.
Adressé au développeur confirmé, ce livre dense et érudit guidera les amoureux de la programmation
iPhone/iPad et Mac OS X à travers toutes les subtilités de ce langage.
Objective-C, langage objet indispensable pour développer en natif
sous Mac OS X et pour l’iPhone et l’iPad
Avec le succès de l’iPhone et de l’iPad, la maîtrise d’Objective-C, langage natif des systèmes Apple Mac OS X et
iPhone/iPad, devient un passage obligé pour les professionnels de la programmation – alors même qu’il ne fait pas
partie de la formation classique des développeurs.
Adressé au développeur qui connaît déjà d’autres langages objet, cet ouvrage éclaire toutes les subtilités
d’Objective-C en le comparant avec les principaux langages que sont C++, Java, C# : syntaxe et concepts objet
(classes, héritage, instanciation), gestion de la mémoire, chaînes de caractères, exceptions, multithreading, concept
des propriétés, mécanismes de modifications à l’exécution… sans oublier les nouveautés d’Objective-C 2.0.
Au sommaire
De C#, Java, C++/QT à Objective-C • Du C au modèle objet • Objective-C et ses API (Cocoa…) • Racines non Unix •
Bibliothèque runtime • Compilation et linkage • 32/64 bits • Syntaxe • Vrais et faux mots-clefs • Syntaxe du C sousjacent • Commentaires • Code/déclarations • Boucle for • Nouveaux types et valeurs • Organisation du code : fichiers
.h, fichiers .m et inclusion • Fonctions et méthodes : une similarité trompeuse • Classes et objets • Classe racine, type
id, valeurs nil et Nil • Déclaration • Attributs et méthodes • Déclarations anticipées (forward) : @class, @protocol
• Visibilité public, protected, private • Messages et fonctions • Prototype et appel, méthodes d’instance, méthodes
de classe • Cibles self et super • Identifiant et signature • Surcharge • Callbacks • Modificateurs de prototype •
Messages et transmission • Délégation de message • Forwarding • Manipulations au runtime • Formes d’héritage •
Héritage simple et multiple • Downcasting • Méthodes virtuelles • Redéfinition et surcharge • Méthodes virtuelles
pures • Extension de classe (sans héritage) : les catégories • Classes abstraites • Protocoles formels et informels
• Design-pattern Class-cluster • Instanciation, destruction et copie • Variable objet et pointeur d’objets • Forme de
Coplien • Constructeurs, initialisateurs • alloc et init • self = [super init…] • Listes d’initialisation • Constructeur
virtuel • Constructeur de classe • Destructeurs • Clonage classique et pseudo-clonage • Comparaison d’objets • ==
et operator<() en C++ • Hash • Gestion de la mémoire et ramasse-miettes • new et delete • Compteur de références
(retain, release) • Autorelease et bassin d’autorelease • Garbage collector • Finalize • Liens faibles et forts • Singleton
• Chaînes de caractères • NSString • Encodages • Chaîne C • Extension de format %@ • Description d’objet • Expressions régulières • Exceptions • @try, @throw, @catch • @finally • Filtres d’exception • Bassin d’autorelease local
• Exceptions C++ • Spécificités 64 bits • Multithreading • @synchronized • Volatile • Utilitaires Cocoa et système •
API de répartition de charge • Boucle événementielle • Code implicite et propriétés • Key-value coding • Interception
• Accès aux propriétés • Différence entre « -> » et « . » • Dynamisme et runtime • RTTI du C++ • Introspection •
Typage fort ou faible • Méthode et fonction d’implémentation • Chargement au runtime • Enrichissement conditionnel •
Swizzling • Binaire Objective-C et outils de consultation • La STL et Cocoa • Conteneurs • Gestion mémoire • Itérateurs
• Énumération rapide • Foncteurs (objets-fonctions) • Mise en cache d’un appel de méthode • Fonctions de rappels
(callbacks) par blocs • Évolutions d’Objective C • Migration vers le 64 bits • Objective-C 2.0 • Objective C++ • Blocks
• Closure (fermeture) • Annexes • Fonctionnalités propres au C++ • Références • Inlining • Templates • Surcharge
d’opérateurs • Friends • Méthodes const • Namespace (espaces de noms) • C++/Objective-C.
À qui s’adresse cet ouvrage ?
– Développeurs expérimentés C++, Java, C#, Python et PHP 5 qui veulent développer pour iPhone ou Mac OS X
– Professionnels du développement web et mobile
– Fans d’iPhone qui souhaitent développer pour iPhone et Mac OS X
P. Y. Chatelier
P. Y. Chatelier
Pierre Y. Chatelier
développe pour Mac OS X
par passion depuis
qu’il a découvert cette
plate-forme en 2002,
et est maintenant l’auteur
de plusieurs logiciels pour
Mac OS et iPhone.
Après avoir fait ses classes
d’ingénieur à l’Isima
de Clermont-Ferrand et
obtenu un doctorat,
il occupe maintenant
un poste en recherche
& développement
en Bourgogne et souhaite
promouvoir le langage
Objective-C, peu enseigné
malgré ses nombreuses
qualités.
Conception : Nord Compo
pour le développeur avancé
Objective-C
pour le développeur avancé
Le langage iPhone/iPad et Mac OS X
pour les développeurs C++/Java/C#
Objective-C
Objective-C
P i e r r e Y. C h a t e l i e r
J. Gabès
Nagios 3
pour la supervision
Objective-C
pour le développeur avancé
Le langage iPhone/iPad et Mac OS X
pour les développeurs C++/Java/C#
Pier r e Y. Chatelier
CHEZ LE MÊME ÉDITEUR
XHTML/CSS, JavaScript pour le développement mobile.
Des sites efficaces pour iPhone, Android avec et XUI/iUI.
E. Sarrion.
N°12775, 2010, 290 pages.
Programmation Android.
D. Guignard, E. Robles, N. Sorel, J. Chable.
N°12587, 2010, 506 p.
Mon GPS en action.
P. Corréia.
N°12668, 2010, 300 pages.
Mac OS X Snow Leopard efficace.
G. Gete.
N°12586, 2010, 370 pages
Audit et optimisation MySQL 5.
P. Borghino, O. Dasini, A. Gadal.
N°12634, 2010, 282 pages
Programmation GWT 2. Développer des applications RIA
et Ajax avec le Google Web Toolkit.
S. Jaber.
N°12569, 2010, 484 pages
Asterisk. Études de cas. (coll. Cahiers de l’Admin).
P. Sultan, dirigé par N. Makarévitch.
N°12434, 2010, 298 pages.
Richard Stallman et la révolution du logiciel libre. Une
biographie autorisée.
R. M. Stallman, S.Williams, C. Masutti (Framasoft).
N°12609, 2010, 344 pages.
Lisibilité des sites web. Des choix typographiques au design
d’information.
M.-V. Blond, O. Marcellin, M. Zerbib.
N°12426, 2009, 326 pages.
Réussir son site web avec XHTML et CSS.
M. Nebra.
N°12485, 3e édition, 2010, 318 pages.
Ergonomie web. Pour des sites web efficaces.
A. Boucher. N°12479, 2e édition, 2009, 458 pages.
Bien rédiger pour le Web… et améliorer son référencement
naturel.
I. Canivet. N°12433, 2009, 412 pages.
Conversion web. Améliorer ses taux de conversion web.
S. Roukine. préface de P. Mosciusko-Morizet.
N°12499, 2009, 270 pages.
La programmation orientée objet. Cours et exercices
en UML 2 avec Java 5, C# 2, C++, Python et PHP 5.
H. Bersini, I. Wellesz. – N°12441, 4e édition, 2009, 602
pages (collection Noire).
Gestion de projet. Vers les méthodes agiles.
V. Messager Rota. – N°12518, 2e édition 2009, 272 pages
(collection Architecte logiciel).
Gestion de projet eXtreme Programming.
J.-L. Bénard, L. Bossavit , R. Médina , D. Williams. –
N°11561, 2002, 300 pages (collection Architecte logiciel).
Programmation Python. Conception et implémentation.
T. Ziadé. – N°12483, 2e édition 2009, 586 pages.
Best practices PHP 5. Les meilleures pratiques
de développement en PHP.
G. Ponçon. – N°11676, 2005, 480 pages.
Sécurité informatique. Principes et méthode à l’usage des
DSI, RSSI et administrateurs.
L. Bloch, C. Wolfhugel. – N°12525, 2009, 292 pages.
BSD, 2e édition (coll. Cahiers de l’Admin).
E. Dreyfus. – N°11463, 2004, 300 pages.
Debian Lenny. Gnu/Linux .
R. Hertzog, R. Mas. Dirigé par N. Makarévitch. – N°12443,
2009, 442 pages avec DVD-Rom.
Nagios 3 pour la supervision et la métrologie. Déploiement,
configuration et optimisation.
J. Gabès. – N°12473, 2009, 510 pages
Symfony. Mieux développer en PHP avec Symfony 1.2
et Doctrine.
F. Potencier et H. Hamon. – N°12494, 2009, 510 pages.
Zend Framework.
G. Ponçon et J. Pauli. – N°12392, 2008, 460 pages.
Drupal 6 et 7. Concevoir et déployer ses sites web.
Y. Brault, préface d’E. Plenel. – N°12465, 2009, 404 pages.
pour le développeu
pour la supervisi
nt aux projets
autaires
t Centreon.
tre un parc
ra, société
e dans
on de solutions
égion de Bordeaux
ssède
me informatique
sur les cinq
s.
Le langage iPhone/iPad et
pour les développeurs C
Nagios 3
Objective-C
pour le développeur avancé
Le langage iPhone/iPad et Mac OS X
Conception : Nord Compo
9 7 8221 2 1 247 3 6
pour les développeurs C++/Java/C#
Pier r e Y. Chatelier
45 e
Pier r e Y. Chatelier
ÉDITIONS EYROLLES
61, bd Saint-Germain
75240 Paris Cedex 05
www.editions-eyrolles.com
Aurélie,
Voilà déjà une des trois choses ; nous ferons les deux autres ensemble.
Le code de la propriété intellectuelle du 1er juillet 1992 interdit en effet expressément la photocopie à
usage collectif sans autorisation des ayants droit. Or, cette pratique s’est généralisée notamment dans les
établissements d’enseignement, provoquant une baisse brutale des achats de livres, au point que la possibilité
même pour les auteurs de créer des œuvres nouvelles et de les faire éditer correctement est aujourd’hui
menacée.
En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le
présent ouvrage, sur quelque support que ce soit, sans autorisation de l’éditeur ou du Centre Français d’Exploitation du
Droit de Copie, 20, rue des Grands-Augustins, 75006 Paris.
© Groupe Eyrolles, 2010, ISBN : 978-2-212-12751-5
Avant-propos
Pourquoi ce livre ?
Si vous vous intéressez à la programmation native pour Mac OS X ou pour
iPod Touch/iPhone/iPad (iPhone OS), vous ne pourrez pas échapper au langage
Objective-C. Or, ce langage, en apparence né avec Mac OS X en 2001, semble un
peu surgi de nulle part. Limité à l’environnement Apple, il ne fait pas partie des formations classiques des développeurs.
Moi-même, il m’avait semblé être au premier abord un obstacle plutôt qu’un tremplin à la programmation pour Mac OS X : il était si peu répandu que je ne comprenais pas son intérêt face à un C++ puissant, efficace et maîtrisé. J’ai cependant découvert qu’il s’agissait au contraire d’un choix particulièrement heureux : Objective-C,
par sa richesse et souplesse, est le langage le plus agréable à programmer que je connaisse. De plus, le succès de l’iPhone l’entraînant dans son sillage, la maîtrise
d’Objective-C est on ne peut plus d’actualité, et sa pertinence, loin de décroître, est
renforcée de jour en jour.
Ce livre enseigne Objective-C, avec la particularité de comparer en permanence ses
fonctionnalités avec celles des autres langages objet principaux ( Java, C++, C#). Le
but avoué est en effet de remplir un espace trop souvent laissé vacant : celui des documentations Objective-C qui ne prennent pas le lecteur pour un débutant en programmation.
Car très certainement, si vous êtes déjà développeur et connaissez la programmation
orientée objet (POO) via le C++, le Java ou le C#, vous n’avez plus besoin
d’apprendre ses paradigmes, vous les connaissez par cœur. Au contraire, vous avez
sûrement plus envie de savoir comment l’Objective-C les implémente. Vous avez
assez d’expérience pour apprendre le langage très rapidement, si l’on vous aiguille
vers l’essentiel.
VI
Objective-C 2.0 pour le développeur avancé
Enfin, ce livre n’est pas une documentation des API utilisées avec Objective-C, mais
traite du langage en tant que tel. La connaissance d’Objective-C « pur » vous donne
alors les moyens de vous adapter à tous ses cas d’utilisation, que ce soit pour
Mac OS X ou iPhone OS. Les API vont forcément évoluer, peut-être en apparaîtrat-il de nouvelles, mais les concepts resteront les mêmes ; ce que vous aurez appris
dans ce livre restera toujours valable.
Cet ouvrage ne se présente pas comme un didacticiel mais comme une référence des
concepts implémentés (ou non) par Objective-C. Il doit être possible de lire ce livre
d’un bout à l’autre, puis de le consulter comme un aide-mémoire. Il permettra ainsi,
je l’espère, d’éviter qu’une méconnaissance du langage conduise un développeur
talentueux, soit à l’abandonner trop vite, soit à utiliser à mauvais escient ses outils
habituels, produisant alors un code bâtard, inélégant et inefficace. Il ne se veut pas
non plus une référence absolument exhaustive.
Pour une description approfondie de certains détails techniques, qui peuvent évoluer avec le temps, la
documentation officielle d’Apple reste incontournable.
À qui s’adresse ce livre ?
Si vous lisez ces lignes, c’est que vous avez une qualité : vous n’avez pas peur de lire
une documentation. Ce livre s’adresse donc d’abord aux gens bien.
Par ailleurs, cet ouvrage semble s’adresser surtout aux développeurs C++, mais c’est
uniquement parce que le C++ est le langage le plus complexe du groupe C++/Java/
C#, et c’est du C++ vers l’Objective-C que la migration est la plus « difficile », car les
points de comparaison sont plus nombreux. Un développeur Java ou C# pourra simplement survoler certains passages qui traitent d’une particularité C++ non pertinente dans les autres langages objet.
Dans tous les cas, il s’agit de vous permettre d’apprendre Objective-C sans vous faire
perdre de temps avec les bases de la programmation objet. Vos connaissances dans les
autres langages vous donnent évidemment les moyens de comprendre les choses
beaucoup plus rapidement qu’un novice. Partant de ce principe, les informations
contenues dans les différentes sections qui suivent se veulent précises, concises et
pointues.
Avant-propos
De C# à Objective-C
Le C# est à mon sens le plus proche parent d’Objective-C. Destiné à la programmation native des applications modernes sur la plate-forme .NET de Microsoft, il fut
lui aussi une sorte de renouveau du développement pour la plate-forme Windows.
Pourtant, le C# souffre d’une complexité excessive pour des choses très simples dans
d’autres langages, et je n’arrive pas à retrouver dans les API .NET la qualité de
Cocoa. Découvrir Objective-C à partir de C# est donc relativement aisé, et ouvre
l’accès à des API dont la conception est extrêmement enrichissante.
De Java à Objective-C
Le Java est souvent le langage choisi pour enseigner le modèle objet. Mais il n’est que
rarement utilisé pour implémenter les applications spécifiques à un système donné.
Le problème le plus courant est en effet de donner à un programme l’interface graphique la plus conforme aux exigences de la plate-forme, domaine où la programmation native est largement favorisée.
Passer de Java à Objective-C ne présente pas de difficulté majeure, car le modèle objet
y est assez similaire. Il présente toutefois des particularités très intéressantes sur la gestion mémoire, l’introspection au runtime, et l’économie de certains codes rébarbatifs.
De C++/QT à Objective-C/Cocoa
Pour répondre à des besoins de portabilité s’étendant aux interfaces graphiques, la
plate-forme QT de Trolltech (rachetée par Nokia) a doté le C++ d’une couche graphique et d’API conviviales. Le succès de QT est en partie dû à la couche signal/slot
greffée au langage C++. Cela montre par ailleurs que le C++ seul ne suffisait pas à
répondre aux besoins de conception d’une interface graphique moderne.
Avec un langage Objective-C relativement simple et une API Cocoa bien conçue, programmer des interfaces pour Mac OS X ou iPhone OS est agréable et rapide ; même la
compilation en est accélérée. La migration vers un langage très souple et dynamique (ce
que n’est pas le C++) expose souvent une autre façon de concevoir le code.
Dans quelles conditions a été écrit ce livre ?
La base de ce livre est en réalité une documentation écrite en 2005 sur Objective-C.
À l’époque, cette documentation était surtout destinée... à moi-même ! Mise en ligne
gratuitement, j’en ai reçu un retour très positif, et de nombreux lecteurs m’ont écrit
VII
VIII
Objective-C 2.0 pour le développeur avancé
pour faire part de corrections ou précisions à apporter. Cinq ans plus tard, étoffée,
ajustée et peaufinée, la publication de cette documentation sous forme de livre est
une sorte d’aboutissement, d’autant que ce projet est à l’initiative de l’éditeur qui a eu
la bonté de la remarquer et l’apprécier.
Si vous connaissez la documentation originale, vous en reconnaîtrez la structure et la
majeure partie du contenu. Mais la transition du PDF-écran au papier a nécessité de
nombreux ajustements pour le confort de la lecture. Au passage, de nombreuses sections ont été retravaillées et enrichies. Nous espérons ainsi que cet ouvrage trouvera
sa place dans la bibliothèque des développeurs soucieux de gagner du temps et de
matérialiser leur savoir au cas où Internet tomberait en panne.
Structure de l’ouvrage
Comme il a déjà été dit plus haut, il doit être possible de lire ce livre d’un bout à
l’autre, puis de le consulter comme un aide-mémoire. Les chapitres se veulent donc
très spécialisés, pour alléger les relectures en évitant les répétitions. Quelques redites
sont toutefois présentes, pour éviter de multiples aller-retours lorsqu’une information
est à cheval sur plusieurs concepts.
Le chapitre 1 explique d’où vient et comment s’utilise Objective-C, son histoire permettant de comprendre à la fois sa conception et la raison pour laquelle il a été choisi
par Apple.
Le chapitre 2 détaille la syntaxe de base d’Objective-C, ce qui permet déjà de lire du
code existant. Quelques nouveautés d’Objective-C 2.0 sont reportées en fin
d’ouvrage pour faciliter la compréhension en première lecture.
Les chapitres 3, 4 et 5 montrent comment les concepts objets (classes, héritage, instanciation) sont implémentés en Objective-C.
Le chapitre 6 détaille la gestion mémoire, qui est très avantageuse une fois qu’elle est
comprise.
Les chapitres 7, 8 et 9 traitent des différentes fonctionnalités classiques (chaînes de
caractères, exceptions, multithreading).
Le chapitre 10 clôt la connaissance de la syntaxe d’Objective-C 2.0 en introduisant
le concept des propriétés. C’est un outil permettant d’économiser du code. Comprendre cette section nécessite une bonne compréhension des chapitres précédents.
Le chapitre 11 traite des nombreuses possibilités qu’offre l’Objective-C pour interroger ou modifier les classes lors de l’exécution du programme.
Avant-propos
Le chapitre 12 expose brièvement la notion de bibliothèque standard qui doit fournir
avec le langage des classes de base pour travailler dans de bonnes conditions.
Le chapitre 13 présente différentes évolutions d’Objective-C, montrant que le langage est maintenu au goût du jour pour satisfaire les développeurs. Y sont notamment récapitulés Objective-C 2.0 et Objective-C++.
Remerciements
Ce livre n’aurait sans doute pas vu le jour si sa forme initiale n’avait pas été affinée au
long des mois grâce aux remarques de certains lecteurs motivés. Je tiens donc à
remercier Jonathon Mah, Jean-Daniel Dupas, Jack Nutting, Ben Rimmington et
Mattias Arrelid pour leur pertinence.
Les amis ont également donné de leur temps pour apporter leur expertise ; Pascal
Bleuyard, Jérôme Cornet, François Delobel, je suis heureux de pouvoir vous citer ici.
À leurs côtés, je place Barthelemy Heyrman, pour qui la part de remerciements
s’étend même au-delà de cet ouvrage.
Ce livre aurait encore moins vu le jour sans Muriel, des éditions Eyrolles, qui a su
l’imaginer, me convaincre de sa légitimité, et le faire évoluer avec toute la diplomatie
nécessaire face au développeur farouche. Et comment ne pas non plus citer Sophie et
Pascale pour leur patience face aux corrections « détaillées » et fleuries ?
Un mot encore pour Gérald, Laurent et Michel de EyeNetics, avec qui il fait bon
travailler ; que vivent nos projets, à l'image de celui-ci !
Et enfin, bien sûr un immense merci à ma chère Aurélie, qui a supporté toutes ces
longues soirées de tapotage de clavier.
IX
Table des matières
CHAPITRE 1
Le monde d’Objective-C ................................................................ 1
Du C au modèle objet : les principaux protagonistes . . . . . . . . . . . . . . . . . . . . . . . 1
DYNAMISME ET PERFORMANCES L’un ne chasse pas l’autre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Objective-C et ses API (Cocoa…) : les racines non Unix de Mac OS X . . . . . . . . 3
POUR EN SAVOIR PLUS Le projet GNUStep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
La bibliothèque standard Objective-C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
UN STANDARD QUI VARIE Cocoa pour Mac OS X et iPhone OS . . . . . . . . . . . . . . . . . . . . . . . . 4
La documentation officielle d’Objective-C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Compilation d’un programme Objective-C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
La bibliothèque runtime d’Objective-C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Compilation et linkage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
POUR EN SAVOIR PLUS La notion de framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
POINT TECHNIQUE Compilation pour iPhone OS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Code minimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Différences 32/64 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
POINT TECHNIQUE Cocoa et le 64 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
32 et 64 bits côte à côte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Interopérabilité d’Objective-C avec d’autres langages . . . . . . . . . . . . . . . . . . . . . . 9
CHAPITRE 2
Généralités sur la syntaxe .......................................................... 11
Les mots-clefs d’Objective-C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Les vrais mots-clefs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Les faux mots-clefs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Syntaxe autorisée par le C sous-jacent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
POINT TECHNIQUE Changer la norme C à utiliser sous gcc . . . . . . . . . . . . . . . . . . . . . . . . . 13
Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Mélange code/déclarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Variable de boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Nouveaux types et valeurs en Objective-C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Type BOOL, valeurs YES et NO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
XII
Objective-C 2.0 pour le développeur avancé
Type id, valeur nil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Type Class, valeur Nil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Type SEL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
@encode() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Organisation du code source : fichiers .h, fichiers .m et inclusion . . . . . . . . . . . . 16
Nom des classes : pourquoi NS ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Fonctions et méthodes : une similarité trompeuse . . . . . . . . . . . . . . . . . . . . . . . . 17
CHAPITRE 3
Classes et objets .......................................................................... 19
Classe racine, type id, valeurs nil et Nil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
UN ŒIL SUR LA SUITE Allocation uniquement dynamique des objets . . . . . . . . . . . . . . . . . . . . 20
Déclaration des classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Attributs et méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
STYLE DE PROGRAMMATION Nom des données membres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
AUTRES LANGAGES Le cas de struct en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Déclarations anticipées (forward) : @class, @protocol . . . . . . . . . . . . . . . . . . . 22
Visibilité public, protected, private . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
UN ŒIL SUR LA SUITE Héritage public, protected ou private . . . . . . . . . . . . . . . . . . . . . . . . . 24
Méthodes « privées » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
STYLE DE PROGRAMMATION Underscore, encore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Données membres de classe (« static ») . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Méthodes, messages et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Prototype et appel, méthodes d’instance, méthodes de classe . . . . . . . . . . . . . . 26
Accès aux données d’instance de son objet déclencheur . . . . . . . . . . . . . . . . . . 28
STYLE DE PROGRAMMATION L’utilisation de self-> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Les cibles self et super . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
SYNTAXE self et super : mots-clefs ou non ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Identifiant et signature du prototype, surcharge . . . . . . . . . . . . . . . . . . . . . . . . 31
UN ŒIL SUR LA SUITE Surcharge et méthodes virtuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Pointeur de méthode : le sélecteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Type SEL et @selector() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Divers usages de sélecteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Callbacks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Paramètres par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Nombre d’arguments variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
USAGE PRATIQUE Utilisation du nombre d’arguments variable pour les collections . . . . . . . . . 39
Arguments muets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Modificateurs de prototype (const, static, virtual, « =0 », friend, throw) . . . . . . 40
Messages et transmission . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Envoi d’un message à nil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Table des matières
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Délégation d’un message vers un objet inconnu . . . . . . . . . . . . . . . . . . . . . . . . 41
USAGE PRATIQUE Comprendre les délégués de Cocoa avec un exemple . . . . . . . . . . . . . . . . . 42
AUTRES LANGAGES delegate et event en C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Forwarding : gestion d’un message inconnu . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Méthodes et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Cohabitation cordiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
La fonction cachée derrière une méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Manipulations au runtime des classes et méthodes . . . . . . . . . . . . . . . . . . . . . . . 45
POUR EN SAVOIR PLUS Envoi à nil et code assembleur
CHAPITRE 4
Les formes d’héritage ................................................................. 47
Héritage simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Héritage interdit ou limité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
UN ŒIL SUR LA SUITE final et sealed pour les méthodes en Java et C# . . . . . . . . . . . . . . . . . . 48
Membres homonymes des sous-classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
AUTRES LANGAGES Membres homonymes en Java et C# . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Héritage multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
AUTRES LANGAGES Popularité de l’héritage multiple : C++ et Python . . . . . . . . . . . . . . . . . 50
Downcasting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Virtualité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Méthodes virtuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
AUTRES LANGAGES Les garde-fous des méthodes virtuelles . . . . . . . . . . . . . . . . . . . . . . . . . 51
Redéfinition silencieuse des méthodes virtuelles . . . . . . . . . . . . . . . . . . . . . . . 52
Surcharge et méthodes virtuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Méthodes virtuelles pures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Héritage « virtuel » du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Extension de classe (sans héritage) : les catégories . . . . . . . . . . . . . . . . . . . . . . . . 54
AUTRES LANGAGES Les extensions de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
USAGE PRATIQUE Les catégories n’ajoutent que peu de contraintes au code . . . . . . . . . . . . . . 57
Classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Protocoles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Protocole formel : @protocol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Protocole formel et méthodes optionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Protocole informel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Objet de type Protocol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Qualificateurs pour messages entre objets distants . . . . . . . . . . . . . . . . . . . . . . . 63
Utilisation conjointe de protocoles, catégories, dérivation . . . . . . . . . . . . . . . . . 64
Le design-pattern « class-cluster » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
XIII
XIV
Objective-C 2.0 pour le développeur avancé
CHAPITRE 5
Instanciation, destruction et copie ............................................ 67
Variable objet et pointeur d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
AUTRES LANGAGES Pointeurs d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
POUR ALLER PLUS LOIN Créer malgré tout des objets Objective-C sur la pile . . . . . . . . . . . . . . 68
Forme de Coplien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Constructeurs, initialisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Distinction entre allocation et initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
alloc et init : lesquels implémenter ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Type de retour d’un init : id . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Syntaxe usuelle de l’application successive de alloc et init . . . . . . . . . . . . . . . . . 70
Exemple d’initialisateur correct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
self = [super init…] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
POUR EN SAVOIR PLUS Le blog de Wil Shipley . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Échec de l’initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Constructeur de commodité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Constructeur par défaut : initialisateur désigné . . . . . . . . . . . . . . . . . . . . . . . . 76
Listes d’initialisation et valeur par défaut des données d’instance . . . . . . . . . . . 78
UN ŒIL SUR LA SUITE Si les données membres sont des objets C++ ? . . . . . . . . . . . . . . . . . . . . 79
Constructeur virtuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Constructeur de classe : initialize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Destructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
POINT TECHNIQUE Destructeurs virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Opérateurs de copie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Clonage classique : copy, copyWithZone: . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
NSCopyObject() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
AUTRE LANGAGES Copie binaire en C#/.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Pseudo-clonage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Mutabilité : mutableCopy et mutableCopyWithZone: . . . . . . . . . . . . . . . . . . 87
Comparaison d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Utilité de == . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
operator<() et operator==() en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
isEqual:, isEqualTo:, isEqualTo"QuelqueChose": . . . . . . . . . . . . . . . . . . . . . . 90
USAGE PRATIQUE isEqual pour les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
USAGE PRATIQUE implémenter isEqual: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
compare: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
hash: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
USAGE PRATIQUE Les hash de Cocoa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
USAGE PRATIQUE Les hash obligatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Étendre un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Table des matières
CHAPITRE 6
Gestion de la mémoire et ramasse-miettes .............................. 95
new et delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
FAUX AMI La méthode new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Compteur de références (retain, release) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
POUR EN SAVOIR PLUS La bibliothèque Boost du C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
retainCount . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Cycles de références : éviter l’abus de retain . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
DANS LA PRATIQUE Cycles de retain perfides en Cocoa . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
alloc, copy, mutableCopy, retain, release . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
USAGE PRATIQUE La règle est connue, et ses pièges aussi . . . . . . . . . . . . . . . . . . . . . . . . . . 99
autorelease . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Indispensable autorelease . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Bassin d’autorelease . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
ATTENTION drain plutôt que release . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Utilisation de plusieurs bassins d’autorelease . . . . . . . . . . . . . . . . . . . . . . . . . 102
autorelease et retain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Prudence avec autorelease . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Efficacité et autorelease . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Exemple de l’utilité des bassins d’autorelease . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Méthodes nécessitant une bonne compréhension de la gestion de la mémoire . 110
Constructeurs de commodité, constructeurs virtuels . . . . . . . . . . . . . . . . . . . 110
Accesseurs en écriture (mutateurs/setters) . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Assignation (code réduit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Assignation avec retenue (code réduit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Copie (code réduit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Assignation (code complet) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Assignation avec retenue (code complet) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Copie (code complet) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Pseudo-clonage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Accesseurs en lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
STYLE DE PROGRAMMATION Accesseurs avec ou sans get ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
UN ŒIL SUR LA SUITE Atomicité de l’accesseur en lecture . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Ramasse-miettes (garbage collector) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
ATTENTION Vider un bassin d’autorelease avec drain . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Le problème du finaliseur : finalize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
AUTRES LANGAGES Le finaliseur en Java et C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Liens faibles et forts : weak, strong . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
NSMakeCollectable() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
AutoZone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
XV
XVI
Objective-C 2.0 pour le développeur avancé
CHAPITRE 7
Les chaînes de caractères en Objective-C ................................ 125
Seuls objets « statiques » possibles d’un code source Objective-C . . . . . . . . . . . 126
NSString et les encodages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
NSString vers chaîne C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
NSLog(), extension de format %@, description d’un objet . . . . . . . . . . . . . . . . 127
AUTRES LANGAGES Description des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
POUR EN SAVOIR PLUS Autres fonctionnalités de NSLog . . . . . . . . . . . . . . . . . . . . . . . . . . 128
NSCharacterSet, NSMutableCharacterSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Interprétation des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
CHAPITRE 8
Les exceptions ........................................................................... 131
Lancer, intercepter, relancer : @try, @throw, @catch . . . . . . . . . . . . . . . . . . . . 132
@finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Méthodes « filtres » d’exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Exception non interceptée (uncaught exception) . . . . . . . . . . . . . . . . . . . . . . . . 135
Exception et bassin d’autorelease local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Exceptions C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Spécificités 64 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
CHAPITRE 9
Le multithreading et les outils associés .................................. 139
@synchronized . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Le cas des propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
volatile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
USAGE PRATIQUE @synchronized sur un accès à un singleton . . . . . . . . . . . . . . . . . . . . . . 141
Les utilitaires Cocoa et système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Les API de répartition de charge : NSOperation, Grand Central Dispatch . . . 142
Se passer du multithread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
La boucle événementielle NSRunLoop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
NSTimer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
CHAPITRE 10
Code implicite et propriétés..................................................... 145
Key-value coding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Interprétation de la clef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Prototypes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Table des matières
Fonctionnalités avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Faiblesse du KVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Utilité des propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Description des propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Attributs des propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Implémentations personnalisées des propriétés . . . . . . . . . . . . . . . . . . . . . . . 154
POINT TECHNIQUE Spécificité 64 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Syntaxe des accès aux propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
L’immense différence entre « -> » et « . » . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
SYNTAXE Débat sur la pertinence du choix du point comme caractère . . . . . . . . . . . . . . 155
CHAPITRE 11
Le dynamisme et les manipulations du runtime .................... 157
De l’utilité du dynamisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
USAGE PRATIQUE Cas courant d’utilisation de l’introspection et des types dynamiques . . . . . . 158
Les RTTI du C++ (Run-Time Type Information) . . . . . . . . . . . . . . . . . . . . . . 158
Introspection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
class, superclass, isMemberOfClass:, isKindOfClass: . . . . . . . . . . . . . . . . . . . 159
conformsToProtocol: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
respondsToSelector:, instancesRespondToSelector: . . . . . . . . . . . . . . . . . . . 160
Typage fort ou typage faible via id . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Manipulations avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Méthode et fonction d’implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
USAGE PRATIQUE Optimisation par IMP-caching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Ajout d’une méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
USAGE PRATIQUE Ajouter une méthode au runtime : pour quoi faire ? . . . . . . . . . . . . . . . . 164
Chargement de classes au runtime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Enrichissement conditionnel du runtime . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Swizzling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Binaire Objective–C et outils de consultation . . . . . . . . . . . . . . . . . . . . . . . . . . 170
CHAPITRE 12
La STL et Cocoa .......................................................................... 173
Conteneurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Les conteneurs standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
POUR EN SAVOIR PLUS Les performances de NSArray . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
AUTRES LANGAGES Tableau associatif en C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Stocker la valeur nil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Gestion mémoire du contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
XVII
XVIII
Objective-C 2.0 pour le développeur avancé
Énumération classique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Énumération rapide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Foncteurs (objets-fonctions) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Utilisation du sélecteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
NSSortDescriptor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
IMP-caching : mise en cache d’un appel de méthode . . . . . . . . . . . . . . . . . . 179
Algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
Fonctions de rappels (callbacks) par blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
CHAPITRE 13
Les évolutions d’Objective-C :
performances et extensions du langage ................................. 181
Évolution des performances d’Objective-C . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Appel des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
POUR EN SAVOIR PLUS Une inspection de objc_msgsend . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Migration vers le 64 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Objective-C 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
Objective-C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
Une évolution non standard du C : les blocks . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Support du concept de closure (fermeture) . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Capture de l’environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
Variables __block . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
ANNEXE A
Fonctionnalités propres au C++................................................ 189
Références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Inlining . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
AUTRES LANGAGES Les templates en Java et C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
POINT TECHNIQUE Détournement du design-pattern Factory . . . . . . . . . . . . . . . . . . . . . . 190
Surcharge d’opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Friends . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
Méthodes const . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Liste d’initialisation dans le constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Namespaces (espaces de noms) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Table des matières
ANNEXE B
Mise en correspondance des fonctionnalités C++/Objective-C 195
ANNEXE C
Glossaire..................................................................................... 197
Abréviations et anglicismes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Index........................................................................................... 199
XIX