Next: Exercice Up: Les tableaux Previous: Les instructions itératives

Sous-sections

Les opérateurs

Opérateur pré et postincrément

Le langage C offre un opérateur d'incrémentation qui peut être utilisé soit de manière préfixé, soit de manière postfixé. Cet opérateur se note ++ et s'applique à une lvalue. Sa syntaxe d'utilisation est donc au choix, soit ++ lvalue (utilisation en préfixé), soit lvalue ++ (utilisation en postfixé). Tout comme l'opérateur d'affectation, l'opérateur d'incrémentation réalise à la fois un effet de bord et délivre une valeur :
++ lvalue incrémente lvalue de 1 et délivre cette nouvelle valeur.
lvalue ++ incrémente lvalue de 1 et délivre la valeur initiale de lvalue.

Exemples

Soient i un int et t un tableau de int :

i = 0;
t[i++] = 0;  /*  met à zéro l'élément d'indice 0  */
t[i++] = 0;  /*  met à zéro l'élément d'indice 1  */

i = 1;
t[++i] = 0;  /*  met à zéro l'élément d'indice 2  */
t[++i] = 0;  /*  met à zéro l'élément d'indice 3  */

Opérateur pré et postdécrément

Il existe également un opérateur de décrémentation qui partage avec l'opérateur incrément les caractéristiques suivantes :

-: il peut s'utiliser en préfixe ou en postfixé ;
-: il s'applique à une lvalue, ;
-: il fait un effet de bord et délivre une valeur.

Cet opérateur se note - et décrémente la lvalue de 1 :
- lvalue décrémente lvalue de 1 et délivre cette nouvelle valeur.
lvalue - décrémente lvalue de 1 et délivre la valeur initiale de lvalue.

Exemples

Soient i un int et t un tableau de int :

i = 9;
t[i--] = 0;  /*  met à zéro l'élément d'indice 9  */
t[i--] = 0;  /*  met à zéro l'élément d'indice 8  */

i = 8;
t[--i] = 0;  /*  met à zéro l'élément d'indice 7  */
t[--i] = 0;  /*  met à zéro l'élément d'indice 6  */

Quelques utilisations typiques de ces opérateurs

Utilisation dans les instructions expression

On a vu qu'une des formes d'instruction possibles en C est :
expression ;
et que cela n'a de sens que si l'expression réalise un effet de bord. Les opérateurs ++ et - réalisant précisément un effet de bord, permettent donc d'écrire des instructions se réduisant à une expression utilisant un de ces opérateurs. Une incrémentation ou une décrémentation de variable se fait classiquement en C de la manière suivante :

i++;    /*   incrémentation de i   */
j--;    /*   décrémentation de j   */

Utilisation dans les instructions itératives

Une boucle for de parcours de tableau s'écrit typiquement de la manière suivante :

for (i = 0; i < N; i++)
   {
   ...
   }

Opérateur et logique

$\bullet$

Syntaxe :

expression :
$\Rightarrow$ expression₁ && expression₂

$\bullet$

Sémantique :

expression₁ est évaluée et :

1.: si sa valeur est nulle, l'expression && rend la valeur 0 ;
2.: si sa valeur est non nulle, expression₂ est évaluée, et l'expression && rend la valeur 0 si expression₂ est nulle, et 1 sinon.

On voit donc que l'opérateur && réalise le et logique de expression₁ et expression₂ (en prenant pour faux la valeur 0, et pour vrai toute valeur différente de 0).

Remarque sur la sémantique

On a la certitude que expression₂ ne sera pas évaluée si expression₁ rend la valeur faux. Ceci présente un intérêt dans certains cas de parcours de tableau ou de liste de blocs chaînés. Par exemple dans le cas d'un parcours de tableau à la recherche d'un élément ayant une valeur particulière, supposons que l'on utilise comme test de fin de boucle l'expression

i < n && t[i] != 234

(on boucle tant que ce test est vrai), où i < n est le test permettant de ne pas déborder du tableau, et t[i] != 234 est le test de l'élément recherché. S'il n'existe dans le tableau aucun élément égal à 234, il va arriver un moment où on va évaluer i < n && t[i] != 234 avec i = n. La sémantique de l'opérateur && assurant que l'expression t[i] != 234 ne sera pas évaluée, on ne court donc pas le risque d'avoir une erreur matérielle (t[n] peut référencer une adresse mémoire invalide).

Exemples d'utilisation

int a,b;
if (a > 32 && b < 64) ...
if ( a && b > 1)  ... 
b = (a > 32 && b < 64);

Opérateur ou logique

$\bullet$

Syntaxe :

expression :
$\Rightarrow$ expression₁ || expression₂

$\bullet$

Sémantique :

expression₁ est évaluée et :

si sa valeur est non nulle, l'expression || délivre la valeur 1 ;
sinon, expression₂ est évaluée, si sa valeur est nulle, l'expression || délivre la valeur 0 sinon elle délivre la valeur 1.

On voit donc que l'opérateur || réalise le ou logique de ses opérandes, toujours avec les mêmes conventions pour les valeurs vrai et faux, à savoir 0 pour faux, et n'importe quelle valeur non nulle pour vrai. Dans ce cas également, on a la certitude que le second opérande ne sera pas évalué si le premier délivre la valeur vrai.

Exemples

int a,b;
if (a > 32 || b < 64) ...
if ( a || b > 1)  ... 
b = (a > 32 || b < 64);

Opérateur non logique

$\bullet$

Syntaxe :

expression :
$\Rightarrow$ ! expression

$\bullet$

Sémantique :

expression est évaluée, si sa valeur est nulle, l'opérateur ! délivre la valeur 1, sinon il délivre la valeur 0.

Cet opérateur réalise le non logique de son opérande.

Next: Exercice Up: Les tableaux Previous: Les instructions itératives

Bernard Cassagne
1998-12-09