Incrémentation

Reprenons de nouveau un des programmes des étapes précédentes, par exemple:

int cacheCache;

void setup(void) {
  Serial.begin(115200);
}

void loop() {
  cacheCache = cacheCache + 1;
  Serial.println(cacheCache);
  delay(1000);
}

Nous allons nous intéresser aujourd'hui à la ligne qui incrémente cacheCache

cacheCache = cacheCache + 1;

Incrémenter c'est augmenter d'un incrément, et par défaut (quand on ne dit rien) l'incrément est de 1. Nous avons déjà utilisé une première forme:

cacheCache = cacheCache + 1;

et je rappelle que cela devrait se lire cacheCache prend la valeur cacheCache+1.

cacheCache += 1;

Quand nous utilisons la version 1 avec les vieux compilateurs peu ou pas optimisés, cela va se passer un peu comme si on demandait à un serveur qui ne sait pas lire, de remplir le verre du client de la table 5. Le serveur demande qu'on lui écrive sur un papier le numéro de la table, il cherche la table, prend le verre, va au distributeur de boisson, remplit le verre puis redemande qu'on lui marque sur un nouveau papier le numéro de la table, et va enfin reposer le verre. Avec les compilateurs du début, On était obligé de donner deux fois l'adresse. Les nouveaux compilateurs optimisent le code et transforment la forme 1 en forme 2. La forme de tout à l'heure c'était cacheCache prend la valeur cacheCache+1, mais on va maintenant dire ajoute 1 à cacheCache. Du coup la variable ne va apparaître qu'une fois, et on sait qu'il faut conserver l'adresse. Cela s'écrit

cacheCache += 1;

+= ne doit pas avoir d'espace entre le "+" et le "=". Et quand on a
<variable> <opérateur>= valeur;
cela veut dire:
<variable> = <variable> <opérateur> valeur;
Ceci est valable pour les 4 opérations + - * / ainsi que trois nouveaux opérateurs %, & et |.

Ainsi:
x += 10; ajoute 10 à x
x *= 2; double x
x /= 4; divise x par 4...

Bien entendu, je vous encourage à tester au minimum

cacheCache += 1;

Essayez aussi d'afficher que les nombres pairs. Puis que les nombres impairs (c'est des nombres qui vont de 2 en 2, mais si on veut afficher 1 au début, il faut initialiser cacheCache à -1). Essayez aussi de faire afficher 1, 2, 4, 8, 16, 32, 64... (au lieu d'ajouter 1, il faut multiplier par 2).

cacheCache++;

Incrémenter est relativement plus courant que d'incrémenter de plusieurs unités. On lui a donné deux formes spécifiques:

cacheCache++;

est la plus courante. C'est bien l'équivalent du français incrémente cacheCache. Dans cette écriture les deux + doivent êtres collés. En principe, on colle aussi ++ au nom de la variable.

On voit de temps en temps les lignes

cacheCache++;
Serial.println(cacheCache);

remplacées par une seule ligne:

Serial.println(cacheCache++);

Notez qu'il ne faut alors pas mettre le point-virgule car ce qui est entre parenthèse est un calcul et pas une instruction. Testez le programme! Aide?int cacheCache; void setup(void) { Serial.begin(115200); } void loop() { Serial.println(cacheCache++); delay(1000); }

Cela va fonctionner presque comme tout à l'heure, sauf qu'il commence par afficher 0! C'est donc que l'incrémentation se fait après l'affichage. cacheCache est évalué, on envoie ce qu'on avait évalué dans le Serial.println, et enfin on ajoute 1. Si on veut avoir la même chose qu'avant, il faudrait d'abord faire l'incrémentation. Avant l'affichage. On va être sympa, on veut le ++ avant? Et bien mettez le avant!

Serial.println(++cacheCache);

N'en mettez pas des deux côtés, cela ne fonctionne pas. Évidemment testez aussi cette manière et vous devez retrouver le comptage à partir de 1.

Cette forme fonctionne aussi pour la décrémentation;

Serial.println(cacheCache--);

va afficher la valeur de la variable puis la décrémenter tandis que

Serial.println(--cacheCache);

va d'abord décrémenter la variable puis l'afficher. Vous pouvez aussi tester! Par contre

Serial.println(cacheCache**);

n'est pas admis, cela pourrait indiquer de multiplier par 1, ce qui n'a aucun intérêt. Pareil pour la division. Doubler l'opérateur n'existe que pour ++ et --

++ avant ou après?

Quand on reprend la ligne

Serial.println(++cacheCache);

on ne se pose pas la question de savoir si on met le ++ avant ou après. Dans un sens on a ce que l'on veut et dans l'autre ses non. Par contre si on écrit les lignes

cacheCache++;
Serial.println(cacheCache);

dans la première ligne on pourrait mettre les ++ avant ou après la variable. Les deux solutions fonctionnent et sont équivalentes. Mais en pratique on a l'habitude de mettre les ++ après.

Une affectation retourne une valeur

Nous avons dit que

cacheCache = cacheCache + 1;
cacheCache += 1;
++cacheCache;

sont équivalents. Alors si on peut mette la troisième forme dans le Serial.println() on devrait pouvoir aussi mettre les deux autres formes? Et bien oui. En fait quand on fait une affectation A = B il faut le comprendre comme:
- je prends la valeur B
- je l'affecte à A
- le tout donne A, (vu que c'est ce qui a été affecté).

Et donc on pourrait écrire

Serial.println(cacheCache = cacheCache + 1);

Cette ligne demande donc d'écrire le résultat de l'opération. Cette écriture est possible et autorisée, mais elle est très très peu utilisée parce qu'elle embrouille plus qu'elle ne simplifie. On évitera de le faire, sauf éventuellement pour ++ ou le --.

Et si les calculs retournent une valeur, que fait-on de cette valeur quand on écrit une des trois lignes de code que nous avons vu? Et bien, elle est ignorée. C'est comme s'adresser à des gens et de dire "cent vingt et un", cette information est complètement ignorée sauf que les personnes vous regarderont de travers, ce que le compilateur ne sait pas faire. Si vous mettez dans votre programme la ligne

cacheCache;

cela ne déclenche pas d'erreur, il y a simplement un résultat qui est annoncé et qui est ignoré. Vous pouvez aussi rajouter la ligne

1;

C'est pareil.

Tout ceci peut sembler superflu, mais bien des erreurs surtout au début arrivent à cette situation. Un programmeur a fait une erreur d'écriture, a mis un point-virgule en trop... et le compilateur accepte sans sourciller. Pour l'humain derrière son clavier, c'est de la faute du compilateur et il devait le signaler. Cela arrive trop souvent que le compilateur comprenne autre chose que ce que l'on a voulu écrire.