Vous êtes ici :
Accueil Cours Programmations Débuter en programmation avec le langage C Les opérateurs

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

 




Vous êtes ici :
Accueil Cours Programmations Débuter en programmation avec le langage C Les opérateurs