Objective-C ! Programmez en - data.brains-master.com · En 1979, Bjarne Stroustrup développe le C++, qui ajoute la POO au C. La création de l'Objective-C intervient un peu plus

Programmez enObjective-C !

Par prs513rosewood

www.openclassrooms.com

Licence Creative Commons 6 2.0Dernire mise jour le 25/07/2011

http://www.openclassrooms.com

Sommaire

2Sommaire ........................................................................................................................................... 2Partager .............................................................................................................................................. 4 Programmez en Objective-C ! ............................................................................................................ 5Partie 1 : Les principes de base .......................................................................................................... 5Introduction l'Objective-C ............................................................................................................................................... 5Historique .................................................................................................................................................................................................................... 5Cration ....................................................................................................................................................................................................................... 5Dveloppement ........................................................................................................................................................................................................... 6Objective-C 2.0 ............................................................................................................................................................................................................ 6Comment a marche ? ................................................................................................................................................................................................ 6Dfinition ..................................................................................................................................................................................................................... 7Organisation du code .................................................................................................................................................................................................. 7Quels logiciels ? .......................................................................................................................................................................................................... 7O se documenter ? .................................................................................................................................................................................................... 7Comment faire ? .......................................................................................................................................................................................................... 7Installation ................................................................................................................................................................................................................... 7Compilation .................................................................................................................................................................................................................

11 l'assaut de l'Objective-C ............................................................................................................................................... 11Pour commencer... .................................................................................................................................................................................................... 13Les objets et l'Objective-C ......................................................................................................................................................................................... 13Les objets .................................................................................................................................................................................................................. 17NSString .................................................................................................................................................................................................................... 17NSString ....................................................................................................................................................................................................................

19Les classes ...................................................................................................................................................................... 20Explications ............................................................................................................................................................................................................... 20Les classes, plan de fabrication ................................................................................................................................................................................ 22L'interface .................................................................................................................................................................................................................. 22Les mthodes ............................................................................................................................................................................................................ 23Les conventions ........................................................................................................................................................................................................ 23Nommer une mthode .............................................................................................................................................................................................. 23Les mthodes d'initialisation ..................................................................................................................................................................................... 24Implmentation des mthodes .................................................................................................................................................................................. 25Les accesseurs .........................................................................................................................................................................................................

27L'hritage ......................................................................................................................................................................... 28Une histoire de famille... ............................................................................................................................................................................................ 30Comment faire hriter ............................................................................................................................................................................................... 30Les protocoles ........................................................................................................................................................................................................... 30La problmatique de la conformit ............................................................................................................................................................................ 31Appliquer un protocole .............................................................................................................................................................................................. 32Crer un protocole .....................................................................................................................................................................................................

33Grer la mmoire ............................................................................................................................................................ 33Retain count et autres joyeusets ............................................................................................................................................................................. 33Compter les utilisations ............................................................................................................................................................................................. 33Copier et assigner ..................................................................................................................................................................................................... 36Crer un objet avec un autre ..................................................................................................................................................................................... 36Librer la mmoire .................................................................................................................................................................................................... 37Possession d'objets ................................................................................................................................................................................................... 38Mmoire automatique ................................................................................................................................................................................................

40TP : Jeu de combat (RPG) .............................................................................................................................................. 41Prliminaires ............................................................................................................................................................................................................. 41Astuce bien pratique ................................................................................................................................................................................................. 42La solution .................................................................................................................................................................................................................

48Partie 2 : Le framework Foundation .................................................................................................. 48Les tableaux .................................................................................................................................................................... 48Crer un tableau ........................................................................................................................................................................................................ 48Initialiser un NSArray ................................................................................................................................................................................................. 49Les mthodes courantes ........................................................................................................................................................................................... 50Le tableau qui change : NSMutableArray .................................................................................................................................................................. 51La mmoire avec NSArray ........................................................................................................................................................................................ 52En bonus ................................................................................................................................................................................................................... 53Exercices ...................................................................................................................................................................................................................

53Donnes sans ordre ........................................................................................................................................................ 54Principe du dictionnaire ............................................................................................................................................................................................. 54Manipuler un dictionnaire .......................................................................................................................................................................................... 55Manipuler les couples ................................................................................................................................................................................................ 57Les ensembles ..........................................................................................................................................................................................................

59Les fichiers ...................................................................................................................................................................... 59Reprsentation d'un chemin ...................................................................................................................................................................................... 59Un chemin comme une chane de caractres ........................................................................................................................................................... 60La classe NSURL ...................................................................................................................................................................................................... 61Lire et crire du texte ................................................................................................................................................................................................. 64crire dans un fichier ................................................................................................................................................................................................ 65Enregistrer un objet, la thorie ..................................................................................................................................................................................

2/92


http://fr.openclassrooms.com

65Le protocole NSCoding ............................................................................................................................................................................................. 69Archiver des objets dans un fichier ........................................................................................................................................................................... 72Dsarchiver des objets ..............................................................................................................................................................................................

75Partie 3 : Cocoa dans son ensemble ................................................................................................ 75Prsentation de Cocoa et de ses outils .......................................................................................................................... 76Cocoa, un framework complet .................................................................................................................................................................................. 76Le code en dur .......................................................................................................................................................................................................... 79Une interface graphique lgre ................................................................................................................................................................................. 80Une interface la souris ...........................................................................................................................................................................................

81Une interface graphique .................................................................................................................................................. 82Un modle d'organisation du code : le MVC ............................................................................................................................................................. 82Cration du projet et de l'interface ............................................................................................................................................................................ 85Faire dialoguer les objets entre eux : outlets et actions ............................................................................................................................................ 85Un peu de thorie ...................................................................................................................................................................................................... 86La mise en place dans notre application ................................................................................................................................................................... 89dition du code .........................................................................................................................................................................................................

Sommaire 3/92



Programmez en Objective-C !

Par prs513rosewood

Mise jour : 25/07/2011Difficult : Intermdiaire Dure d'tude : 20 jours

C'est quoi, l'Objective-C ?

L'Objective-C est un langage de programmation compil, multi-plates-formes, libre et orient objet.

C'est un langage assez puissant, bas sur le C. C'est en fait du C auquel on a ajout de l'orient objet, un peu comme le C++.

Ce tutoriel propose un apprentissage de l'Objective-C et de la programmation oriente objet dans ce langage. La premire partiedonne les bases du langage, et la seconde propose d'aborder des concepts plus avancs de l'Objective-C, ainsi que divers objetsde la bibliothque Foundation. Enfin, la troisime partie s'inscrit dans le schma des tutoriels de ce site et propose de mettreen application les connaissances acquises avec la bibliothque Cocoa (qui contient aussi son lot de concepts propres).

Je vous recommande galement la lecture du tutoriel de Tchouk! : Dvelopper sous OS X avec Cocoa, qui propose une approchediffrente des sujets traits dans ce tutoriel.

Avant de commencer, soyez sr d'tre au point sur vos connaissances en C, donc d'avoir lu au moins les parties I et IIdu tutoriel C. L'Objective-C tant grandement inspir de ce langage, vous ne serez pas dpays.

Et si on commenait ?

Sommaire 4/92


http://www.v3.siteduzero.com/membres-294-72901.htmlhttp://www.v3.siteduzero.com/tutoriel-21-200557-programmez-en-objective-c.htmlhttp://creativecommons.org/licenses/by-nc-sa/2.0/fr/http://www.siteduzero.com/membres-294-186432.htmlhttp://www.siteduzero.com/tutoriel-3-176943-developper-sous-os-x-avec-cocoa.htmlhttp://www.siteduzero.com/tuto-3-8-0-apprenez-a-programmer-en-c.htmlhttp://www4.smartadserver.com/call/pubjumpi/24617/166249/13290/M/1389182833326/?http://www4.smartadserver.com/call/pubjumpi/24617/166249/13290/M/1389182833326/?http://fr.openclassrooms.com

Brad Cox

Logo de NeXT

Partie 1 : Les principes de base

C'est par ici qu'on commence. Cette partie a pour but de vous familiariser avec les concepts de l'Objective-C, et de vousapprendre l'utiliser de la meilleure faon.

Introduction l'Objective-CPour commencer ce tutoriel, je vous propose une introduction plutt riche l'Objective-C. Comme tous les langages, l'Objective-C a une histoire particulire derrire lui. En effet, il a t influenc par plusieurs langages de programmation, qui lui ont chacunapport diffrents aspects.

Je parlerai galement des volutions du langage, qui n'est certainement pas rest sans dveloppement depuis sa cration.Certaines entreprises, qui mritent d'tre cites pour leur contribution l'volution de l'Objective-C, ont eu une grande influencesur la diffusion du langage et son utilisation dans certains projets.

HistoriqueCration

Il faut dj situer le langage dans son contexte historique. Vers la fin des annes 70, l'informatique estmarque par l'effervescence autour du systme d'exploitation UNIX et par le langage de programmation C,cr par Dennis Ritchie. Le C est la base d'UNIX ; c'tait un langage de programmation trs utilis l'poque.Mais comme tout langage, le C a ses limites. Vous devez srement savoir que le C ne propose pas demoyens clairs pour faire de l'orient objet. Lorsque les programmeurs ont pens faire voluer le C, c'taitpour favoriser l'criture de gros programmes, qui devenaient complexes et peu efficaces en C. Pour la plupartdes programmeurs, la programmation oriente objet offrait une solution ce problme.

