Project:Omega.org

Par Seth Roby le 01/08/2003

Traduit par Olivier, le 13/01/2004

Le plus long des voyages commence quand même par un premier pas, et le plus grand programme commence par une ligne de code.
Maintenant que nous avons commencé, nous devons poser un pied devant l’autre et progresser vers notre but qui est de connaitre suffisamment de langqge C pour apprendre Objective-C.
Avec chaque nouvelle ligne de code que nous voyons et dont nous apprenons, nous nous rapprochons un peu plus du but.

Mais une des choses les plus importantes à apprendre n’est pas dans une ligne de code, mais dans une idée que notre code doit suivre, une structure de base sur laquelle s’appuiera tout le code que nous écrivons. En fait, on pourrait dire qu’en C, ce n’est pas simplement une structure, mais la structure.

C est ce que l’on appelle un langage impératif, ce qui signifie que pour réaliser des actions, on demande à l’ordinateur d’exécuter impérativement des instructions, les une après les autres. Vous créez des fonctions pour démarrer, stopper et faire tourner votre application. Vous créez des fonctions pour vérifier, initialiser, lire et écrire des choses. Vou créez des fonctions pour manipuler les bits, pour dessiner des lignes. C vit et respire à travers les fonctions.

La Fonction main

La première fonction que nous allons écrire est appelée, de manière appropriée, la fonction main.
Cette fonction est la première à laquelle tout programme C, C++ ou Objective-C fait appel et à partir de laquelle tout s’enchaine dans tous ces langages.

Notre fonction main utilisera le code de notre leçon précédente, mais premièrement, nous devons la placer quelque part.
Avant de commencer à coder, nous devons faire une petite pause pour voir comment utiliser les outils de développement d’Apple.

Si vous utilisez Mac OS X version 10.0 à 10.2 (Jaguar), l’outil que vous utiliserez est Project Builder.
Il s’agit d’une installation en option sur la plupart des systèmes, donc vous devrez retrouver le CD Developer Tools qui est livré avec votre Mac, ou votre système d’exploitation et l’installer ou le télécharger chez Apple ici.

Si vous utilisez Mac OS X 10.3 (Panther), vous utilisez Xcode, en version 1.0 lors de la rédaction de cet article.
Je vais tenter de vous aider dans l’utilisation des deux systèmes.
La remarque d’installation pour Project Builder est également valable pour Xcode, que vous pouvez télécharger ici.

La première chose que vous faites une fois que vous avez installé une application est de la lancer.
Vous trouverez les applications outils dans /Developer/Applications.
Vous pouvez placer l’icône dans votre dock si vous pensez l’utilisez souvent, ou si vous voulez y accéder facilement pour les articles suivants.

Si c’est la première fois que vous utilisez les outis de développement d’Apple, les applications vous poserons probablement quelques questions.
Cliquez simplement sur le bouton Next (Suivant) jusqu’à la faire disparaitre, car les options par défaut sont suffisantes et peuvent être modifiées dans les préférences ultérieurement.
Après la disparition de cette boite de dialogue, une autre pourra apparaitre vous indiquant les nouveautés de cette version.
Lisez-les si vous le souhaitez, et fermer la pour poursuivre la leçon.

Créer un Projet

La première chose que nous devons faire est de créer un Projet, qui signifie dans les termes d’Apple “un groupe de fichiers utilisés pour un programme”. Les outils vous aident à gérer ces fichiers et construire votre programme. Dans le menu File (Fichier), choisissez New Project (Nouveau Projet)…Ceci ouvrira une boite de dialogue vous demandant quel type de Projet vous souhaitez créer. Les outils de développement d’Apple proposent une gamme très large de différents types de projets, et c’est de là que viennent leur deux noms : ils gèrent tous les deux des Projets de Code complexes.

