Les pointeurs et leurs utilisations

C'est quoi un pointeur?
Si vous ne savez pas ce qu'est un pointeur (pointer), imaginez simplement que c'est une variable qui contient l'adresse d'un espace mémoire dans lequel se trouve une valeur ou un objet (qu'il aura fallut préalablement allouer).

Exemples
Voici quelques exemples commentés permettant de comprendre la notation.

Un pointeur "pointe" vers une zone mémoire
déjà allouée et contenant une valeur

Distinction entre pointeurs et valeurs:

int* p; // déclaration d'un pointeur vers un entier
int i; // déclaration d'une valeur entière
i = 5; // assignation d'une valeur entière

Vous pouvez transformer une valeur en pointeur à l'aide de & (obtenir l'adresse de la variable où la valeur est stockée):

p = &i; // Pointeur vers l'entier
int* p2 = &i; // Second pointeur vers l'entier (stocké dans la variable "i")

On transforme le pointeur en valeur (comprenez obtenir la valeur à l'adresse pointée par le pointeur) à l'aide de *:

int i2 = *p; // obtenir la valeur entière

Il est donc possible d'envoyer la valeur entière sur la connexion série à l'aide de:

Serial.println( i ); // affichage de la valeur entière
Serial.println( *p );// Affichage de la valeur entière pointée par le pointeur p

Dans le cas des tableaux (arrays), ces derniers sont traités de façon semblable aux pointeurs. Si vous pensez à eux comme des pointeurs, vous utiliserez * pour obtenir la valeur dans le tableau (comme expliqué ci-dessus). Une façon plus commune est d'utiliser l'opérateur [] :

int a[2]; // un tableau d'entier
int i = *a; // la valeur du premier élément de a
int i2 = a[0]; // Une autre façon d'obtenir la première valeur

Pour obtenir le second élément:

int a[2]; // Le tableau
int i = *(a + 1); // La valeur du second élément
int i2 = a[1]; // La valeur du second élément

L'opérateur d'indexation [] est comme une forme un peu spéciale de l'opérateur * qui fonctionne comme suit:

a[i] == *(a + i); // ces deux expressions sont identiques

Les puristes verront ici un article d'introduction dont le but est de se familiariser avec le concept.

Usage des pointeurs
Si cette notion peut paraître farfelue, mais elle est vraiment très utile dans les systèmes ayant peu de ressource.

Cela permet de passer une variable par référence à une fonction.
Vous pouvez modifier une valeur dans la fonction et disposer de la modification hors de la fonction. Ce sont bien des pointeurs qui sont utilisés (même si le compilateur prend tout en charge pour vous).
L'autre avantage de cette technique est d'économiser la mémoire puisque le compilateur ne doit pas dupliquer la variable avant d'appeler la fonction.
Permettre de passer la référence vers un objet, une variable ou une structure.
Une fois encore, cela évite des allocations de mémoire (réaliser par le compilateur). Mémoire qu'il faut économiser sur un Arduino.
Cela permet de modifier l'adresse soit même (appelé arithmétique des pointeurs) pour naviguer le long d'une structure (chaine de caractère, tableau), etc). En incrémentant l'adresse du pointeur... le pointeur passe d'une zone mémoire à l'autre (et permet donc d'atteindre les différents éléments stockés).

Ressources
Vous trouverez différentes informations utiles ci-dessous.