Les opérateurs et les expressions en langage C:
Il existe plusieurs opérateurs en langage C: les opérateurs classiques (arithmétiques, relationnels, logiques) ou moins classiques (manipulation des bits); et il y a aussi un éventail d’opérateurs originaux d’affectation et d’incrémentation.
Une expression est une instruction qui contient un ou plusieurs opérandes et des opérateurs.
Les opérandes peuvent être des variables, des constantes, ou des fonctions qui renvoient des valeurs.
Opérateurs arithmétiques:
Le langage dispose de deux catégories d'opérateurs arithmétiques:
- Des opérateurs binaires (deux opérandes) : +, −, *, /, et % .
- Des opérateurs unaires (un opérande) : +, −, ++, et −− .
Le tableau ci-dessous présente cette famille d'opérateurs :
| Opérateur | Opération | Exemple | Résultat |
| * | Multiplication | x * y | Produit de x et y |
| / | Division | x / y | Quotient de x par y |
| % | Modulo | x % y | Reste de la division de x par y |
| + | Addition | x + y | Somme de x et y |
| − | Soustraction | x − y | Différence de x et y |
| +(unaire) | Positif | + x | Valeur positive de x |
| −(unaire) | Négatif | − x | Opposé de x |
Certains d'entre-eux ont des particularités.
L’opérateur de division :
Cet opérateur est vraiment différent des autres car le type du quotient obtenu dépend du type de ses deux opérandes.
Si une division est effectuée entre deux entiers int ou char par exemple, le quotient sera du type int ou char. Si l’un des opérandes est du type float ou double, le résultat sera un nombre en virgule flottante qui sera stocké dans la mémoire en tant que float ou double.
Exemples :
Exemple 1:
int a = 10 ;
int b = 4 ;
float c ;
c = a / b ;Dans cet exemple même si la variable c est déclarée comme float, son contenu sera tronqué car la division s’effectue sur deux entiers, par conséquent:
La variable c contiendra : 2.000000
Le résultat équivaut à un entier, même si la partie décimale ne contient que des 0.
Exemple 2 :
int a = 10 ;
float b = 4.0f ;
float c ;
c = a / b ;La variable c contiendra 2.500000, car l’une des variables de la division est du type float.
L’opérateur modulo :
Cet opérateur ne porte que sur des entiers et donne le reste de la division de son premier opérande par le second. Il peut être utilisé pour :
> Effectuer une troncature. Exemple :
x % 2n ; n désigne la taille du mot désigné (par exemple 8 pour 8 bits : x % 256).
Renvoie juste la valeur des n bits de rang inférieur de x (x supérieur ou égal à 2n).
> Séparer un nombre de n’importe quelle base, en simples digits. L'exemple ci-dessous affiche à l'écran le chiffre des unités d'un nombre entier:
#define MAX_DIGITS 3456
int main(void)
{
int units;
units = MAX_DIGITS%10;
printf("Le dernier chiffre est: %d", units);
}
Les opérateurs d’incrémentation et de décrémentation:
Ce sont des opérateurs unaires car ils n’ont besoin que d’un seul opérande qui peut être placé à leur droite ou à leur gauche.
Exemples d’utilisations :
| Opérateur | Opération | Exemple | Résultat |
| ++ | Incrémenter |
x++ ++x |
utilise x, puis incrémente x de 1 incrémente x de 1 puis utilise x |
| −− | Décrémenter |
x−− −−x |
utilise x puis décrémente de 1 décrémente de 1 puis utilise x |
Exemple de post-incrémentation :
x = 5 ;
y = (x++) + 5 ;Après l’exécution de ces deux instructions par le microprocesseur, les deux variables contiendront :
y = 10 et x = 6 ;
Exemple de pré-incrémentation :
x = 5 ;
y = (++x) + 5 ;Après l’exécution de ces deux instructions, les deux variables contiendront :
y = 11 et x = 6 ;
Tant que l’opération n’a qu’un seul opérande et l’opérateur ++ (ou −−), le résultat sera le même si l’opérateur est placé avant ou après l’opérande. Mais les deux exemples précédents montrent que ce n’est plus le cas lorsque l’expression qui contient l’opérateur a plusieurs termes.
Les opérateurs d’affectation en C:
Une déclaration d’affectation est une opération qui attribue une valeur à une variable.
Syntaxe d'une affectation simple :
variable = expression ;
L’expression est d’abord évaluée, puis le résultat est affecté à la variable.
Exemple :
x = 5 ;
Affecte à la variable x la valeur 5.
L’opérateur d’affectation simple "=", affecte à la variable qui se situe à sa gauche, la valeur qui est à sa droite.
Affectation composée:
C'est un type d'affectation qui a pour syntaxe:
variable = variable opérateur expression ;
Pour ce type de déclaration où on retrouve la même variable de part et d’autre du signe « = », un opérateur d'affectation élargie peut-être employé.
Le tableau ci-après liste quelques exemples d’opérateurs élargis possibles en C :
| Opérateur | Opération | Exemple | Résultat |
| += | Affectation composée | x += y | x = x + y |
| −= | Affectation composée | x −= y | x = x − y |
| *= | Affectation composée | x *= y | x = x * y |
| /= | Affectation composée | x /= y | x = x / y |
| %= | Affectation composée | x %= y | x = x % y |
| &= | Affectation composée | x &= y | x = x & y |
| ^= | Affectation composée | x ^= y | x = x ^ y |
| |= | Affectation composée | x |= y | x = x | y |
| <<= | Affectation composée | x <<= y | x = x << y |
| >>= | Affectation composée | x >>= y | x = x >> y |
Exemple:
L'expression x = x + 5; pourrait s'écrire: x += 5;
Opérateurs de manipulation des bits en C :
Les opérateurs de manipulation des bits sont utilisés par l’algèbre de Boole. Le tableau ci-après en donne la liste:
| Opérateur | Opération | Exemple | Résultat (pour chaque position de bits) |
| & | ET (AND: au niveau du bit) | x & y |
1, si x et y sont à 1, 0 si x ou y, ou les deux sont à 0 |
| | | OU (OR: au niveau du bit) | x | y | 1, si x ou y, ou les deux sont à 1, 0 si x et y sont à 0 |
| ^ | OU exclusif (XOR: au niveau du bit) | x ^ y | 1, si x est à 1 et y à 0, ou x est à 0 et y à 1, 0 si x et y sont à 1, ou x et y sont à 0 |
| ~ | NON (NOT: au niveau du bit) | ~ x | 1, si x est à 0, et 0 si x est à 1 |
Fonctionnement:
Supposons une opération de manipulation de bit sur deux valeurs binaires de quatre bits chacune. L'opération s'effectuera entre les bits 0 des deux valeurs, puis entre les bits 1, ...et ainsi de suite jusqu'aux derniers bits des deux valeurs.
Les opérateurs conditionnels:
Un opérateur conditionnel est une notation raccourcie du test. L’usage de cet opérateur peut être intéressant, lorsqu’on veut affecter une valeur à une variable sous condition.
Syntaxe :
(expression_de_test) ? faire_si_vrai : faire_si_faux ;
Exemple :
x = (condition) ? a : b ;
Si la condition est vraie, la valeur a sera affectée à la variable x, sinon ce sera la valeur b.
Cette expression équivaut à :
(condition) ? (x = a) : (x = b) ;
Celle-ci est moins utilisée.
Dans les deux cas a sera affectée à x lorsque la condition est vraie, si non b sera affectée à x.
Exemple :
int x = 5 ;
(x % 2 != 0) ?
printf("%d est impaire\n" , x) :
printf("%d est paire\n" , x) ;A l’exécution du programme précédent : 5 est impaire.
Les opérateurs logiques :
Ils sont souvent utilisés pour prendre une décision, dans le cadre des instructions de test comme le « if ». Ils peuvent être utilisés pour exécuter un code de façon sélective selon une condition donnée.
Le tableau donne une liste d’opérateurs logiques en langage C :
| Opérateur | Opération | Exemple | Résultat(faux=0, vrai ≠ 0) |
| && | Opérateur logique ET (AND) | x && y | 1 si x ≠ 0 et y ≠ 0, sinon 0 |
| || | Opérateur logique OU (OR) | x || y | 0 si x = 0 et y = 0, sinon 1 |
| ! | Opérateur logique NON (NOT) | ! x | 1 si x = 0, 0 si x = 1 |
Dans une expression conditionnelle, toute valeur différente de 0 est VRAIE, toute valeur égale à 0 est FAUSSE.
Différence entre les deux opérateurs & et &&
L'opérateur & est utilisé pour la manipulation des bits; tandis que && vérifie une condition logique entre deux expressions.
Exemple : 1010 & 1101 donnera 1000
Tandis que 1010 && 1101 donnera 0001 (les deux valeurs étant différentes de zéro, donc la valeur logique est vraie).
Considérons ces deux programmes :
Programme 1
char x = 1010 ;
char y = 0101 ;
if (x & y ) printf (" hello! ") ;
Programme 2
char x = 1010 ;
char y = 0101 ;
if (x && y ) printf (" hello! ") ;
Le programme 1 n’affichera rien car le ET bit à bit entre x et y donne 0000, soit une expression différente de 1 (donc fausse), tandis que le programme 2 affichera hello! car deux expression différentes de zéro sont évaluées par un ET logique, donc le résultat est vrai.
Deux expressions opérandes d'un ET logique (&&), différentes de zéro, produisent un résultat vrai (ou égal à 1).
Les opérateurs relationnels :
Il est possible de comparer des expressions à l'aide d'opérateurs relationnels. En langage C, le résultat d'une comparaison est, non pas une valeur booléenne (Vraie ou Fausse), mais un nombre entier qui vaut:
- 1 lorsque le résultat de la comparaison est vrai
- Ou 0 lorsque le résultat de la comparaison est faux.
Ci-dessous, la liste des opérateurs de comparaison en C:
| Opérateur | Opération | Exemple | Résultat |
| < | inférieur à | x < y | 1 si x est plus petit que y, 0 sinon |
| <= | inférieur ou égal à | x <= y | 1 si x est plus petit ou égal à y, 0 sinon |
| > | supérieur à | x > y | 1 si x est plus grand que y, 0 sinon |
| >= | supérieur ou égal à | x >= y | 1 si x est plus grand ou égal à y, 0 sinon |
| == | égal à | x == y | 1 si x est égal à y, 0 sinon |
| != | différent de | x != y | 1 si x est différent de y, 0 sinon |
En C, il ne faudra pas confondre l'égalité (==) et l'affectation (=).
Les opérateurs de décalages :
Les opérateurs de décalages déplacent les bits de l’opérande, à droite ou à gauche suivant un nombre de bits spécifiés.
Le décalage à gauche opère de la même façon, quelque soit l’opérande.
Le décalage à droite se comporte différemment lorsque l'opérande est signé ou non signé.
Avec un décalage à gauche, les bits déplacés à gauche sont perdu, et tous les autres bits à droite sont remplacés par des zéros.
Avec un décalage à droite, si c’est un nombre non signé, les bits à gauche sont remplacés par des zéros, si le nombre est signé, le signe est étendu; les bit décalés à droite sont perdus dans les deux cas.
| Opérateur | Opération | Exemple | Résultat |
| << | Décalage à gauche | x << y | Décale x de y bits vers la gauche |
| >> | Décalage à droite | x >> y | Décale x de y bits vers la droite |
Exemple décalage à droite pour un nombre codé sur 8 bits:
x = 250 ; // x = 11111010 = 250
y = x >> 2 ; // y = 00111110 = 62
Autre exemple de décalage à droite :
x = -6 ; // x = 11111010 = -6
y = x >> 2 ; // y = 11111110 = -2
Division par les puissances de 2 et décalage à droite :
Si effectue une division d’un nombre entier ou à virgule par une puissance de deux, il est plus judicieux d'utiliser une opération de décalage à droite pour optimiser le programme:
Exemple:
20 / 2;
En binaire: 20 vaut 00010100; Une division de 20 par 2 équivaut à faire décaler 20 à droite de 1.
20 >> 1 donnera: 00001010 ce qui, en décimal, vaut 10.
Les opérateurs d’adressage mémoire en C :
Il y a cinq opérateurs d'adessage mémoire:
| Opérateur | Opération | Exemple | Résultat |
| & | Adresse de ... | &x | Pointeur sur x |
| * | Contenu de l'adresse de... | *p | L'objet ou fonction pointée par p |
| [ ] | Indice d'un tableau | x [y] | Y ième élément du tableau x |
| • | Membre d'une structure ou d'une union | x . y | Membre nommé y de la structure ou union x |
| -> | Membre par référence d'une structure ou d'une union | p -> y | Membre nommé y de la structure ou union pointée par p |
Ces opérateurs seront à abordés par la suite dans le cadre des notions sur les pointeurs, les structures et les unions.
Autres opérateurs:
| Opérateur | Opération | Exemple | Résultat |
| ( ) | Appel de fonction | bar(x) | Passe le contrôle à la fonction avec les arguments spécifiés |
| sizeof | Taille ou type d'un objet en octets | sizeof x | Le nombre d'octets occupé en mémoire par x |
| (type) | Type cast explicite | (type) x | Convertit la valeur de x au type spécifié |
| ? : | Expression conditionnelle | x ? y : z | La valeur sera y si x est vrai, ou z si x est faux |
| , | Evaluation séquentielle | x , y | Evalue x ensuite y |
Evaluations raccourcies :
Lorsqu’une opération logique est évaluée en C, si le résultat est connu avant l’évaluation de l’expression toute entière, celle-ci sera stoppée. Par exemple lorsque la première expression d’un opérateur logique AND est fausse.
Conversion de type implicite :
Dans certains cas les expressions des opérandes peuvent être de type différents; ce type d’expression est nommé « expression mixte ».
Prenons l’exemple ci-après:
int x = 10;
float y = 2.0, z ;
z = x * y ; //x devient implicitement du type float à cause de y
Avant d’effectuer ce produit, le compilateur va mettre en place une instruction de conversion de la valeur de x vers le type float (car il considère que le type int peut être convenablement représenté par le type float; la réciproque est fausse). Ainsi, la multiplication aura donc deux opérandes du type float, et le résultat z sera du type float.
Le passage de int vers float se nomme un ajustement de type. Une telle conversion se fait selon une hiérarchie :
int - -> long - -> float - -> double - -> long double
On peut naturellement convertir un int en double, et non un double en int ou en float.
Cas particulier : les expressions numériques ne sont pas définies pour les type char et short en langage C. Si l’un de ces deux types apparaît dans une expression, il est d’abord converti en type int. Cette opération est nommée « promotion de types ».
Hiérarchie de conversion de type détaillée:
char --> unsigned char --> short --> unsigned short --> int -->
unsigned int --> long --> unsigned long --> long long -->
unsigned long long --> float --> double --> long double
Priorité des opérateurs:
Le tableau ci-dessous groupe les opérateurs par priorité. Ceux ayant une priorité identique sont sur la même ligne:
| Opérateur | Description | Associativité |
|
( ) [ ] • -> |
Expression entre parenthèses Element d'un tableau Membre d'une structure Pointeur de structure |
De gauche à droite |
|
+ et − ++ et −− ! et ~ * & sizeof (type) |
Signe positif et négatif, unaire + et - Incrémentation et décrémentation NOT logique et complément élément binaire Pointeur (Déréférencement) Adresse de... Taille d'une expression ou d'un type type cast explicite (opérateur cast) |
De droite à gauche |
| * / % | Multiplication, division , modulo | De gauche à droite |
| + − | Addition, soustraction | De gauche à droite |
| << >> | Décalage à gauche, décalage à droite | De gauche à droite |
|
< <= > >= |
Inférieur, inférieur ou égal Supérieur, supérieur ou égal |
De gauche à droite |
| == != | Egal à, différent de | De gauche à droite |
| & | AND opération au niveau du bit | De gauche à droite |
| ^ | XOR opération au niveau du bit (ou exclusif) | De gauche à droite |
| | | OR opération au niveau du bit (ou) | De gauche à droite |
| && | Opérateur logique AND | De gauche à droite |
| | | | Opérateur logique OR | De gauche à droite |
| ? : | Opérateur conditionnel | De gauche à droite |
|
= += −= /= *= %= <<= =>> &= | = ^= |
Affectation Addition, soustraction avec affectation Division, multiplication avec affectation Modulo avec affectation Décalage à droite ou à gauche avec affectation AND, OR élément binaire avec affectation XOR avec affectation |
De droite à gauche |
| , | Opérateur de séquentiel | De gauche à droite |
Lorsqu’une expression contient plusieurs opérateurs, leur priorité détermine l’ordre d’évaluation de cette expression.
Exemple :
a – b*c sera considéré comme a – (b*c)
a + ++b sera considéré comme a + (++b)
a + ++b * c sera considéré comme a + ((++b)*c)
Dans le cas d’une expression basée sur deux fonctions : y = f() + g(), on ne peut pas savoir l’ordre d’évaluation qui sera appliqué à l’avance.
Si deux opérations ont la même priorité, c’est la règle de l’associativité qui sera appliquée.
Exemple :
x / y % z associativité de gauche à droite (x / y) % z
x = y = z associativité de droite à gauche x = (y = z)
~ ++ x de même de droite à gauche ~ ( ++ x)
On peut utiliser ce type d’expression (comme celles de l'exemple) en tant que tel en tenant compte de la règle d'associativité. Mais il est plus pratique d’employer des parenthèses pour faciliter la lisibilité du programme.