En 1979, Bjarne Stroustrup dveloppe le C++, qui ajoute la POO au C. La cration de l'Objective-C intervientun peu plus tard. C'est l'amricain Brad Cox qui cre l'Objective-C au dbut des annes 80. Comme le C++ cette poque, il a pourobjectif de rajouter des classes au langage C. Pour cela, Cox s'appuie sur un autre langage, le Smalltalk-80, qui est un langageorient objet cr au dbut des annes 70. On peut donc dire que l'Objective-C a principalement t cr partir du langage C etdu Smalltalk.

Dveloppement

Brad Cox fit de son langage un langage libre, dont tout le monde peut analyser les standards et lesrutiliser. La premire entreprise utiliser l'Objective-C dans l'un de ses projets fut NeXT, qui vendaitdes systmes d'exploitation et du matriel informatique en visant un public universitaire. Le systmed'exploitation en question s'appelait NeXTStep, et tait crit en Objective-C. Ce systme taitgalement bas sur un environnement BSD, ce qui en fait un systme UNIX-like. La socit NeXT, la suite de problmes financiers, se spcialisa dans la vente du systme NeXTStep et arrta defabriquer des ordinateurs. On pourrait citer diffrentes crations faites sur un ordinateur NeXT :l'invention du Web par Tim Berners-Lee, ainsi que le dveloppement de Doom et de Wolfenstein 3Dpar John Carmack. Les avantages de NeXTStep taient nombreux : une API trs performante et oriente objet, un bonenvironnement de dveloppement, ainsi qu'une base UNIX. Mais la firme NeXT, cre par Steve Jobs la suite de son dpartd'Apple, aprs onze ans d'activit, a t rachete par cette dernire en 1996. Cela donna un nouveau souffle pour Apple, quidveloppa un nouveau systme d'exploitation pour les Macintosh bas sur NeXTStep. Aujourd'hui, NeXTStep est abandonn,mais les standards du systme sont toujours prsents dans les frameworks Cocoa et GNUstep.

Mac OS X

Mac OS X est un systme d'exploitation dvelopp par Apple. Il est bas, comme NeXTStep, sur BSD. C'est un systmepropritaire, bien que le noyau et la structure interne du systme soient libres. Mac OS X dispose de plusieurs API pour ledveloppement d'applications : Carbon (en), qui est l'API des versions de Mac OS antrieures Mac OS X. Elle possde uneinterface C(++), et a t conserve pour des raisons de compatibilit. La seconde API est Cocoa, qui, arrive avec Mac OS X, estbase sur le framework de NeXTStep (donc crite en Objective-C). Elle possde une interface Objective-C, ce qui signifie quel'Objective-C est le langage d'utilisation de Cocoa (on peut aussi l'utiliser en Python et en Perl). Il est d'ailleurs aujourd'huifortement recommand de dvelopper des applications avec Cocoa sous Mac.

OPENSTEP et GNUstep

Programmez en Objective-C ! 5/92


http://www.v3.siteduzero.com/uploads/fr/files/185001_186000/185782.pnghttp://fr.wikipedia.org/wiki/C_%28langage%29http://fr.wikipedia.org/wiki/C%2B%2Bhttp://fr.wikipedia.org/wiki/Objective_Chttp://fr.wikipedia.org/wiki/Smalltalkhttp://fr.wikipedia.org/wiki/NeXThttp://fr.wikipedia.org/wiki/NeXTSTEPhttp://fr.wikipedia.org/wiki/Berkeley_Software_Distributionhttp://fr.wikipedia.org/wiki/Cocoa_%28Apple%29http://fr.wikipedia.org/wiki/GNUstephttp://fr.wikipedia.org/wiki/Mac_OS_Xhttp://en.wikipedia.org/wiki/Carbon_%28API%29http://fr.wikipedia.org/wiki/Cocoa_%28Apple%29http://fr.wikipedia.org/wiki/Python_%28langage%29http://fr.wikipedia.org/wiki/Perl_%28langage%29http://fr.openclassrooms.com

Image utilisateurGNUstep

Vers la fin de sa vie, NeXT a dvelopp, en partenariat avec Sun Microsystems, une srie de standards pour des frameworksorients objet, appels OpenStep (en). La principale implmentation de ces standards est l'API OPENSTEP. C'est unebibliothque qui reprend l'API de NeXTStep, mais elle est libre, contrairement NeXTStep. OPENSTEP fonctionnait sur Mac OS,sur Solaris et mme sur Windows NT (note : Mac OS X ne rentre pas aujourd'hui dans les standards OpenStep).

GNUstep, quant lui, est une autre implmentation des standards OpenStep, bien que sa crationremonte avant celle des standards. C'est un projet libre qui vise offrir une implmentation accessible,d'abord de l'API de NeXTStep, puis de l'API Cocoa (on pourrait le comparer Mono par rapport

.NET). Mais en plus de fournir une API, GNUstep propose aussi des outils de dveloppement, ainsi que leurs propresamliorations de Cocoa.

Aujourd'hui, Cocoa et GNUstep sont les principales implmentations (ou volutions) des standards OpenStep, et pour ainsi direles deux seules bibliothques crites en Objective-C et utilisables dans ce langage.

Objective-C 2.0

En 2007, l'occasion de la sortie de Mac OS X v10.5 (dit Leopard), Apple a propos une mise jour des standards de l'Objective-C. La firme a dvelopp de nouveaux outils de gestion de mmoire dynamique, regroups dans un systme nomm garbagecollector (ramasse-miettes), qui simplifie et rend le code Objective-C plus performant. Il y a eu aussi quelques modifications desyntaxe, ainsi que des ajouts de mots-cls, qui simplifient la programmation des objets.

Au dbut de ce tutoriel, nous n'aborderons pas l'Objective-C 2.0. Bien que celui-ci soit totalement compatible avec l'Objective-Cclassique, nous apprendrons grer la mmoire avec le systme classique , et utiliserons la syntaxe normale (les ajouts del'Objective-C 2.0 dans ce domaine sont quand mme mineurs ).

Comment a marche ?Dfinition

Voici la dfinition de l'Objective-C dans son article Wikipdia franais :

Citation : Wikipdia - Objective-C

L'Objective-C est un langage de programmation orient objet rflexif. C'est une extension du C ANSI, comme le C++, mais quise distingue de ce dernier par sa distribution dynamique des messages, son faible typage, son typage dynamique et sonchargement dynamique.

Je vais expliquer point par point cette dfinition.

Je l'ai rpt plusieurs fois, l'Objective-C est un langage orient objet. a veut dire qu'il intgre (presque) toutes les notions dePOO existantes. La POO est donc une trs grosse partie du langage. Nous l'aborderons d'ailleurs dans le prochain chapitre.

L'Objective-C est un langage rflexif . Cela veut dire qu'il a une capacit se modifier l'excution. Par exemple : imaginez qu'enC, vous criez une variable vie de type int. Une fois le code compil, impossible de changer ces informations, n'est-ce pas ?Eh bien, la rflexivit le permet : on peut dfinir le type d'une variable en fonction d'une chane de caractres par exemple. Engros, le type d'une variable peut changer l'excution, cela dpend souvent des actions de l'utilisateur. La rflexivit est unenotion un peu avance, que l'on ne verra pas avant un petit moment.

L'Objective-C est une extension du C. Cela veut dire que l'Objective-C se construit autour des mcanismes du C ; il hrite doncde sa syntaxe. Mais l'Objective-C est une stricte surcouche du C. Cela veut dire que n'importe quel code crit en C est compilablepar un compilateur Objective-C. Il n'y a aucune incompatibilit entre le C et l'Objective-C, contrairement au C++.

L'Objective-C utilise un systme de messages : c'est la cl de vote de l'Objective-C. C'est une partie du langage qui est hritede Smalltalk. Les messages servent principalement la POO, nous en verrons dans le prochain chapitre.

L'Objective-C possde un typage dynamique et faible : le type d'une variable est dfini l'excution, et il peut changer en coursde route. Pour plus d'informations sur le typage, je vous conseille ce tutoriel : Le typage : prsentation thmatique et historique.

L'Objective-C possde un systme de chargement dynamique. a ne veut pas dire grand-chose comme a, mais en ralit,l'Objective-C s'excute dans un runtime, la manire de Java. Il y a donc une machine virtuelle qui se charge de distribuer lesmessages , de crer les objets et les classes, d'valuer le type des variables, etc. En revanche, il n'y a pas besoin d'installer unemachine comme Java, et elle est beaucoup plus lgre que celle de Java.

Partie 1 : Les principes de base 6/92


http://en.wikipedia.org/wiki/OpenStephttp://fr.wikipedia.org/wiki/GNUstephttp://fr.wikipedia.org/wiki/Mac_OS_X_v10.5http://www.siteduzero.com/tutoriel-3-37366-le-typage-presentation-thematique-et-historique.htmlhttp://fr.openclassrooms.com

