Les types entiers

Dans les programmes, il est fréquent que l'on ait a évaluer des expressions, que ce soit pour affecter un résultat à l'aide de l'opérateur d'affectation, ou bien de prendre une décision dans un branchement conditionnel, ou dans une boucle. Dans tous ces cas, ces opérations sont composées d'opérandes et aussi d'opérateurs (pas toujours). Les opérateurs servent a former des expressions avec les opérandes.

Les opérateurs arithmétiques

Les opérateurs se séparent en deux groupes, suivant qu'ils agissent sur une ou deux opérandes. Commençons par examiner ceux du deuxième groupe, appelés opérateurs binaires (par opposition a ceux du premier groupe appelés unaires).

Les opérateurs binaires

Quatre opérateurs arithmétiques sont utilisables avec les numériques discrets (les nombres) : addition (+), soustraction (-), multiplication (*) et division (/), ainsi que le calcul du reste de la division entière (%). Voici un récapitulatif :

Opérateur	Description :
`+`	Addition.
`-`	Soustraction.
`*`	Multiplication.
`/`	Division
`%`	Reste de la division entière (modulo).

Remarque : ces opérateurs agissent sur des entiers et donc retournent des entiers, 9 / 2 = 4. l'opérateur / peut aussi être utilise sur des réels, et renverra un réel. Le résultat est du type de l'opérande de plus grande taille. Seul le % ne peut être utilise sur autre chose que des entiers.

Remarque : Lors de l'utilisation de / et %, vous devez vous assurer que la deuxième opérande est non nulle, car la division par 0 est illicite.

Note : Dans certaines instructions d'affectation, il est possible d'utiliser une forme abrégée. en effet, une instruction du type :

expression_1 = expression_1 op expression_2

où op est un opérateur arithmétique parmi les suivants : +, -, *, /, %, ou un opérateur bit a bit parmi les suivants : &, |, ^, <<, >>, peut être remplace par l'écriture :

expression_1 op= expression_2

Par exemple :

i = i + ( j - k * l )

peut être avantageusement remplace par

i += j - k * l

Les opérateurs unaires

Les entiers peuvent aussi apparaître comme opérandes d'un certain nombre d'opérateurs unaires, c'est à dire se référant a un seul opérande. Les trois opérandes de cette catégorie sont :

Opérateur	Description :
`-`	Inversion du signe pour les types signés.
`++`	Incrémentation (opérateur préfixé ou postfixé).
`--`	Décrémentation (opérateur préfixé ou postfixé).

L'opérateur ++ incrémente la valeur d'une variable de 1. Inversement, l'opérateur -- lui soustrait 1. Ces opérateurs peuvent être préfixés ou postfixés, c'est à dire placés avant ou après l'opérande auquel ils s'appliquent. La différence entre ces modes d'utilisation réside dans l'ordre d'évaluation. Dans le cas où ++ (--) est postfixé, l'expression est évaluée et l'opérande est ensuite incrémenté (décrémenté). Dans le cas où l'opérande est préfixé, l'opérande est d'abord incrémenté (décrémenté) puis l'expression est évaluée. Par exemple :

#include <stdio.h> /* directive du preprocesseur */ void main () { int i, j; /* Declaration de deux variables entieres */ i = 0; /* Initialisation de i */ j = i++; /* Affectation de j et incrementation de i */ printf("i = %d, et j = %d\n", i, j); /* i = 1 et j = 0 */ i = 0; j = ++i; /* Incremenation de i et affectation de j */ printf("i = %d, et j = %d\n", i, j); /* i = 1 et j = 1 */ }

Vous comprenez donc que l'instruction :

j = i++;

équivaut à :

j = i; i = i + 1;

Et que celle là :

j = ++i;

équivaut à :

i = i + 1; j = i;

Les opérateurs relationnels

Les entiers (incluant les valeurs booléennes et les caractères) forment des ensembles ordonnés. Il est donc possible d'évaluer la position respective de deux valeurs de ce type relativement à cet ordre. On utilisera pour cela des opérateurs relationnels appelés également opérateurs de comparaison, formant des expression dont l'évaluation renvoi une valeur booléenne vrai ou faux. Voici la liste de ces opérateurs :

