Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Ce cours existe en eBook.

J'ai tout compris !
  • 4 semaines
  • Moyen

Comme je vous le disais dans la première partie de ce livre, nous allons utiliser le langage Objective-C pour développer nos applications. Et pour bien comprendre comment fonctionne l'Objective-C, vous devez dans un premier temps en acquérir les bases. Tout ce qui sera dit ici vous sera profitable lorsque vous écrirez des applications en Objective-C.

Nous allons y aller en douceur et vous verrez que, progressivement, vous serez capables de réaliser de plus en plus de choses avec ce langage. Alors allons-y !

Mise en pratique de ce chapitre

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.

Insérez une instruction dans votre code

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.

Le texte est bien affiché

Est-ce que NSLog() peut afficher autre chose que du texte ?

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.

Instructions

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.

Je vois que toutes les lignes se terminent par un « ; ». Est-ce que ce caractère est obligatoire ?

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 « ; ».

Variables, constantes et opérateurs

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;

Pas si vite ! Qu'est-ce que veut dire int et pourquoi le deuxième mot est orthographié ainsi : maVariable et pas Ma variable ?

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;

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 résultat est affiché dans le volet de débogage

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.

Type

Signification

%@

Objet Cocoa. NSString par exemple

%d, %i

Entier signé (c'est-à-dire avec un signe "-" si nécessaire)

%f

Float ou Double

%c

Caractère

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.

Opérateur

Signification

Exemple

=

Affectation

int maVariable = 2;

+=

Ajout de la valeur spécifiée

maVariable += 5; // Ajoute 5 à maVariable

-=

Soustraction de la valeur spécifiée

maVariable -= 5; // Soustrait 5 à maVariable

/=

Divise par la valeur spécifiée

maVariable /= 5; // Divise par 5 maVariable

*=

Multiplie par la valeur spécifiée

maVariable *= 5; // Multiplie par 5 maVariable

%=

Donne le reste de la division entière dont le diviseur est spécifié

maVariable %= 5; // Stocke dans maVariable le reste de la division entière de maVariable par 5

Je ne comprends rien à ce tableau ! Quelques explications seraient les bienvenues.

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 quoi exactement ce % dont tu nous parles ?

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.

Opérateur

Fonction

+

Addition

-

Soustraction ou inversion de signe

++

Ajout de 1

--

Soustraction de 1

*

Multiplication

/

Division

%

Modulo (reste de la division entière)

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.

Les résultats sont bien affichés et sont corrects

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é.

Commentaires

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
*/

Types de données

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.

Variable

Valeurs possibles

short int

-32768 à 32768

unsigned short int

0 à 65535

unsigned int et unsigned long int

0 à 4294967295

int et long int

-2147483647 à 2147483647

long long int

-9223372036854775807 à 9223372036854775808

unsigned long long int

0 à 18446744073709551615

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\times 10^{-38}$$ et $$3.4\times 10^{38}$$. Quant aux variables/constantes de type double, elles peuvent être comprises entre $$1.7\times 10^{-308}$$ et $$1.7\times 10^{308}$$.

Que signifie 3.4*10^-38 ?

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.

$3.4\times 10^{-38}$ est en fait un nombre à virgule avec 38 zéros

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

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.

L'emplacement d'adresse 17 contient un pointeur vers l'emplacement d'adresse 207

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.

Qu'est-ce encore que cela ?

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);

Est-il possible d'avoir quelques explications sur la ligne 3 ?

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.

Code ASCII ? Mais qu'est-ce donc que cela ?

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).

Découvrez aussi ce cours en...

Exemple de certificat de réussite
Exemple de certificat de réussite