Devenir un Xcoder

Ce chapitre contient des concepts avancés et traite de concepts implicites du langage C que les débutants pourront trouver intimidants. Si vous ne comprenez pas tout maintenant, ne vous inquiétez pas. Heureusement, en général (bien que la compréhension du fonctionnement des pointeurs soit utile) ce n'est pas indispensable pour commencer la programmation en Objective-C.

Lorsque vous déclarez une variable, votre Mac associe cette variable à de l'espace dans sa mémoire pour y stocker la valeur de la variable.

Par exemple, examinez les instructions suivantes :

//[1]
int x = 4;

Pour l'exécuter, votre Mac trouve de l'espace non encore utilisé dans sa mémoire puis note que cet espace est l'endroit où la valeur de la variable x doit être stockée (bien sûr, nous aurions pu et dû utiliser ici un nom plus descriptif pour notre variable). Examinez à nouveau l'instruction [1]. Indiquer le type de la variable (ici int) permet à votre ordinateur de savoir combien d'espace mémoire est nécessaire pour stocker la valeur de x. Si la valeur était de type long long ou double, plus de mémoire devrait être réservée.

L'instruction d'affectation x = 4 stocke le chiffre 4 dans cet espace réservé. Bien sûr, votre ordinateur se souvient d'où la valeur de la variable x est stockée dans sa mémoire, ou, en d'autres termes, quelle est l'adresse de x. De cette façon, chaque fois que vous utilisez x dans votre programme, votre ordinateur peut aller au bon endroit (à la bonne adresse) et trouver la valeur réelle de x.

Un pointeur est simplement une variable qui contient l'adresse d'une autre variable.

Étant donné une variable, vous pouvez obtenir son adresse en écrivant & devant la variable. Par exemple, pour obtenir l'adresse de x, vous écrivez &x.

Lorsque l'ordinateur évalue l'expression x, il retourne la valeur de la variable x (dans notre exemple, il retournera 4). En revanche, lorsque l'ordinateur évalue l'expression &x, il retourne l'adresse de la variable x, et non la valeur qui y est stockée. L'adresse est un nombre qui désigne un endroit précis dans la mémoire de l'ordinateur (comme un numéro de chambre désigne une chambre précise d'un hôtel).

Vous déclarez un pointeur de cette façon :

//[2]
int *y;

Cette instruction définit une variable nommée y qui contiendra l'adresse d'une variable de type int. Encore une fois : elle ne contiendra pas une variable int, mais l'adresse d'une telle variable. Pour stocker dans la variable y quelle est l'adresse de la variable x (en jargon informatique officiel : assigner l'adresse de x à y), vous faites :

//[3]
y = &x;

Maintenant y "pointe sur" l'adresse de x. Ainsi, à l'aide de y, vous pouvez retrouver x. Voici comment.

Étant donné un pointeur, vous pouvez accéder à la variable sur laquelle il pointe, en mettant un astérisque devant le pointeur. Par exemple, évaluer l'expression :

*y

retournera 4. Ceci est équivalent à évaluer l'expression x. Exécuter l'instruction :

*y = 5

est équivalent à exécuter l'instruction :

x = 5

Les pointeurs sont utiles parce que parfois vous ne voudrez pas vous référer à la valeur d'une variable, mais à l'adresse de cette variable. Par exemple, vous pourrez vouloir programmer une fonction qui ajoute 1 à une variable. Bon, ne pouvez-vous simplement le faire comme ça ?

//[4]
void incrementer(int x)
{
    x = x + 1;
}

Eh bien, non. Si vous appelez cette fonction depuis un programme, vous n'obtiendrez pas les résultats que vous attendiez :

//[5]
int maValeur = 6;
incrementer(maValeur);
NSLog(@"%d:\n", maValeur);

Ce code afficherait 6 sur votre écran. Pourquoi ? N'avez-vous pas incrémenté maValeur en appelant la fonction incrementer ? Non, vous ne l'avez pas fait. Vous voyez, la fonction en [4] n'a fait que prendre la valeur de maValeur (c'est-à-dire le chiffre 6), l'incrémenter de un, puis... en gros, l'a jetée. Les fonctions ne marchent qu'avec les valeurs que vous leur passez, pas avec les variables qui véhiculent ces valeurs. Même si vous modifiez le x (comme vous pouvez le voir dans [4]), vous ne faites que modifier la valeur que la fonction a reçue. Toute modification de ce type sera perdue lorsque la fonction retourne. En outre, ce x n'est même pas forcément une variable : si vous appelez incrementer(5);, que vous attendez-vous à incrémenter ?

Si vous voulez écrire une version de la fonction incrementer qui marche vraiment, c'est-à-dire accepte une variable comme son argument et incrémente en permanence la valeur de cette variable, vous devez lui passer l'adresse d'une variable. De cette façon, vous pouvez modifier ce qui est stocké dans cette variable, et non pas simplement utiliser sa valeur actuelle. Par conséquent, vous utilisez un pointeur comme argument :

//[6]
void incrementer(int *y)
{
    *y = *y + 1;
}

Vous pouvez alors l'appeler de cette façon :

//[7]
int maValeur = 6;
incrementer(&maValeur); // passe l'adresse
// Maintenant maValeur est égal à 7