Tutoriel : Créez des applications pour iPhone, iPad et iPod Touch

Eh bien, je suis désolé de vous l'apprendre, mais les développements pour iPhone, iPad et iPod Touch se font presque exclusivement sur Mac. Et ce n'est pas tout ! Le Mac doit :

1. être équipé d'un processeur Intel ;

2. posséder au moins 1 gigaoctet (1 Go) de mémoire vive ;

3. utiliser le système d'exploitation Mac OS X Lion, Snow Leopard ou Leopard ;

4. disposer d'un port USB libre et/ou d'une connexion wifi afin de connecter votre iPhone/iPod Touch/iPad à l'ordinateur et de tester vos applications.

Il est également possible de développer des applications pour les produits Apple en utilisant un ordinateur fonctionnant sous Windows ou Linux, mais ce n'est (vraiment) pas la voie la plus simple, ni bien évidemment celle recommandée par Apple.
Ce livre s'intéressera uniquement à la méthode de développement traditionnelle : sur un Mac, via l'application Xcode.

Si vous possédez déjà un Mac, je vais vous montrer comment savoir s'il est équipé en conséquence : cliquez sur la pomme dans le Finder et sélectionnez À propos de ce Mac dans le menu. À la figure suivante par exemple, le Mac est équipé d'un processeur Intel Core 2 Duo et utilise le système OS X 10.6.7, donc Snow Leopard.

Si vous devez vous équiper, allez faire un tour sur l'Apple Store. Tous les Mac vendus dans le Store peuvent être utilisés. Selon votre budget, vous choisirez un Mac Mini, un MacBook, un MacBook Air, un MacBook Pro ou un iMac.

Si votre budget est limité, rabattez-vous sur une machine reconditionnée. Vous y trouverez des Mac testés et agréés par Apple. Sous garantie pendant un an, les machines proposées sont à un prix sensiblement inférieur à celui du neuf et (sauf exception) dans un excellent état !

Dans la mesure du possible, investissez dans un écran large de 22 ou 24 pouces. Comme vous le verrez dans ce livre, l'environnement de développement est à l'aise sur un grand écran, et un 22 pouces n'est vraiment pas un luxe !
Si vous êtes déjà équipés d'un écran pour PC, vous pourrez le connecter sur votre Mac, à condition que sa connexion soit de type DVI (figure suivante).

J'entends déjà bon nombre d'entre vous se plaindre : « mon écran n'a qu'un connecteur VGA ! Est-ce que je dois acheter un nouvel écran ? »
Non, rassurez-vous, il vous suffit d'acheter un adaptateur VGA/DVI (figure suivante). Pour quelques euros, vous pourrez connecter votre Mac sur votre écran VGA.

Pour les plus ambitieux d'entre vous, sachez qu'il est possible de connecter deux écrans sur tous les Mac récents. À vous de trouver les adaptateurs qui conviennent, comme par exemple un Mini DisplayPort/VGA (figure suivante).

Un autre matériel est-il nécessaire ?

Je vais encore jouer les rabat-joie : il ne suffit pas d'être équipé d'un Mac pour écrire des applications destinées aux appareils mobiles Apple. Vous devez également posséder un iPhone, un iPod Touch et/ou un iPad. Ou encore mieux, les trois !

En effet, si l'environnement de développement est en mesure de simuler le fonctionnement de ces trois appareils, le comportement des applications est cependant biaisé car elles ne disposent pas des mêmes ressources (mémoire et processeur) si elles sont exécutées sur un Mac ou sur un device (entendez par là un iPhone, un iPad ou un iPod Touch).

Une bonne nouvelle : les iPod Touch et les iPad sont également disponibles en version reconditionnée ! Vous pourrez faire de substantielles économies en vous rendant sur ces pages. Par cet intermédiaire, je me suis équipé d'un iPad et d'un iPod Touch reconditionnés, et je dois dire que je m'en félicite tous les jours. :-)

À l'origine d'Apple, deux amis : Steve Wozniak et Steve Jobs. Le premier est un électronicien et un programmeur de génie. Le deuxième est un visionnaire qui saura imposer la marque à la pomme en lui conférant une simplicité d'utilisation et une ligne uniques. Steve Jobs est l'instigateur de cinq évolutions majeures dans le monde de l'informatique personnelle :

• l'Apple II ;

• le Macintosh ;

• l'iPod ;

• l'iPhone ;

• l'iPad.

C'est courant 1975 que naît l'Apple I dans le garage de Steve Jobs. Rencontrant un succès mitigé mais suffisant, il apporte suffisamment de capitaux pour que Steve Wozniak se consacre à temps plein à son digne successeur, l'Apple II. Cette machine révolutionnaire conquiert un large public grâce à ses innovations majeures, notamment un affichage texte et graphique, un interpréteur BASIC, le tableur VisiCalc et un lecteur de disquettes !

Début 1984, le grand public découvre le premier modèle de Macintosh. C'est encore à Steve Jobs que l'on doit ce beau succès commercial. Son design innovant, sa compacité, son écran graphique de grande qualité, sa simplicité d'utilisation et… sa souris révolutionnent l'utilisation de l'ordinateur. Le succès est immédiat et perdure depuis lors.

Mais l'aventure ne s'arrête pas là : en 2001 naît l'iPod, en 2007 l'iPhone et en 2010 l'iPad. Bien sûr, l'iPod n'est pas le premier baladeur MP3, l'iPhone n'est pas le premier téléphone cellulaire et l'iPad n'est pas la première tablette tactile. Par contre, ces trois périphériques sont vraiment simples à utiliser, et c'est ce qui fera leur succès. Une fois encore, Steve Jobs a su flairer le marché et adapter ce qui a fait le succès d'Apple : la simplicité d'utilisation et la ligne esthétique.

Aujourd'hui, Steve Jobs n'est plus avec nous, mais son empreinte demeure indélébile dans la galaxie Apple !

Les iPhone, iPod Touch et iPad

L'iPhone

Les iPhone (figure suivante) sont en tout point comparables aux iPod Touch, si ce n'est qu'ils permettent de téléphoner. Vous pouvez donc les utiliser pour :

• joindre un correspondant par téléphone ;

• écouter de la musique ;

• prendre des photos (à partir de l'iPhone 3) ;

• joindre un autre utilisateur d'iPhone/iPod Touch/iPad en visioconférence (à partir de l'iPhone 4) ;

• exécuter les applications écrites pour les iPhone.

iPod Touch

Les iPod Touch (figure suivante) sont équipés d'un écran tactile de 3,5 pouces de diagonale. Ils peuvent être utilisés pour :

• écouter de la musique ;

• prendre des photos (à partir de l'iPod Touch 4) ;

• joindre un autre utilisateur d'iPhone/iPod Touch/iPad en visioconférence (à partir de l'iPod Touch 4) ;

• exécuter les applications écrites pour les iPhone.

iPad

Les iPad (figure suivante) sont en gros des iPod Touch un peu plus grands. Ils peuvent donc être utilisés pour :

• écouter de la musique ;

• prendre des photos (à partir de l'iPad 2) ;

• joindre un autre utilisateur d'iPhone/iPod Touch/iPad en visioconférence (à partir de l'iPad 2) ;

• exécuter toutes les applications écrites pour les iPhone ainsi que les applications propres à l'iPad.

La grande taille de l'affichage les rend également plus agréables que les iPod Touch ou les iPhone pour surfer sur le Web et lire des e-books et autres fichiers PDF.

Vous avez maintenant une idée des possibilités offertes par les appareils mobiles Apple. Une question cruelle va se poser à vous : de quel(s) appareil(s) devez-vous vous équiper ?

Le mieux serait d'avoir un iPhone, un iPod Touch et un iPad. Vous pourriez ainsi développer pour ces trois périphériques et toucher un vaste public. Notez cependant que les différences entre l'iPod Touch et l'iPhone sont très réduites : grossièrement, le premier est équivalent au second, excepté qu'il ne peut pas être utilisé pour téléphoner.

Un bon choix consiste donc à acheter :

• un iPhone et un iPad si vous avez l'utilité d'un téléphone mobile ;

• un iPod Touch et un iPad si vous n'avez pas l'utilité d'un téléphone mobile ;

• un iPhone ou un iPod Touch si vos applications ne sont pas destinées aux tablettes iPad.

Limitations des appareils mobiles Apple

Les appareils mobiles Apple sont limités par :

• la taille de l'affichage :

• 480 x 320 pixels : iPod Touch 3 et iPhone 3 ;

• 960 x 640 pixels : iPod Touch 4 et iPhone 4 ;

• 1024 x 768 pixels : iPad 1 et 2 ;

• 2048 x 1536 pixels : iPad 3 ;

• la quantité de mémoire vive disponible :

• 128 Mo : iPod Touch 3 avec 8 Go de mémoire flash ;

• 256 Mo : iPod Touch 3 avec plus de 8 Go de mémoire flash, iPod Touch 4, iPhone 3 et iPad 1 ;

• 512 Mo : iPhone 4 et iPad 2 ;

• dans une moindre mesure, le type et la vitesse du processeur.

La taille de l'affichage est un facteur déterminant. Elle conditionnera la mise en page de vos applications et devra s'adapter aux tailles caractéristiques des différents appareils mobiles.
La quantité de mémoire vive est assez limitée. C'est pour cela qu'il est absolument nécessaire de tester une application sur un périphérique physique avant de la rendre disponible sur l'Apple Store.

Le type et la vitesse du processeur n'influent qu'assez peu sur la vitesse d'exécution des applications. Ils ne seront pris en compte que dans le cas de jeux manipulant un grand nombre d'éléments graphiques.

Qu'est-ce qu'un programme ?

Les ordinateurs, les téléphones, les tablettes graphiques et, d'une certaine manière, tous les appareils numériques, utilisent des programmes (appelés aussi applications) pour accomplir des tâches bien précises. Ainsi par exemple, lorsque vous démarrez votre traitement de texte, votre navigateur Web ou votre messagerie, vous utilisez un programme. Autour de ces programmes, un « super programme », appelé système d'exploitation, joue le rôle de chef d'orchestre et permet aux applications d'accéder au matériel sur lequel elles s'exécutent. On dit qu'il sert d'interface entre le matériel et les programmes. À titre d'exemple, Microsoft Windows et Mac OS X sont des systèmes d'exploitation.

Selon le matériel et le système d'exploitation utilisés, les applications sont écrites en utilisant un ou plusieurs langages de programmation. Les iPhone, iPod Touch et iPad sont orchestrés par un système d'exploitation identique. Pour écrire des applications destinées à ce système, un seul langage de programmation peut être utilisé : Objective-C.

Connaissances préalables nécessaires pour programmer

Vous êtes en train de lire un Livre du Zéro, et à ce titre, et pour ne pas déroger à la règle, aucune connaissance préalable n'est nécessaire ! Ceci étant dit, si vous avez déjà une première expérience de la programmation orientée objet ou du langage Objective-C, ce sera un vrai plus : vous comprendrez très rapidement bon nombre de notions qui seront évoquées ici et vous serez très vite capables de passer à la pratique. Si vous n'avez jamais programmé, ne vous en faites surtout pas ! Je serai votre guide tout au long de votre apprentissage. Pour peu que vous ayez un peu de temps, d'intérêt, de passion et de persévérance, vous progresserez très vite.

Langages, API et système

Tout au long de ce tutoriel, nous allons souvent parler d'Objective-C, de Cocoa Touch et d'iOS. Il est temps pour moi de vous présenter ces termes.

• Objective-C est le langage de programmation utilisé pour développer des applications pour iPhone, iPod Touch et iPad. Il s'agit d'un langage hérité du langage C, c'est-à-dire que l'Objective-C emprunte au C bon nombre de choses.

• Cocoa Touch est une API (Application Programming Interface ou, en français, interface de programmation) dédiée à l'écriture d'applications pour iPhone, iPod Touch et iPad. Une API est constituée d'un ensemble de programmes pré-écrits (classes et méthodes dans le jargon des spécialistes). Cocoa Touch ne déroge pas à la règle ; elle est spécifiquement développée pour les devices Apple. Elle est accessible à travers Xcode, le logiciel de développement que nous utiliserons.

• iOS est le système d'exploitation des iPhone/iPod Touch/iPad.

Vous trouverez à la figure suivante un schéma pour vous aider à visualiser tout ce petit monde.

Les réponses à cette question sont multiples.
Si tous les logiciels nécessaires sont installés et si vous voulez juste créer votre première application sans vraiment comprendre ce que vous faites, dix minutes sont suffisantes !

Si rien n'est encore installé (je suppose quand même que vous avez un Mac sous la main), comptez trois à quatre heures pour installer le logiciel et mettre au point une application qui affiche un texte sur votre device.

Je vous conseille cependant de ne pas compter le temps passé : vous vous lancez dans une grande aventure. Il vous faudra du temps (beaucoup de temps même) pour comprendre les mécanismes de la programmation Objective-C, mais cela en vaut la peine ! Une fois les mécanismes de base assimilés, vous pourrez réaliser tout ce qui vous vient en tête…

Xcode sur votre Mac

Xcode est le programme que vous utiliserez pour développer vos applications. La version utilisée dans ce tutoriel est la 4.2 (sous OS X Lion 10.7.2). Si vous utilisez une autre version, quelques détails différeront, mais la plupart de ce qui sera dit restera valable. Par défaut, Xcode est normalement déjà installé sur votre Mac. Pour vous en assurer, cliquez sur l'icône du Finder, à l'extrême gauche du dock. Cette action ouvre une fenêtre dans laquelle sont affichés vos principaux dossiers, comme le montre la figure suivante.

Dans le volet de gauche, sous APPAREILS, cliquez sur Macintosh HD. Dans le volet de droite, double-cliquez sur Developper, sur Applications, puis sur Xcode. Une boîte de dialogue est alors affichée, comme à la figure suivante.

La version du logiciel est affichée juste en dessous du titre « Welcome to Xcode ». Ici, il s'agit de la version 3.2.6. Si votre version de Xcode n'est pas au moins égale à la 4.2, je vous conseille vivement de télécharger puis d'installer la toute dernière version disponible. Pour cela, vous devez rejoindre la communauté des développeurs Apple. Rassurez-vous, cette opération est entièrement gratuite. Connectez-vous sur la page d'enregistrement d'Apple, cliquez sur Get Started et suivez la procédure indiquée pour rejoindre la communauté des développeurs.

