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.
Le terme « variable » a été choisi car la donnée mémorisée est susceptible de changer de valeur pendant l'exécution du programme. Elle est donc… variable.
Pour définir une variable, vous utiliserez la syntaxe suivante :
Code : Objective-C
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.
Souvenez-vous qu'une instruction doit se terminer par un « ; ».
Par exemple, pour définir une variable nommée « maVariable » dont le type est
int, vous utiliserez l'instruction suivante :
Code : Objective-C
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.
Notez également qu'Objective-C est sensible à la casse des caractères, c'est-à-dire aux minuscules et aux majuscules. Ainsi par exemple, les variables unEntier, UnEntier et UNentier sont différentes. Si vous tentez d'utiliser plusieurs de ces noms pour désigner une même variable, des erreurs se produiront et l'application ne pourra pas s'exécuter.
Si vous le souhaitez, il est possible d'affecter une valeur à une variable pendant sa déclaration. Vous utiliserez alors la syntaxe suivante :
Code : Objective-C | 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 :
Code : Objective-C
Ici, la valeur 10 est affectée à la variable
maVariable de type
int.
Vous pouvez manipuler ces variables comme bon vous semble. Par exemple :
Code : Objective-C | 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.
Notez que pour la première instruction, je n'ai renseigné qu'une seule fois le type des variables, avant de les séparer par des virgules. C'est plus rapide à écrire (oui les développeurs sont des fainéants).
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 :
Code : Objective-C | 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.
Avez-vous remarqué l'étrange « %d » dans la fonction NSLog() ?
Ce paramètre indique à Xcode le type de la valeur à afficher. Ici, %d signifie « variable entière ».
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 :
Code : Objective-C | 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 :
Code : Objective-C | 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 |
Il existe d'autres opérateurs d'affectation, mais nous les passerons sous silence pour l'instant car ils risqueraient de vous embrouiller. Arrivés à ce point du livre, ce qui compte c'est que vous compreniez la logique d'utilisation des opérateurs d'affectation.
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 :
Code : Objective-C
Il s'agit d'une facilité, ou plutôt d'un raccourci d'écriture. Cette instruction est équivalente à :
Code : Objective-C | 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 :
Code : Objective-C
Est équivalent à :
Code : Objective-C | 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 :
Code : Objective-C | 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 ?
Code : Objective-C | 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 ?
Code : Objective-C | 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 :
Code : Objective-C 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 | - (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 ?
Code : Objective-C | 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é.
Les bases de l'Objective-C
Durée d'étude :
2
heures
MichelMartin
)
:
Trouvez une formation
Suggestions
Facebook
Google+