Il se peut (c'est mme fortement probable) que vous ne compreniez que peu ces dfinitions. Ne vous en faites pas, nousaborderons chacun de ces points en temps voulu.

Organisation du code

Tout comme un fichier de code C, l'Objective-C attribue sa propre extension un fichier de code Objective-C. Par exemple :un_fichier.m (l'extension est donc m ). Les fichiers headers, en revanche, ne changent pas leur extension : on a toujours lefichier .h .Il y a aussi des conventions d'organisation du code pour les objets, mais nous verrons cela plus tard.

Quels logiciels ?

Comme d'habitude : un diteur de texte, un compilateur et un dbogueur. Il n'y a aucun des trois qui soit spcifique l'Objective-C, sauf peut-tre le compilateur : GCC est le plus rpandu pour l'Objective-C. Il y a galement des IDE disponibles pourl'Objective-C : sous Mac, le plus adapt est Xcode. C'est un IDE fourni avec Mac OS X. Sous GNU/Linux, il y aProjectCenter.app, qui fait partie du projet GNUstep. Nous verrons galement deux logiciels pour dvelopper des interfacesgraphiques : Interface Builder sous Mac OS X et Gorm.app avec GNUstep.

O se documenter ?

Nous utiliserons beaucoup des objets du framework Foundation. C'est une collection d'objets qui sont indispensables au bonfonctionnement de l'Objective-C. La documentation officielle d'Apple se trouve sur leur site :http://developer.apple.com/mac/library [...] ic/index.html. La documentation officielle de GNUstep se trouve sur leur wiki :http://wiki.gnustep.org/index.php/Foundation ; elle est en revanche fortement incomplte.Il y a dans ces documents la liste de tous les objets disponibles, ainsi que leur usage, etc. Vous n'aurez dans un premier tempspas besoin de la documentation, mais gardez-la toujours porte de main, c'est le bien le plus prcieux du programmeur.

Comment faire ?Installation

L'Objective-C est un langage multi plates-formes, bien que certains le cantonnent Mac OS X et Cocoa. GNUstep estfonctionnel sur les trois systmes d'exploitation majeurs : GNU/Linux, Mac OS X et (oh surprise ) Windows. Sur Mac OS X,par contre, il n'y a pas besoin d'installation supplmentaire : les Xcode tools contiennent tous les logiciels qu'il faut pourdvelopper des applications. Sous GNU/Linux, il faudra installer GCC pour pouvoir compiler du code Objective-C, et GNUsteppour avoir les bibliothques spcifiques au langage et les outils de dveloppement. Pour cela, il vous faudra installer les paquetsgnustep et gnustep-devel. Sous Windows, la procdure est dcrite sur cette page. Je ne sais pas en revanche si la man?uvre estfiable.

Compilation

En thorie, GCC peut compiler de l'Objective-C sans poser de problme, avec l'option -x objective-c. En revanche, pourpouvoir profiter de tous les outils fournis par GNUstep et Cocoa, il faut linker avec les bibliothques, c'est--dire les inclure dans le programme. Sur Mac OS X, Xcode fait cela automatiquement. Pour crer un nouveau projet en Objective-C, il faut choisirle Foundation Tool dans la liste des projets disponibles.



http://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/ObjC_classic/index.htmlhttp://wiki.gnustep.org/index.php/Foundationhttp://www.gnustep.org/experience/Windows.htmlhttp://fr.openclassrooms.com

La compilation se fait par l'habituel bouton Build de Xcode.

L'IDE principal avec GNUstep se nomme ProjectCenter.app. Une fois GNUstep install avec les outils de dveloppement, lancezProjectCenter.app avec la commande suivante :

Code : Console

openapp ProjectCenter.app

Cette technique est la seule faon valable de lancer des applications GNUstep. Le problme, c'est que le processus deProjectCenter restera li au terminal que vous utilisez. Pour contourner le problme, utilisez la commande nohup :nohup openapp ProjectCenter.app >/dev/null 2>&1 &

Dans le menu en haut gauche, slectionnez Project > New pour crer un nouveau projet.Dans la fentre qui s'ouvre, choisissez un emplacement pour votre projet, ainsi qu'un nom et un type.




Pour le moment, slectionnez le type Tool dans le menu droulant.

Pour compiler le projet, cliquez sur l'icne du tournevis rouge, ce qui ouvre la fentre de compilation. Pour compiler, cliquez nouveau sur le bouton du tournevis, cette fois dans la fentre de compilation.

