1. 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
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.
2. 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 xy.
3 Les opérateurs relationnels
> |
strictement supérieur |
| >= | supérieur ou égal |
< |
strictement inférieur |
| <= | inférieur ou égal |
| == | égal |
| != | différent |
Leur syntaxe est
expression-1 op expression-2
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
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 !
4 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
expression-1 op-1 expression-2 op-2 ...expression-n
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.
5. 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 |
En pratique, les opérateurs &, | et ~ consistent à appliquer bit à bit les opérations suivantes:
0&0 = 0
0&1 = 0
1&0 = 0
1&1 = 1
0|0 = 0
0|1 = 1
1|0 = 1
1|1 = 1
0^0 = 0
0^1 = 1
1^0 = 1
1^1 = 0
L'opérateur unaire ~ change la valeur de chaque bit d'un entier. Le décalage à droite et à gauche effectuent respectivement une multiplication et une division par une puissance de 2. Notons que ces décalages ne sont pas des décalages circulaires (ce qui dépasse disparaît).
Considérons par exemple les entiers a=77 et b=23 de type unsigned char (i.e. 8 bits). En base 2 il s'écrivent respectivement 01001101 et 00010111.
| valeur | |||
| expression | binaire | décimale | |
| a | 01001101 | 77 | |
| b | 00010111 | 23 | |
| a & b | 00000101 | 5 | |
| a | b | 01011111 | 95 | |
a ^ b |
01011010 | 90 | |
~a |
10110010 | 178 | |
| b << 2 | 01011100 | 92 | multiplication par 4 |
| b << 5 | 11100000 | 112 | ce qui dépasse disparaît |
| b >> 1 | 00001011 | 11 | division entière par 2 |
6. Les opérateurs d'affectation composée
Les opérateurs d'affectation composée sont
+= -= *= /= %= &=^= |=<<=>>=
Pour tout opérateur op, l'expression
expression-1 op= expression-2
est équivalente à
expression-1 = expression-1 op expression-2
Toutefois, avec l'affection composée, expression-1 n'est évaluée qu'une seule fois.
7. 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 */
8. L'opérateur virgule
Une expression peut être constituée d'une suite d'expressions séparées par des virgules :
expression-1, expression-2, ... , expression-n
Cette expression est alors évaluée de gauche à droite. Sa valeur sera la valeur de l'expression de droite. Par exemple, le programme
main()
{
int a, b;
b = ((a = 3), (a + 2));
printf("\n b = %d \n",b);
}
imprime b = 5.
La virgule séparant les arguments d'une fonction ou les déclarations de variables n'est pas l'opérateur virgule. En particulier l'évaluation de gauche à droite n'est pas garantie. Par exemple l'instruction composée
{
int a=1;
printf("\%d \%d",++a,a);
}
(compilée avec gcc) produira la sortie 2 1 sur un PC Intel/Linux et la sortie 2 2 sur un DEC Alpha/OSF1.
9. L'opérateur conditionnel ternaire
L'opérateur conditionnel ? est un opérateur ternaire. Sa syntaxe est la suivante :
condition ? expression-1 : expression-2
Cette expression est égale à expression-1 si condition est satisfaite, et à expression-2 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.
10. 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,
main()
{
int i = 3, j = 2;
printf("%f \n",(float)i/j);
}
retourne la valeur 1.5.
11. L'opérateur adresse
L'opérateur d'adresse & appliqué à une variable retourne l'adresse-mémoire de cette variable. La syntaxe est
&objet
12. Règles de priorité des opérateurs
Le tableau suivant classe les opérateurs par ordres de priorité décroissants. Les opérateurs placés sur une même ligne ont même priorité. Si dans une expression figurent plusieurs opérateurs de même priorité, l'ordre d'évaluation est définie par la flèche de la seconde colonne du tableau. On préferera toutefois mettre des parenthèses en cas de doute...
opérateurs () [] -> . ® ! ~++ -- -(unaire) (type) *(indirection)&(adresse) sizeof¬ * / %® + -(binaire) ® <<>>® <<=>>=® == != ® &(et bit-à-bit)® ^® |® &&® ||® ? : ¬ = += -= *= /= %=&=^=|=<<=>>=¬ , ® Règles de priorité des opérateurs
Par exemple, les opérateurs logiques bit-à-bit sont moins prioritaires que les opérateurs relationnels. Cela implique que dans des tests sur les bits, il faut parenthéser les expressions. Par exemple, il faut écrire if ((x ^ y) != 0)
2017-10-15 15:57:24 / mazoughou@magoe.gn
0 commentaires
Votre impression compte aussi