Opérateurs d'incrémentation et de décrémentation

Les opérateurs d'incrémentation et de décrémentation sont des opérateurs unaires qui augmentent ou diminuent leur opérande de un.

On les trouve couramment dans les langages de programmation impératifs . Les langages de type C proposent deux versions (pré- et post-) de chaque opérateur, avec des sémantiques légèrement différentes.

Dans les langages syntaxiquement dérivés de B (y compris C et ses différents dérivés), l'opérateur d'incrémentation s'écrit inc(x) ++et l'opérateur de décrémentation s'écrit dec( --x). Plusieurs autres langages utilisent les fonctions inc(x) et dec(x).

L'opérateur d'incrémentation augmente et l'opérateur de décrémentation diminue la valeur de son opérande de 1. L'opérande doit être de type arithmétique ou pointeur et doit faire référence à un objet de données modifiable . Les valeurs des pointeurs sont incrémentées (ou décrémentées) de manière à pointer vers l'élément adjacent suivant (ou précédent) en mémoire.

Dans les langues qui prennent en charge les deux versions des opérateurs :

Les opérateurs de pré- incrémentation et de pré- décrémentation incrémentent (ou décrémentent) leur opérande de 1, et la valeur de l'expression est la valeur incrémentée (ou décrémentée) résultante.
Les opérateurs post -incrémentation et post- décrémentation augmentent (ou diminuent) la valeur de leur opérande de 1, mais la valeur de l'expression est la valeur de l'opérande avant l'opération d'incrémentation (ou de décrémentation).

Dans les langages où l'incrémentation/décrémentation n'est pas une expression (par exemple, Go ), une seule version est nécessaire (dans le cas de Go, uniquement les opérateurs post).

L'opérateur d'incrémentation/décrémentation modifiant son opérande, son utilisation répétée dans une même expression peut produire des résultats indéfinis selon le langage. En C, par exemple , dans des expressions telles que x - ++x`increment(increment)`, l'ordre d'exécution des opérations de soustraction et d'incrémentation n'est pas clair. De telles expressions peuvent alors engendrer un comportement indéfini et sont donc à éviter.

Dans les langages à pointeurs typés comme le C, l'opérateur d'incrémentation déplace le pointeur vers l'élément suivant du même type, en augmentant sa valeur de la taille de cet élément. Lorsqu'un pointeur (du type approprié) pointe vers un élément d'un tableau, l'incrémenter (ou le décrémenter) le fait pointer vers l'élément suivant (ou précédent) de ce tableau. Ainsi, incrémenter un pointeur vers un entier le fait pointer vers l'entier suivant (généralement en augmentant sa valeur de 4) ; incrémenter un pointeur vers une structure de 106 octets le fait pointer vers la structure suivante en augmentant sa valeur de 106.

Exemples

L'extrait de code C suivant illustre la différence entre les opérateurs d'incrémentation et de décrémentation avant et après :

int x ; int y ;// Opérateurs d'incrémentation // Pré-incrémentation : x est incrémenté de 1, puis y prend la valeur de x. x = 1 ; y = ++ x ; // x vaut maintenant 2, y vaut également 2// Post-incrémentation : y prend la valeur de x, puis x est incrémenté de 1. x = 1 ; y = x ++ ; // y vaut 1, x vaut maintenant 2// Opérateurs de décrémentation // Pré-décrémentation : x est décrémenté de 1, puis y prend la valeur de x. x = 1 ; y = --x ; // x vaut maintenant 0, y vaut également 0// Post-décrémentation : y prend la valeur de x, puis x est décrémenté de 1. x = 1 ; y = x -- ; // y vaut 1, x vaut maintenant 0

Dans les langages dépourvus de ces opérateurs, des résultats équivalents nécessitent une ligne de code supplémentaire :

# Pré-incrémentation : y = ++x x = 1 x = x + 1 # x vaut maintenant 2 (peut s'écrire « x += 1 » en Python) y = x # y vaut également 2# Post-incrémentation : y = x++ x = 1 y = x # y vaut 1 x = x + 1 # x vaut maintenant 2

L'opérateur d'incrémentation postérieure est couramment utilisé avec les indices de tableaux . Par exemple :

// Somme des éléments d'un tableau float sum_elements ( float arr [], int n ) { float sum = 0.0 ; int i = 0 ;while ( i < n ) sum += arr [ i ++ ]; // Post-incrémentation de i, qui parcourt // les n éléments du tableau return sum ; }

L'opérateur d'incrémentation postérieure est également couramment utilisé avec les pointeurs :

// Copie un tableau dans un autre void copy_array ( float * src , float * dst , int n ) { while ( n -- > 0 ) // Boucle décrémentant n à zéro * dst ++ = * src ++ ; // Copie l'élément *(src) dans *(dst), // puis incrémente les deux pointeurs }

Ces exemples fonctionnent également dans d'autres langages de type C, tels que C++ , Java et C# .

L'opérateur d'incrémentation peut être illustré par un exemple :
#include <stdio.h> int main () { int c = 2 ; printf ( "%d " , c ++ ); // cette instruction affiche 2, puis c est incrémenté de 1 à 3. printf ( "%d" , ++ c ); // cette instruction incrémente c de 1, puis c est affiché. return 0 ; }
- Sortir:
  2 4

Langues prises en charge

La liste suivante, bien que non complète et non exhaustive, répertorie certains des principaux langages de programmation qui prennent en charge les opérateurs d'incrémentation et de décrémentation.

Le Swift d'Apple prenait autrefois en charge ces opérateurs, mais ils ont été dépréciés depuis la version 2.2 et supprimés à partir de la version 3.0.

Pascal , Delphi , Modula-2 et Oberon utilisent des fonctions ( inc(x)et dec(x)) au lieu d'opérateurs. Tcl utilise la incrcommande.

À noter que Python , Ruby et Rust ne prennent pas en charge ces opérateurs.

Histoire

Le concept a été introduit dans le langage de programmation B vers 1969 par Ken Thompson .

Thompson est allé plus loin en inventant les opérateurs ++ et --, qui incrémentent ou décrémentent ; leur position (préfixe ou postfixe) détermine si la modification a lieu avant ou après la valeur de l'opérande. Absents des premières versions de B, ils sont apparus progressivement. On suppose souvent qu'ils ont été créés pour exploiter les modes d'adressage à incrémentation et décrémentation automatiques du DEC PDP-11, système sur lequel C et Unix ont connu leurs premiers succès. Historiquement, cela est impossible, car le PDP-11 n'existait pas lors du développement de B. Le PDP-7, en revanche, disposait de quelques cellules mémoire à « incrémentation automatique », dont la propriété était qu'une référence mémoire indirecte entraînait l'incrémentation de la cellule. Cette caractéristique a probablement inspiré ces opérateurs à Thompson ; la généralisation permettant leur utilisation en préfixe et en postfixe est de son fait. En réalité, les cellules à incrémentation automatique n'ont pas été utilisées directement dans l'implémentation des opérateurs, et la principale motivation de cette innovation était probablement son observation que la traduction de ++x était plus courte que celle de x=x+1.