Une fois enregistrés, connectez-vous sur la page de téléchargement de Xcode, cliquez sur Log in et connectez-vous en utilisant votre identifiant Apple ID.

• Leopard : Xcode 3.1 ;

• Snow Leopard : Xcode 3.2 ou 4.0 ;

• Lion : Xcode 4.2.

Et surtout, armez-vous de patience : le fichier à télécharger pèse quelque 4 Go !

Installation de Xcode

Une fois Xcode téléchargé, une icône d'installation est affichée dans le dock, comme à la figure suivante.

Cliquez sur l'icône Install Xcode. Cette action ouvre la fenêtre Install Xcode. Cliquez sur Install, sur Agree, entrez votre nom et votre mot de passe puis patientez jusqu'à la complète installation du programme. Une fois l'installation terminée, l'icône Install Xcode du dock se transforme en Xcode. Il suffit de cliquer dessus pour accéder à Xcode.

En résumé

• Les développements pour iPhone, iPod Touch et iPad se font sur un Mac équipé d'un processeur Intel.

• Pour développer des applications pour iPhone, iPod Touch et iPad, vous utiliserez l'application Xcode, normalement déjà installée sur votre Mac. Si tel n'était pas le cas, vous pouvez télécharger Xcode depuis le site pour développeurs d'Apple.

• Pour utiliser la dernière version de l'application Xcode (4.2.x), le Mac doit utiliser le système d'exploitation OS X Lion ou supérieur.

Avant toute chose, il nous faut lancer Xcode, en cliquant par exemple sur l'icône présente dans le dock (figure suivante).

La fenêtre Welcome to Xcode s'affiche alors, comme à la figure suivante.

Nous allons ensuite créer un nouveau projet. Pour cela, rien de plus simple, il vous suffit de cliquer sur Create a new Xcode project. Une nouvelle boîte de dialogue s'affiche (figure suivante). Dans le volet de gauche, sous iOS, choisissez Application. Dans la partie centrale de la boîte de dialogue, choisissez Single View Application.

Cliquez sur Next, donnez le nom « premier » au projet, tapez « test » dans la zone de texte Company Identifier, sélectionnez iPhone dans la liste Device Family, et cochez la case Include Unit Tests, comme indiqué à la figure suivante.

Cliquez sur Next et choisissez le dossier dans lequel le projet sera créé (figure suivante), au besoin en cliquant sur New Folder pour créer un nouveau dossier.

Cliquez sur Create. Le projet est alors créé et ouvert dans Xcode, comme à la figure suivante.

Cette fenêtre va vous permettre de définir l'allure de l'application, de saisir du code Objective-C et de tester l'application. Pour l'instant, nous n'allons pas entrer dans les détails de la fenêtre de Xcode, cela ne ferait que vous embrouiller.

La première étape va consister à dessiner ce que l'on souhaite voir s'afficher sur l'écran du device (Je vous rappelle que device désigne le périphérique sur lequel s'exécutera l'application ; il peut tout aussi bien s'agir d'un iPhone, d'un iPod Touch ou d'un iPad. Ici, la cible de l'application étant un iPhone ou iPod Touch, device désigne ces deux périphériques).
L'interface de Xcode est composée de plusieurs modules (éditeur de code, zone de débogage, utilitaires, éditeur d'interface, etc.). Chacun d'entre eux utilise un ou plusieurs volets, accessibles à partir de la zone de navigation ou de la barre d'outils. Dans cette première étape, vous allez utiliser Interface Builder pour construire la partie visuelle de l'application. Pour ce faire, procédez selon les trois étapes suivantes en vous aidant au besoin de la figure suivante.

1. Dans la zone de navigation, cliquez sur MainStoryboard.storyboard (1) pour accéder à Interface Builder.

2. Dans la barre d'outils, cliquez sur l'icône Hide or Show the utilites (2), au-dessus du libellé View, pour révéler le volet des utilitaires.

3. Dans la partie inférieure du volet des utilitaires, cliquez sur l'icône Show the Object library (3) pour afficher la bibliothèque d'objets. Cliquez si nécessaire sur l'icône Icon View (4) pour afficher plus de contrôles dans la bibliothèque d'objets.

Glissez-déposez un contrôle Label de la bibliothèque d'objets dans la zone d'édition. Si vous n'êtes pas (encore) familiers avec cette opération, sachez qu'elle consiste à cliquer sur le contrôle Label dans la bibliothèque d'objets, à maintenir le bouton gauche de la souris enfoncé, à déplacer l'élément ainsi sélectionné au-dessus de la zone d'édition puis à relâcher le bouton de la souris, comme le montre la figure suivante.

Glissez-déposez ensuite un contrôle Round Rect Button (un bouton) de la bibliothèque d'objets dans la zone d'édition, comme indiqué à la figure suivante.

Vous allez maintenant modifier le texte affiché par défaut dans le Label. Double-cliquez sur celui-ci dans la zone d'édition, écrivez « Cliquez sur le bouton » puis appuyez sur la touche Entrée de votre clavier.
Faites de même pour afficher un texte sur le bouton : double-cliquez sur le bouton, écrivez « Cliquez ici » et appuyez sur la touche Entrée.
La zone d'édition doit maintenant ressembler à la figure suivante.

Cette application doit afficher un texte dans le Label lorsque l'utilisateur clique sur le bouton. Pour que le code Objective-C puisse agir sur les contrôles définis dans l'étape précédente, il faut relier les contrôles au code.

Cliquez sur l'icône Show the Assistant editor, au-dessus du libellé Editor, dans la partie droite de la barre d'outils (figure suivante). Cette action affiche le code du fichier ViewController.h dans un volet vertical.

Si votre écran n'est pas assez large pour visualiser la zone d'édition et le code, désactivez la zone d'utilitaires en cliquant sur l'icône Hide or Show the Utilities, dans la partie droite de la barre d'outils, au-dessus du libellé View (figure suivante).

Le fichier ViewController.h contient les déclarations relatives aux objets manipulés.

Les applications développées avec Xcode sont composées de nombreux fichiers. Certains ont un nom qui se termine par .h, comme par exemple ViewController.h dans le cas qui nous intéresse. Ces fichiers sont dits fichiers d'en-têtes.
Ils contiennent des instructions Objective-C qui permettent d'identifier les objets (c'est-à-dire les contrôles déposés sur la zone d'édition depuis Interface Builder) utilisés dans l'application. Ces instructions sont appelées déclarations.

Pour ajouter les déclarations nécessaires pour le Label, contrôle-glissez-déposez le contrôle Label du volet d'édition dans le volet de code, juste au-dessus de la dernière ligne (figure suivante). Cette technique deviendra vite habituelle. Elle consiste à :

1. placer le pointeur de la souris sur le contrôle Label dans le volet d'édition ;

2. maintenir la touche Ctrl de votre clavier enfoncée ;

3. maintenir le bouton gauche de la souris enfoncé et déplacer le contrôle Label du volet d'édition dans le volet de code, juste au-dessus de la ligne où apparaît l'instruction @end ;

4. relâcher le bouton gauche de la souris ainsi que la touche Ctrl.

Au relâchement du bouton gauche de la souris, une boîte de dialogue est affichée. Tapez « message » dans la zone de texte Name, comme à la figure suivante.

Cliquez sur Connect. Le code du fichier ViewController.h devrait maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UILabel *message;

@end

Passons quelques minutes sur ce code si vous le voulez bien.

La première ligne, sur laquelle figure le mot import, fait référence à tout ce dont vous aurez besoin pour développer une interface utilisateur pour périphérique iOS. En ajoutant cette simple ligne au début de l'application, le code pourra afficher sur l'écran du device et répondre aux gestuelles (appui, déplacement, rotation, etc.) des utilisateurs.

La ligne 3, sur laquelle figure le mot interface, indique que l'application ViewController est de type UIViewController :

@interface ViewController : UIViewController

La ligne 5, qui contient le mot property, indique le comportement de l'objet :

@property (weak, nonatomic) IBOutlet UILabel *message;

Enfin, la ligne 7 matérialise la fin du fichier ViewController.h :

@end

Contrôle-glissez-déposez le bouton de la zone d'édition dans le volet de code, juste au-dessus de la dernière ligne, comme à la figure suivante

Au relâchement du bouton de la souris, une boîte de dialogue est affichée. Ici, nous voulons associer une action au bouton, afin qu'un message soit affiché dans le Label lorsque l'utilisateur appuie sur le bouton. Choisissez Action dans la liste déroulante Connection et tapez « reagir » dans la zone de texte Name. La boîte de dialogue devrait maintenant ressembler à la figure suivante.

Comme vous pouvez le voir sur cette image, l'action reagir (paramètre Name), exécutée lorsque l'utilisateur appuie sur le bouton (Touch Up Inside, soit « au relâchement du bouton de la souris » dans le paramètre Event), est sur le point d'être définie.

Cliquez sur Connect. Le code est complété avec une nouvelle instruction :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UILabel *message;

- (IBAction)reagir:(id)sender;

@end

Comme vous pouvez le voir, une ligne a été ajoutée dans le code pour déclarer l'action reagir dans le code (ligne 7).

Cliquez sur l'entrée ViewController.m dans le volet de navigation. Un code assez imposant apparaît dans la partie centrale de la fenêtre. Il a (gentiment) été généré par Xcode.

//
//  ViewController.m
//  premier
//
//  Created by Michel Martin on 24/10/11.
//  Copyright (c) 2011 __MyCompanyName__. All rights reserved.
//

#import "ViewController.h"

@implementation ViewController
@synthesize message;

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

