Objective-C pour le développeur avancé

-

Livres
175 pages
Lire un extrait
Obtenez un accès à la bibliothèque pour le consulter en ligne
En savoir plus

Description

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 iOS 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 iOS, devient un passage obligé pour les professionnels de la programmation - alors que l'engouement pour ces systèmes ne l'a introduit que récemment dans 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 récentes évolutions apportées au langage.



A 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




  • Le monde d'Objective-C


  • Généralités sur la syntaxe


  • Classes et objets


  • Les formes d'héritage


  • Instanciation, destruction et copie


  • Gestion de la mémoire


  • Objets libellés (literals) et chaînes de caractères


  • Les exceptions


  • Le multithreading et les outils associés


  • Code implicite et propriétés


  • Le dynamisme et les manipulations du runtime


  • Bibliothèques de classes standard


  • Les évolutions d'Objective-C, performances et extensions du langage




  • A : Fonctionnalités propres a C++/Java/C#


  • B : Mise en correspondance des fonctionnalités C++/Objective-C


  • C : Glossaire

Sujets

Informations

Publié par
Date de parution 11 avril 2013
Nombre de lectures 229
EAN13 9782212191806
Langue Français

Informations légales : prix de location à la page 0,0165€. Cette information est donnée uniquement à titre indicatif conformément à la législation en vigueur.

Signaler un problème