Par la suite, vous utiliserez le type de projet “Cocoa”, situé en haut de la liste. Mais pour le moment, nous allons développer ce qu’Apple appelle un “Tool” (Outil), et plus précisément, un “Standard Tool” (Outil Standard). Il s’agit du Projet le plus simple, car il ne comporte qu’un seul fichier et son environnement. Une fois que vous avez sélectionné “Standard Tool”, cliquez sur le bouton Next (Suivant) en bas de la boite de dialogue. La fenêtre vous demandera alors où vous souhaitez conserver le Projet, et quel nom vous souhaitez lui donner.
Je conserve tous mes projets dans un dossier Developer dans mon répertoire racine. Ceci à l’avantage que ce répertoire est également utilisé par les add-on qui viennent compléter les outils de développement.

Cliquez sur le bouton Choose (Choisir) et créez un dossier appelé Developer dans votre répertoire racine. Choisissez ce dossier pour y créer votre projet, donnez-lui un nom. Pour l’instant, nous utiliserons “C is For Cocoa” (C est pour Cocoa). Cliquez sur Finish (Terminer) et voyez la fenêtre de votre premier projet s’ouvrir.

Remarquez quelques petites choses avant de commencer. Le titre de la fenêtre correspond à celui de votre projet. En haut se trouve une barre d’outils pleine d’actions que nous allons souvent utiliser. Si vous utilisez Xcode, cliquez sur le bouton Editor (Editeur) pour ouvrir un panneau dans la fenêtre où pourrez voir le code. Nous viendrons au reste plus tard. Sur la gauche se trouve la liste des choses avec lesquelles vous pourrez travailler durant votre développement. Sur la droite se trouve un aperçu de ce sur quoi vous travaillez. Ce design vous rappelera peut-être iTunes, dans lequel vous choisissez une playlist sur la gauche, et son contenu apparait sur la droite.

Premièrement, regardons sur la gauche. Clickez sur le triangle près du répertoire Source (dans Xcode, vous devez dabord ouvrir le dossier portant le nom de votre projet). Un fichier nommé main.c apparaitra. Cliquez dessus, et son contenu apparaitra sur la droite. Pour le moment, il s’agit du squelette d’un fichier, mais malgré cela, il peut nous enseigner quelques petites choses.

