C'est une constante, une variable ou un appel de fonction.

Exemple : 3, x (si x est une variable), f () (si f est une fonction) ...




 C'est une expression localisée en mémoire : une lvalue possède une adresse. Si x est une variable, x est un lvalue. Par contre 5 n'est pas une lvalue.




 Contrairement à la plupart des langages où l'affectation est une instruction, en C l'affectation est une expression. L'opérateur = agit par effet de bord puisqu'il modifie son premier opérande en lui affectant la valeur du deuxième. Le premier opérande doit donc être une lvalue. L'expression globale, quant à elle, a une valeur égale à celle du deuxième opérande.

 e1 = e2 est une expression égale à e2. L'expression e2 est évaluée, puis l'expression e1, et la valeur de e2 est affectée à e1.


Exemple :

a = 2;   /* est une expression qui vaut 2 et a reçoit la valeur 2 */ a = b = 0;  /* est équivalent à : a = (b = 0) car l'opérateur d'affectation est associatif à droite */  /* l'expression vaut 0, a et b reçoivent la valeur 0 */

 Les opérateurs arithmétiques binaires sont :

+	(somme)	e1 + e2	entiers ou réels
-	(différence)	e1 - e2	entiers ou réels
*	(produit)	e1 * e2	entiers ou réels
/	(quotient)	e1 / e2	entiers ou réels
%	(modulo)	e1 % e2	entiers uniquement

 + et - peuvent être utilisés comme des opérateurs unaires, la valeur de l'expression +exp sera la valeur de exp après exécution des conversions arithmétiques usuelles.

 Les autres opérateurs arithmétiques unaires sont les opérateurs d'incrémentation ++ et de décrémentation -- . Ce sont des opérateurs à effet de bord qui modifient leur opérande. L'opérande doit impérativement être une lvalue.

• exp++ est une expression dont la valeur est exp, ++exp est une expression dont la valeur est exp+1. Dans les deux cas exp est incrémentée.
  
  
• exp-- est une expression dont la valeur est exp, --exp est une expression dont la valeur est exp-1. Dans les deux cas exp est décrémentée.

 Les opérateurs arithmétiques effectuent des conversions standard appelées conversions arithmétiques usuelles. L'algorithme est le suivant :

 SI l'un des opérandes est de type double ALORS

 l'autre opérande est converti en double;
 le résultat est double;

 SINON SI l'un des opérandes est de type unsigned long ALORS

 l'autre opérande est converti en unsigned long;
 le résultat est unsigned long;

 SINON SI l'un des opérandes est de type long ALORS

 l'autre opérande est converti en long;
 le résultat est long;

 SINON SI l'un des opérandes est de type unsigned ALORS

 l'autre opérande est converti en unsigned;
 le résultat est unsigned;

 SINON

 les 2 opérandes doivent être du type int;
 le résultat est int;

 FIN SI;



 Ce sont les opérateurs : += -= *= /= %= ^= &= |= <<= et >>=
 Ces opérateurs sont à effet de bord : ils modifient leur premier opérande, qui doit être une lvalue. Les opérateurs e1 op= e2 sont équivalents à écrire e1 = e1 op e2, si ce n'est que e1 n'est évaluée qu'une seule fois.

 x = x + 1 est équivalent à x += 1 qui est encore est équivalent à x++

 Cette famille d'opérateurs est utilisée pour générer du code rapide et compact.



 Ce sont les opérateurs == != < > <= et >=
 Le type booléen n'existe pas en C. L'entier 0 est considéré comme la valeur FAUX et tout autre entier est considéré comme la valeur VRAI.

 e1 == e2 vaut 1 si les expressions e1 et e2 ont la même valeur, 0 sinon
 e1 != e2 vaut 1 si les expressions e1 et e2 ont des valeurs différentes, 0 sinon

||	OR logique
&&	AND logique
!	NOT logique

Exemple : if ( ((a >= 20) && (a < 30) && !(a == 25)) || ((a >= 40) && (a < 50)) )



 Ce sont les opérateurs & | ^ ~ << et >>

e1 & e2	e1 AND e2
e1 | e2	e1 OR e2
e1 ^ e2	e1 XOR e2
~exp	complément de exp, chaque bit est inversé
e1 << e2	décale e1 de e2 bits vers la gauche, les bits sortant sont perdus et des 0 sont insérés à droite
e1 >> e2	décale e1 de e2 bits vers la droite, les bits sortant sont perdus et des 0 sont insérés à gauche. Si e1 est signé, les valeurs introduites dépendent de l'artchitecture de la machine

AND 0 1 0 0 0 1 0 1

OR 0 1 0 0 1 1 1 1

XOR 0 1 0 0 1 1 1 0

NOT   0 1 1 0

 Ce sont les opérateurs * et & (réciproques l'un par rapport à l'autre)

 &exp donne l'adresse de l'expression, exp doit être une lvalue, &exp est de type pointeur
 *exp est l'objet contenu à l'adresse exp, et exp doit être une adresse



 L'opérateur conditionnel noté condition ? valeur1 : valeur2 est défini comme suit :

 e1 ? e2 : e3 donne la valeur de e3 si e1 vaut 0 (est faux), ou la valeur de e2 sinon (e1 est vrai). e1 est évaluée et suivant sa valeur, e2 ou e3 est évaluée.


Exemple : abs = x > 0 ? x : -x;



 C'est l'opérateur virgule qui sert à évaluer plusieurs expressions séquentiellement.

 e1, e2 est une expression égale à e2, ensuite e1 est évaluée, sa valeur est perdue, puis e2 est évaluée. L'intérêt est ici d'avoir une expression e1 à effet de bord.


Exemple : x = z++, MACRO(z);

 La virgule sert aussi :

• de séparateur de variables dans une liste de déclarations
• de séparateur de paramètres effectifs dans un appel de fonction
• de séparateur de paramètres formels dans une déclaration ou une définition de fonction
• de séparateur d'arguments dans une référence ou une définition de macro

 Une expression constante est une expression qui peut être évaluée à la compilation. Elle peut être composée de constantes entières ou caractères non nommées (par exemple 5 ou 'C'), d'opérateurs unaires, arithmétiques, relationnels, logiques, de manipulation de bits, conditionnels et des opérateurs sizeof et defined. Elle peut contenir également des symboles et des macros.

Retour en haut de page

Page suivante