Devenir un Xcoder

Nous avons bien progressé dans notre programme, mais n'avons pas discuté de la façon d'afficher les résultats de nos calculs. Le langage Objective-C ne sait pas comment faire cela, mais heureusement des gens ont écrit des fonctions d'affichage, dont nous pouvons tirer profit. Il existe différentes façons d'afficher un résultat à l'écran. Dans ce livre, nous utiliserons une fonction fournie par l'environnement Cocoa d'Apple : la fonction NSLog(). C'est appréciable, car maintenant vous n'avez plus à vous soucier de "l'impression" de vos résultats à l'écran (ni rien à programmer).

Mais où donc NSLog() s'affiche-t-elle ? Xcode fournit la Console pour afficher des messages d'historique. Pour ouvrir la Console, choisir Console dans le menu Run (Exécuter) (Pomme-Maj-R). Lorsque vous créez et exécutez votre application, tous les messages NSLog() de cette application s'affichent ici.

La fonction NSLog() est originellement destinée à l'affichage des messages d'erreur, et non à la sortie des résultats d'application. Cependant, elle est tellement facile à utiliser que nous l'adopterons dans ce livre pour afficher les résultats. Une fois acquise une certaine maîtrise de Cocoa, vous pourrez utiliser des techniques plus sophistiquées.

Voyons comment la fonction NSLog() est utilisée. Dans le fichier main.m, entrez le code suivant :

//[1]
int main()
{
    NSLog(@"Julia est mon actrice favorite.");
    return 0;
}

À l'exécution, la déclaration de l'exemple [1] se traduira par l'affichage du texte "Julia est mon actrice préférée.". Ce texte entre @" et " est appelé une chaîne.

En plus de la chaîne elle-même, la fonction NSLog() affiche diverses informations supplémentaires, comme la date et le nom de l'application. Par exemple, la sortie complète du programme [1] sur mon système est :

2005-12-22 17:39:23.084 test[399] Julia est mon actrice favorite.

Une chaîne peut avoir une longueur de zéro ou plusieurs caractères.

Note : dans les exemples suivants, seules les déclarations intéressantes de la fonction main() sont affichées.

//[2]
NSLog(@"");
NSLog(@" ");

La déclaration [2.1] contient zéro caractère et est appelée une chaîne vide (c'est-à-dire qu'elle a une longueur égale à zéro). La déclaration [2.2] n'est pas une chaîne vide, en dépit de son apparence. Elle contient un espace, de sorte que la longueur de cette chaîne est de 1.

Plusieurs séquences de caractères spéciaux ont une signification particulière dans une chaîne. Ces séquences de caractères spéciaux sont dites séquences d'échappement.

Par exemple, pour forcer le dernier mot de notre phrase à commencer à s'afficher sur une nouvelle ligne, un code spécial doit être inclus dans la déclaration [3,1]. Ce code est \n, raccourci du caractère de retour à la ligne.

//[3]
NSLog(@"Julia est mon actrice \nfavorite.");

Désormais, la sortie ressemble à ceci (seule la sortie concernée est affichée) :

Julia est mon actrice
favorite.

Le slash inversé de [3.1] est un caractère d'échappement, qui indique à la fonction NSLog() que le caractère suivant n'est pas un banal caractère à afficher à l'écran, mais un caractère qui a une signification spéciale : dans ce cas, le "n" signifie "commencer une nouvelle ligne".

Dans les rares cas où vous souhaitez afficher un slash inversé à l'écran, cela peut vous sembler un problème. Si un caractère suivant un slash inversé a un sens particulier, comment est-il possible d'afficher un slash inversé ? Eh bien, il suffit de mettre un autre slash inversé avant (ou bien sûr après) le slash inversé. Cela indique à la fonction NSLog() que le (second) slash inversé, c'est-à-dire celui le plus à droite, doit être affiché, et que toute signification spéciale doit être ignorée). Voici un exemple :

//[4]
NSLog(@"Julia est mon actrice favorite.\\n");

La déclaration [4.1] donnerait, lors de l'exécution :

Julia est mon actrice favorite.\n

Jusqu'ici, nous n'avons affiché que des chaînes statiques. Affichons à l'écran la valeur obtenue par un calcul.

//[5]
int x, entierAffichable;
x = 1;
entierAffichable = 5 + x;
NSLog(@"La valeur de l'entier est %d.", entierAffichable);

Bien noter que, entre les parenthèses, nous avons une chaîne, une virgule et un nom de variable. La chaîne contient quelque chose de bizarre : %d. À l'instar du slash inversé, le caractère pourcentage % a une signification spéciale. S'il est suivi d'un d (raccourci pour nombre décimal), après exécution, la valeur de sortie de ce qui se trouve après la virgule, c'est-à-dire la valeur actuelle de la variable entierAffichable, sera insérée à l'emplacement de %d. L'exécution de l'exemple [5] donne pour résultat :