Résumé
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
iOS 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 iOS, devient un passage obligé pour les professionnels de la programmation – alors que
l’engouement pour ces systèmes ne l’a introduit que récemment dans 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 récentes évolutions apportées au langage.
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 • Interopérabilité
avec d’autres langages • Core Foundation, toll-free bridging et gestion de la mémoire • Robustesse
du langage • Syntaxe • Vrais et faux mots-clefs • Syntaxe du C sous-jacent • 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 pseudoclonage • Comparaison d’objets
• == et operator<_28_29_ en="" _c2b_2b_="">• Hash • Gestion de la mémoire • new et delete •
Compteur de références (retain, release) • Ramasse-miettes : une courte vie • ARC (Automatic
Reference Counting) • 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 • Bibliothèques de classes standard. • 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) • Les
taggedpointers • 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
Biographie auteur
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, dont les
qualités méritent d’être connues des néophytes comme des programmeurs confirmés.
www.editions-eyrolles.comObjective-C
pour le développeur avancé
Le langage d’iOS 6 et Mac OS X
pour les développeurs C++/Java/C#
e2 édition
Pierre Y. ChatelierÉDITIONS EYROLLES
61, bd Saint-Germain
75240 Paris Cedex 05
www.editions-eyrolles.com
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 l’autorisation de l’Éditeur ou du Centre Français
d’exploitation du droit de copie, 20, rue des Grands Augustins, 75006 Paris.
© Groupe Eyrolles, 2013, ISBN : 978-2-212-13686-9COLLECTION BLANCHE
F. DAOUST, D. HAZAËl-MASSIEUX. – Relever le défi du Web mobile.
Bonnes pratiques de conception et de développement.
N°12828, 2011, 300 pages.
E. SARRION. – jQuery Mobile.
La bibliothèque JavaScript pour le Web mobile.
N°13388, 2012, 610 pages.
J. STARK. – Applications iPhone avec HTML, CSS et JavaScript.
Conversions en natifs avec PhoneGap.
N°12745, 2010, 190 pages.
J.-M. DEFRANCE. –Ajax, jQuery et PHP.
42 ateliers pour concevoir des applications web 2.0.
N°13271, 3e édition, 2011, 482 pages.
R. GOETTER. – CSS avancées. Vers HTML 5 et CSS 3.
N°13405, 2e édition, 2012, 400 pages.
R. RIMELÉ. HTML5. Une référence pour le développeur web.
N°13638, à paraître en 2013, 644 pages.
E. DASPET, C. PIERRE DE GEYER. – PHP 5 avancé.
N°13435, 6e édition, 2012, 900 pages environ.
J. PAULI, G. PLESSIS, C. PIERRE DE GEYER. – Audit et optimisation LAMP.
N°12800, 2012, 300 pages environ.
S. JABER. – Programmation GWT 2.5.
Développer des applications HTML5/JavaScript en Java avec Google Web Toolkit.
N°13478, 2e édition, 2012, 540 pages.
C. PORTENEUVE. – Bien développer pour le Web 2.0.
Bonnes pratiques Ajax.
N°12391, 2e édition, 2008, 674 pages.
COLLECTION ACCÈS LIBRE
A. FAQUE. – Google Android 4 efficace
Utilisation avancée des smartphones Android (Samsung Galaxy, Nexus, HTC…)
N° 13481, 2012, 218 pages.
T. BAILLET. – Créer son propre thème WordPress pour mobile.
N°13441, 2012, 128 pages.
A. BOUCHER. – Ergonomie web illustrée. 60 sites à la loupe.
N°12695, 2010, 302 pages (Design & Interface).
I. CANIVET. – Bien rédiger pour le Web.
Stratégie de contenu pour améliorer son référencement naturel.
N°12883, 2e édition, 2011, 552 pages.
N. CHU. – Réussir un projet de site web.
N°12742, 6e édition, 2010, 256 pages.
H. COCRIAMONT. – Réussir son premier site Joomla! 2.5.
N°13425, 2012, 160 pages.
COLLECTION DESIGN WEB
C. SCHILLINGER. – Intégration web : les bonnes pratiques.
Le guide du bon intégrateur.
N°13370, 2012, 400 pages.
K. DELOUMEAU-PRIGENT. – CSS maintenables avec Sass & Compass.
Outils et bonnes pratiques pour l’intégrateur web.
N°13417, 2012, 272 pages.
I. CANIVET ET J-M. HARDY. – La stratégie de contenu en pratique.
30 outils passés au crible.
N°13510, 2012, 176 pages.
S. DAUMAL. – Design d’expérience utilisateur.
Principes et méthodes UX.
N°13456, 2012, 208 pages.Apolline,
Grâce à toi, ça fait deux.A v a n t - p r o p o s
Pourquoi ce livre ?
Si vous vous intéressez à la programmation native pour Mac OS X ou pour iPod Touch/iPhone/iPad (iOS), vous n’échapperez pas 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.
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 iOS. Les
API vont forcément évoluer, il en apparaîtra 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.
Il peut s'agir de la documentation du langage lui-même (Objective–C) ou des outils de développement (Xcode et LLVM), qui apportent
des fonctionnalités supplémentaires.
http://developer.apple.com/library/mac/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf
http://developer.apple.com/library/mac/#documentation/CompilerTools/Conceptual/LLVMCompilerOverview/
http://developer.apple.com/library/mac/documentation/ToolsLanguages/Conceptual/Xcode4UserGuide/Xcode4UserGuide.pdf
À 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.
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 à mon sens 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’interaction utilisateur 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 Nokia (initialement développée par
Trolltech) 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 interaction utilisateur
moderne.
Avec un langage Objective–C relativement simple et une API Cocoa très bien conçue, programmer pour Mac OS X ou iOS est agréable etrapide ; même la compilation en est accélérée. Mais la migration vers un langage très souple et dynamique (ce que n’est pas le C++) impose
souvent une autre façon de concevoir le code, les bonnes pratiques étant alors différentes.
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 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.
La deuxième édition de cet ouvrage permet d’introduire les quelques nouveautés (peu nombreuses mais parfois majeures) apparues depuis
Mac OS 10.6 et iOS 5. Il est intéressant de constater qu’Objective–C est toujours officiellement en version 2, les nouveautés reposant
principalement sur des fonctionnalités apportées par le compilateur et le runtime.
Nouveautés de la deuxième édition
Les principales nouveautés apportées par cette deuxième édition sont les suivantes :
• détails sur l’évolution des outils de développement, la migration vers LLVM s’étant accompagnée des principales nouveautés apportées
au langage ;
• détails sur les pratiques devenues obsolètes, notamment le ramasse-miettes ;
• nouvelle gestion de la mémoire avec l’ARC (Automatic Reference Counting) ;
• nouvelle distinction entre catégorie et extension de classe ;
• les sucres syntaxiques literals et subscripting ;
• les tagged pointers.
Et bien sûr, dans l’éternelle quête de perfection, de nombreux ajustements ont été apportés à la première édition, avec en particulier des
explications plus détaillées sur certaines fonctionnalités comme le toll-free bridging, les blocks, etc.
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. Certaines nouveautés introduites par
les évolutions d’Objective–C sont reportées dans des chapitres ultérieurs 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. En plus du ramasse-miettes maintenant
obsolète, il existe deux formes possibles de gestion de la mémoire : le comptage de références manuel ou automatique, le second ne
pouvant être compris que grâce au premier.
L e s chapitres 7, 8 et 9 traitent de différentes fonctionnalités classiques (chaînes de caractères, libellés (literals), 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. Une bonne compréhension des chapitres précédents, notamment de la gestion de la mémoire, est requise.
L e chapitre 11 traite du comportement d’Objective–C lors de l’exécution du programme (le runtime), notamment des fonctionnalités
offertes pour interroger ou modifier les classes.
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.
L e chapitre 13 récapitule les évolutions d’Objective–C, pour y situer les compatibilités attendues entre l’architecture, le système
d’exploitation, le runtime, et les variantes comme 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, Jerôme Cornet, François Delobel, je suis
heureux de pouvoir vous citer ici.
À leurs côtés je place Dominique Ginhac et 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 citer Sophie et Pascale pour leur patience
face aux corrections « détaillées » et fleuries ?
Un mot encore pour Gérald, Yoan et Pierre-Jean, avec qui il fait bon travailler ; que vivent nos projets, à l’image de celui-ci !
Et enfin, un immense merci à ma chère Aurélie, qui a supporté toutes ces longues soirées de tapotage de clavier, et à ma petite Apolline
pour son enthousiasme sans faille.Table des matières
Avant-propos
Pourquoi ce livre ?
À qui s’adresse ce livre ?
De C# à Objective–C
De Java à Objective–C
De C++/QT à Objective–C/Cocoa
Dans quelles conditions a été écrit ce livre ?
Nouveautés de la deuxième édition
Structure de l’ouvrage
Remerciements
CHAPITRE 1
Le monde d’Objective–C
Du C au modèle objet : les principaux protagonistes
Objective–C et ses API (Cocoa…) : les racines non Unix de Mac OS X
La bibliothèque standard Objective–C
La documentation officielle d’Objective–C
Compilation d’un programme Objective–C
La bibliothèque runtime d’Objective–C
Compilateurs, compilation et linkage
Code minimal
Différences 32/64 bits
32 et 64 bits côte à côte
Interopérabilité d’Objective–C avec d’autres langages
Core Foundation et toll-free bridging
Toll-free bridging et gestion mémoire
Robustesse du langage
Fautes en langage C
Débordements dans des collections
Déréférencement du pointeur nul
Mauvaise gestion mémoire : ARC à la rescousse
Débordement de pile
Injection de code et protection
CHAPITRE 2
Généralités sur la syntaxe
Les mots-clefs d’Objective–C
Les vrais mots-clefs
Les faux mots-clefs
Syntaxe autorisée par le C sous-jacent
Commentaires
Mélange code/déclarations
Variable de boucle for
Nouveaux types et valeurs en Objective–C
Type BOOL, valeurs YES et NOType id, valeur nil
Type Class, valeur Nil
Type SEL
@encode()
Organisation du code source : fichiers .h, fichiers .m et inclusion
Nom des classes : pourquoi NS ?
Fonctions et méthodes : une similarité trompeuse
CHAPITRE 3
Classes et objets
Classe racine, type id, valeurs nil et Nil
Déclaration des classes
Attributs (ivar) et méthodes, @interface, @implementation
Déclarations anticipées (forward) : @class, @protocol
Visibilité public, protected, private
Méthodes « privées », non déclarées
Données membres de classe (« static »)
Données d’instance et @implementation
Méthodes, messages et fonctions
Prototype et appel, méthodes d’instance, méthodes de classe
Accès à ses propres données (de this à self)
Les cibles self et super
Identifiant et signature du prototype, surcharge
Pointeur de méthode : le sélecteur
Type SEL et @selector()
Divers usages de sélecteur
Gestion de la compatibilité
Callbacks
Paramètres par défaut
Nombre d’arguments variable
Arguments muets
Modificateurs de prototype (const, static, virtual, « =0 », friend, throw)
Messages et transmission
Envoi d’un message à nil
Délégation d’un message vers un objet inconnu
Forwarding : gestion d’un message inconnu
Méthodes et fonctions
Cohabitation cordiale
La fonction cachée derrière une méthode
Manipulations au runtime des classes et méthodes
CHAPITRE 4
Les formes d’héritage
Héritage simple
Héritage interdit ou limité
Membres homonymes des sous-classes
Héritage multiple
Downcasting
Virtualité
Méthodes virtuelles
Redéfinition silencieuse des méthodes virtuellesSurcharge et méthodes virtuelles
Méthodes virtuelles pures
Héritage « virtuel » du C++
Enrichissement de classes (sans héritage)
Les catégories
Les extensions
Classes abstraites
Protocoles
Protocole formel : @protocol
Protocole formel et méthodes optionnelles
Protocole informel
Objet de type Protocol
Qualificateurs pour messages entre objets distants
Utilisation conjointe de protocoles, catégories, dérivation
Le design-pattern « class-cluster »
CHAPITRE 5
Instanciation, destruction et copie
Variable objet et pointeur d’objets
Forme de Coplien
Constructeurs, initialisateurs
Distinction entre allocation et initialisation
alloc et init : lesquels implémenter ?
Type de retour d’un init : id
Syntaxe usuelle de l’application successive de alloc et init
Exemple d’initialisateur correct
self = [super init…]
Échec de l’initialisation
Constructeur de commodité
Constructeur par défaut : initialisateur désigné
Listes d’initialisation et valeur par défaut des données d’instance
Constructeur virtuel
Constructeur de classe : initialize
Destructeurs
Opérateurs de copie
Clonage classique : copy, copyWithZone:
NSCopyObject() (obsolète)
Pseudo-clonage
Mutabilité : mutableCopy et mutableCopyWithZone:
Comparaison d’objets
Utilité de ==
operator<_28_29_ et="" operator="=" _28_29_="" en="">
isEqual:, isEqualTo:, isEqualTo"QuelqueChose":
compare:
hash:
Extension d’instance
CHAPITRE 6
Gestion de la mémoire
new et delete
Compteur de références (retain, release)retainCount
Cycles de références : éviter l’abus de retain
alloc, copy, mutableCopy, retain, release
autorelease
Indispensable autorelease
Bassin d’autorelease, NSAutoreleasePool et @autoreleasepool
Utilisation de plusieurs bassins d’autorelease
autorelease et retain
Prudence avec autorelease
Efficacité et autorelease
Exemple de l’utilité des bassins d’autorelease
Méthodes nécessitant une bonne compréhension de la gestion de la mémoire
Constructeurs de commodité, constructeurs virtuels
Accesseurs en écriture (mutateurs/setters)
Assignation (code réduit) : référence « faible »
Assignation avec retenue (code réduit) : référence « forte »
Copie (code réduit)
Assignation (code complet) : référence faible
Copie (code complet)
Pseudo-clonage
Accesseurs en lecture
Ramasse-miettes (garbage collector) : une courte vie
Le problème du finaliseur : finalize
Liens faibles et forts : weak, strong
NSMakeCollectable()
AutoZone
ARC : Automatic reference counting
Qualificateurs : lien fort, lien faible, transfert de lien
Destruction d’objet
Gestion de l’autorelease
Lien faible intelligent : mise à nil automatique
Toll-free bridging et ARC
Données d’instance et liens forts
Migration vers ARC
retain, retainCount, release, autorelease, dealloc
Propriétés
Accesseurs
Précisions diverses
Cycles de retain
Pointeurs d’objet non initialisés
Autres
Rétro-compatibilité : ARC « Lite »
Performances
Singleton
CHAPITRE 7
Objets libellés ( l i t e r a l s) et chaînes de caractères
Types de base et encapsulation objet
Syntaxe des objets libellés (literals)
Structures, collections et literals
Gestion mémoire des objets libellés (literals)
Appel de méthodes sur literals
La classe NSStringDe const char* à NSString
NSString et les encodages
La chaîne vide
NSLog(), extension de format %@, description d’un objet
NSCharacterSet, NSMutableCharacterSet
Interprétation des chaînes
Expressions régulières
CHAPITRE 8
Les exceptions
Lancer, intercepter, relancer : @try, @throw, @catch
@finally
Méthodes « filtres » d’exception
Exception non interceptée (uncaught exception)
Exception et bassin d’autorelease local
Exceptions C++
Coût des exceptions
CHAPITRE 9
Le multithreading et les outils associés
Se passer du multithread
La boucle événementielle NSRunLoop
NSTimer
Classes standards et opérations asynchrones
Verrous et protections
volatile
@synchronized
Le cas des propriétés
Les utilitaires Cocoa et système
Grand Central Dispatch et blocks
Notion de block, syntaxe élémentaire
Exemples d’utilisation de Grand Central Dispatch
CHAPITRE 10
Code implicite et propriétés
Propriétés
Utilité des propriétés
Description des propriétés
Attributs des propriétés
Implémentations personnalisées des propriétés
@synthesize et données d’instance
Syntaxe des accès aux propriétés
L’immense différence entre « -> » et « . »
Key-value coding
Principe
Interprétation de la clef
Prototypes
Fonctionnalités avancées
Key-value coding et refactoring
KVO : Key-value observingCHAPITRE 11
Le dynamisme et les manipulations du runtime
De l’utilité du dynamisme
Les RTTI du C++ (Run-Time Type Information)
Introspection
class, superclass, isMemberOfClass:, isKindOfClass:
conformsToProtocol:
respondsToSelector:, instancesRespondToSelector:
Typage fort ou typage faible via id
Manipulations avancées
Méthode et fonction d’implémentation
Ajout d’une méthode
Chargement de classes au runtime
Enrichissement conditionnel du runtime
Swizzling
Binaire Objective–C et outils de consultation
CHAPITRE 12
Bibliothèque de classes standard
Valeurs encapsulées
NSNull
NSNumber
NSDecimal, NSDecimalNumber
NSValue
NSData
Temps, NSTimeInterval, NSDate, NSCalendarDate
NSFileHandle, NSPipe…
Toll-free bridging
Conteneurs, collections
Les conteneurs standards
Gestion mémoire du contenu
Indiçage (subscripting)
Itérateurs
Énumération classique
Énumération rapide
Foncteurs (objets-fonctions)
Utilisation du sélecteur
Énumération par block
Tri avec NSSortDescriptor
IMP-caching : mise en cache d’un appel de méthode
Algorithmes
Sérialisation
CHAPITRE 13
Les évolutions d’Objective–C : performances et extensions du
langage
Évolution des performances d’Objective–C
Appel des méthodes
iOS et migration vers le 64 bits : runtime « moderne »Objective–C 2.0, Objective–C « 3.0 » ?
Objective–C++
Les blocks
Support du concept de closure (fermeture)
Syntaxe
Capture de l’environnement
Variables __block
Copie et destruction de block
Block et tableaux C standards
Les tagged pointers
Implémentation sous Mac OS X
Gestion mémoire
Récapitulatifs des évolutions
ANNEXE A
Fonctionnalités propres à C++/Java/C#
Cas particulier du C++
Références
Inlining
Templates ou Generics
Surcharge d’opérateurs
Friends
Méthodes const
Liste d’initialisation dans le constructeur
Namespaces (espaces de noms)
ANNEXE B
Mise en correspondance des fonctionnalités C++/Objective-C
ANNEXE C
Glossaire
Abréviations et anglicismes
Index1
Le monde d’Objective–C
Vous pensiez peut-être couper à l’inévitable historique, mais celui d’Objective–C est intéressant pour justifier le choix de ce langage par Apple. Il
permet aussi d’éclairer sur ce que n’est pas Objective–C, afin d’éviter les confusions. Quelques points techniques relatifs à la compilation sont
abordés.
Ce chapitre a pour but de présenter Objective–C et ses satellites, pour définir clairement les rôles. Entre langage, normes, API, extensions et
évolutions, quelques précisions sont nécessaires. Les détails techniques avancés sont toutefois reportés tout au long de cet ouvrage, pour ne
pas complexifier inutilement cette présentation. Les évolutions du langage sont également récapitulées dans le dernier chapitre.
Du C au modèle objet : les principaux protagonistes
Il est assez difficile de dater précisément les naissances des langages de programmation. Selon qu’on considère leurs balbutiements, leur
développement, leur annonce officielle ou leur standardisation, la marge est importante. Malgré tout, un historique sommaire, présenté dans
la figure page suivante, permet de situer Objective–C vis-à-vis de ses ancêtres et de ses « concurrents ».
Smalltalk-80 est un des tout premiers langages réellement objet, qui a donc fortement influencé les développements ultérieurs de ce concept.
Le C++ et l’Objective–C sont deux branches différentes visant à créer un langage objet basé sur le C.
Figure 1–1 Historique sommaire de Smalltalk, Java, C, C#, C++ et Objective–C
Tandis que C++ se tourne vers une forme de programmation très statique minimisant le « coût » du modèle objet pour les performances
d’exécution, Objective–C choisit la voie du dynamisme de Smalltalk, dont il emprunte aussi une partie de la syntaxe.
DYNAMISME ET PERFORMANCES L’un ne chasse pas l’autre
Peut-être voyez-vous déjà dans cette divergence un avantage très net de C++ pour ce qui est des performances. C’est en partie vrai. Les
performances d’Objective–C sont toutefois excellentes lorsqu’il est correctement utilisé. Une section y est consacrée dans le chapitre 13
intitulé « Les évolutions d’Objective–C : performances et extensions du langage », en fin d’ouvrage.
Java veut se placer en remplaçant du C++, toujours avec une syntaxe très proche du C mais un meilleur modèle objet, lui aussi inspiré de
Smalltalk.
Le langage C#, développé par Microsoft, est un concurrent direct d’Objective–C. Les similitudes sont nombreuses et dénotent en réalité un
renouveau du développement objet pour la conception d’applications modernes.
L’Objective–C++ est une fusion des syntaxes de l’Objective–C et du C++. Attention : il ne s’agit pas vraiment d’un langage, mais plutôt
d’une fonctionnalité du compilateur. Il ne s’agit pas ici de fusionner les concepts, mais d’autoriser les deux syntaxes dans le même code
source. Ainsi, une classe C++ ne peut pas être interchangeable avec une classe Objective–C, mais les deux peuvent cohabiter. Voyez la
section consacrée à Objective–C++ pour des explications plus poussées et connaître les limites de cette cohabitation, qui est tout de même
assez poussée.
L’Objective–C 2.0 est une évolution d’Objective–C, publiée par Apple avec Mac OS 10.5. Quelques mots-clefs et fonctionnalités ont alors
été rajoutés au langage. Puis, Mac OS 10.6 et iOS 5 ont permis d’exploiter encore des nouveautés, dont l’originalité est d’avoir été
introduites non par une évolution du langage, mais par le compilateur et le runtime.
Ces ajouts sont précisés au long des chapitres de ce livre, et résumés dans le chapitre 13 « Les évolutions d’Objective–C : performances et
extensions du langage ».
Actuellement, aucun Objective–C 3.0 ne semble prévu, mais cela n’a pas grande importance, puisque les évolutions, telles les plus récentes à
ce jour, ont lieu indépendamment du langage.
Objective–C et ses API (Cocoa…) : les racines non Unix de Mac OS X
Une première précision me semble indispensable : il est courant de voir une confusion entre Objective–C et Cocoa. Soyons précis :
Objective–C est un langage alors que Cocoa est une API (Application Programming Interface), c’est-à-dire un ensemble de classes
permettant de programmer de façon native sous Mac OS X et iOS.
En réalité, Cocoa est l’implémentation par Apple, pour Mac OS X, du standard OpenStep publié par NeXT Computer en 1994. Cela n’a rien
d’étonnant puisque Mac OS X est né du rachat des technologies NeXT. Cocoa est donc une bibliothèque de développement d’applications
basée sur Objective–C.
Apple est actuellement le seul acteur majeur à promouvoir l’Objective–C. Il n’y a donc que peu d’homologues à Cocoa. On peut citer
GNUStep et Cocotron, deux autres implémentations, libres… non pas d’OpenStep, cette fois, mais de Cocoa ! Cette dernière est en effet