- (void)viewDidUnload
{
  [self setMessage:nil];
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

- (void)viewWillAppear:(BOOL)animated
{
  [super viewWillAppear:animated];
}

- (void)viewDidAppear:(BOOL)animated
{
  [super viewDidAppear:animated];
}

- (void)viewWillDisappear:(BOOL)animated
{
  [super viewWillDisappear:animated];
}

- (void)viewDidDisappear:(BOOL)animated
{
  [super viewDidDisappear:animated];
}

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

- (IBAction)reagir:(id)sender {
}
@end

Jetez un œil aux dernières lignes du code. Est-ce que cela ne vous rappelle rien ?
La ligne 62 est la copie conforme de la déclaration qui a été générée lorsque vous avez contrôle-glissé-déposé le bouton de la zone d'édition dans le fichier ViewController.h. Avez-vous remarqué les accolades, juste après le mot sender ? C'est à cet endroit que vous allez écrire le code qui permettra d'afficher un message dans le Label lorsque l'utilisateur clique sur le bouton. Complétez cette déclaration comme suit :

- (IBAction)reagir:(id)sender {
  NSString *lemessage = [[NSString alloc] initWithFormat:@"Bravo !"];
  message.text = lemessage;
}

Ce n'est pas comme ça que parle votre iPhone, mais plutôt comme ça qu'Objective-C se fait comprendre de votre device. Je sais que la syntaxe de ces instructions a de quoi surprendre. Ne vous en faites pas, et surtout, n'essayez pas de tout comprendre tout de suite. Pour l'instant, contentez-vous de voir le mot « Bravo » sur la deuxième ligne. C'est ce mot qui sera affiché sur l'iPhone lorsque vous cliquerez sur le bouton.

Dans la barre d'outils, cliquez sur l'icône Run (figure suivante).

Au bout de quelques instants, une fenêtre complémentaire nommée Simulateur iOS est affichée, et l'application apparaît dans son état initial. Cliquez sur le bouton. Le texte « Bravo ! » remplace le texte « Cliquez sur le bouton », comme à la figure suivante. Je vous félicite ! Vous venez de réaliser votre première application sur iPhone !

En résumé

• Le design des applications est défini dans la composante Interface Builder de l'application Xcode.

• La bibliothèque d'objets est accessible en cliquant sur l'icône Hide or Show the Utilities, puis sur l'icône Show the Object library.

• Pour ajouter un contrôle dans une vue, il suffit de le glisser-déposer depuis la bibliothèque d'objets dans le Storyboard.

• Pour relier un contrôle au code, contrôle-glissez-déposez-le depuis le Storyboard dans le fichier .h correspondant et indiquez si vous voulez créer un outlet ou une action.

• Le code de l'application est écrit dans le fichier .m qui correspond à la vue.

• Pour construire et exécuter l'application dans le simulateur iOS, il suffit de cliquer sur l'icône Run, dans l'angle supérieur gauche de la fenêtre de Xcode.

Lorsque vous définissez un nouveau projet Xcode, vous devez choisir un type de device : iPhone/iPod Touch ou iPad (figure suivante).

Si vous voulez utiliser le simulateur iOS, vous pouvez à tout moment changer de device en utilisant la liste déroulante Scheme, dans la partie supérieure gauche de la fenêtre de Xcode (figure suivante).

Une autre possibilité consiste à utiliser le menu du simulateur. La fenêtre de ce dernier étant en avant-plan, déroulez le menu Matériel, pointez Appareil et choisissez un des devices proposés, comme à la figure suivante.

Le menu Matériel offre des possibilités complémentaires, puisqu'il est possible de simuler la version du système iOS (on dit aussi firmware) utilisé. Déroulez le menu Matériel, pointez Version et choisissez la version d'iOS à utiliser, comme à la figure suivante.

Une fois le simulateur iOS choisi comme cible de l'application, cliquez sur le bouton Run pour lancer l'application dans le simulateur.

Le simulateur iOS est une application Mac. Il s'exécute dans une fenêtre affichée sur l'écran relié à votre ordinateur. Étant donné que cet écran est une simple dalle réservée à l'affichage, il n'est pas capable de réagir aux gestuelles ni aux actions effectuées sur un iPhone/iPod Touch/iPad. Toutefois les ingénieurs en charge du développement de cette application ont eu la bonne idée de lui associer des raccourcis clavier pour simuler les gestuelles et les actions des utilisateurs.

Simuler les gestuelles de l'utilisateur

Vous vous en doutez, il n'est pas possible de faire tourner votre écran d'ordinateur ou de le secouer pour simuler ces actions dans le simulateur iOS. Par contre, vous pouvez utiliser des commandes dans le menu Matériel du simulateur iOS, ou les raccourcis clavier équivalents.

Simuler les actions de l'utilisateur

Les actions liées au toucher (clic, double-clic, agrandir, etc.) peuvent également être simulées dans le simulateur iOS en utilisant la souris.

Installer/désinstaller une application

Pour installer une application, il suffit de l'exécuter dans le simulateur en cliquant sur le bouton Run de Xcode. Elle est alors disponible sur l'écran des applications (figure suivante), et le restera jusqu'à ce que vous la désinstalliez.

Pour désinstaller une application, pointez son icône et maintenez le bouton gauche de la souris enfoncé jusqu'à ce que toutes les icônes se mettent à bouger. Cliquez alors sur la case de fermeture de l'application que vous voulez désinstaller (figure suivante).

Retourner à la configuration d'usine

Une commande permet de réinitialiser le simulateur iOS pour lui redonner sa configuration d'usine, c'est-à-dire sa configuration juste après l'installation de Xcode. Toutes les applications installées, contenus et réglages sont supprimés et placés dans la corbeille du Mac.
Pour réinitialiser votre simulateur iOS, cliquez sur le menu Simulateur iOS et sélectionnez Réinitialiser le contenu et les réglages. Une boîte de dialogue de confirmation est affichée. Cliquez sur Réinitialiser pour confirmer votre choix.

Déboguer une application lors de son exécution sur le simulateur

L'application Xcode est dotée d'un volet de débogage, aussi appelé « console ». Ce volet permet d'afficher des informations textuelles pendant qu'une application s'exécute, et ce, quelle qu'en soit la cible : le simulateur iOS ou un device réel. Cette section est une première approche du débogage. N'ayant pas encore abordé l'exécution d'une application sur un device, vous allez apprendre à afficher des données dans la console pendant l'exécution sur le simulateur iOS.

Pour afficher le volet de débogage, il suffit de cliquer sur l'icône Hide or show the Debug area, dans la barre d'outils de Xcode (figure suivante).

Vous utiliserez une instruction, NSLog(), pour afficher des informations dans le volet de débogage :

NSLog(@"Le texte à afficher");

Comme vous pouvez le voir sur la figure précédente, l'instruction NSLog() affiche le texte « Bonjour » dans le volet de débogage (à la dernière ligne).

En résumé

• Le simulateur iOS fait partie intégrante de l'application Xcode.

• La liste Scheme (dans l'angle supérieur gauche de la fenêtre de Xcode) permet de choisir si l'application s'exécutera dans le simulateur iPhone ou dans le simulateur iPad. Vous pouvez également utiliser la commande Appareil dans le menu Matériel pour parvenir au même résultat. Si vous le désirez, vous pouvez également choisir la version d'iOS utilisée avec la commande Version dans le menu Matériel.

• Certaines gestuelles et actions de l'utilisateur peuvent être reproduites dans le simulateur iOS, à l'aide de commandes dans le menu Matériel ou de raccourcis clavier.

• Une application peut afficher des informations textuelles dans le volet de débogage en utilisant l'instruction NSLog().

Avant tout chose, je vous rappelle que le langage Objective-C hérite du langage C, c'est-à-dire que leur syntaxe de base est relativement similaire. Si vous connaissez déjà le C, vous pouvez directement vous rendre au chapitre suivant. Si vous voulez en savoir plus sur le langage C, le Site du Zéro propose un tutoriel.

Tout ce qui va être dit dans ce chapitre est relativement théorique. Malheureusement, c'est un passage obligé pour apprendre le langage Objective-C. Cependant, rien ne vous empêche de tester ce que vous apprenez au fur et à mesure.

Pour commencer, définissez un nouveau projet appelé « test » basé sur le modèle Single View Application. Cliquez sur ViewController.m dans le volet de navigation (1) et entrez les instructions à tester dans la méthode viewDidLoad, juste après le message [super viewDidLoad]; (2), comme indiqué à la figure suivante.

Pour tester votre code, une des façons les plus simples consiste à afficher des éléments textuels dans le volet de débogage (aussi appelé « console ») avec la fonction NSLog(). À titre d'exemple, tapez cette ligne de code à la suite de [super viewDidLoad] :

NSLog(@"texte à afficher");

Cliquez sur l'icône Run (1) pour exécuter l'application et, si nécessaire, cliquez sur Hide or show the Debug area (2) pour afficher le volet de débogage. Comme vous pouvez le constater à la figure suivante, le texte passé à la fonction NSLog() est affiché dans le volet de débogage.

Oui, bien sûr. N'ayez crainte, vous découvrirez cela en temps utile. Passez vite à la suite pour faire connaissance avec vos premières instructions Objective-C.

Avant de pouvoir conduire une voiture, vous devez apprendre un certain nombre de règles. Pour cela, vous devez potasser le code de la route. Une fois cette première étape acquise, vous pouvez vous lancer dans la conduite. Là encore, vous devez apprendre plusieurs choses. Certaines ne sont pas essentielles. Par exemple, il n'est pas indispensable de savoir comment fonctionne le moteur de la voiture. D'autres sont par contre vitales : il est impensable de se mettre au volant d'une voiture si on ne sait pas mettre en route le moteur ou passer les vitesses !

Les choses sont assez similaires en programmation. Vous allez devoir apprendre des règles, acquérir des mécanismes et beaucoup pratiquer avant d'arriver à faire ce que vous voulez. Cela vous prendra du temps et de l'énergie, mais imaginez quelle joie vous éprouverez lorsqu'une de vos applications sera téléchargée, utilisée et appréciée par des milliers d'inconnus ! Pour l'instant, nous n'en sommes pas là. Commençons déjà par les bases de la programmation.

Tous les programmes sont constitués d'instructions. Une instruction demande à l'ordinateur d'effectuer quelque chose de précis. Généralement, on écrit une seule instruction par ligne.

Voici une instruction Objective-C plutôt simple :

int leNombreDix = 10;

Et voici une instruction Objective-C un peu plus compliquée :

NSDateFormatter *miseEnForme = [[NSDateFormatter alloc] init];

Je suis sûr que vous trouvez la première plus sympathique que la deuxième. Mais rassurez-vous, ces deux instructions sont très simples à comprendre du moment que l'on connaît le « code de la route » Objective-C.

Pour l'instant, contentez-vous de retenir qu'un programme est constitué d'un ensemble d'instructions. Au fil des chapitres, votre compréhension du langage Objective-C sera de plus en plus claire et vous pourrez commencer à concevoir vos propres applications.

Eh bien oui, le « ; » est obligatoire. Il indique à l'ordinateur que l'instruction est terminée. Il faudra donc vous y faire : toutes les instructions se terminent par un « ; ».

Les variables

Le langage Objective-C n'aurait aucun intérêt s'il n'était pas capable de manipuler des données. Ceci est possible grâce aux variables. En effet, ces dernières permettent de stocker temporairement des informations dans la mémoire de votre device et d'y accéder par la suite. Grâce à elles, vous allez pouvoir stocker l'âge ou la taille du visiteur, mais aussi effectuer des calculs et bien d'autres choses encore.

Pour définir une variable, vous utiliserez la syntaxe suivante :

type nomVariable;

Où :

• type est le type de la variable. Cet élément indique ce que la variable est censée représenter : un entier, un nombre à virgule, un caractère, etc.

• nomVariable est le nom de la variable.

Par exemple, pour définir une variable nommée « maVariable » dont le type est int, vous utiliserez l'instruction suivante :

int maVariable;

int vient du mot anglais integer (« entier » en français). Il faudra vous y faire : la plupart des langages de programmation sont en anglais. Pour ceux qui auraient des lacunes en maths, un entier est un nombre sans virgule, comme par exemple 12 ou 65241.

Quant à la syntaxe du deuxième mot, elle adopte la convention camelCase, qui consiste à utiliser une première lettre minuscule et une lettre majuscule pour chaque nouveau mot. Cette façon de faire n'est pas obligatoire, c'est juste une convention : vos programmes fonctionneront quand même si vous ne l'utilisez pas.

De plus, l'Objective-C interdit les espaces et les accents dans les noms de variables. Par exemple, maPremiereVariable respecte la convention camelCase et ne contient ni espace ni accent ; le nom est donc correct. A contrario, Ma première variable ne respecte pas la convention camelCase et contient des espaces et un accent ; le nom est donc incorrect.

Si vous le souhaitez, il est possible d'affecter une valeur à une variable pendant sa déclaration. Vous utiliserez alors la syntaxe suivante :

type nomVariable = valeur;

Où type est le type de la variable, nomVariable est son nom et valeur est la valeur que vous voulez lui affecter. Par exemple :

int maVariable = 10;

Ici, la valeur 10 est affectée à la variable maVariable de type int.

Vous pouvez manipuler ces variables comme bon vous semble. Par exemple :

int resultat, nombre1 = 10, nombre2 = 5;
resultat = nombre1 + nombre2;

Ici la variable resultat vaudra 15 : 10 + 5 = 15. Bon, je vous l'accorde, pour le moment ça ne nous sert pas à grand-chose. Mais croyez-moi, c'est primordial.

Que diriez-vous maintenant d'un peu de pratique ?
Ouvrez votre projet de test, celui défini quelques pages avant.

Comme vous le montre la figure suivante, cliquez sur ViewController.m (1) dans le volet de navigation, repérez la méthode viewDidLoad et ajoutez les deux lignes de code précédentes à la suite de [super viewDidLoad].

Ajoutez un NSLog pour afficher la valeur de la variable resultat dans le volet de débogage :

NSLog (@"Résultat vaut %d",resultat);

Cliquez sur Run (2) pour exécuter l'application. Si le volet de débogage n'est pas affiché, cliquez sur Hide or show the Debug area (3). Au bout de quelques instants, le volet de débogage affiche fièrement le résultat.

Le langage Objective-C peut utiliser plusieurs autres types de variables. Les plus fréquents ont été rassemblés dans le tableau ci-dessous. Ne vous attardez pas trop sur ce tableau. Vous y reviendrez dans les sections suivantes, lorsque vous testerez des variables d'un de ces types.

Les constantes

Les constantes sont comparables aux variables, à ceci près qu'une fois définies leur valeur ne peut pas changer. Voici la syntaxe à utiliser :

const type nomConstante = valeur;

La syntaxe est identique à celle des variables, à ceci près que l'on ajoute le mot-clé const au début de l'instruction.

Par exemple :

const float pi = 3.1415926536;

En résumé, vous utiliserez des variables pour mémoriser des valeurs qui peuvent changer dans le temps et des constantes pour stocker des valeurs fixes tout au long du programme (une TVA de 19,6 \% par exemple).

Les opérateurs

Comme leur nom le laisse supposer, les opérateurs permettent d'effectuer des opérations. Dans cette section, nous allons nous intéresser aux opérateurs d'affectation et aux opérateurs arithmétiques.

Opérateurs d'affectation

Les opérateurs utilisables en Objective-C sont regroupés dans le tableau qui suit.

L'instruction suivante (issue de la deuxième ligne du tableau) vous paraît certainement un peu farfelue, voire même totalement incompréhensible :

maVariable += 5;

Il s'agit d'une facilité, ou plutôt d'un raccourci d'écriture. Cette instruction est équivalente à :

maVariable = maVariable + 5;

Est-ce que c'est plus clair pour vous maintenant ? Ou avez-vous encore un peu de mal à comprendre comment on peut stocker dans maVariable la valeur maVariable + 5 ? Si vous accrochez là-dessus, sachez que le résultat de maVariable + 5 est calculé dans un premier temps, puis ensuite stocké dans maVariable.

Les autres opérateurs d'affectation fonctionnent de même. Ainsi par exemple :

maVariable %= 5;

Est équivalent à :

maVariable = maVariable % 5;

Après l'exécution de cette instruction, maVariable contient le reste de la division entière (%) de maVariable par 5 (maVariable % 5).

C'est ce qu'on appelle un modulo. Il permet d'obtenir le reste d'une division. Par exemple, si je divise 5 par 2 ($5 / 2$), il reste 1. Ainsi, $5 % 2 = 1$

Opérateurs arithmétiques

Vous connaissez forcément les quatre opérateurs arithmétiques de base : plus, moins, divisé par et multiplié par. Vous aurez également à faire à quelques autres opérateurs, moins fréquents mais très utiles en programmation. Je les ai regroupés dans le tableau suivant.

Ne soyez pas effrayés si c'est la première fois que vous rencontrez certains de ces opérateurs.

• ++ ajoute 1 à une variable entière. À titre d'exemple, variable++ ou ++variable est équivalent à variable = variable + 1.

• -- soustrait 1 d'une variable entière. À titre d'exemple, variable-- ou --variable est équivalent à variable = variable - 1.

%problème corrigé avec "variable--" qui s'affiche en "variable-"

• % renvoie le reste d'une division entière. Par exemple $15 % 2$ renvoie 1. En effet, si vous divisez 15 par 2, le reste de la division est 1.

Et maintenant, voici quelques exemples d'utilisation :

int var1 = 10;
int var2 = 15;
int result;
result = var1 *  var2;
result++;
result = 15 % 10

• Les lignes 1 et 2 définissent les variables int var1 et var2 valant (respectivement) 10 et 15.

• La ligne 3 définit la variable int result, mais ne lui affecte aucune valeur.

• La ligne 4 affecte à result le résultat de la multiplication de var1 par var2. Après l'exécution de cette instruction, result vaut donc 150 ($10 * 15$).

• La ligne 5 ajoute 1 à la variable result. Cette dernière vaut donc 151 après l'exécution de l'instruction.

• Enfin, la ligne 6 affecte à result le reste de la division entière de 15 par 10. Après l'exécution de cette instruction, result vaut 5. En effet $15 / 10 = 1$, reste 5.

Lorsque plusieurs opérateurs apparaissent dans une expression mathématique, il est nécessaire de savoir dans quel ordre ils sont utilisés. Pour les opérateurs +, -, * et /, les règles sont les mêmes que dans l'algèbre traditionnelle. À savoir que * et / sont prioritaires par rapport à + et -. En cas de priorités identiques, les calculs sont effectués de gauche à droite.

D'après vous, quelle est la valeur stockée dans la variable result ?

float result = 10 * 2 + 120 / 2;

Le résultat de cette opération est 80. L'évaluation se fait en calculant $10*2$ puis $120/2$. Ces deux valeurs sont ensuite ajoutées. Ainsi $20 + 60 = 80$.

Si nécessaire, vous pouvez utiliser un ou plusieurs jeux de parenthèses pour modifier l'ordre d'évaluation, et donc le résultat.
D'après vous, quelle est la valeur stockée dans la variable result ?

float result = 10 * (2 + 120) / 2;

Le résultat est 610. L'opération $2 + 120$ étant entourée de parenthèses, elle est prioritaire et donc calculée en premier. Les opérateurs * et / ayant le même niveau de priorité, l'expression est évaluée de la gauche vers la droite. Ainsi, result a pour valeur 10 multiplié par 122 puis divisé par 2, soit 610.

L'opérateur unaire - (en d'autres termes, le « - » qui inverse le signe d'un nombre ou d'une variable) est prioritaire. Il en va de même des opérateurs ++ et -- lorsqu'ils sont utilisés en préfixe (++variable et --variable). Ils sont donc exécutés en premier. Viennent ensuite au même niveau les opérateurs *, / et %, et enfin les opérateurs + et-.

Et maintenant, un peu de pratique !

Dans votre projet de test, cliquez sur ViewController.m dans le volet de navigation, repérez la méthode viewDidLoad et ajoutez les lignes de code précédentes à la suite de [super viewDidLoad]. Invoquez la fonction NSLog() chaque fois que vous voulez tester une variable. Voici à quoi pourrait ressembler la méthode viewDidLoad :

- (void)viewDidLoad
{
  [super viewDidLoad];
  int var1 = 10;
  int var2 = 15;
  int result;

  result = var1 *  var2;
  NSLog(@"var1 * var2 = %d",result);

  result++;
  NSLog(@"Après le ++, result vaut  %d",result);
        
  result = 15 % 10;
  NSLog(@"15 %% 10 vaut  %d",result);
            
  float result1 = 10 * 2 + 120 / 2;
  NSLog(@"10 * 2 + 120 / 2 vaut  %f",result1);
              
  float result2 = 10 * (2 + 120) / 2;
  NSLog(@"10 * (2 + 120) / 2 vaut %f",result2);
}

Cliquez sur Run pour exécuter l'application. Si le volet de débogage n'est pas affiché, cliquez sur Hide or show the Debug area. Au bout de quelques instants, le volet de débogage affiche les divers résultats. Comme vous pouvez le voir à la figure suivante, ils sont conformes aux attentes.

Avant d'en terminer avec ceci, je voudrais faire une remarque sur une des fonctions NSLog() utilisées dans ce code.

Avez-vous remarqué un détail surprenant dans l'instruction suivante, vers le milieu de la méthode viewDidLoad ?

NSLog(@"15 %% 10 vaut  %d",result);

Le signe « % » a une signification particulière. En effet, associé à une lettre (%d ou %f par exemple), il précise le type d'une variable que l'on désire afficher. Dans cette instruction, on désire afficher le signe « % » dans le volet de débogage. C'est la raison pour laquelle il est doublé.

Un commentaire est un texte dans un programme, non pris en compte lors de l'exécution de ce dernier. Ils sont très utiles en programmation puisqu'ils vous permettent de vous y retrouver dans votre code. Imaginez que vous créiez une application et que, quelques mois ou même quelques années plus tard, vous décidiez de la mettre à jour. Même si vous êtes l'auteur du code, il vous sera difficile de tout comprendre au premier coup d'œil. C'est pourquoi il est fortement recommandé d'insérer des commentaires qui expliquent de manière claire ce que vous avez fait.

Pour insérer un commentaire qui tient sur une seule ligne, vous le ferez précéder d'un double slash :

int maVariable = 10; // maVariable vaut 10

Si le commentaire s'étale sur plusieurs lignes, vous utiliserez les caractères « /* » pour marquer le début et « */ » pour marquer la fin du commentaire :

/*
Ceci est un commentaire
sur
plusieurs lignes
*/

Les variables utilisées jusqu'ici étaient de type entier (int) et à virgule (float). Ces deux types ne sont pas les seuls. Vous allez maintenant découvrir les différents types de base utilisables en Objective-C. Vous apprendrez également à effectuer des conversions entre ces différents types de données.

Booléens

Le type BOOL est utilisé lorsque vous devez manipuler des informations de type vrai/faux, oui/non ou 0/1. Ces informations sont dites « booléennes ».

Voici quelques exemples de déclaration :

BOOL booleen1 = 0;
BOOL booleen2 = NO;
BOOL booleen3 = 1;
BOOL booleen4 = YES;

Entiers

Il n'existe pas un mais plusieurs types de variables entières. Vous choisirez un type plutôt qu'un autre en fonction des valeurs maximales que peuvent prendre les variables ou constantes concernées.

Par exemple :

int variableEntiere = 123456;
short int entierCourt = -54;

Réels

Les réels, aussi appelés « nombres à virgule flottante », sont des nombres à virgule, comme par exemple 176.45 ou encore -0.561. Selon leur précision (c'est-à-dire selon le nombre de chiffres après la virgule), ils sont mémorisés dans des variables de type float ou double.

Les variables/constantes de type float peuvent être comprises entre $\$\$3.4\backslash times\; 10^\{-38\}\$\$$ et $\$\$3.4\backslash times\; 10^\{38\}\$\$$. Quant aux variables/constantes de type double, elles peuvent être comprises entre $\$\$1.7\backslash times\; 10^\{-308\}\$\$$ et $\$\$1.7\backslash times\; 10^\{308\}\$\$$.

Il s'agit d'une convention d'écriture dite « scientifique ». 10^-38 signifie 38 zéros avant la valeur numérique. Et 3.4* signifie que le nombre 3,4 est multiplié par le nombre 10^-38. Si vous avez du mal à visualiser tout ça, la figure suivante devrait vous aider.

Caractères

Le type char permet de manipuler des chaînes composées d'un et d'un seul caractère. Le caractère manipulé doit être délimité par des apostrophes :

char monCaractere = 'a';

Les pointeurs sont généralement redoutés comme la peste par les programmeurs débutants. Pourtant, ils rendent de grands services et vous devez absolument comprendre leur fonctionnement pour bien programmer en Objective-C. Pour l'instant, retenez leur principal intérêt : ils facilitent la manipulation des objets en Objective-C. Jusqu'ici, tout va bien. Nous allons donc aller un peu plus loin.

Sachez que les pointeurs ne sont pas un type de données. Il est donc impossible d'écrire quelque chose comme ceci :

pointer maVariable;

Contrairement aux types de données, les pointeurs ne sont pas utilisés pour stocker des données, mais des adresses. Par exemple, lorsque vous faites int monEntier = 10; , un espace en mémoire (dont la taille dépend du type de la variable) est réservé pour stocker la valeur 10. Cet espace se trouve à l'adresse &monEntier. Utilisons une instruction NSLog pour afficher la valeur et l'adresse de la variable monEntier :

NSLog(@"monEntier vaut %i et son adresse en mémoire est %p",monEntier, &monEntier);

Voici le résultat affiché dans la console :

2011-07-06 17:29:47.613 test[498:207] monEntier vaut 10 et son adresse en mémoire est 0xbfffd6f4

Ce qui vient d'être dit n'est peut-être pas très clair pour vous. Si tel est le cas, nous allons prendre quelques instants pour approfondir les choses. Sans vouloir jeter un froid, voici une définition sur laquelle vous devriez méditer : « un pointeur est une variable qui contient l'adresse d'une autre variable d'un type donné ».

Examinez la figure suivante.

Le rectangle horizontal représente une partie de la mémoire de votre ordinateur. Chaque case correspond à un emplacement en mémoire. Pour repérer facilement les différents emplacements, on leur affecte un nombre appelé « adresse ». Dans cette figure, l'emplacement d'adresse 17 contient un pointeur vers l'emplacement d'adresse 207. En utilisant le « pointeur » d'adresse 17, on pourra donc accéder à la donnée stockée à l'adresse 207. En résumé :

• les pointeurs sont utilisés pour mémoriser des adresses, pas des données ;

• les données contenues dans les emplacements en mémoire ainsi « pointés » peuvent changer ;

• les variables, quant à elles, ont un type défini une fois pour toutes et sont donc « figées ».

Les deux derniers points représentent la différence essentielle entre les pointeurs et les variables. Si vous réfléchissez à cela, vous découvrirez un autre intérêt majeur des pointeurs : ils font référence à des données dont le contenu et la taille peuvent changer.

Voyons comment définir un pointeur en Objective-C :

int *pointeurSurMonEntier;

Supposons que pointeurSurMonEntier représente l'adresse de la variable monEntier. Afin de relier ces deux éléments, nous allons utiliser le signe & :

int monEntier = 10;
int *pointeurSurMonEntier = &monEntier;

Il est possible de modifier la valeur d'une variable en agissant sur son pointeur. Par exemple, pour affecter la valeur 25 à la variable monEntier, on peut utiliser indifféremment les deux instructions suivantes :

monEntier = 25;
*pointeursurMonEntier = 25;

Chaînes de caractères

Les chaînes de caractères sont composées de zéro, un ou plusieurs caractères. Comme il a été vu un peu plus tôt, les variables et constantes de type char ne peuvent mémoriser qu'un et un seul caractère. Pour mémoriser des chaînes, nous utiliserons des pointeurs de char.

Les pointeurs de char sont des zones mémoire qui mémorisent l'emplacement d'une suite de zéro, un ou plusieurs char. C'est précisément ce que sont les chaînes de caractères. Les pointeurs de char sont donc particulièrement bien adaptés à leur définition.

À titre d'exemple, l'instruction suivante définit la chaîne nom et l'initialise avec une chaîne de caractères :

char *nom = "Mon nom est Bond, James Bond";

Structures

Jusqu'ici, nous avons étudié des types de données « simples » : booléens, entiers, flottants, doubles, caractères et chaînes de caractères. Il est parfois nécessaire de regrouper plusieurs informations disparates dans une seule et même variable. Imaginez par exemple que vous désiriez mémoriser le prénom, le nom et l'âge de plusieurs personnes. Le plus simple consiste à regrouper ces informations dans une structure en utilisant l'instruction struct :

struct unePersonne
{
  char *prenom;
  char *nom;
  int age;
};

Une fois cette structure définie, on peut définir une variable de type unePersonne et accéder à ses différentes composantes en utilisant des instructions « à point ». Par exemple :

struct unePersonne schwarzi;
schwarzi.prenom = "Arnold";
schwarzi.nom = "Schwarzenegger";
schwarzi.age = 64;

Conversions de type

Dans votre vie de programmeur Objective-C, vous serez souvent amenés à convertir une variable d'un certain type en une variable d'un autre type. En effet, les types des variables manipulées doivent être exactement ceux attendus dans le langage, sans quoi une erreur se produira et il sera impossible d'exécuter le programme.

La conversion peut être « implicite » (c'est-à-dire sans nécessiter l'intervention du programmeur) ou « explicite » (c'est-à-dire en utilisant un opérateur de conversion).

Conversion implicite

Examinons les quelques lignes de code suivantes :

int a = 10;
float b = 13.562;
int c = a * b;
float d = a * b;

Le produit de a par b est égal à 135.62. Cette valeur est de type flottant puisqu'elle comporte des décimales.

Quelles valeurs auront les variables c et d selon vous ?

À la ligne 3, lorsque la valeur 135.62 est stockée dans la variable entière c, elle est « tronquée » (c'est-à-dire privée de ses décimales) à 135. L'instruction int c = a * b; a effectué une conversion implicite du type float vers le type int afin que le résultat puisse être mémorisé dans la variable entière c.

Par contre, dans la ligne 4, lorsque la valeur 135.62 est stockée dans la variable flottante d, elle est égale à 135.62.

Conversion explicite

Pour effectuer une conversion explicite (on dit aussi un casting), il suffit de préciser le type visé entre parenthèses avant la valeur à convertir.

int a = 10;
float b = 13.562;
float c = a * (long int)b;
NSLog(@"%f",c);

La variable b est de type float, puisqu'elle est déclarée comme telle à la ligne 2.
Le casting (long int)b convertit la valeur de la variable b en un long int. Cette valeur est ensuite multipliée par la valeur contenue dans la variable a, de type int. Le résultat est donc de type long int.
Enfin, ce résultat est stocké dans la variable c de type float (float c =). Il est donc converti dans le type float.

Quel résultat sera affiché par l'instruction NSLog selon vous ?
Le casting de b en un long int donne la valeur entière 13. Le résultat de la multiplication est donc 130. Mais étant donné que ce résultat est stocké dans une variable float, NSLog affichera 130.000000.

Pour aller un peu plus loin, nous allons nous intéresser à un autre exemple, basé sur l'utilisation d'un code ASCII.

ASCII est l'abréviation de American Standard Code for Information Interchange. Il s'agit d'une norme d'encodage des caractères alphanumériques de l'alphabet latin. Ainsi par exemple, le nombre 64 représente le caractère « @ », le nombre 65 représente le caractère « A », le nombre 66 représente le caractère « B », et ainsi de suite. Pour avoir de plus amples informations sur le codage ASCII, je vous suggère de vous reporter à cette table ASCII.

Voici notre exemple :

int i = 65;
char c = (char)i;
NSLog(@"%c", c);

En lui appliquant un casting de type (char), la variable char c est initialisée avec le caractère A. C'est donc ce qu'affiche l'instruction NSLog. L'entier 65 est donc équivalent au caractère A.

En résumé

• Une variable permet de stocker temporairement des informations dans la mémoire de votre device et d'y accéder par la suite.

• Pour définir une variable, vous utiliserez l'instruction suivante : type nomVariable;.

• Il est possible d'affecter directement une valeur à une variable lors de sa définition : type nomVariable = valeur;.

• Pour définir une constante, utilisez la syntaxe suivante : const type nomConstante = valeur;.

• Un certain nombre de traitements peuvent être appliqués aux variables par l'intermédiaire d'opérateurs. On distingue essentiellement les opérateurs d'affectation (=, +=, -=, /=, *= et %=) et les opérateurs arithmétiques (+, -, ++, --, *, / et %).

• Les commentaires peuvent occuper une seule ligne. Dans ce cas, ils sont précédés d'un double slash (//). Ils peuvent également s'étaler sur plusieurs lignes. Dans ce cas, ils commencent par les caractères /* et se terminent par les caractères */.

• Les variables sont caractérisées par leur type : booléen, entier, réel, caractère, chaîne, pointeur et structure.

• Les conversions de types peuvent être implicites (lors de la définition d'une variable) ou explicites (en précisant le type recherché entre parenthèses avant la valeur à convertir).

En programmation, on utilise des conditions pour tester la valeur des variables. Selon le résultat obtenu, zéro, une ou plusieurs instructions peuvent alors être exécutées.
Avant de nous intéresser aux conditions, nous allons passer un peu de temps avec les opérateurs de comparaison. En effet, ces opérateurs sont très souvent utilisés dans des conditions. Par exemple pour savoir si une variable est supérieure à une autre, ou encore si une variable est égale à zéro.

Opérateurs de comparaison

Les opérateurs de comparaison (dits logiques) sont très importants. Ils permettent de comparer des valeurs entre elles. Par leur intermédiaire, vous pourrez savoir qui de Pierre ou de Jean est le plus grand, ou encore si les prunes sont plus chères au kilo que les bananes. J'ai regroupé tous les opérateurs logiques dans le tableau suivant.

Maintenant, nous allons mettre en pratique les opérateurs de comparaison en les utilisant dans des conditions.

if

Pour tester une condition, l'opérateur de base est le if ( « si » en français). Par exemple, imaginez que la variable pointure contienne une pointure de chaussures. Si la pointure est inférieure ou égale à 30, vous voulez afficher un message qui dit « Vous devez vous chausser au rayon enfants ». Vous écrirez quelque chose comme ceci :

if (pointure <= 30)
{
  NSLog(@"Vous devez vous chausser au rayon enfants");
}

Si la condition est vérifiée (si la variable pointure est inférieure ou égale à 30), alors ce qui se trouve entre les accolades sera exécuté. Les plus observateurs d'entre vous auront sans doute remarqué que la condition ainsi que les accolades la délimitant ne se terminent pas par un « ; ». C'est tout à fait normal, ce ne sont pas des instructions.

Bien entendu, il est possible d'exécuter plusieurs instructions :

if (pointure <= 30)
{
    NSLog(@"Vous avez de petits pieds");
    NSLog(@"Vous devez vous chausser au rayon enfants");
    // etc.
}

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants"); // Ici les accolades sont facultatives

Que diriez-vous d'un peu de pratique ?
Ouvrez le projet de test créé au chapitre précédent. Si vous ne l'avez plus, pas de panique, vous pouvez en créer un nouveau, il fera aussi bien l'affaire.

Cliquez sur ViewController.m dans le volet de navigation et complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
    [super viewDidLoad];
    int pointure = 29;
    if (pointure <= 30)
    {
        NSLog(@"Vous avez de petits pieds");
        NSLog(@"Vous devez vous chausser au rayon enfants");
    }
}

À la ligne 4, la variable pointure est initialisée à 29. Mais rien ne vous empêche de choisir une autre valeur.

Exécutez l'application en cliquant sur Run. Si nécessaire, affichez le volet de déboguage en cliquant sur Hide or show the Debug area. Voici ce qui devrait s'afficher dans le volet de déboguage :

Attaching to process 877.
2011-11-18 11:35:20.428 test[877:f803] Vous avez de petits pieds
2011-11-18 11:35:20.430 test[877:f803] Vous devez vous chausser au rayon enfants

else

Il arrive parfois que l'on doive exécuter une instruction si une condition est remplie, et une autre instruction dans le cas contraire. Pour cela, on a recours au mot-clé else (c'est-à-dire « sinon » en français) :

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else
  NSLog(@"Vous devez vous chausser au rayon adultes");

elseif

Imaginez maintenant que vous vouliez exécuter :

• une première instruction si la pointure est inférieure ou égale à 30 ;

• une deuxième instruction si la pointure est supérieure à 45 ;

• une troisième instruction si la pointure ne répond à aucune de ces deux conditions.

Pour cela, vous utiliserez les mots clés if (si), else if (sinon si) et else (sinon) :

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else if (pointure > 45)
  NSLog(@"Vous devez vous chausser sur mesure");
else
  NSLog(@"Vous devez vous chausser au rayon adultes");

Il est bien évidemment possible d'utiliser plusieurs else if. Vous pourriez très bien écrire quelque chose comme ceci, même si l'intérêt de ce code est limité :

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else if (pointure == 36)
  NSLog(@"Vous chaussez du trente six");
else if (pointure == 37)
  NSLog(@"Vous chaussez du trente sept");
else if (pointure == 38)
  NSLog(@"Vous chaussez du trente huit");

N'hésitez pas à tester ce code (n'oubliez pas de déclarer votre variable pointure) en changeant ses valeurs. C'est comme ça qu'on apprend !

Plusieurs conditions dans un test

Les opérateurs logiques && (et), || (ou) et ! (non) peuvent être utilisés dans une condition. Par exemple, pour tester si la pointure est supérieure à 35 et inférieure à 42, vous écrirez ceci :

if (pointure >35 && pointure <42)

D'après-vous, que devriez-vous écrire pour tester si la pointure est comprise entre 35 et 42, mais différente de 40. Je vous laisse quelques instants…

Voilà la solution :

if (pointure >35 && pointure <42 && pointure != 40)

Facile, non ?

Il est parfois nécessaire d'utiliser des parenthèses dans un test complexe pour modifier l'ordre d'exécution des éléments qui composent le test. Par exemple, les deux tests suivants ne sont pas équivalents :

if ((a+3)/4 < 10)
if (a+3/4 < 10)

Le premier test ajoute 3 à la variable a, divise cette somme par 4 et compare le résultat obtenu à 10. Le deuxième test ajoute 3/4 à la variable a et compare le résultat obtenu à 10.

À titre d'information, voici l'ordre d'exécution des principaux opérateurs, du plus prioritaire vers le moins prioritaire :

L'instruction switch

Il existe une variante de l'instruction if… elseif… else… : l'instruction switch. Voici sa syntaxe :

switch (variable)
{
  case valeur1:
    une ou plusieurs instructions;
    break;
  case valeur2:
    une ou plusieurs instructions;
    break;
  case valeur3:
    une ou plusieurs instructions;
    break;
  ...
  default:
    une ou plusieurs instructions;
    break;
}

Où :

• variable est la variable utilisée dans le test ;

• les case valeur1:, case valeur2:, etc. correspondent aux valeurs à tester ;

• une ou plusieurs instructions sont des instructions définies sur une ou plusieurs lignes;

• les instructions situées après le mot default sont exécutées lorsqu'aucune des conditions spécifiées dans les instructions case n'a été vérifiée ;

• break marque la fin des instructions qui suivent une instruction case ou default.

L'instruction switch est un peu plus complexe que celles que nous avons vu jusqu'ici. Un exemple va vous aider à en comprendre le fonctionnement.

Considérez le test suivant :

if (pointure == 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else if (pointure ==36)
  NSLog(@"Vous chaussez du trente six");
else if (pointure ==37)
  NSLog(@"Vous chaussez du trente sept");
else if (pointure ==38)
  NSLog(@"Vous chaussez du trente huit");
else
  NSLog(@"Vous ne chaussez pas du 30, 36, 37 ou 38");

Vous pourriez tout aussi bien écrire :

switch (pointure)
{
  case 30:
    NSLog(@"Vous devez vous chausser au rayon enfants");
    break;
  case 36:
    NSLog(@"Vous chaussez du trente six");
    break;
  case 37:
    NSLog(@"Vous chaussez du trente sept");
    break;
  case 38:
    NSLog(@"Vous chaussez du trente huit");
    break;
  default:
    NSLog(@"Vous ne chaussez pas du 35, 36, 37 ou 38");
    break;
}

Encore une fois, n'hésitez pas à tester ce code en modifiant ses valeurs.

En programmation, il est souvent nécessaire d'exécuter à plusieurs reprises une instruction ou un groupe d'instructions, par exemple tant qu'une condition n'est pas vérifiée.

Supposons que vous vouliez afficher à dix reprises le mot « Bonjour ». Comment vous y prendriez-vous ? La première idée qui vient à l'esprit consiste à répéter dix fois l'instruction d'affichage NSLog :

NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");

Imaginez maintenant que vous vouliez répéter 100 fois l'affichage du mot « Bonjour ». Allez-vous écrire cent fois la même instruction ? Heureusement non ! Il existe plusieurs solutions bien plus élégantes : vous utiliserez pour cela une boucle for, while ou do while.

Dans tous les cas, la procédure est la même. Regardez la figure suivante, elle représente le fonctionnement d'une boucle.

Voici ce qui se passe:

• l'ordinateur lit les instructions de haut en bas ;

• arrivé à la fin de la boucle, il retourne à la première instruction ;

• il lit de nouveau les instructions de haut en bas ;

• il repart à la première instruction ;

• etc

Malheureusement il y a un problème : la boucle est infinie! Si on ne l'arrête pas, l'ordinateur va lire les instructions ad vitam æternam. Heureusement, les conditions vont nous aider. Lorsqu'on crée une boucle, on indique une condition pour sortir de la boucle.

La boucle for

La boucle for est là pour vous éviter une luxation du poignet. Voici sa syntaxe :

for (début; fin; incrément)
{
  //Une ou plusieurs instructions
}

Trois paramètres sont passés à l'instruction for :

• début représente la valeur initiale du compteur de boucle ;

• fin représente la condition qui permet de décider si la boucle se poursuit ou se termine ;

• incrément modifie la valeur du compteur de boucle à la fin de chaque tour de boucle.

Tout ceci vous semble peut-être obscur. Rassurez-vous, un petit exemple va vite clarifier les choses. Considérez le code suivant :

int compteur;
for (compteur = 0; compteur < 100; compteur++)
{
  NSLog(@"Bonjour");
}

Lors de la première exécution de la boucle, la variable entière compteur est initialisée à 0. La condition compteur < 100 est alors vérifiée, puisque 0 < 100. L'instruction NSLog est exécutée, l'ordinateur repart au début de la boucle.

Lors de la deuxième exécution de la boucle, le compteur est incrémenté de 1 (compteur++). Il a donc pour valeur 1. La condition étant vérifiée (1 < 100), l'instruction NSLog est de nouveau exécutée.

Ainsi de suite jusqu'à ce que compteur soit égal à 100. Dans ce cas, la boucle for prend fin et le programme continue de s'exécuter. Si vous faites le compte, l'instruction NSLog aura été exécutée … 100 fois, ce qui est exactement l'effet recherché.

Etant donné qu'une seule instruction est exécutée dans la boucle for, les accolades ne sont pas obligatoires. Dans notre exemple, vous auriez donc tout aussi bien pu écrire :

for (compteur = 0; compteur < 100; compteur++)
  NSLog(@"Bonjour");

Que diriez-vous d'un peu de pratique?

Toujours dans votre projet test, cliquez sur ViewController.m dans le volet de navigation. Repérez la méthode viewDidLoad et complétez-la comme suit :

- (void)viewDidLoad
{
    [super viewDidLoad];
    int compteur;
    for (compteur = 0; compteur < 100; compteur++)
        NSLog(@"Bonjour");
}

Exécutez l'application en cliquant sur Run. Très rapidement, cent lignes contenant le mot "Bonjour" sont affichées dans le volet de déboguage :

Attaching to process 2440.
2011-11-18 15:22:32.967 test[2440:f803] Bonjour
...
2011-11-18 15:22:33.048 test[2440:f803] Bonjour

La boucle while

La boucle while est une variante de l'instruction for. Elle exécute une ou plusieurs instructions tant qu'une condition est vérifiée. Voici sa syntaxe :

while(condition)
{
  //Une ou plusieurs instructions
}

Voyons comment résoudre notre problème précédent avec une boucle while.

int compteur = 0;
while (compteur < 100)
{
  NSLog(@"Bonjour");
  compteur++;
}

La première instruction initialise à 0 la variable compteur.

La boucle while se poursuit jusqu'à ce que la variable compteur soit supérieure ou égale à 100 (while (compteur < 100)). Lors de l'entrée dans la boucle, compteur vaut 0.

Les instructions entre les accolades sont donc exécutées: la première affiche le texte « Bonjour », la deuxième incrémente d'un la variable compteur, qui vaut alors 1.

Après l'incrémentation, la condition compteur < 100 est toujours vérifiée, puisque compteur vaut 1. Les instructions à l'intérieur des accolades sont donc exécutées une nouvelle fois.

Ainsi de suite jusqu'à ce que compteur soit égal à 100.

N'hésitez pas à tester le fonctionnement de la boucle while. Dans votre projet test, repérez la méthode viewDidLoad et complétez-la comme suit :

- (void)viewDidLoad
{
    [super viewDidLoad];
    int compteur = 0;
    while (compteur < 100)
    {
        NSLog(@"Bonjour");
        compteur++;
    }
}

Exécutez l'application en cliquant sur Run pour constater que cent lignes contenant le mot "Bonjour" sont affichées dans le volet de débogage.

Vous pouvez vous amuser à modifier la condition initiale du compteur (ligne 4) et la limite supérieure du compteur (ligne 5). Relancez l'application pour voir l'effet résultant.

La boucle do while

L'instruction do while est une variante de l'instruction while. Mais ici, la condition est testée après l'exécution des instructions entre accolades. Dans tous les cas, les instructions entre les accolades seront donc exécutées au moins une fois. Voici la syntaxe de cette instruction :

do
{
  //Une ou plusieurs instructions
} while (condition);

Si on voulait adapter notre exemple précédent, voici comment il faudrait faire avec une boucle do while :

int compteur = 0;
do
{
  NSLog(@"Bonjour");
  compteur++;
} while (compteur < 100);

La première instruction initialise la variable compteur à 0. Les instructions entre les accolades sont alors exécutées une première fois : le mot « Bonjour » est affiché avec la fonction NSLog() et la variable compteur est incrémentée de 1.

La condition à la suite du while est alors examinée. Après la première exécution des instructions entre les accolades, compteur vaut 1. Il est donc bien inférieur à 100 et la boucle se poursuit. Ainsi de suite jusqu'à ce que compteur devienne égal à 100.

Une fonction peut être comparée à une boîte dont l'intérieur ne peut être vu. On lui fournit (éventuellement) une ou plusieurs données, elle effectue un traitement et retourne (éventuellement) une ou plusieurs autres données (figure suivante).

Une fonction consiste donc en un ensemble d'instructions qui effectuent un traitement et transforment les données qui lui sont fournies en d'autres données.

Découper le code d'une application en plusieurs fonctions présente plusieurs avantages : chaque fonction étant indépendante du reste du code, il est facile de la tester et de la faire évoluer au grès des différentes versions de l'application.

Pour déclarer une fonction, vous utiliserez la syntaxe suivante :

type nom(paramètres)
{
  //Une ou plusieurs instructions
  return retour;
}

Où :

• type indique le type de la donnée retournée par la fonction (int, float etc.),

• nom est le nom de la fonction ;

• paramètres représente les éventuelles données fournies à la fonction ;

• retour représente la donnée renvoyée par la fonction.

La fonction nom utilise le ou les paramètres qui lui sont fournis pour effectuer un traitement et retourner la donnée retour.

L'appel d'une fonction n'a rien de bien compliqué : il suffit d'indiquer son nom, éventuellement suivi des paramètres qui doivent lui être passés. Si la fonction renvoie une valeur, vous l'affecterez à une variable du même type que la valeur renvoyée.

À titre d'exemple, la fonction ttc ci-après renvoie le prix TTC correspondant au prix HT qui lui est passé. Le prix HT et le prix TTC sont de type float.

float ttc(float ht)
{
  return ht * 1.196;
}

Ici un paramètre de type float doit être fourni à la fonction (le prix HT) qui renvoie une valeur de type float. L'instruction utilisée sera donc du type suivant (ici, nous calculons la valeur TTC correspondant à un prix HT de 100) :

float lePrixTTC = ttc(100);

Il est possible d'aller plus loin! Supposons que la fonction TTC doive calculer deux types de prix TTC : un avec une TVA de 5,5%, un autre avec une TVA de 19.6%. Comment devriez-vous compléter la fonction ttc précédente ? Je vous laisse réfléchir.

...

Si c'est vraiment trop difficile pour vous, je vais vous mettre sur la voie :

• La fonction va avoir besoin de connaître le prix HT et la TVA à appliquer. Ces éléments seront passés à la fonction sous la forme de paramètres, donc entre les parenthèses. La TVA peut être fournie à la fonction telle quelle, au format float, ou représentée par un nombre int, qui pourrait valoir "1" dans le cas d'une TVA à 5,5% et "2" dans le cas d'une TVA à 19,6%.

• Dans la fonction, il faudra effectuer un calcul ou un autre en fonction du taux de TVA à appliquer. Une instruction if semble donc tout à fait appropriée.

Cette fois-ci, je vous laisse vraiment réfléchir. Vous avez tous les éléments pour écrire cette fonction.

Voici le code que je vous propose :

float ttc(float ht, int tva)
{
  if (tva==1)
    return ht * 1.055;
  else
    return ht * 1.196;
}

La fonction ttc a maintenant deux paramètres : le prix HT et la TVA. Le deuxième paramètre est de type int. S'il est égal à 1, la fonction ttc renverra un prix TTC calculé avec une TVA de 5.5%. Dans tous les autres cas, la fonction ttc renverra un prix TTC calculé avec une TVA de 19.6%.

Et pour appeler la fonction:

float prix1 = ttc (100, 1); // Prix HT de 100 et TVA à 5,5%
float prix2 = ttc (100, 2); // Prix HT de 100 et TVA à 19,6%

Par exemple, une fonction qui affiche le mot « Bonjour » dans le volet de débogage ne demande aucun paramètre et ne retourne aucune valeur. Elle pourrait avoir l'allure suivante :

void bonjour(void)
{
  NSLog(@"Bonjour\n");
}

En résumé

• Pour comparer des valeurs entre elles, on utilise des opérateurs logiques.

• Pour tester une condition, on utilise if, else if et else.

• Il est possible d'effectuer plusieurs conditions dans un test, en séparant ces conditions par un opérateur logique.

• switch est équivalent à if... elseif... else.... Cela permet de comparer une variable avec plusieurs valeurs et d'exécuter une ou plusieurs instructions en conséquence.

• Pour répéter un certain nombre de fois une ou plusieurs instructions, vous utiliserez une boucle for, while ou do while. La boucle for est particulièrement bien adaptée lorsque l'on connaît le nombre d'itérations de la boucle. Les instructions while et do while prennent fin lorsqu'une condition logique est vérifiée.

• Une fonction consiste en un ensemble d'instructions qui effectuent un traitement et transforment les données qui lui sont fournies en d'autres données. Pour définir une fonction, précisez son type, la ou les variables qui lui sont passées en paramètre et utilisez return pour retourner une valeur. Pour appeler une fonction, indiquez son nom et passez-lui une ou plusieurs variables entre parenthèses.

Dans la programmation « traditionnelle », les programmes sont constitués d'un ensemble d'instructions qui s'exécutent les unes à la suite des autres (voir figure suivante).

Dans la plupart des programmes, on définit une boucle qui ne fait rien d'autre qu'attendre l'arrivée d'un événement. Par exemple, la fin d'un calcul, un changement d'heure, un clic souris ou un autre type d'événement quelconque. Si aucun événement ne se produit, la boucle se contente d'attendre, encore et encore. C'est pourquoi on l'appelle souvent « boucle d'attente ». Si un événement survient, il est identifié et traité en conséquence. La figure suivante illustre mes propos.

Dans la programmation orientée objet, les programmes sont constitués d'un ensemble de blocs de code indépendants appelés objets. Chaque objet contient sa propre boucle d'attente. Lorsqu'un événement concernant un objet particulier survient, c'est à cet objet de traiter l'événement, comme le montre la figure suivante.

Les langages orientés objet utilisent plusieurs termes techniques bien particuliers. Pour vous aider à les appréhender, je vais utiliser une analogie en me basant sur des objets courants de la vie de tous les jours : des voitures.

Une voiture est définie par un ensemble de caractéristiques : modèle et couleur entre autres. Elle est fabriquée dans une usine. Lors de la fabrication, une ou plusieurs options sont ajoutées au modèle de base.

Dans un langage orienté objet :

• l'usine est une classe : c'est elle qui fabrique les objets ;

• la voiture est un objet ;

• les caractéristiques de la voiture sont des propriétés ;

• les options sont des méthodes de la classe Usine.

Je vous ai fait un schéma en figure suivante pour vous aider à mieux visualiser tout ça.

Maintenant que vous avez le vocabulaire nécessaire, nous allons rentrer dans le vif du sujet.

Revenons au petit monde des devices Apple. Une application iOS est bâtie autour d'une classe qui contient un ensemble d'objets, de propriétés (qui représentent l'état des objets) et de méthodes (qui régissent le fonctionnement des objets) (voir figure suivante) .

Supposons que vous vouliez définir la classe maClasse (oui, je sais, c'est très original !).
Vous devrez agir dans deux fichiers distincts : maClasse.h et maClasse.m.

• maClasse.h est un fichier d'en-têtes. Il est utilisé pour déclarer les éléments manipulés dans le code.

• maClasse.m contient le code source de l'application.

Le fichier .h

Pour interagir avec ses utilisateurs, une application utilise une interface. Dans une application iOS, cette interface peut contenir du texte, des images, des vidéos, des boutons et bien d'autres choses encore. En tant que programmeur, vous devrez utiliser des classes pour définir ces différents éléments. Bien qu'il soit possible de définir à partir de zéro tous ces éléments (forme, ombrage, couleur, comportement sur l'écran etc.), vous préférerez sans aucun doute utiliser des classes toutes faites. Pour faciliter la vie des développeurs, Apple a eu la bonne idée de regrouper ces classes dans une sorte de boîte à outils (on dit aussi framework) appelée UIKit. C'est par son intermédiaire que vous pourrez ajouter du texte, des images, des boutons, des vidéos, etc. à vos applications.

Pour établir le lien entre l'application en cours de développement et le framework UIKit, la première instruction d'un fichier .h doit toujours être la suivante :

#import <UIKit/UIKit.h>

Cette simple instruction donne accès à toutes les classes du framework UIKit.

Les lignes qui suivent l'instruction #import définissent le nom et le type de l'application, ainsi que les variables utilisées dans l'application :

@interface nom : type 
{
  Une ou plusieurs variables
}

Où nom est le nom de l'application et type définit son type.

Supposons donc que vous définissiez l'application test de type UIViewController. L'instruction @interface aura l'allure suivante :

@interface testViewController : UIViewController
{
  //Une ou plusieurs variables
}

Les variables définies entre les accolades sont appelées variables d'instance.

Quand vous développez une application iOS, vous définissez une nouvelle classe. Lorsque l'application est lancée, on dit qu'une « instance de la classe » est créée. Cela signifie qu'un objet de cette classe est créé. Les variables d'instance sont propres à cette instance : si vous lancez deux fois l'application, les variables utilisées dans la première instance ne seront pas liées à la seconde, et inversement. Si vous avez du mal à comprendre, la figure suivante devrait vous éclairer.

Voici un exemple de fichier d'en-têtes .h :

#import <UIKit/UIKit.h>

@interface Voiture : NSObject {
  NSString* modele;
  NSString* couleur;
}
@end

La classe a pour nom Voiture. Le fichier qui définit l'interface a donc pour nom Voiture.h.

La classe Voiture possède deux variables d'instance NSString : modele et couleur.

NSString représente le type des variables modele et couleur. Il s'agit d'un type permettant de manipuler des chaînes de caractères.
L'astérisque indique que les variables modele et couleur sont des pointeurs de NSString. Elles contiendront donc l'adresse des chaînes et non les chaînes elles-mêmes. Comme vous le verrez tout au long de ce livre, l'utilisation de pointeurs dans Objective-C est monnaie courante.

Définir des variables d'instance, c'est bien, mais pouvoir y accéder, c'est mieux ! En effet, les variables d'instance sont là pour mémoriser des données, et ces données doivent pouvoir être écrites dans les variables d'instance et lues depuis les variables d'instance.

Pour accéder aux variables d'instance, nous allons ajouter des getters (pour connaître la valeur stockée dans les variables) et des setters (pour stocker des valeurs dans les variables et y accéder) :

- (NSString*) modele;
- (NSString*) couleur;
- (void) setModele: (NSString*)input;
- (void) setCouleur: (NSString*)input;

Les deux premières instructions sont des getters. Elles permettent de lire les valeurs stockées dans les variables d'instance modele et couleur ; en d'autres termes, de connaître le modèle et la couleur de la voiture. La valeur renvoyée est de type NSString. Au début de ces deux lignes, le signe - indique qu'il s'agit de méthodes d'instance.

Les deux dernières lignes sont des setters. Elles permettent de stocker des valeurs dans les variables d'instance modele et couleur, c'est-à-dire définir le modèle et la couleur de la voiture. Ici aussi, il s'agit de méthodes d'instance, d'où le signe - au début des instructions. Ces méthodes ne renvoient aucune valeur, ce qui explique le (void) au début des instructions.

Le fichier d'en-têtes est maintenant complet. Voici les instructions qui le composent :

#import <UIKit/UIKit.h>

@interface Voiture : NSObject {
  NSString* modele;
  NSString* couleur;
}
- (NSString*) modele;
- (NSString*) couleur;
- (void) setModele: (NSString*)input;
- (void) setCouleur: (NSString*)input;
@end

Le fichier .m

Nous allons maintenant implémenter (c'est-à-dire écrire le code de) la classe Voiture en définissant ses getters et ses setters dans le fichier Voiture.m. Je vous rappelle que les getters vont permettre de lire le contenu des variables d'instance et que les setters vont permettre de les modifier.

Commençons par les getters. Le but du jeu est d'obtenir la valeur stockée dans les variables d'instance modele et couleur. Une simple instruction return fera donc l'affaire :

#import "Voiture.h"
@implementation Voiture
- (NSString*) modele {
  return modele;
}
- (NSString*) couleur {
  return couleur;
}
@end

Passons maintenant aux setters. Leur but est de modifier les valeurs contenues dans les variables d'instance modele et couleur. Que pensez-vous du code suivant ?

- (void) setModele: (NSString*)nouvModele {
  modele = nouvModele;
}
- (void) setCouleur: (NSString*)nouvCouleur {
  couleur = nouvCouleur;
}

Vous devez encore écrire une méthode pour définir et initialiser les variables d'instance. Cette méthode est le constructeur de la classe. Elle pourrait contenir quelque chose comme ceci :

- (id) init
{
  if ( self = [super init] )
  {
    [self setModele:@"Maserati Spyder"];
    [self setCouleur:@"Rouge"];
  }
    return self;
}

La première ligne identifie le constructeur. Ne cherchez pas à comprendre le pourquoi du comment : c'est la syntaxe à utiliser !

En observant les lignes 5 et 6, vous pouvez déduire que ces deux instructions affectent la valeur « Maserati Spyder » à la variable d'instance modele en utilisant le setter setModele et la valeur « Rouge » à la variable d'instance couleur en utilisant le setter setCouleur. Rien ne vous empêche de choisir d'autres valeurs par défaut, mais j'ai pensé que ce choix n'était pas dépourvu d'intérêt.

La troisième ligne affecte le résultat de [super init] à self.

Le mot self identifie l'objet courant. Dans notre cas, une instance de la classe Voiture. Quant au mot super, il identifie la classe « parente », c'est-à-dire la classe à partir de laquelle la classe Voiture a été créée. Un simple coup d'œil au fichier Voiture.h nous montre que la classe parente de Voiture est NSObject :

@interface Voiture : NSObject {
  ...
}

[super init] exécute donc la méthode init de la classe parente. Ici, NSObject. Cette méthode initialise la classe Voiture. La valeur renvoyée est nil si un problème s'est produit pendant l'initialisation. Dans le cas contraire, l'adresse de l'objet Voiture est renvoyée.

L'instruction if teste la valeur stockée dans self, c'est-à-dire la valeur retournée par [self init]. Si la valeur renvoyée est différente de nil, les variables d'instance peuvent être initialisées. Dans le cas contraire, il est inutile de poursuivre l'exécution puisque l'initialisation de la classe a échoué.

J'espère que l'initialisation de la classe n'a maintenant plus aucun secret pour vous. N'hésitez pas à relire plusieurs fois les lignes qui précèdent jusqu'à ce que vous ayez bien compris. Ne vous en faites toutefois pas si vous ne comprenez pas encore parfaitement cette section. Cela viendra avec la pratique et vous n'en êtes encore qu'à vos premiers pas en programmation Objective-C. Et croyez-moi, c'est assurément la partie la plus difficile de votre apprentissage !

Allez, pour vous encourager, voici le code complet du fichier Voiture.m :

#import "Voiture.h"
@implementation Voiture
- (NSString*) modele {
  return modele;
}
- (NSString*) couleur {
  return couleur;
}
- (void) setModele: (NSString*)nouvModele
{
  modele = nouvModele;
}
- (void) setCouleur: (NSString*)nouvCouleur
{
  couleur = nouvCouleur;
}
- (id) init
{
  if ( self = [super init] )
  {
    [self setModele:@"Ferrari 360"];
    [self setCouleur:@"Rouge"];
  }
  return self;
}

@end

Les méthodes Objective-C peuvent être attachées à une classe (méthode de classe) ou à une instance (méthode d'instance). Par exemple, stringWithFormat est une méthode de classe, rattachée à la classe NSString ; ou encore arrayWithArray est une méthode de classe, rattachée à la classe NSArray.

Dans une de vos applications, vous pourriez être amenés à définir une méthode d'instance nombreElementsTableau qui renverrait le nombre d'éléments du tableau qui lui est communiqué en paramètre.
Voici la syntaxe générale permettant de déclarer une méthode :

typeMethode (typeRetour) nomMethode : paramètres
{
  //Une ou plusieurs instructions
};

Où :

• typeMethode vaut + pour une méthode de classe ou - pour une méthode d'instance ;

• typeRetour est le type de l'objet retourné par la méthode ;

• nomMethode est le nom de la méthode ;

• parametres correspond aux paramètres de la méthode, s'ils existent. Dans ce cas, ils sont constitués d'un ou de plusieurs couples (type)nom, où type est le type du paramètre et nom le nom du paramètre.

Quelques exemples vont vous aider à y voir plus clair.
L'instruction suivante déclare la méthode d'instance premierJour, qui renvoie le nom du premier jour de la semaine lorsqu'on lui transmet une année (an) et un numéro de semaine (numSem) :

- (NSString *) premierJour : (int) an: (int) numSem;

Cette autre instruction déclare la méthode de classe maMethode, qui ne renvoie rien (void) et qui ne demande aucun paramètre :

+ (void) maMethode ;

Enfin, cette dernière instruction déclare la méthode d'instance changePropriete, qui renvoie un booléen et qui admet deux paramètres : le nom de la propriété à modifier (prop) et la valeur à lui affecter (valeur) :

- (BOOL) changePropriete: (NSString *)prop: (NSString *)valeur;

Avant la pratique, un peu de théorie

En Objective-C, appeler une méthode de classe revient à envoyer un message. Pour cela, on utilise une syntaxe un peu particulière : le nom de l'objet est placé entre crochets et on le fait suivre du nom de la méthode :

[objet methode];

Si la méthode demande une valeur en entrée, faites suivre le nom de la méthode par le caractère « : » et entrez la valeur après ce caractère :

[objet methode:entree];

Si une méthode demande plusieurs paramètres, séparez-les par un espace et indiquez la valeur de ces paramètres après le caractère « : ». Ici par exemple, trois paramètres sont transmis à la méthode. Le premier suit le nom de la méthode (methode:valeur1) et les deux autres sont précédés du nom du paramètre correspondant (param2:valeur2 et param3:valeur3) :

[objet methode:valeur1 param2:valeur2 param3:valeur3];

Une méthode peut retourner un objet. Dans ce cas, vous pouvez le stocker dans une variable :

variable = [objet methode];

Ou encore :

variable = [objet methode:entree];

Si la méthode retourne un objet, vous pouvez enchaîner plusieurs appels de méthodes (c'est d'ailleurs ce qu'on appelle un chaînage). Dans l'exemple suivant, le paramètre param1 est envoyé à la méthode methode1, et cette dernière est appliquée à l'objet objet1. Le résultat de la méthode est un objet auquel on applique la méthode methode2 avec le paramètre param2 :

[[objet1 methode1:param1] methode2:param2];

Si les choses ne sont pas très claires, examinez la figure suivante.

Pour comprendre ce schéma, il suffit de suivre les flèches, de la gauche vers la droite.

parametre 1 est passé à la methode 1 de l'objet 1. Cette méthode fait un traitement et retourne un résultat sous la forme d'un objet (la deuxième flèche rouge). La methode 2 de cet objet est exécutée, en lui passant le parametre 2 en entrée (la troisième flèche rouge). Le résultat final est représenté par la quatrième flèche rouge.
J'espère que c'est plus clair cette fois-ci. Dans le cas contraire, relisez ce qui vient d'être dit. Il n'y a rien de vraiment sorcier là-dedans… ;-)

Les méthodes ne sont pas l'apanage des objets : elles peuvent également être appliquées à des classes. Par exemple, pour créer une variable de type NSString, vous appliquerez la méthode string de la classe NSString :

NSString* uneChaine [NSString string];

Cette instruction peut être simplifiée comme suit :

NSString* uneChaine;

Je suis sûr que vous préférez la deuxième syntaxe à la première. Je dois bien avouer que moi aussi !

Appel d'une méthode existante

Et maintenant, un peu de pratique. Vous allez utiliser un peu de code Objective-C pour concaténer (coller si vous préférez) deux chaînes NSString et afficher le résultat dans la console du Simulateur iOS.

Définissez un nouveau projet basé sur le modèle Single View Application et donnez-lui le nom « test ».
Cliquez sur ViewController.m dans le volet de navigation et repérez la méthode viewDidLoad. Cette méthode est exécutée dès le démarrage de l'application. Vous allez y ajouter quelques instructions pour tester l'exécution de méthodes.
La méthode viewDidLoad (ainsi que de nombreuses autres méthodes) a été générée par Xcode. Voici à quoi elle doit ressembler :

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

Le message [super viewDidLoad] exécute la méthode viewDidLoad de la classe parente (super) de la classe en cours d'exécution. Étant donné que notre classe test hérite de la classe UIView, cette instruction va exécuter la méthode viewDidLoad de la classe UIView.

La ligne de commentaire n'a aucune utilité. Vous pouvez la supprimer.
Pour concaténer deux chaînes, vous utiliserez la méthode stringByAppendingString en envoyant un message du type suivant :
[chaine1 stringByAppendingString: chaine2];
où chaine1 et chaine2 sont les deux chaînes à concaténer.

Complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
  [super viewDidLoad];
  NSString* chaine = @"un ";
  chaine = [chaine stringByAppendingString:@"texte"];
  NSLog(@"%@",chaine);
}

Exécutez l'application en cliquant sur l'icône Run. La figure suivante représente ce que vous devriez obtenir dans la console.

Examinons les instructions utilisées dans la méthode viewDidLoad.

La ligne 4 définit l'objet NSStringchaine et lui affecte la valeur « un » :

NSString* chaine = @"un ";

La ligne 5 applique la méthode stringByAppendingString à l'objet NSStringchaine en lui passant le paramètre « texte ». Le résultat est stocké dans l'objet chaine (chaine =) :

chaine = [chaine stringByAppendingString:@"texte"];

Enfin, la ligne 6 affiche le contenu de l'objet chaine (c'est-à-dire « un texte ») :

NSLog(@"%@",chaine);

Création et appel d'une méthode

Vous venez d'apprendre à appeler la méthode stringByAppendingString. Cette méthode fait partie des méthodes standards de la classe NSString.
Vous allez maintenant aller un peu plus loin en créant une méthode et en l'appelant. Cette méthode :

1. aura pour nom « concat » ;

2. recevra deux paramètres NSString ;

3. renverra leur concaténation dans un objet NSString.

Munis de toutes ces informations, vous devriez pouvoir définir le gabarit (c'est-à-dire l'allure) de la méthode :

-(NSString*) concat:(NSString*)ch1: (NSString*)ch2;

Cliquez sur ViewController.h dans le volet de navigation et ajoutez ce gabarit dans le fichier d'en-têtes, après l'instruction @interface.

Il n'y a rien de bien compliqué dans ce gabarit. Si vous ne comprenez pas comment il est construit, relisez la section « Définir des méthodes ».
Le fichier d'en-têtes doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>
@interface ViewController : UIViewController

-(NSString*) concat:(NSString*)ch1: (NSString*)ch2;

@end

Maintenant, vous allez écrire quelques lignes de code dans le fichier ViewController.m. Cliquez sur ce fichier dans le volet de navigation et définissez la méthode concat, juste au-dessous de l'instruction @implementation :

-(NSString*) concat:(NSString*)ch1: (NSString*)ch2
{
  return [ch1 stringByAppendingString:ch2];
}

La première ligne reprend le gabarit de la fonction.

La troisième ligne définit l'objet retourné par la méthode (viareturn). Cet objet est le résultat de la concaténation de ch1 et ch2, passés en arguments.

Et maintenant, modifiez la méthode viewDidLoad comme suit pour appeler la méthode concat et afficher le résultat retourné dans la console :

- (void)viewDidLoad
{
  [super viewDidLoad];
  NSString* chaine = [self concat: @"premier ":@"deuxième"];
  NSLog(@"%@",chaine);
}

La ligne 4 définit le NSString chaine (NSString* chaine) et lui affecte la valeur retournée par la méthode concat, en lui passant les NSString « premier » et « deuxième ».

Il signifie que la méthode concat a été définie dans la classe courante, tout simplement.

Enfin, la ligne 5 affiche le résultat retourné par concat dans la console. Exécutez l'application. La figure suivante représente ce que vous devriez obtenir dans la console.

Crochet ou point ?

Deux styles d'écriture peuvent être utilisés pour appeler une méthode : les crochets ou les points. À titre d'exemple, les deux instructions suivantes sont équivalentes :

[voiture setCouleur:@"rouge"];
voiture.couleur = @"rouge";

Ces deux écritures font une seule et même action : elles appliquent la méthode couleur à l'objet voiture en lui passant l'entrée rouge.

Les deux lignes suivantes sont elles aussi équivalentes :

laCouleur = [voiture couleur];
laCouleur = voiture.couleur;

Vous l'aurez compris, elles lisent la couleur de l'objet voiture et la stockent dans la variable laCouleur.

Créer un objet

La gestion mémoire d'un objet peut être automatique ou manuelle. Dans le premier cas, lorsque l'objet n'est plus utilisé, il est automatiquement retiré de la mémoire. Dans le deuxième cas, c'est à vous de le retirer de la mémoire pour éviter qu'elle ne se sature.
À titre d'exemple, pour créer l'objet NSString maChaine avec une gestion automatique de la mémoire, vous utiliserez l'instruction suivante :

NSString* maChaine = [NSString string];

Ou plus simplement :

NSString* maChaine;

Si vous préférez gérer manuellement l'objet NSString maChaine en mémoire, vous utiliserez l'instruction suivante :

NSString* maChaine = [[NSString alloc] init];

Examinons cette deuxième écriture. Dans un premier temps, la méthode alloc est appliquée à la classe NSString. Cette opération réserve un espace mémoire et instancie un objet NSString. Dans un deuxième temps, la méthode init est appliquée à cet objet pour l'initialiser et le rendre utilisable (ce n'est qu'après l'initialisation de l'objet que l'on peut lui appliquer des méthodes).

Si nécessaire, il est possible d'affecter une valeur à un objet NSString.

Voici l'instruction à utiliser si vous optez pour une gestion automatique de la mémoire :

NSString* maChaine = [NSString stringWithString:@"Une chaîne quelconque"];

Ou plus simplement :

NSString* maChaine = @"Une chaîne quelconque";

Et voici les instructions à utiliser si vous optez pour une gestion manuelle de la mémoire :

NSString* maChaine2 = [[NSString alloc] init];
maChaine2 = @"Une chaîne quelconque";

Cycle de vie des objets

Tout comme les êtres vivants, les objets utilisés dans une application iOS ont un cycle de vie.

1. Création.

2. Utilisation.

3. Destruction.

Une très bonne nouvelle : iOS 5 introduit un système nommé ARC (Automatic Reference Counting) qui automatise le cycle de vie des objets. Désormais, c'est le compilateur qui se charge de cette tâche ingrate qui consiste à détruire les objets une fois qu'ils ne sont plus utilisés.

Je ne m'étendrai pas plus sur le sujet, mais sachez que vous échappez à des complications aussi inutiles que dangereuses.

En résumé

• En programmation orientée objet, les programmes sont constitués d'un ensemble de blocs de code indépendants appelés objets. Chaque objet contient sa propre boucle d'attente. Lorsqu'un événement concernant un objet particulier survient, c'est à cet objet de traiter l'événement.

• Via l'instruction #import <UIKit/UIKit.h>, le fichier .h fait référence au framework UIKit. Il définit également l'interface de l'application, les variables d'instance, et leurs accesseurs (getters et setters).

• Le fichier .m implémente les getters et les setters des objets utilisés dans l'application, ainsi qu'une ou plusieurs méthodes complémentaires pour effectuer les traitements demandés par l'application.

• Les variables d'instance sont propres à une instance de classe. Si plusieurs instances sont exécutées, les variables n'entreront donc pas en conflit.

• Les méthodes sont appelées par l'intermédiaire de messages de type [objet methode]; ou [objet methode:entree];. Les méthodes peuvent être chaînées en imbriquant plusieurs messages : [[objet1 methode1: param1] methode2: param2];.

• Pour appeler une méthode d'une variable d'instance, il est possible d'utiliser une syntaxe « à point ». Ainsi, [objet methode] et objet.methode sont équivalents.

• Dans iOS 5, le système ARC (Automatic Reference Counting) automatise le cycle de vie des objets : désormais, c'est le compilateur qui se charge de détruire les objets une fois qu'ils ne sont plus utilisés.

Une chaîne de caractères est une suite de zéro, un ou plusieurs caractères. Voici quelques exemples de chaînes de caractères :

Ceci est une chaîne de caractères
123 est plus petit que 456
@ç/w&!

Dans une application destinée aux iPhone, iPod Touch ou iPad, les chaînes de caractères sont manipulées à travers la classe Cocoa Touch NSString :

NSString *maChaine;

Il se peut qu'un jour vous tombiez sur une variante de cette déclaration :

NSString * maChaine; 
(NSString*) maChaine; 
NSString* maChaine;

Ces trois déclarations sont strictement équivalentes à celle que je viens de vous présenter.

Si nécessaire, il est possible d'affecter une valeur à une chaîne lors de sa définition :

NSString *maChaine = @"Ceci est une chaîne de caractères";

Avez-vous remarqué le signe @ avant le début de la chaîne ? Il est là pour indiquer à Xcode que les caractères suivants sont une chaîne de caractères.

Et maintenant, nous allons voir comment manipuler les chaînes de caractères en étudiant quelques méthodes de la classe NSString.

Tester l'égalité de deux NSString

Il est souvent utile de comparer deux chaînes entre elles. Vous pensez peut-être qu'il suffit d'utiliser une instruction du type suivant :

if (chaine1 == chaine2)
{
  // Traitement
}

Eh bien, ce serait trop simple ! En fait, cette instruction compare non pas le contenu mais l'adresse des deux chaînes. Rappelez-vous, lorsque vous définissez une nouvelle chaîne, vous le faites en créant un pointeur :

NSString *chaine1;

Heureusement, il existe une solution pour comparer simplement deux chaînes. Vous utiliserez pour cela la méthode isEqualToString de la classe NSString :

if ([chaine1 isEqualToString:chaine2])
{
  // Traitement
}

Si cette syntaxe vous laisse perplexes, jetez un œil à la section « Appeler des méthodes » du chapitre précédent et tout deviendra plus clair. Pour ceux qui auraient la mémoire courte, les méthodes de classe sont appelées en utilisant la syntaxe suivante :

[objet methode:entrée];

Dans le cas qui nous occupe, la méthode isEqualToString est appliquée à l'objet chaine1 en lui transmettant l'objet chaine2 en entrée. Cette méthode retourne la valeur TRUE si les deux chaînes sont égales, FALSE dans le cas contraire.

Longueur d'un NSString

La longueur d'une chaîne est obtenue avec la méthode length de la classe NSString. Voici un exemple d'utilisation de cette méthode :

NSString *a = @"ceci est une chaîne";
NSLog(@"Longueur de la chaine : %i", [a length]);

L'instruction NSLog affiche le texte suivant dans le volet de débogage :

Longueur de la chaîne : 19

Concaténer deux NSString

Pour concaténer deux chaînes, c'est-à-dire pour les mettre bout à bout, vous utiliserez la méthode stringWithFormat :

NSString *chaine1=@"première partie";
NSString *chaine2= @" deuxième partie";
NSString *chaine3;
chaine3 = [NSString stringWithFormat:@"%@%@",chaine1,chaine2];
NSLog(@"%@",chaine3);

Les trois premières instructions ne devraient pas vous poser de problème. Pour tous ceux qui pensent que la quatrième ligne est incompréhensible, faisons quelques étapes intermédiaires.
L'objet NSString chaine3 a été défini à la ligne précédente. Pour lui affecter une valeur, il suffit de faire suivre son nom du signe = et de la valeur souhaitée : chaine3 = valeur;.

La valeur est obtenue en utilisant la méthode stringWithFormat de la classe NSString. Le début de l'expression est donc tout à fait clair : [NSString stringWithFormat ...].

La méthode stringWithFormat admet un paramètre de type NSString. Dans cet exemple, ce paramètre a pour valeur @"%@%@",chaine1,chaine2. Le signe @ devant le premier guillemet indique que la suite est une chaîne de caractères. Quant aux %@, ils se réfèrent aux éléments spécifiés juste après le deuxième guillemet. Ainsi, le premier %@ est remplacé par chaine1 et le deuxième par chaine2. Le résultat renvoyé est la concaténation des deux chaînes. L'instruction NSLog affiche donc le texte suivant dans le volet de débogage :

première partie deuxième partie

Définir une chaîne pendant l'exécution d'une l'application

Supposons que l'objet NSString maChaine soit défini et initialisé avec l'instruction suivante :

NSString *maChaine = @"Bonjour";

Pour initialiser un objet NSString à partir d'une chaîne de type char, vous utiliserez les instructions suivantes :

char *chaineC;
NSString *chaineObjC;
...
// Instructions qui initialisent la variable char chaineC
...
chaineObjC = [NSString stringWithString: chaineC];

Inversement, pour initialiser une chaîne de type char à partir d'un objet NSString, vous utiliserez les instructions suivantes :

const char *chaineC;
NSString *chaineObjC = @"Bonjour";
chaineC = [chaineObjC String];

Parcourir un NSString, caractère par caractère

Un jour ou l'autre, vous serez certainement confrontés à ce problème : comment isoler chacun des caractères contenus dans un objet NSString afin d'effectuer des comparaisons ou de leur appliquer un traitement individuel ?
La solution est des plus simples : il suffit d'appliquer de manière répétitive la méthode characterAtIndex à la chaîne.

NSString *chaine;
chaine = @"helloworld";
int i = chaine.length; // La variable i contient le nombre de caractères de la chaîne
int j;
char uneLettre;
for(j=0; j<i; j++)  // Boucle de 0 à i en incrémentant j
{
  uneLettre = [chaine characterAtIndex:j];  // Extraction d'un caractère de la chaîne
  NSLog(@"La lettre en position %i est %c ", j, uneLettre);
}

La figure suivante représente le résultat dans la fenêter de débogage.

Nous allons ici parler des objets de classe NSNumber, qui peuvent laisser perplexe. En effet, pourquoi utiliser une classe dédiée à la manipulation des nombres alors que les types int, float, double, etc. sont déjà disponibles ?

Et pourtant, vous aurez besoin de la classe NSNumber dans plusieurs cas bien précis. Par exemple, pour convertir des types de données. Le type d'un objet NSNumber peut être facilement modifié en utilisant les méthodes floatValue, doubleValue, intValue, longValue, etc. Ici par exemple, un nombre entier est converti en un nombre double avec la méthode doubleValue :

NSNumber *unEntier = [NSNumber numberWithInteger:23];
float unDouble = [unEntier doubleValue];

La première instruction définit l'objet unEntier de type NSNumber et l'initialise avec la valeur entière 23. La deuxième instruction définit la variable unDouble de type float et lui affecte la conversion en un double de l'objet unEntier.

À la vue de ce code, vous vous sentez certainement désorientés. Ne vous en faites pas, tout deviendra plus clair au fur et à mesure de votre apprentissage. Pour l'instant, il vous suffit de savoir que les types numériques cohabitent avec la classe NSNumber, et que cette dernière est utile dans certains cas bien précis.

Plusieurs classes sont associées à la manipulation des objets date et heure dans Objective-C : NSDate, NSCalendar, NSTimeZone, NSDateComponents, NSDateFormatter. Pour mieux appréhender ces différentes classes, rien de tel qu'un peu de code.

Affichage de la date courante

Ces quelques lignes de code affichent la date courante au format américain (en_US) et français (fr_FR) :

/* ---Définition de l'objet date et de sa mise en forme--- */

// Aujourd'hui
NSDate *date = [NSDate date];
NSDateFormatter *miseEnForme = [[NSDateFormatter alloc] init];

// Aucun affichage de l'heure
[miseEnForme setTimeStyle:NSDateFormatterNoStyle];

// Affichage de la date au format semi-abrégé
[miseEnForme setDateStyle:NSDateFormatterMediumStyle]; 

/* ---Affichage de la date au format US--- */
NSLocale *usLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US"];
[miseEnForme setLocale:usLocale];
NSLog(@"Date au format %@: %@", [[miseEnForme locale] localeIdentifier], [miseEnForme stringFromDate:date]);

/* ---Affichage de la date au format FR--- */
NSLocale *frLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"fr_FR"];
[miseEnForme setLocale:frLocale];
NSLog(@"Date au format %@: %@", [[miseEnForme locale] localeIdentifier], [miseEnForme stringFromDate:date]);

Et voici ce que ça donne dans la console :

[...] test[1527:207] Date au format en_US: Jun 7, 2011
[...] test[1527:207] Date for locale fr_FR: 7 juin 2011

Examinons le premier bloc d'instructions. La ligne 4 définit l'objet NSDate date (NSDate *date) et lui affecte la date courante ([NSDate date]).

NSDate *date = [NSDate date];

La ligne 5 définit l'objet miseEnForme de type NSDateFormatter. C'est par l'intermédiaire de cet objet que l'on définira un format d'affichage pour la date.

NSDateFormatter *miseEnForme = [[NSDateFormatter alloc] init];

La ligne 8 indique que l'heure ne doit pas être affichée. La méthode setTimeStyle est donc appliquée à l'objet miseEnForme en lui transmettant un paramètre :

[miseEnForme setTimeStyle:NSDateFormatterNoStyle];

Enfin, la quatrième instruction donne le format d'affichage de la date. Les messages autorisés pour la méthode setDateStyle sont :

• NSDateFormatterNoStyle

• NSDateFormatterShortStyle

• NSDateFormatterMediumStyle

• NSDateFormatterLongStyle

• NSDateFormatterFullStyle

Je vous invite à modifier l'instruction en question afin d'observer les différents comportements de ces méthodes.

[miseEnForme setDateStyle:NSDateFormatterMediumStyle];

Examinons maintenant le deuxième bloc d'instructions.
La ligne 14 définit l'objet NSLocale usLocale et l'initialise au format en_US, c'est-à-dire anglais américain :

NSLocale *usLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US"];

La ligne suivante utilise la classe setLocale pour indiquer à l'objet NSDateFormatter miseEnForme que l'affichage devra se faire au format anglais américain :

[miseEnForme setLocale:usLocale];

Enfin, la ligne 16 affiche la date courante dans ce format. Le premier message entre crochets récupère l'identificateur de langue (en_US) et le deuxième la date au format miseEnForme :

NSLog(@"Date au format %@: %@", [[miseEnForme locale] localeIdentifier], [miseEnForme stringFromDate:date]);

Le troisième bloc d'instructions est très proche du deuxième, à ceci près qu'il demande l'affichage de la date au format français.

Création d'une date relative à la date système

La méthode initWithTimeIntervalSinceNow permet de créer un objet NSDate en lui appliquant un décalage par rapport à la date système. Le décalage peut être positif (pour définir une date postérieure à la date système) ou négatif (pour définir une date antérieure à la date système).
Examinez le code suivant :

NSDate *dateCourante = [NSDate date]; //Aujourd'hui
NSTimeInterval secondesParJour = 24 * 60 * 60;
NSDate *demain = [[NSDate alloc] initWithTimeIntervalSinceNow:secondesParJour];
NSDate *hier = [[NSDate alloc] initWithTimeIntervalSinceNow:-secondesParJour];

La première ligne définit l'objet NSDate dateCourante et y mémorise la date système.
La deuxième ligne définit l'objet NSTimeInterval secondesParJour et y mémorise le nombre de secondes contenues dans une journée.
La troisième ligne définit l'objet NSDate demain et y stocke la date système plus un jour. Pour cela, la méthode initWithTimeIntervalSinceNow lui est appliquée en lui transmettant la valeur secondesParJour. L'objet demain est donc initialisé avec la date qui suit le jour courant.
La quatrième ligne est très proche de la troisième, mais ici, le paramètre passé à la méthode initWithTimeIntervalSinceNow est égal à -secondesParJour. L'objet hier est donc initialisé avec la date qui précède le jour courant.

Définition d'une date autre que la date système

Pour définir une date différente de la date système, vous devez :

1. définir et initialiser un objet NSDateComponents ;

2. l'affecter à un objet NSDatevia un objet NSCalendar.

Tout ceci a l'air bien compliqué, mais vous allez voir qu'il n'en est rien en examinant le code suivant :

// Définition d'un objet NSDateComponents
NSDateComponents *nsDatePerso = [[NSDateComponents alloc] init];
[nsDatePerso setYear:2065];
[nsDatePerso setMonth:8];
[nsDatePerso setDay:12];

// Création d'un objet NSDate et affectation de l'objet nsDatePerso défini précédemment
NSDate *datePerso = [[NSCalendar currentCalendar] dateFromComponents:nsDatePerso];
NSLog(@"Date utilisateur : %@", datePerso);

Voici le résultat affiché dans la console :

[...] test[1680:207] Date utilisateur : 2065-08-11 22:00:00 +0000

Comme vous le voyez, aucune mise en forme NSFormatter n'a été appliquée à l'objet datePerso.

Examinons les instructions qui composent ce code.
La première instruction définit l'objet NSDateComponents nsDatePerso et réserve son emplacement en mémoire :

NSDateComponents *nsDatePerso = [[NSDateComponents alloc] init];

Les trois instructions suivantes initialisent les composants année, mois et jour de cet objet.

[nsDatePerso setYear:2065];
[nsDatePerso setMonth:8];
[nsDatePerso setDay:12];

Le deuxième bloc d'instructions définit un objet NSDate de nom datePerso (NSDate *datePerso). Cet objet est initialisé avec la date définie dans l'objet nsDatePerso (dateFromComponents:nsDatePerso) en passant par un objet NSCalendar ([NSCalendar currentCalendar]) :

NSDate *datePerso = [[NSCalendar currentCalendar] dateFromComponents:nsDatePerso];

Une variante pour définir une date autre que la date système

Pour définir et initialiser un objet NSDate avec une date différente de la date système, il est également possible d'utiliser une chaîne de caractères. Cette technique est plus simple que la précédente. Elle consiste à passer en paramètre la chaîne qui contient la date à la méthode dateFromString, qui elle-même est appliquée à un objet NSDateFormatter :

NSDateFormatter* df = [[NSDateFormatter alloc]init];
[df setDateFormat:@"dd-MM-yyyy"];
NSDate *uneDate = [df dateFromString:@"12-08-2011"];

La première instruction définit l'objet NSDateFormatter df et lui réserve un emplacement en mémoire :

NSDateFormatter* df = [[NSDateFormatter alloc]init];

La deuxième instruction définit le format utilisé dans l'objet NSDateFormatter :

[df setDateFormat:@"dd-MM-yyyy"];

Enfin, la troisième instruction affecte une date à l'objet NSDate uneDate en transmettant une chaîne à la méthode dateFromString de l'objet NSDateFormlatter df :

NSDate *uneDate = [df dateFromString:@"12-08-2011"];

Extraction des composants d'un objet NSDate

Pour accéder aux composants (jour, mois, année, heure, minute et seconde) d'une date au format NSDate, vous devez utiliser la méthode components: fromDate: d'un objet NSCalendar dans lequel vous aurez stocké la date.

À titre d'exemple, le code ci-dessous extrait le jour, le mois, l'année, l'heure, les minutes et les secondes de la date système et les affiche dans la console :

NSDate *date = [NSDate date]; //Aujourd'hui
NSCalendar *calendrier = [NSCalendar currentCalendar];
NSDateComponents *composants = [calendrier components:(NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit | NSHourCalendarUnit | NSMinuteCalendarUnit | NSSecondCalendarUnit) fromDate:date];
NSLog(@"Nous sommes le %i / %i / %i", [composants day], [composants month], [composants year]);
NSLog(@"Il est  %i : %i : %i", [composants hour], [composants minute], [composants second]);

La première instruction crée l'objet NSDate date et y stocke la date système :

NSDate *date = [NSDate date]