La valeur de l'entier est 6.

Pour afficher un flottant, vous devez utiliser %f au lieu de %d.

//[6]
float x, flottantAffichable;
x = 12345.09876;
flottantAffichable = x/3.1416;
NSLog(@"La valeur du flottant est %f.", flottantAffichable);

Le nombre de chiffres significatifs affichés (ceux après le point) dépend de vous. Pour afficher deux chiffres significatifs, mettre .2 entre % et f, comme ceci :

//[7]
float x, flottantAffichable;
x = 12345.09876;
flottantAffichable = x/3.1416;
NSLog(@"La valeur du flottant est %.2f.", flottantAffichable);

Ensuite, si vous savez comment répéter les calculs, vous pourrez souhaiter créer une table de valeurs. Imaginez une table de conversion de degrés Fahrenheit en degrés Celsius. Si vous souhaitez un bel affichage des valeurs, vous voudrez que les valeurs des deux colonnes de données aient une largeur donnée. Vous pouvez spécifier cette largeur par une valeur entre % et f (ou % et d, dans ce cas). Toutefois, si la largeur que vous spécifiez est inférieure à la largeur du nombre, la largeur du nombre prévaut.

//[8]
int x = 123456;
NSLog(@"%2d", x);
NSLog(@"%4d", x);
NSLog(@"%6d", x);
NSLog(@"%8d", x);

L'exemple [8] donne la sortie suivante :

123456
123456
123456
  123456

Dans les deux premières déclarations [8.2, 8.3], nous réclamons trop peu de place pour l'affichage du nombre dans son intégralité, mais l'espace est quand même pris. Seule la déclaration [8.5] spécifie une largeur supérieure à la valeur, aussi nous voyons maintenant l'apparition d'espaces additionnels, ce qui est indicatif de la largeur de l'espace réservé pour le nombre.

Il est également possible de combiner les spécifications de largeur et le nombre de chiffres décimaux à afficher.

//[9]
float x=1234.5678;
NSLog(@"Réserver un espace de 10, et afficher 2 chiffres significatifs.");
NSLog(@"%10.2f", x);

Bien sûr, il est possible d'afficher plus d'une valeur, ou toute combinaison de valeurs [10,3]. Vous devez vous assurer que vous avez bien indiqué le type de données (int, float), en utilisant %d et %f.

//[10]
int x = 8;
float pi = 3.1416;
NSLog(@"La valeur de l'entier est %d, alors que la valeur du flottant est %f.", x, pi);

Une des erreurs les plus courantes des débutants est de mal spécifier le type de données dans NSLog() et autres fonctions. Si vos résultats sont bizarres, ou tout simplement que le programme plante sans raison, examinez les indicateurs de votre frappe de données !

Par exemple, si vous vous trompez pour le premier, le deuxième peut ne pas être affiché correctement non plus ! Par exemple,

//[10b]
int x = 8;
float pi = 3.1416;
NSLog(@"La valeur de l'entier est %f, alors que la valeur du flottant est %f.", x, pi);
// Ceci lira : NSLog(@"La valeur de l'entier est %d, alors que la valeur du flottant est %f.", x, pi);

donnera la sortie suivante :

La valeur de l'entier est 0.000000, alors que la valeur du flottant est 0.000000.

Nous ne sommes qu'à une question et une réponse de l'exécution de notre premier programme.

Alors, comment notre programme a-t-il connaissance de cette si utile fonction NSLog() ? Eh bien, il ne l'a pas, à moins que nous ne lui demandions. Pour ce faire, notre programme doit dire au compilateur d'importer une bibliothèque de choix (qui heureusement est fournie gratuitement avec tout Mac), incluant la fonction NSLog(), en utilisant la déclaration :

#import <Foundation/Foundation.h>

Cette déclaration doit être la première déclaration de notre programme. Lorsque l'on réunit tout ce que nous avons appris dans ce chapitre, on obtient le code suivant, que nous exécuterons dans le prochain chapitre.

//[11]
#import <Foundation/Foundation.h>
float cercleAire(float leRayon);
float rectangleAire(float largeur, float hauteur);
int main()
{
    float imageLargeur, imageHauteur, imageAire,
    cercleRayon, cercleSurfaceAire;
    imageLargeur  = 8.0;
    imageHauteur = 4.5;
    cercleRayon  = 5.0;
    imageAire = rectangleAire(imageLargeur, imageHauteur);
    cercleSurfaceAire = cercleAire(cercleRayon);
    NSLog(@"Aire du cercle: %10.2f.", cercleSurfaceAire);
    NSLog(@"Area d'image: %f. ", imageAire);
    return 0;
}

float cercleAire(float leRayon)               // première fonction personnelle
{
    float lAire;
    lAire = 3.1416 * leRayon * leRayon;
    return lAire;
}
float rectangleAire(float largeur, float hauteur) // seconde fonction personnelle
{
    return largeur*hauteur;
}