Débuter en programmation avec le langage C : Les opérateurs
L'affectation
En C, l'affectation est un opérateur à part entière. Elle est symbolisée par le signe =. Sa syntaxe est la suivante :
variable = expression
Le terme de gauche de l'affectation peut être une variable simple, un élément de tableau mais pas une constante. Cette expression a pour effet d'évaluer expression et d'affecter la valeur obtenue à variable. De plus, cette expression possède une valeur, qui est celle expression. Ainsi, l'expression i = 5 vaut 5. L'affectation effectue une conversion de type implicite : la valeur de l'expression (terme de droite) est convertie dans le type du terme de gauche.Par exemple, le programme suivant :
int main()
{
int i, j = 2;
float x = 2.5;
i = j + x;
x = x + i;
printf("\n %f \n",x);
}
imprime pour x la valeur 6.5 (et non 7), car dans l'instruction i = j + x;, l'expression j + x a été convertie en entier.
Les opérateurs arithmétiques
Les opérateurs arithmétiques classiques sont l'opérateur unaire - (changement de signe) ainsi que les opérateurs binaires
+ addition
- soustraction
* multiplication
/ division
% reste de la division (modulo)
Ces opérateurs agissent de la façon attendue sur les entiers comme sur les flottants. Leurs seules spécificités sont les suivantes :
Contrairement à d'autres langages, le C ne dispose que de la notation / pour désigner à la fois la division entière et la division entre flottants. Si les deux opérandes sont de type entier, l'opérateur / produira une division entière (quotient de la division). Par contre, il délivrera une valeur flottante dès que l'un des opérandes est un flottant. Par exemple,
float x;
x = 3 / 2;
affecte à x la valeur 1. Par contre
x = 3 / 2.;
affecte à x la valeur 1.5.
L'opérateur % ne s'applique qu'à des opérandes de type entier. Si l'un des deux opérandes est négatif, le signe du reste dépend de l'implémentation, mais il est en général le même que celui du dividende.
Notons enfin qu'il n'y a pas en C d'opérateur effectuant l'élévation à la puissance. De façon générale, il faut utiliser la fonction pow(x,y) de la librairie math.h pour calculer x^y.
Les opérateurs relationnels
> supérieur
>= supérieur ou égal
< strictement inférieur
<= inférieur ou égal
== égal
!= différent
Leur syntaxe est :
expression1 operateur expression2
Les deux expressions sont évaluées puis comparées. La valeur rendue est de type int (il n'y a pas de type booléen en C); elle vaut 1 si la condition est vraie, et 0 sinon.
ATTENTION : à ne pas confondre l'opérateur de test d'égalité = = avec l'opérateur d'affection =. Ainsi, le programme
int main()
{
int a = 0;
int b = 1;
if (a = b)
printf("\n a et b sont egaux \n");
else
printf("\n a et b sont differents \n");
}
imprime à l'écran a et b sont egaux !
Les opérateurs logiques booléens
&& ET logique
|| OU logique
! négation logique
Comme pour les opérateurs de comparaison, la valeur retournée par ces opérateurs est un int qui vaut 1 si la condition est vraie et 0 sinon.
Dans une expression de type
expression1 op1 expression2 op2 ...expressionN
l'évaluation se fait de gauche à droite et s'arrête dès que le résultat final est déterminé. Par exemple dans
int i;
int p[10];
if ((i >= 0) && (i <= 9) && !(p[i] == 0))
...
la dernière clause ne sera pas évaluée si i n'est pas entre 0 et 9.
Les opérateurs logiques bit à bit
Les six opérateurs suivants permettent de manipuler des entiers au niveau du bit. Ils s'appliquent aux entiers de toute longueur (short, int ou long), signés ou non.
& et
| ou inclusif
^ ou exclusif
~ complément à 1
<< décalage à gauche
>> décalage à droite
Les opérateurs d'affectation composée
Les opérateurs d'affectation composée sont :
+= -= *= /= %= &= ^= |= <<= >>=
Pour tout opérateur op, l'expression
expression1 op = expression2 est équivalente à
expression1 = expression1 op expression2
Toutefois, avec l'affection composée, expression1 n'est évaluée qu'une seule fois.
Les opérateurs d'incrémentation et de décrémentation
Les opérateurs d'incrémentation ++ et de décrémentation -- s'utilisent aussi bien en suffixe (i++) qu'en préfixe (++i). Dans les deux cas la variable i sera incrémentée, toutefois dans la notation suffixe la valeur retournée sera l'ancienne valeur de i alors que dans la notation préfixe se sera la nouvelle. Par exemple,
int a = 3, b, c;
b = ++a; /* a et b valent 4 */
c = b++; /* c vaut 4 et b vaut 5 */
L'opérateur virgule
Une expression peut être constituée d'une suite d'expressions séparées par des virgules :
expression1, expression2, ... , expressionN
Cette expression est alors évaluée de gauche à droite. Sa valeur sera la valeur de l'expression de droite. Par exemple, le programme
int main()
{
int a, b;
b = ((a = 3), (a + 2));
printf("\n b = %d \n",b); /* imprime b = 5 */
}
L'opérateur conditionnel ternaire
L'opérateur conditionnel ? est un opérateur ternaire. Sa syntaxe est la suivante :
condition ? expression1 : expression2
Cette expression est égale à expression1 si condition est satisfaite, et à expression2 sinon. Par exemple, l'expression
x >= 0 ? x : -x
correspond à la valeur absolue d'un nombre. De même l'instruction
m = ((a > b) ? a : b);
affecte à m le maximum de a et de b.
L'opérateur de conversion de type
L'opérateur de conversion de type, appelé cast, permet de modifier explicitement le type d'un objet. On écrit
(type) objet
par exemple :
int main()
{
int i = 3, j = 2;
printf("%f \n",(float)i/j); /* retourne la valeur 1.5 */
}
L'opérateur adresse
L'opérateur d'adresse & appliqué à une variable retourne l'adresse mémoire de cette variable. La syntaxe est :
&objet