La première chose que vous devez remarquer est comment le fichier est divisé en deux sections par la ligne blanche. La première section consiste en une ligne (#include ), et nous en reparlerons dans la prochaine leçon. Pour le moment, ignorez-la, et rappelez-vous juste qu’elle nous permettra de faire ce que l’on à besoin de faire.

La prochaine section est une fonction. Enfin, après quelques détours, nous avons fini par en trouver une. Il s’agit d’une définition de fonction. Comme il s’agit de notre première vraie fonction, étudions la un peu. Voici ce que me donne ma version de Develop Tools :

int main (int argc, const char * argv[]) {
    // insert code here...
    printf("Hello, World!n");
    return 0;
}

Vous remarquerez le maintenant familier int. Le prochain élément est main, qui est le nom de la fonction. Après cela viennent plusieurs choses entre parenthèses. si vous vous en souvenez, c’est comme cela que nous appelons une fonction. Chaque argument est défini à son tour, a un type, un nom, et toute autre distinction que nous souhaitons. Le premier argument de main est de type int, et est appelé argc, pour argument count (compteur d’arguments). L’argument suivant est appelé argv, pour argument values (valeurs d’arguments) ou argument vector (vecteur d’arguments), selon à qui vous parlez. En tout cas, son type est const char * et il est suivi de crochets. Toutes ces choses sont importantes, mais pas pour le moment, alors nous les laissons pour la leçon suivante.

Ensuite, vient quelque chose de nouveau. Le { ouvre un bloc de code, qui se termine quelques lignes plus bas (ligne 7 dans l’exemple ci-dessus), avec }. Tout se qui se trouve à l’intérieur d’accolades est “dans un bloc”. Les blocs nous aideront à comprendre ce qu’est la fonction et pourquoi vous avez besoin de les utiliser.

En gros, une fonction est un bout de code que vous utilisez et réutilisez encore et encore. Elle effectue un petit travail dont le résultat peut-être un peu modifié en lui passant des arguments différents. Le code exécuté est celui qui se trouve dans son bloc, qui est souvent appelé le corps de la fonction.

Ici, la fonction main contient trois lignes de code. La première est un commentaire, donc nous savons que l’ordinateur va les ignorer.
La seconde est un appel à une autre fonction, et c’est une fonction que nous avons déjà vu : printf. Cet appel à printf demande à l’ordinateur d’afficher “Hello, World!”, suivi d’un retour à la ligne (c’est ce que cet étrange n signifie : c’est la séquence d’échappement pour une nouvelle ligne). Si vous avez déjà programmé auparavant, vous savez que les programmes “Hello, World!” sont les premiers que l’on écrit. Voici un exemple en C pour vous, et vous n’avez pas besoin d’en écrire une ligne.

La dernière ligne de code dans le bloc est nouvelle pour nous. Pour comprendre cette ligne, nous devons revenir au début. Nous avons remarqué le int devant la fonction, mais nous n’avons pas dit à quoi il sert. La réponse à cette question et l’explication de la dernière ligne sont liées.

Les fonctions en C effectuent le travail que vous leur spécifiez dans le code défini dans le corps de la fonction, et elles peuvent vous retourner un résultat. Vous pouvez créer une fonction qui détermine l’heure qu’il est (et il se trouve qu’il s’agit d’une fonction), mais la fonction a besoin de retourner au code appelant le résultat. Pour faire cela, la fonction retourne une valeur. Cette valeur, comme toute les données que C connait, est stockée dans une variable de type int, qui est notre maintenant bien connu entier. En fait, main est définie par le langage C pour retourner un entier, mais les fonctions que vous écrirez peuvent retourner n’importe quel type.

Sachant que main retourne un entier, cette dernière ligne de code dans le bloc indique à l’ordinateur de retourner zéro, qui est un int. Par convention, retourner zéro depuis main signifie que le programme s’est exécuté correctement. Toute autre valeur retournée est considérée comme une erreur.

Compiler et Exécuter

Avant que nous ne modifions le code que nous venons de voir, exécutons-le. En haut de la fenêtre, dans la barre d’outils, il y a une icône qui ressemble à celle-ci si vous utilisez Project Builder :

Et à celle-là si vous utilisez Xcode :

Il s’agit du bouton Build (Compiler) et Run (Exécuter), qui compilera (transformer le langage C en un langage que l’ordinateur peut exécuter) le projet sur lequel vous travaillez, et l’exécutera ensuite.
Si vous cliquez sur ce bouton maintenant, vous compilerez et exécuterez le code de ce projet, qui consiste juste en la fonction main que nous avons étudiée.
Faites le maintenant, et observez l’ordinateur exécuter le code, afficher le message dans la fenêtre (dans Xcode, vous devez aller dans le menu Debug et sélectionner “Show Run Log” pour voir le message).
Si vous avez une erreur durant la compilation, assurez-vous que tout le code a été copié correctement.

Voici ce que vous pouvez faire sans une seule ligne de code. Mais vous avez déjà quelques lignes de code de notre dernière leçon, alors ressortons-les. Supprimez les commentaires et l’appel à printf, et copiez votre code. Maintenant, le fichier main.c devrait ressembler à cela :

#include 

int main (int argc, const char * argv[]) {
        //Computes our favorite number
        int favoriteNumber = (3 * 4) / 2;       //is anyone's favorite number not an int?
        favoriteNumber = favoriteNumber + 2;
        /* now let's tell the world
                what our favorite number is! */
        printf("My favorite number is %d!", favoriteNumber);
        return 0;
}

Et de nouveau, cliquez sur le bouton Build and Run (rappelez-vous qu’avec Xcode, vous devez sélectionner “Show Run Log” du menu “Debug”).
Maintenant, au lieu de “Hello, World!”, ce qui s’affiche est “My favorite number is 8!”.
Et c’est vous qui lui avez fait imprimer.

Mais que pouvez-vous faire d’autre ?
Nous allons explorer les frontières un peu plus en définissant notre propre fonction.
Alors sous la fonction main, ajoutez le bout de code suivant :

int integerForSeedValue(int seedNumber) {
        //code goes here
}

Il s’agit d’une nouvelle définition de fonction, appelée ainsi, parce qu’elle définit la fonction.
Il y a quelques petites choses à noter ici, la première étant que le nom de la fonction suit le même style que celui que nous avons utilisé pour nos variables : prenez tous les mots qui représentent ce que vous voulez décrire, accolez-les les uns aux autres en mettant en majuscule la première lettre de chaque mot, mais la toute première lettre du mot est minuscule.

Remarquez que notre fonction a un argument, et cet argument est décrit entre les parenthèses.
Notre code définit son type qui est un int, et nous lui donnons un nom, seedNumber, qui encore une fois suit notre schéma de nommage de variables.
Chaque fois que nous appelons cette fonction, nous devons lui passer un entier, sinon le compilateur s’en plaindra et arrêtera la compilation.

Remarquez où sont placées les accolades.
Il s’agit du style du C traditionnel, avec l’accolade ouvrante sur la même ligne que le nom de la fonction.
Objective-C utilise également ce style, mais C++ place l’accolade ouvrante à la ligne suivante, toute seule.
Puisque C ignore les espaces, les deux styles sont acceptables, et puisque beaucoup de personnes utilisent C++, elles sont plus habituées à voir l’accolade sur la ligne d’après.
Ne vous affolez pas si vous les voyez se déplacer un peu.

Puis, nous retournons un entier, mais rien dans notre code n’indique ce que nous retournons.
C’est un problème, mais avant que nous ne corrigions la fonction, cliquons sur le bouton Build, et voyons ce que Developper Tool en pense.
Nous voulons compiler, mais pas encore exécuter, parce que notre code est incorrect, et nous avons besoin de voir comment Developer Tool va nous en informer.
Le bouton Build ressemble à ceci dans Project Builder :

Et à cela si vous utilisez Xcode :

En cliquant sur le bouton Build, la fenêtre du projet s’active pour montrer qu’il se passe quelque chose.
Dans Project Builder, un panneau s’ouvre pour vous indiquer comment la compilation s’est passée.
Dans Xcode, l’élement Erreurs and Warnings, situés sur la gauche, s’ouvrira.
En tout cas, vous verrez le message warning : control reaches end of non-void function (attention : la fin d’une fonction non-void à été atteinte).

De quoi s’agit-il ? C’est un warning.
Les warnings vous indiquent que pendant que le compilateur était en train d’essayer de comprendre votre code, quelque chose semblait bizarre, et il décide de vous en informer.
Cette fonction vous indique que vous avez créez une fonction dont la définition indique que la fonction retourne une valeur (un int dans notre cas), mais le corps de la fonction ne retourne rien.
Ceci serait correct dans une fonction void (nous la verrons plus tard), mais c’est un peu bizarre ici, alors le compilateur vous l’indique.
Une erreur est un problème plus sérieux qui signifie que votre code ne peut pas être compilé tel que, et vous devez corriger ce problème avant de pouvoir l’exécuter.
Les deux informations apparaissent au même endroit, mais les warnings ne vous empêcheront pas d’exécuter votre programme, bien qu’ils annoncent souvent des erreurs qui pourront stopper votre programme durant son exécution.
Cliquez sur le texte, et l’environnement de développement vous affichera la ligne de code problématique.
Pour le moment, il est clair que notre nouvelle fonction est la coupable, mais dans de grand projet, ce click-and-go peut vous sauver la vie.

Pour l’instant, nous pouvons apporter une correction simple à notre problème.
Nous ajoutons simplement une ligne à notre fonction, qui ressemble à cela :

int integerForSeedValue(int seedNumber) {
        //code goes here
        return 0;
}

Cliquez de nouveau sur Build, et vous verrez les warnings disparaitre.
C’est une bonne habitude d’écrire un code sans warning, et nous nous efforcerons de le faire y compris pour un code plus complexe.

Agrémenter la Fonction (Juste pour s’Amuser)

Mais pour le moment, vous devez vous demander à quoi correspond notre correction.
Notre fonction ignore notre argument d’entrée, ne fait rien d’utile, et retourne toujours la même chose.
Qu’est-ce donc ? Une boite de dialogue d’erreurs de Windows ?

Alors modifions notre fonction pour qu’elle ressemble à ça :

int integerForSeedValue(int seedNumber) {
        return seedNumber - 3;
}

Maintenant, nous effectuons quelque chose dans notre fonction, et nous retournons quelque chose de différent, qui est fonction de ce qu’on lui donne.
Nous retournons la variable seedNumber, à laquelle nous enlevons la constante 3.
Vous vous demandez peut-être comment nous pouvons utiliser la variable seedNumber sans avoir de déclaration de variable, et c’est une très bonne question.
La réponse est que nous avons une définition de variable, mais elle n’est pas écrite comme les autres que nous avons déjà faites.
Cette définition se trouve entre les parenthèses, dans la liste des arguments.
Là, quand nous écrivons les arguments que la fonction accepte, nous effectuons également leur déclaration.

Maintenant que nous avons une fonction, nous devons l’appeler.
Dans notre fonction main, remplacez la ligne

favoriteNumber = favoriteNumber + 2;

par une ligne légèrement modifiée :

favoriteNumber = integerForSeedValue(favoriteNumber + 2);

Maintenant, nous appelons notre fonction integerForSeedValue depuis notre fonction main.
Quand l’ordinateur exécute cette ligne de code, il ira dans notre fonction integerForSeedValue et exécutera toutes les instructions dans ce bloc de code avant de poursuivre à la ligne suivante dans main.
Remarquez que pendant que l’ordinateur exécute les lignes dans integerForSeedValue, la variable seedNumber aura la valeur évaluée de favoriteNumber + 2, qui est 8.
Donc integerForSeedValue retournera 8-3, soit 5.
Compilons notre programme.
Cliquez le bouton Build, et assurez vous de ne pas avoir de warning ou d’erreur.

Que faisons-nous maintenant ?
Le warning que nous avons maintenant est warning: implicit declaration of function ‘integerForSeedValue’.
Qu’est-ce-que cela signifie ?
Nous savons ce qu’une déclaration de variable, et nous savons que nous ne pouvons pas utiliser de variable avant de l’avoir déclarée.
Et si nous cliquons sur ce warning, il nous pointe vers l’endroit où nous utilisons notre fonction, et donc l’étape logique est de penser que les fonctions doivent elles aussi être déclarées, et c’est exact.

Nous ajoutons donc une ligne en haut de main, pour déclarer notre fonction.
Maintenant, notre fichier ressemble à ceci :

#include 

int integerForSeedValue(int seedNumber);

int main (int argc, const char * argv[]) {
        //Computes our favorite number
        int favoriteNumber = (3 * 4) / 2;       //is anyone's favorite number not an int?
        favoriteNumber = integerForSeedValue(favoriteNumber+2);
        /*now let's tell the world
                what our favorite number is! */
        printf("My favorite number is %d!", favoriteNumber);
    return 0;
}

int integerForSeedValue(int seedNumber) {
        return seedNumber - 3;
}

Cela vous rappelle quelque chose ?
Ce que nous avons fait, c’est de prendre la fonction, supprimer son bloc de code, et la coller là, suivie par un point-virgule.
Cela suffit au compilateur, cette simple ligne est la déclaration de fonction dont nous avions besoin, et une nouvelle tentative de compilation nous le confirme en n’affichant aucun warning ou erreur.
Exécutez le programme, et vous verrez que notre nombre favori est 5, comme il devait l’être.

Conclusion

Ouah ! Nous avons fait de gros progrès avec cette leçon.
Nous avons découvert les outils que nous devrons utiliser tous les jours que nous développerons, nous avons compilé et exécuté “Hello World!”, nous avons écrit quelques lignes de code et nous en avons fait un programme, nous avons appris à reconnaitre, implémenter, déclarer et appeler des fonctions et nous avons appris comment obtenir des informations depuis notre environnement de développement sur des problèmes avec notre code, et les corriger.

Mais il nous reste encore une longue route à faire.
La prochaine fois, nous nous plongerons dans le contrôle de flux, qui agira sur la façon dont notre code est exécuté, pour que nous puissions faire des choses plus compliquées que simplement “une liste de choses à faire” comme nous l’avons fait jusque là.
Cette prochaine leçon nous fournira les outils dont nous avons besoin pour des programmes plus complexes avec les connaissances que nous avons acquises.

Textes originaux en anglais sur O’Reilly : What’s Your Function par Seth Roby

opoppon Programmation Cocoa C, cocoa, Mac OS X