Opérateur	Description :
`==`	Egal.
`!=`	Différent.
`<`	Inférieur.
`<=`	Inférieur ou égal.
`>`	Supérieur.
`>=`	Supérieur ou égal.

Les opérateurs booléens

Les expressions booléennes sont des expressions qui s'appliquent à des opérandes (considérées comme des) booleens et qui retournent également une valeur booléennes, c'est à dire nulle ou non nulle. voici la liste des opérateurs booleens :

Opérateur	Description :
`!`	Négation logique (NOT) : la valeur booléenne est inversée.
`&&`	ET logique (AND) : renvoie vrai si les deux opérandes sont vrais.
`\|\|`	OU logique (OR) : renvoie vrai si au moins l'un des deux opérandes est vrai.
`^^`	OU Exclusif logique (XOR) : renvoie vrai si l'un des deux opérandes est vrai et pas les deux.

Les expressions utilisant ces opérateurs ne sont pas évaluées entièrement si une partie peut donner le résultat, par exemple :

( ( i == j ) && ( ( j > 0 ) || ( k == 0) ) )

si la première condition est fausse (i!=j), le tout ne pourra pas être vrai, et donc, il est inutile d'aller plus loin. De même pour le ||, si (j>0) il n'est pas nécessaire de tester si (k==0) puisque le résultat sera de toute façon vrai.

Les opérateurs de niveau bit

Le langage C offre la possibilité de manipuler des entiers (char, short, int, long) signés et non signés au niveau des bits, à l'aide des six opérateurs suivant :

Opérateur	Description :
`&`	ET bit à bit.
`\|`	OU inclusif bit à bit.
`^`	OU exclusif bit à bit.
`<<`	Décalage à gauche.
`>>`	Décalage à droite.
`~`	Complément à un (opérateur unaire).

L'ordre de priorité des opérateurs

La façon dont le compilateur évalue les expressions dépends de plusieurs facteurs. Il s'agit des éléments suivants :

L'ordre de priorité des opérateurs.
L'ordre d'apparition des opérateurs dans l'expression.
L'associativité des opérateurs.
La présence des parenthèses dans l'expression.

La priorité de traitement des opérateurs par défaut en C, c'est à dire en l'absence de parenthèses, est présente ici, de la plus haute a la plus basse :

Opérateurs	Associativité :
`() [] -> .`	De gauche à droite
`! ~ ++ -- + - * & () sizeof`	De droite à gauche
`* / %`	De gauche à droite
`+ -`	De gauche à droite
`<< >>`	De gauche à droite
`< <= > >=`	De gauche à droite
`== !=`	De gauche à droite
`&`	De gauche à droite
`^`	De gauche à droite
`\|`	De gauche à droite
`&&`	De gauche à droite
`^^`	De gauche à droite
`\|\|`	De gauche à droite
`?:`	De droite à gauche
`= += -= *= /= %= &= ^= \|= <<= >>=`	De droite à gauche
`,`	De gauche à droite

L'utilisation des parenthèses

Les parenthèses permettent de forcer l'évaluation des termes d'une expression compliquées dans le sens que l'on veut. Par exemple, l'expression i = 3 + 5 * 3 sera évaluée dans cet ordre : tout d'abord la multiplication 5*3 puis l'addition de 3 et du résultat de la multiplication c'est à dire 3+15, d'ou i=18. Par contre, l'expression i = ( 3 + 5 ) * 3 aura tout d'abord son addition d'évaluée : 3+5, puis la multiplication de ce résultat par 3 c'est à dire 8*3, d'ou i=24.

Exercice

Nombre premier

Ecrire une fonction estPremier qui reçoit en arguments un entier n et qui renvoie comme valeur un booléen, vrai si n est premier et faux sinon... C'est à dire 1 ou 0

Rappel : un nombre est dit premier si il est seulement divisible par 1 et par lui même. par exemple, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41 sont premiers. De plus, par définition, 1 n'est pas premier.

solution