Pour excuter le programme, cliquez, dans la fentre du projet, sur le bouton avec une fuse. Cela ouvre la fentre d'excution.Pour lancer le programme, cliquez nouveau sur l'icne de la fuse. Dans le cadre blanc qui se trouve dessous, vous avez lasortie du programme (ce qu'il affiche).

Pour l'instant, contrairement la capture d'cran, ce cadre n'affiche rien. Le projet Tool ne se compose que d'un seul fichier de code : main.m. C'est ce fichier que l'on va diter dans un premier temps, auprochain chapitre.Voil, j'espre que ce premier chapitre vous a plu. En tout cas, vous savez prsent ce qu'est l'Objective-C, d'o il vient et quoiil sert. Tout au long du tutoriel, je reviendrai galement sur Mac OS X et GNUstep, qui sont deux acteurs majeurs de l'Objective-C.



http://www.v3.siteduzero.com/uploads/fr/files/188001_189000/188247.pnghttp://fr.openclassrooms.com

Bon, jusqu' prsent, l'Objective-C c'tait piece of pie, piece of cake . Et si on attaquait le code ?




l'assaut de l'Objective-CL'Objective-C (souvent abrg ObjC ) est un langage trs intressant qui offre des possibilits immenses, pour peu que voussachiez vous en servir.

L'approche est assez droutante, c'est pourquoi je vais commencer par des choses simples pour ce chapitre. Nous dcouvrironsles diffrences entre le C et l'Objective-C, ainsi que le fonctionnement des objets, dont on verra les dtails dans d'autreschapitres. Les connaissances acquises dans ce premier chapitre seront utiles tout au long du tutoriel, et vous permettront desurvivre quand on attaquera les objets du framework Foundation.

Pour commencer...Nous avons vu dans le chapitre prcdent comment crer un nouveau projet (avec Xcode ou ProjectCenter.app). Chacun de cesprojets se base sur un unique (pour le moment) fichier de code source Objective-C. Il porte l'extension *.m.

Pour commencer, voyons le contenu de ce fichier :

Code : Objective-C

#import

int main (int argc, const char * argv[]){ NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

// insert code here... NSLog(@"Hello, World!"); [pool drain]; return 0;}

Le code par dfaut peut changer selon les IDE. Ce code est issu de Xcode. Il est similaire celui de PC.app, mais par soucid'exactitude et de cohrence, je demanderai aux utilisateurs de PC.app de prendre ce code la place.

L'Objective-C est assez similaire au C ?! C'tait une blague ? Il n'y a que des crochets partout !!!

En effet, c'est assez droutant au premier abord, mais on se fait vite aux crochets, d'autant plus que c'est le point de pivot del'Objective-C.

Pas pas

On va commencer en douceur et voir ce code ligne par ligne.

Code : Objective-C

#import

Cela est une directive de prprocesseur. Vous devez dj savoir ce que c'est. La seule nouveaut est la directive #import ; elleest trs similaire #include, ceci prs : elle empche les inclusions infinies, vous n'avez donc plus besoin de protger lesheaders avec l'ternel #ifndef. Cette ligne inclut le fichier Foundation.h du framework Foundation . Le frameworkFoundation contient tous les objets ncessaires au bon fonctionnement de l'Objective-C. Il ne sert pas crer de GUI.

Code : Objective-C

int main (int argc, const char * argv[])

Cette ligne ne devrait pas tre nouvelle pour vous, part peut-tre le const devant le char, qui n'affecte pas grand-chose :c'est une question de got.




Code : Objective-C

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

Ne vous proccupez pas de cette ligne pour le moment, on l'abordera plus tard.

Code : Objective-C

NSLog(@"Hello, World!");

Cette ligne, vous l'aurez devin, affiche Hello, World! dans la console ; mais pas seulement : elle affiche galement lesinformations spcifiques votre programme, comme la date, le PID de votre processus, etc. Elle sert principalement crire dansles fichiers *.log et ainsi tracer les bogues, mais elle est trs peu utilise pour les utilitaires en console, tels que le FoundationTool. Le symbole arobase (@) devant la chane de caractres indique que c'est une chane d'Objective-C, et non une chane C.Exemple :

Code : Objective-C

@"Bonjour !" // Ceci est une chane ObjC"Salut !" // Ceci est une chane C

En Objective-C, on peut bien sr mlanger les deux, mais il est prfrable de prendre l'habitude de travailler avec des chanesObjective-C. La plupart des fonctions que vous allez utiliser vont attendre une chane Objective-C.

Code : Objective-C

[pool drain];

Ceci est un message, pour les plus curieux. On verra plus tard ce qu'ils signifient.

Code : Objective-C

return 0;

Sans commentaire ?

Nouveauts

prsent, je vais expliquer quelques nouveaux points de l'Objective-C par rapport au C. Tout comme le C++, l'Objective-C faitquelques ajouts au langage C pour faciliter son utilisation. Voyons d'abord le type BOOL.

BOOL est un type de boolen. Comme il en manquait un au C (bien qu'on n'en ait pas vraiment besoin), les crateurs del'Objective-C ont dcid de le rajouter. Une variable de type BOOL se dclare comme n'importe quelle autre variable ; exemple :

Code : Objective-C

BOOL estRouge;

Un BOOL ne peut, comme tout bon boolen, avoir que deux valeurs : YES et NO.

Code : Objective-C

BOOL estRouge = YES;




estRouge = NO;

if (estRouge) //...else if (!estRouge) //...

Vous avez compris le principe. En fait, il n'y a pas tellement de diffrences entre le C et l'Objective-C tant qu'on ne touche pas l'orient objet. On peut voir l'apparition d'un autre type de variables : id. Nous l'aborderons dans la partie suivante, qui sera djplus avance en terme de diffrences.

Les objets et l'Objective-CC'est dans cette partie que l'on apprendra dchiffrer puis comprendre le code orient objet que nous avons vu dans l'extrait au-dessus.

Les objets

Je vous rabats les oreilles avec la programmation oriente objet et les objets depuis tout l'heure, il serait donc temps de mettreles choses au clair. Commenons par voir un peu ce qu'est la programmation oriente objet. Pour faire simple, c'est une faon deprogrammer qui utilise des objets. Les objets sont un type de variables, comme un int. videmment, ce n'est pas aussi simpleque a ; je vais expliquer ce qu'est un objet tout de suite, pour viter les confusions.

Vous vous souvenez des structures, ces variables composes de sous-variables ? Voici un exemple pour vous rafrachir lammoire :

Code : Objective-C

struct Personne{ char * adresse; char * nom; int age;};

On peut accder aux sous-variables par le point (.), comme ceci :

Code : Objective-C

struct Personne monVoisin;monVoisin.age = 34;

Imaginez un objet comme une structure. Il contient des sous-variables. Mais en plus de ces variables, il contient autre chose(sinon, on utiliserait une structure toute bte) : l'objet peut contenir des fonctions , qui vont servir manipuler les variablesinternes, qui sont l'interface. Les fonctions sont appeles mthodes.

Les objets simplifient les fonctions qui servent manipuler les structures dans une bibliothque comme la SDL. Les fonctionssont intgres la structure.

Voici un schma pour mieux illustrer a :




Le type objet en Objective-C est le type id. On dclare un objet comme ceci :

Code : Objective-C

id unObjet;

Dans cet exemple, unObjet est gnrique et ne fait absolument rien, il n'a aucune caractristique.

Comme je l'ai dit, un objet a aussi des mthodes, fonctions qui agissent sur ses variables internes. Voici comment procder pourappeler la mthode d'un objet :

Code : Objective-C

[unObjet uneMethode];

On dit qu'on envoie un message l'objet. Nous avons vu dans le premier chapitre que c'est le runtime de l'Objective-C quis'occupe des messages, l'excution du programme ; voici comment cela se passe (en version simplifie ) :

La syntaxe d'un message est un peu particulire. Ce qu'il y a entre crochets est le contenu du message, spar en deux parties : gauche, le receveur est l'objet qui va recevoir le message et excuter la mthode appele ; droite, c'est la mthode elle-mme.

Code : Objective-C

[receveur methode];

Un message peut aussi prendre des paramtres :

Code : Objective-C

[receveur methode:parametre];

On a rajout au nom de la mthode deux-points, aussi appels colon en anglais. Notez que ces deux-points font partie du nom dela mthode. Si on veut donner plusieurs paramtres une mthode :

Code : Objective-C

[uneCouleur couleurAvec:234 :192 :0];[uneCouleur couleurAvecRouge:234 vert:192 bleu:0];

Quelle est donc la diffrence entre la premire et la deuxime ? Lorsqu'on a plusieurs paramtres, on ajoute au nom de la fonctiondes labels. Ils servent sparer les diffrents paramtres. Un label se compose de : et de texte, comme dans le second exemple.L'avantage de rajouter du texte, c'est la diffrenciation des paramtres. Dans la premire ligne, on ne peut savoir dans quel ordreil faut donner les paramtres, ni mme quels paramtres donner. Dans la deuxime, la mthode nous dit clairement ce qu'il fautenvoyer. Le nom de la mthode est aussi diffrent. Dans le premier cas, le slecteur (le nom de la mthode) estcouleurAvec:::, dans le second cas il est couleurAvecRouge:vert:bleu:. Cela peut paratre un peu lourd aupremier abord, mais a vite beaucoup de prises de tte avec des fonctions qui prennent douze arguments et des allers et retoursdans la documentation.




prsent, nous allons tudier un petit bout de code :

Code : Objective-C

id unObjet = nil;[unObjet uneMethode];

unObjet est de type id, c'est--dire un objet gnrique. En ralit, unObjet est un pointeur. Tous les objets en Objective-Csont des pointeurs. Ici, on met la valeur du pointeur nil, qui est un quivalent de NULL, mais pour les objets. Ensuite, onenvoie un message unObjet, qui lui dit d'excuter la mthode uneMethode.

Mais si l'objet est initialis avec nil, c'est autoris de lui envoyer un message ?

Oui, on peut parfaitement le faire. Un objet qui a pour valeur nil peut recevoir toutes sortes de messages. videmment, il neragira pas, puisque ce n'est pas un objet spcifique.

Il existe plusieurs types d'objets. Par exemple, vous utilisez dans un programme des objets qui reprsentent des formes dessines l'cran. Mettons un carr dans votre dessin. Il faut donc un pointeur (qui nous servira d'objet) de type Carre. Ensuite, il fautinitialiser ce pointeur, c'est--dire allouer la mmoire pour les variables internes et les mthodes.

Code : Objective-C

id uneForme = [Carre alloc];

On excute donc la mthode alloc de l'objet Carre. C'est un objet assez spcial dont nous aurons l'occasion de reparler plustard. Sachez seulement que c'est un objet constructeur : il construit l'objet dont nous avons besoin en suivant un plan, uneprocdure. La mthode alloc alloue la mmoire pour les variables et les mthodes. Elle retourne un objet de type id, qui atoutes les caractristiques d'un Carre. Le problme, c'est qu'elle n'initialise pas les variables. a, c'est le rle de la mthodeinit de notre objet allou :

Code : Objective-C

[uneForme init];

Elle retourne un id. Pour rendre la syntaxe moins charge, on peut combiner les deux messages :

Code : Objective-C

id uneForme = [[Carre alloc] init];

Dans les deux mthodes qui s'enchanent (alloc -> init), Carre est le premier receveur. Le receveur du message init estl'objet retourn par [Carre alloc]. Le tout est stock dans le pointeur uneForme de type id. Notre objet est donc prt tre utilis. Vous aurez peut-tre remarqu qu'on ne donne aucune valeur pour les dimensions du carr. Cela aurait pu se fairecomme ceci :

Code : Objective-C

id uneForme = [[Carre alloc] initAvecDimension:4];

On appelle la mthode initAvecDimension pour donner une longueur aux cts du carr. On peut prsent faire toutessortes de choses :

Code : Objective-C




[uneForme positionnerEnX:12 y:23];[uneForme rotation:45];// etc.

Pour se dbarrasser de uneForme, il faut librer la mmoire avec la mthode release :

Code : Objective-C

[uneForme release];uneForme = nil;

Notez que la deuxime ligne n'est pas obligatoire. Elle n'est utile que dans le cas des objets de type id, si on veut les rutiliser.Ce code, par exemple, est parfaitement valide :

Code : Objective-C

id uneForme = [[Carre alloc] initAvecDimension:4];[uneForme release];uneForme = nil;uneForme = [[Cercle alloc] init];

Quoi ? Il est possible de changer le type d'un objet en cours d'excution ?

Oui, cela s'appelle le typage dynamique. Comme id est un objet gnrique (dont on ne connat pas le type exact), il peut devenirn'importe quel objet. On ne peut connatre son type qu' l'excution. Pour parer cela, il faut donner un type spcifique notre pointeur.

Code : Objective-C

Carre * unCarre = [[Carre alloc] init];

Attention, cette fois on met l'toile du pointeur. Quand on cre un objet de type id, elle est implicite. prsent, unCarre estde type Carre et ne peut tre chang en un autre type. Il peut prendre la valeur nil, ce n'est pas interdit.

Reprenons le code du Hello, World! :

Code : Objective-C

#import

int main (int argc, const char * argv[]){NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

// insert code here... NSLog(@"Hello, World!");[pool drain]; return 0;}

Vous devriez comprendre les lignes surlignes.

Mais l'objet pool n'est pas libr, o est le [pool release] ?




En fait, la mthode drain de pool libre la mmoire que prenait pool, en plus de remplir la fonction principale d'unNSAutoreleasePool, que l'on abordera plus tard.

prsent, voyons un peu la pratique.

NSStringMaintenant que vous savez vous servir des objets en Objective-C, nous allons voir un objet cl du framework Foundation :NSString.

NSString

Vous l'avez devin, NSString est un objet qui gre des chanes de caractres. On pourrait le comparer string en C++, quelques grosses diffrences prs.

NSString n'chappe pas la rgle, voici comment crer une NSString :

Code : Objective-C

id chaine = [[NSString alloc] init];

Le problme, c'est que NSString est dfini comme un objet immuable. Cela veut dire qu'une fois la chane grave dansl'objet, on ne peut la changer. Donc si on l'initialise de cette faon, l'objet sera inutile car il ne contiendra pas de chane. Pourl'initialiser avec une chane, il faut utiliser la mthode initWithUTF8String:. Le nom de cette mthode peut paratre bizarre: pourquoi donc UTF-8 ? Une petite explication s'impose.

Les chanes de caractres

Le systme des chanes de caractres en Objective-C n'est pas le mme que celui du C. L'Objective-C utilise des symbolesdiffrents autres que les guillemets pour dsigner une chane. Voici deux faons de manipuler une chane, en C et Objective-C,avec deux mthodes similaires : printf() et NSLog().

Code : Objective-C

printf("Voici une chaine de caractres en C.");NSLog(@"Voici une chaine de caractres en Objective-C.");

Notez bien le symbole @, que l'on a d'ailleurs dj vu dans le Hello, World! au mme endroit. Une chane en Objective-C sedlimite comme ceci : @"chaine". Mais j'ai dj parl de a un peu plus haut.

Quel rapport avec la mthode d'initialisation de NSString ?

J'y viens. Quand on excute la mthode initWithUTF8String:, celle-ci attend en paramtre une UTF8String, autrementdit une chane C. Cette mthode, en revanche, n'est pas extrmement utile. En effet, comme en C++, pourquoi utiliser deschar [] quand on peut utiliser des string ? La mthode d'initialisation de NSString qui fait appel aux chanes Objective-C (aux NSString en fait) est initWithString:. Exemple :

Code : Objective-C

NSString * chaineAvecChaineObjC = [[NSString alloc]initWithString:@"Hello World!"]; // ObjC : @"..."NSString * chaineAvecChaineC = [[NSString alloc]initWithUTF8String:"Hello World!"]; // C : "..."

Ces deux syntaxes sont absolument quivalentes, mais je vous conseille vivement d'utiliser la premire, d'autant plus que leschanes que vous manipulerez avec Foundation et Cocoa seront toujours des NSString.

Il ne reste plus qu' librer la mmoire avec release.




Code : Objective-C

[chaine release];

On peut aussi initialiser avec d'autres fonctions. Il y a la mthode de classe stringWithString:. Une mthode de classe estune mthode qui appartient un objet de classe, cet objet usine qui sert construire des objets courants. DoncstringWithString: appartient l'objet de classe NSString. Voici comment on l'utilise :

Code : Objective-C

id chaine = [NSString stringWithString:@"Hello World!"];

La particularit de cette mthode est la gestion de la mmoire. Vous pouvez voir que l'appel la mthode alloc, galementmthode de NSString, a disparu. Plus d'alloc, plus de release. La mmoire est gre automatiquement. La prochainemthode d'initialisation est la plus simple, elle est strictement quivalente celle que nous venons de voir avecstringWithString: :

Code : Objective-C

NSString * chaine = @"Hello World!";

Simple, isn't it ? La gestion de la mmoire est la mme que prcdemment, pas d'alloc, pas de release.

D'autres mthodes

Les NSString sont des objets assez complets, et je vais m'efforcer de faire une liste sommaire des diffrentes mthodesqu'elles proposent.

length : comme son nom l'indique en anglais, cette mthode retourne le nombre de caractres d'une chane.

Code : Objective-C

int nb_caracteres = [chaine length];

characterAtIndex:(int) index : prend en paramtre un entier qui reprsente le numro de la case mmoire ducaractre que l'on veut rcuprer. 0 est l'index de la premire case, comme en C. Attention toutefois, on ne peut pas utiliser lescrochets comme en C ou en C++.

Code : Objective-C

char caractere = chaineC[3];char caractere = [chaineObjC characterAtIndex: 3];

Si on donne en paramtre un index plus grand que la taille de la chane, la mthode envoie une exception. C'est une erreur quipeut tre traite, on verra plus tard de quelle manire.

stringByAppendingString: (NSString *) chaine : prend en paramtre une autre NSString pour l'ajouter lafin de la chane receveuse du message, et retourne une nouvelle chane (rappel : les NSString sont immuables).

Code : Objective-C

NSString * hello = @"Hello, ";NSString * name = @"my name is prs !";NSString * presentation = [hello stringByAppendingString:name];




initWithFormat: (NSString *)format, ... : cette mthode d'initialisation est un peu spciale. Elle fait appel auxformats (rien voir avec les formats de fichiers). Pour les comprendre, je vous propose un bout de code en C :

Code : Objective-C

printf("Nous sommes le %s, il fait %d degrs et je vais au boulot.", date, temperature);

La chane comporte des %s, des %d, qui vont tre remplacs par les valeurs de date et temperature. initWithFormat:fait exactement la mme chose que printf() :

Code : Objective-C

id chaine = [NSString stringWithFormat:@"Bonjour, mon nom est %@ etj'ai %d ans !", nom, age];

Ici, on utilise la mthode de classe stringWithFormat:, mais le rsultat est le mme. Vous remarquerez le %@, qui sert insrer une NSString dans une autre. C'est une sorte de remplacement pour %s. Attention tout de mme, les virgules que l'onmet entre les diffrentes valeurs des symboles de la chane formate ne font pas partie du nom de la fonction. D'ailleurs, dans ladocumentation, initWithFormat: ne comporte pas de virgules. Ne les confondez pas en revanche avec les :, eux sparentdes arguments dfinis dont on connat le type (avec printf(), ceux-ci sont indfinis), et font partie du nom de la fonction.Souvenez-vous de couleurAvecRouge:vert:bleu:.

UTF8String : retourne une chane de type C si jamais vous en avez besoin.

Code : Objective-C

char * chaineC = [chaineObjC UTF8String];

isEqualToString: (NSString *) autreChaine : retourne un boolen qui vaut YES si les chanes sont gales (sielles ont le mme id ou si les caractres sont les mmes dans le mme ordre).

Code : Objective-C

if ( [chaine1 isEqualToString:chaine2] ) // ...

Les fonctions de recherche dans une NSString utilisent des objets et des structures qui n'ont pas d'intrt tre vusmaintenant.

Pour une liste exhaustive des diffrentes fonctions de NSString, allez voir la documentation sur le site d'Apple : NSString.

Pour utiliser une chane de caractres que vous pouvez modifier aprs l'initialisation, utilisez NSMutableString. Les mthodesd'initialisation sont les mmes qu'avec NSString, bien qu'elles n'apparaissent pas dans la documentation.Voici le chapitre termin. (Dj ?!) Mine de rien, vous avez fait un sacr bout de chemin. Dans le prochain chapitre, nous verronscomment crer nos propres objets, qui rpondent des mthodes que nous aurons nous-mmes crites. N'hsitez pas revoir cechapitre, il explique les bases de l'Objective-C qui seront essentielles pour la suite, surtout dans les deux prochains chapitres.



http://developer.apple.com/documentation/Cocoa/Reference/Foundation/Classes/NSString_Class/Reference/NSString.htmlhttp://developer.apple.com/documentation/Cocoa/Reference/Foundation/Classes/NSMutableString_Class/Reference/Reference.htmlhttp://fr.openclassrooms.com

Les classes prsent que vous avez fait vos premiers pas en Objective-C, je vous propose d'entrer dans le vif du sujet et d'attaquer un trsgros morceau du langage, mme si on n'est qu'au dbut du tutoriel (ne vous inquitez pas, j'en garde pour la fin ).

Au menu aujourd'hui : les interfaces , les mthodes , et l'implmentation, le tout sur plusieurs classes (Voiture, Personnage,etc.) qui nous suivront sur quelques chapitres.

ExplicationsOn a beaucoup parl des objets dans le dernier chapitre. Pour rcapituler, un objet est constitu de sous-variables (ou variablesmembres), ainsi que de mthodes.

Un objet rpond un type, c'est--dire que deux objets du mme type possdent les mmes variables et les mmes mthodes. Onpeut donc les comparer. Ils sont galement issus du mme procd de fabrication. Et ils ont tous deux la mme classe. On ditqu'un objet issu d'une classe est une instance de cette classe.

Les classes, plan de fabrication

Une classe dfinit en ralit les variables membres et les mthodes d'un objet. La classe est le squelette d'un objet. Elle donne l'objet diffrentes caractristiques : une interface, ainsi que des mthodes, et bien sr leur implmentation.

L'interface

L'interface, c'est l'ensemble des variables membres. Elle est la mme pour chaque objet d'un type donn. En revanche, la valeurdes variables peut changer en cours d'excution (incrmentation de compteur, changement de NSString, etc.).On pourrait comparer l'interface d'un objet avec une structure C, un seul point prs : les variables sont inaccessibles depuisl'extrieur.

a veut dire quoi exactement ?

Prenons une structure en C toute simple. Une fois une variable cre de type struct QuelqueChose, on peut en modifierles sous-variables :

Code : C

struct QuelqueChose { int foo; double bar;};

/* ... */

struct QuelqueChose machin;machin.foo = 42;machin.bar = 3.1415;

Avec un objet, on ne peut tout simplement pas. En fait, ce n'est pas entirement vrai. Le programmeur ne peut pas modifier lui-mme la valeur des variables membres : c'est l'objet qui va modifier ses propres variables. Le fait que les variables ne soient pasaccessibles depuis l'extrieur de l'objet s'appelle l'encapsulation des donnes.




Comme le montre le schma, on ne peut modifier les variables membres que depuis les mthodes de l'objet. C'est le principe del'encapsulation.

Mais alors, comment fait-on quand on veut modifier les variables la main ?

Une des solutions l'encapsulation est de dfinir des accesseurs. Nous verrons ce qu'ils sont au cours de ce chapitre.

Les mthodes

Le rle d'une classe est galement de dfinir les mthodes d'un objet, ainsi que leur implmentation (rappel : une mthode sedfinit en deux parties, le prototype et l'implmentation).

On distingue deux types de mthodes : les mthodes qui appartiennent un objet, dites mthodes d'instance, et les mthodesqui appartiennent la classe, dites mthodes de classe. Quelle est la diffrence entre les deux ? Les mthodes d'instancerequirent qu'un objet soit cr pour pouvoir tre appeles. Par exemple :

Code : Objective-C

NSMutableString * chaine = @"foo";[chaine setString:@"bar"];

La mthode setString: est une mthode d'instance. On la reconnat galement par le message envoy l'objet : le receveurest le nom de l'objet cr.

La mthode de classe, en revanche, ne requiert pas d'objet cr au pralable :

Code : Objective-C

NSMutableString * chaine = [NSMutableStringstringWithString:@"foo"];

Vous remarquerez que le message n'est pas adress l'objet chaine, mais la classe NSMutableString. La mthode n'a pasbesoin de l'objet chaine, car l'excution de stringWithString, celui-ci n'existe pas encore.

Je suis un peu oblig de mentir pour ne pas compliquer les choses, mais le receveur du message[NSMutableString stringWithString:@"foo"] est un objet-classe. Il peut agir comme un objetquelconque (recevoir des messages), mais il sert principalement construire des objets normaux . Nous enreparlerons dans la rflexivit de l'Objective-C.

S'organiser

En Objective-C, la convention dicte au programmeur de sparer les dclarations d'une classe de l'implmentation des mthodes.Une classe se constitue de deux fichiers : un *.h, qui contient l'interface et les prototypes, et un *.m (compil) qui contiendra




l'implmentation des mthodes.L'interface

Maintenant qu'on a tabli quelques bases, voyons un peu de code (dans un fichier *.h) :

Code : Objective-C

@interface Voiture : NSObject{ int kilometres; int essence;}

@end

On retrouve bien ici le symbole @ qui sert marquer les mots-cls de l'Objective-C. La premire ligne sert dclarer la classeVoiture, qui hrite de NSObject, la classe de base pour tout objet. Contrairement au C++, tous les objets doiventimprativement hriter de NSObject. Cette classe dfinit des variables et des pointeurs ncessaires au bon fonctionnementd'un objet. Nous verrons l'hritage plus en dtail au prochain chapitre.

Les variables membres sont ici kilometres et essence, toutes deux de type int. Un objet, comme une structure C, peutcontenir tout type de variables ainsi que tout type d'objets, mme inconnu, car on peut utiliser id qui, je le rappelle, symboliseun objet gnrique.

Code : Objective-C

@interface Voiture : NSObject{ id moteur; NSArray * passagers;}

@end

Ici, on utilise un objet id dont on ne connat pas le type exact (mais que l'on peut deviner dans cet exemple). On utilise aussi unobjet NSArray, qui est un tableau dynamique, un peu comme std::vector en C++, sauf que le NSArray n'a pas de limiteau niveau du type de l'objet contenu : un objet Voiture peut trs bien se trouver avec un objet Personne ou NSString.

Les mthodesC'est ici que a devient intressant. On va voir prsent comment dfinir les mthodes qui vont agir sur les variables quiconstituent l'interface. Une mthode se dfinit, en Objective-C, diffremment d'une fonction C classique. Comme une fonction, ilfaut noncer le type de la mthode, le nom de la mthode, ainsi que les diffrents paramtres dont elle a besoin. Mais en plus dea, il faut dfinir si une mthode est une mthode de classe ou une mthode d'instance.

Commenons par - init, la mthode d'initialisation.

Code : Objective-C


- (id) init; // Voici la dclaration de - init

@end

Dj, la premire question que l'on se pose est : a veut dire quoi le moins devant la dclaration ? C'est justement pour aque j'ai parl des mthodes de classe. Le symbole - veut dire mthode d'instance . Ainsi, quand je parle de mthodesd'instance, je mets le symbole - devant, pour faire la diffrence.




Mais alors, comment dfinit-on une mthode de classe ?

Avec le symbole +. Voici une mthode de classe :

Code : Objective-C


+ (id) voitureAvecPassagers: (NSArray *) passagers; // Mthode declasse

- (id) init; // Mthode d'objet

@end

Ainsi, si on veut une Voiture initialise avec des passagers, on procdera de cette manire :

Code : Objective-C

Voiture * taxi = [Voiture voitureAvecPassagers:clients];

On appelle bien la mthode de classe. Si on veut une Voiture sans passager, par exemple, on utilisera - init :

Code : Objective-C

Voiture * tacot = [[Voiture alloc] init];

Ici, on appelle la mthode de classe + alloc qui va allouer la mmoire pour chaque variable.Les conventions

videmment, comme dans tout langage de programmation, il y a des conventions respecter pour tre compatible avec les autresobjets et bibliothques. En effet, si vous crez une mthode dans une classe et que vous ne respectez pas les conventions, lesprogrammeurs qui utiliseront votre classe auront du mal en deviner le fonctionnement.

Nommer une mthode

Pour nommer une mthode, on commence toujours par une lettre minuscule : init. chaque nouveau mot ajout au nom de lamthode, on ajoute une majuscule : stringWithString. Pour les labels (texte avant les deux-points), on utilise desminuscules : indexOfObject: inRange: (notez que inRange commence par une minuscule, suivie d'une majuscule pourchaque nouveau mot).

Chaque texte avant un paramtre annonce celui-ci : on sait grce au nom de la mthode ce qu'elle attend. Ainsi, la mthodeindexOfObject: inRange: attend un objet de type id et une structure de type NSRange (attention : ce n'est pas unobjet, mais une structure C classique).

Bien entendu, pour lire et crire des noms de mthode conformes ces rgles (qui ne sont en aucun cas obligatoires), il faut despetites connaissances en anglais (savoir ce qu'est un range par exemple).

Mais il y a galement des mthodes qu'il faut absolument dfinir, et qui reprennent toujours le mme nom.

Les mthodes d'initialisation

On l'a dj rencontre un nombre important de fois (qui va rapidement devenir incalculable) ; la mthode - init estprobablement la plus importante mthode d'un objet : c'est elle qui va initialiser toutes les variables d'un objet. Ce serait leconstructeur si on parlait de C++.




Chaque nouvelle classe que vous crez doit implmenter cette mthode. Si vous ne le faites pas, c'est la mthode d'initialisationde NSObject qui sera appele, et celle-ci ne fait pas grand-chose l'objet que vous voulez dfinir (si on parlait d'uneVoiture, la mthode d'initialisation de NSObject ne ferait que rserver un volume pour la Voiture).

- init doit donc toujours figurer dans une classe. Elle doit galement toujours retourner un objet de type id.

Code : Objective-C

- (id) init;

Comment fait-on si on veut passer des arguments - init ?

C'est l que l'on fait intervenir les labels. Nous avons vu dans le chapitre prcdent que les labels servaient introduire denouveaux paramtres. Voici comment crire le prototype d'une fonction qui comporte des labels et des paramtres :

tout d'abord, on dcide si notre mthode est une mthode de classe ou non (+ ou -). Ensuite, on dfinit le type de lafonction (le type de la valeur de retour) entre parenthses : id, int, NSArray *, etc. On choisit le nom de notremthode selon la convention : ici, pour une mthode d'initialisation, on va crer un objet avec des valeurs ou d'autresobjets. On va utiliser le mot-cl avec , ou with en anglais. Au dbut, je vais crire le nom des mthodes en franais,mais il faudra s'habituer l'anglais, car toutes les mthodes sont crites en anglais dans Cocoa ou Foundation, ainsi quedans la documentation ;on a donc - (id) initAvec. Il faut prsent dcrire le prochain paramtre ; dans le cas de notre voiture, on va direun moteur (pourquoi pas, aprs tout ) : - (id) initAvecMoteur ;on termine le label par deux-points. C'est ici que le paramtre entre en scne. Son type est indiqu entre parenthses (il nefaut pas oublier l'toile dans le cas d'un objet spcifique, NSString * par exemple) : - (id) initAvecMoteur:(Moteur *) moteur ou - (id) initAvecMoteur: (id) moteur ; les deux sont possibles, car id n'estpas un objet spcifique. L'avantage, c'est que l'on peut passer n'importe quel objet, l'inconvnient, c'est qu'on ne peutpas savoir si l'objet donn est un moteur ou non ( la compilation seulement) ;si on a besoin d'un autre paramtre, il suffit de rajouter un label : - (id) initAvecMoteur: (Moteur *)moteur couleur: (NSColor *) couleur; (ne pas oublier le point-virgule).

Implmentation des mthodes

prsent, il faut crire le code de ces fonctions. Une interface se trouve dans un fichier *.h et l'implmentation va, elle, setrouver dans un fichier *.m. Voici le code de base d'une implmentation :

Code : Objective-C

#import "Voiture.h"

@implementation Voiture

- (id) init { // Du code...}

@end

On retrouve bien les mots-cls de l'Objective-C qui commencent par @. Ici, on indique que l'on implmente les mthodes de laclasse Voiture. On va donc voir de plus prs l'implmentation de - init.

Quelques mots-cls

l'intrieur d'une classe, il y a des expressions qui sont trs utiles pour se rfrer l'objet en cours d'utilisation, ou encore saclasse, ou la classe dont il hrite. self est un pointeur qui pointe sur l'objet qui excute la mthode (dans notre cas, uneinstance de Voiture). C'est trs utile quand on veut faire excuter d'autres mthodes un objet pendant l'excution de la




mthode d'initialisation. Par exemple :

Code : Objective-C

- (id) init{ [self faireLePlein];}

Mais self sert principalement renvoyer l'objet initialis : en effet, - init doit toujours renvoyer l'objet initialis.

Code : Objective-C

- (id) init{ [self faireLePlein]; return self;}

Parlons brivement d'hritage : la classe Voiture hrite de NSObject. Elle a donc toutes les caractristiques d'unNSObject. Mais si vous voulez crer un nouveau bouton d'interface graphique, votre classe doit hriter de NSButton, etcomme vous n'avez aucune ide de la faon dont s'initialise un NSButton, il faut appeler la mthode - init d'une instance dela classe mre. Pour nous faciliter la vie, les crateurs de l'ObjC ont introduit le mot-cl super qui symbolise cet objet.

Code : Objective-C

- (id) init{ [super init]; return self;}// ou encore- (id) init{ self = [super init]; if (self) { // du code... return self; } else return nil;}

Ici, on teste la valeur retourne par le message [super init] pour trouver les erreurs. Si jamais la valeur obtenue est nil,alors on retourne nil.

Ensuite, dans l'emplacement o j'ai crit // du code... , il faut initialiser les variables de l'objet, excuter diffrentesmthodes qui vont rendre l'objet utile. Il y a donc deux choses faire imprativement dans la mthode - init : appeler lamthode d'initialisation de la classe mre (avec [super init]) et retourner l'objet cr (avec return self). C'est laconvention.

Les accesseurs

On entend souvent parler de mthodes accesseurs en POO. Ce sont des mthodes qui servent modifier les variables d'un objetdepuis l'extrieur.

Il n'y a que les mthodes d'un objet qui peuvent toucher aux variables, cause de l'encapsulation des donnes. Pourquois'embter autant ? Parce que si c'est vous qui programmez vos mthodes, il n'y a aucun risque (sauf si vous codez avec vospieds) que l'objet fonctionne mal cause de mauvaises valeurs de variables membres. Si on a une classe Personnage, et quele programmeur (malintentionn ) peut mettre la valeur -100 la vie du Personnage, que va-t-il se passer ? C'est pour




cette raison que par des mthodes accesseurs, on peut vrifier la valeur entre et viter les bogues.

Solution l'encapsulation

Il y a une convention de nommage respecter pour les accesseurs. Dj, et j'ai peut-tre oubli de le mentionner ( ), il fautdeux mthodes accesseurs pour une variable : une mthode pour obtenir la valeur et une pour modifier la valeur de la variable. Lamthode qui sert obtenir le nom de la variable (que je vais appeler getter en anglais) porte seulement le nom de cette variable.Contrairement au C++ o deux coles se disputent pour mettre le prfixe get aux getters, en Objective-C on a dcid de garderle nom de la variable, sans prfixe. Par contre, la mthode qui sert modifier la valeur de la variable (le setter) porte le prfixe set.

Code : Objective-C - Interface

@interface Personnage : NSObject{ int vie; int mana;}

- (id) init;- (int) vie;- (int) mana;- (void) setVie:(int) uneVie;- (void) setMana:(int) unMana;

@end

Bien entendu, les getters et setters ne servent qu' modifier les variables depuis l'extrieur. l'intrieur d'un objet, vous utilisezles variables par leur nom :

Code : Objective-C

- (id) init{ [super init]; vie = 100; mana = 100; return self;}

Voici un exemple d'implmentation d'accesseurs :

Code : Objective-C

- (void) setMana: (int) aMana{ if (aMana < 0) mana = 0; else




mana = aMana;}

- (int) mana{ return mana;}

Crer des accesseurs pour chaque variable d'une classe peut tre trs long (d'ailleurs, rien ne vous oblige le faire). EnObjective-C, il y a d'autres moyens de crer des accesseurs et de modifier distance des variables membres, mais j'en parleraidans un autre chapitre. Encore un gros morceau avaler... prsent, vous savez :

comprendre du code Objective-C ;utiliser des objets ;crer vos propres objets ;et vous connaissez certaines rgles de l'Objective-C.

a fait peut-tre beaucoup pour deux chapitres, mais il ne faut pas hsiter relire celui-ci, et surtout pratiquer. Le prochainchapitre est un gros morceau galement ; on en a parl discrtement, mais il est un pilier de la Programmation Oriente Objet :c'est l'hritage, mes amis.




L'hritageJ'en ai dj parl dans les chapitres prcdents, et il est temps d'y arriver. L'hritage est probablement LE point-cl de la POO.C'est un systme trs efficace qui permet une rutilisation du code optimale, ainsi qu'une modularit des objets et des classes.

De plus, c'est une notion facile prendre en main (contrairement d'autres concepts de l'Objective-C), qui ncessite juste un peud'imagination.

Une histoire de famille...Tout d'abord, expliquons l'hritage : c'est la transmission de biens d'une gnration l'autre. Cela peut tre un hritage familial,culturel, etc. En terme d'informatique, on a aussi plusieurs hritages : celui des systmes d'exploitation (Mac OS X porte l'hritaged'UNIX, mais aussi de NeXTStep), des programmeurs, des socits, et aussi des objets et des classes. En Objective-C, on credes classes qui hritent d'autres classes. Il est d'ailleurs obligatoire, quand on cre une classe, de lui donner une classe mredont elle va hriter.

Prenons comme exemple la classe NSMutableArray : celle-ci hrite de NSArray, qui elle-mme hrite de NSObject.

Mais comment se fait-il que NSObject n'hrite pas d'une autre classe ?

NSObject est une classe racine (root-class), c'est--dire qu'elle sert de classe mre pour toutes les autres. NSObject dfinitdes mthodes et des variables membres qui sont ncessaires au bon fonctionnement de tous les objets.

Voici un petit schma de l'arbre d'hritage de NSMutableArray :

Mais qu'est-ce que l'hritage en ralit ? C'est la rutilisation du code d'une classe mre dans une classe fille. C'est--dire quetout ce qui est dclar dans une classe mre est rutilis dans la classe fille, que ce soient les mthodes ou les variablesmembres. La classe NSMutableArray hrite donc de toutes les spcificits de NSArray. Cela permet de simplifier lecode, et d'introduire de la modularit dans les classes.

Prenons un exemple : dans le framework Cocoa, il y a une classe nomme NSView qui hrite directement de NSResponder,une classe utilise pour les vnements. NSView est utilise pour dessiner n'importe quoi l'cran. On pourrait l'utiliser pourdessiner un bouton, un menu, un slider, etc. Mais dans le framework Cocoa, les dveloppeurs ont dj pens a : NSButtonhrite de NSView. On peut donc utiliser directement un NSButton, plutt que de s'embter dessiner un bouton avecNSView.




La simplification du code vient du fait que le programmeur ne doit pas tout recoder chaque nouvelle classe. Tout le code deNSObject est prsent dans un NSButton, pourtant le programmeur n'a pas l'crire. Il se contente de rajouter du codespcifique la classe fille :

Est-ce qu'on peut modifier le code d'une classe mre dans une classe fille, par exemple redfinir une mthode ?

Bien sr, et c'est mme fortement conseill. La premire mthode que l'on doit modifier en gnral est la mthode - init, carchaque classe s'initialise d'une faon diffrente. Le problme, quand on crit la mthode - init de NSButton, c'est qu'on nesait pas comment s'initialise la classe mre, on ne peut donc pas savoir quelles valeurs affecter aux diffrentes variables. C'estpour a que l'on utilise le mot-cl super. Un message envoy super va excuter la mthode de la classe mre. Ainsi, un[super init] dans la mthode - init de NSButton va appeler la mthode d'initialisation de NSControl. On n'a donc




pas besoin de connatre la classe mre.

Comment faire hriterC'est dans le fichier qui dclare l'interface d'une classe que l'on choisit la classe mre. On l'a d'ailleurs dj fait avec la classeNSObject :

Code : Objective-C

#import

@interface Personnage : NSObject{

}

@end

C'est aprs les deux-points que l'on choisit la classe mre. On peut aussi prendre une classe que l'on a dclare nous-mmes :

Code : Objective-C

#import #import "Personnage.h"

@interface Guerrier : Personnage{

}

@end

Attention cependant ! Pour les adeptes du C++, sachez que l'hritage multiple est strictement interdit en Objective-C !

Les classes que nous crons ici ne sont que des copies de NSObject. En effet, elles ne contiennent pas de code additionnelpar rapport NSObject. Il faut prsent rajouter les mthodes que l'on veut utiliser dans la classe fille.

Il y a cependant une rgle savoir. Les mthodes que vous rajoutez appartiennent une classe. Elles sont reprises dans lesclasses filles, que vous l'indiquiez ou non. Si vous dfinissez une fonction - setMana: dans la classe Personnage, ellesera reprise dans la classe fille, et fonctionnera de la mme manire : on n'a pas besoin de la recoder. De plus, une fonction - setMana: n'aura pas besoin d'tre retouche, car la variable membre mana existe dans toutes les classes filles.

En revanche, si vous dcidez de changer l'implmentation d'une mthode appartenant une classe mre, l'implmentation decelle-ci sera crase. C'est pour cela qu'il est utile d'appeler la mthode de la classe mre dans certains cas.

Les protocolesLes protocoles sont (plus ou moins) une faon diffrente de faire hriter une classe, mais qui ne se focalise cette fois que sur lesmthodes.

La problmatique de la conformit

Dans les frameworks Foundation (objets non GUI) et AppKit (objets GUI), l'organisation des objets entre eux est lgrementdiffrente de celle des bibliothques orientes objet telles que Qt. Pour grandement schmatiser, le programmeur utilise lesbibliothques de diffrentes faons : dans une bibliothque comme Qt, on peut dire que le dveloppeur donne des ordres auxobjets. Par exemple, c'est lui qui va dire un objet de s'afficher, c'est lui qui va donner la valeur d'une case d'un tableau, etc. Lesclasses que le programmeur va crer vont commander les autres objets.

Dans le framework Cocoa (et GNUstep), on peut observer l'inverse. Beaucoup d'objets de ce framework possdent une variabledelegate de type id. Cette variable est un objet qui va aider l'objet qui excute la tche. Prenons un exemple : pour afficherdes valeurs dans un tableau (un objet NSTableView dans le framework AppKit), au lieu de dire au tableau ce qu'il doit afficher,c'est ce dernier qui demande au delegate ce qu'il doit afficher. C'est trs important de comprendre comment les objetss'organisent, car c'est nous qui allons coder des delegates quand nous nous pencherons sur Cocoa.




Les flches sur ce schma sont des messages. Sur la deuxime moiti du schma, le message est en deux parties : la premireflche symbolise un appel de mthode, la deuxime est le retour de cette mthode.

Mais qui appartient la mthode qui retourne la valeur demande ?

l'objet delegate. C'est cette mthode que va appeler le tableau. Quelque part dans le code du tableau, il va y avoir ceslignes :

Code : Objective-C

delegate = notre_objet;valeur = [delegate tableau:self valeurPourColonne:3 ligne:4];

Je simplifie, mais c'est peu prs la mme chose dans le code.

La partie de la mthode tableau:self sert l'objet delegate pour savoir qui appelle la mthode, et ventuellement luidemander d'effectuer des tches, etc.

C'est maintenant qu'intervient notre problme de conformit : que se passe-t-il si un objet delegate n'implmente pas lamthode appele ? Comment savoir quelles mthodes implmenter ?En effet, un objet NSTableView (un tableau) possde un objet dataSource qui se charge de distribuer les donnes l'objet(le contenu des cases du tableau), comme notre delegate sur le schma. Si l'objet dataSource n'implmente pas la mthodequi donne les valeurs l'objet NSTableView, celui-ci appelle une mthode dans le vide.

C'est pour a qu'on a invent le protocole en Objective-C. Un protocole est une liste de mthodes qu'une classe doitobligatoirement implmenter. Ainsi, si notre dataSource est conforme au protocole NSTableViewDataSource, l'objetpeut tre sr que la mthode est implmente.

Appliquer un protocole

C'est dans l'interface que l'on dcide d'appliquer un protocole une classe.

Code : Objective-C

#import

@interface Foo : NSObject {




}

/* Mthodes qu'il faut implmenter */

@end

Je prends NSCoding pour exemple car c'est un protocole rpandu, contrairement NSTableViewDataSource qui n'estdisponible que dans Mac OS X v10.6.

Si vous tentez de compiler sans implmenter les mthodes, vous obtenez un cri d'agonie du compilateur :

Code : Autre

Foo.m:5: warning: incomplete implementation of class ?Foo?Foo.m:5: warning: method definition for ?-initWithCoder:? not foundFoo.m:5: warning: method definition for ?-encodeWithCoder:? not foundFoo.m:5: warning: class ?Foo? does not fully implement the ?NSCoding? protocol

Vous n'avez pas implment les mthodes demandes.

Crer un protocole

Un protocole se dclare comme une classe dans un fichier *.h. La syntaxe est vraiment similaire celle de l'interface d'une classe :

Code : Objective-C

#import

@protocol MonProtocole- (void) methodeRequise;

@optional- (void) methodeOptionelle;

@required- (void) autreMethodeRequise;

@end

Comme vous le voyez, on peut choisir si une mthode doit tre implmente ou pas, grce aux mots-cls @optional et@required .

Il se peut que beaucoup d'eau coule sous les ponts avant que vous n'ayez produire un protocole pour une application. Enrevanche, crer des classes conformes des protocoles est beaucoup plus courant. Cette partie sur les protocoles n'estfranchement pas importante pour la suite du cours, mais au moins vous savez que a existe. Un chapitre plus light, mais nanmoins dense en informations, surtout la notion de delegate qui est vraiment rcurrent dansle framework Cocoa.

prsent, je vous propose un peu de repos avec un chapitre sur la gestion de la mmoire en Objective-C, qui est plus ou moinsreste floue pour vous jusqu' prsent.




Grer la mmoireLe casse-tte du programmeur : la gestion de la mmoire. Tous les langages ont leur propre systme : allocation et libration de lammoire automatiquement, manuellement, etc.

L'Objective-C a, en revanche, une technique bien lui (en tout cas, je ne l'ai jamais vue dans d'autres langages ) : latechnique du retain count. C'est assez simple comprendre, mais a l'est moins mettre en place.

Retain count et autres joyeusetsOn a dj vu plusieurs mthodes de classe qui graient la mmoire, toutes d'une faon diffrente (ou presque).

La mthode + alloc alloue de la mmoire pour l'objet demand. Toutes les variables et les mthodes prennent une certaineplace dans la mmoire. Cette place est donc rserve par la mthode + alloc, sans que le programmeur n'ait se soucier dunombre de variables, etc.

La seconde mthode que l'on a vue pour grer la mmoire est - release. Cette mthode est une mthode d'instance, maiscontrairement ce qu'on pourrait penser, elle ne libre pas la mmoire alloue par + alloc. Elle ne fait que baisser le retaincount de 1.

Compter les utilisations

Mais qu'est-ce que c'est que ce retain count, la fin ? C'est un systme trs simple pour grer la mmoire : chaque objet possdeun compteur, le retain count, qui va compter le nombre d'objets qui ont besoin de lui. Quand trois objets diffrents ont besoin del'objet en question, le retain count est de 3.

Prenons l'exemple du chien. Son matre a besoin de lui, ainsi que le dresseur et le vtrinaire :

Que fait donc - release ? Lorsqu'un de ces objets n'a plus besoin de Chien, il lui fait savoir en lui envoyant un message.

Lorsque le retain count de Chien atteint zro, c'est--dire que personne n'a besoin de lui, la mthode d'instance - deallocentre en scne. Celle-ci fait vraiment le contraire de + alloc.

Il ne faut jamais appeler - dealloc directement, vous risqueriez de supprimer un objet qui est utilis ailleurs.

prsent, comment savoir si l'on augmente le retain count d'un objet ou pas ? Dj, l'appel de la mthode + alloc ou undriv (+ new, - copy), le retain count est incrment. En revanche, partir de l, le seul moyen d'incrmenter le retain countest d'utiliser la mthode - retain. Si l'objet Matre cre l'objet Chien, alors les autres doivent utiliser - retain pours'approprier l'objet. En revanche, ils travaillent tous avec le mme objet, il n'y a pas de copie (n'oubliez pas que tous les objetssont des pointeurs).

Copier et assignerCe systme, bien que simple en apparence, pose quelques problmes lorsque l'on veut excuter quelques tches spcifiques,comme copier un objet, ou assigner un objet un pointeur.

Le principe de l'assignation

Ce que l'on cherche faire, c'est modifier un de nos objets partir d'un autre. Les objets, en Objective-C, sont tous des




pointeurs. Un objet pointe donc vers un endroit en mmoire o se trouvent toutes les donnes dont il a besoin. Assigner unobjet un pointeur, c'est changer l'endroit o va pointer ce pointeur. On ne change pas l'objet en lui-mme, on change lepointeur.

Lorsque l'on code une nouvelle classe, on met trs souvent des objets dans les variables d'instance. On cre galement desaccesseurs pour contrler ces objets d'instance. C'est lorsque l'on veut implmenter un accesseur qu'on utilise l'assignation.Prenons l'exemple de notre classe Personnage. Celle-ci pos

Documents

Objective-C ! Programmez en - data.brains-master.com · En 1979, Bjarne Stroustrup développe le C++, qui ajoute la POO au C. La création de l'Objective-C intervient un peu plus