Atelier Programmation 1 ___________________________________________________________________________________________

A.U 2010/2011 Technologies de l'Informatique

Niveau L1 (Tronc Commun)

Annexe TP3

I. Les opérateurs en C

1. Opérateurs d’incrémentation

Si l'opérateur d'incrémentation (++) ou de décrémentation (--) est placé avant l'opérande
alors la variable sera incrémentée ou décrémentée avant d'être utilisée.

Exemple 1:

#include <stdio.h>
void main(){
int a,b; /* Déclaration de variable a et b */
a=2; /* Initialisation de a et b */
b=10;
/* Affichage de a avec incrémentation avant l'utilisation */
printf("a = %d\n",++a); /* Affichage : a=3 */
/* Affichage de b avec décrémentation avant l'utilisation */
printf("b = %d",--b); /* Affichage : b=9 */
printf("a = %d\n",a); /* Affichage : a=3 */
printf("b = %d",b); /* Affichage de b=9 */
}

Si l'opérateur d'incrémentation ou de décrémentation est placé après l'opérande alors la

variable sera incrémentée ou décrémentée après avoir été utilisée.

Exemple 2 :

#include <stdio.h>
void main(){
int a,b; /* Déclaration de variables a et b */
a=2; /* Initialisation de a et b */
b=10;
/* Affichage de a avec incrémentation après l'utilisation */
printf("a = %d\n",a++); /* Affichage : a=2 */
/* Affichage de b avec décrémentation après l'utilisation */
printf("b = %d\n",b--); /* Affichage : b=10 */
printf("a = %d\n",a); /* Affichage : a=3 */
printf("b = %d",b); /* Affichage : b=9 */
}

__________________________________________________________________________
ISETMA 2010/2011
-1-
Atelier Programmation 1 ___________________________________________________________________________________________

2. Opérateurs de comparaison
Ils permettent de comparer une variable par rapport à une autre variable ou une valeur ou
une expression. Le résultat ne peut être que VRAI (correspond à 1) ou FAUX (correspond à
0).

3. Opérateurs logiques
Les résultats des opérateurs logiques sont du type int:

la valeur 1 correspond à la valeur booléenne vrai

la valeur 0 correspond à la valeur booléenne faux

Exemple :

#include <stdio.h>
void main()
{
/* Déclaration d'entiers */
int a,b,c;
int res;
a=2,b=3,c=5;
res= ( (a>3) && (c>5) );
printf("res = %d\n",res); /* Affichage : res=0 */
res= ( (b>2) || (c<4) );
printf("res = %d\n",res); /* Affichage : res=1 */
res= !(a<b);
printf("res = %d\n",res); /* Affichage : res=0 */
}

4. Opérateurs logiques bit à bit

Ce type d'opérateur traite ses opérandes comme des données binaires plutôt que des données
décimales, hexadécimales ou octales. Ces opérateurs retournent des valeurs numériques
avec le format d'origine des opérandes.

__________________________________________________________________________
ISETMA 2010/2011
-2-
Atelier Programmation 1 ___________________________________________________________________________________________

5. Opérateurs de décalage
Ce type d'opérateur traite ses opérandes comme des données binaires d'une longueur de 32
bits. Les opérateurs suivants effectuent des rotations sur les bits, c'est-à-dire qu'il décale
chacun des bits d'un nombre de bits vers la gauche ou vers la droite.
Le premier opérande désigne la donnée sur laquelle on va faire le décalage, le second
désigne le nombre de bits duquel il va être décalé.

6. Opérateurs combinés
Pour la plupart des expressions de la forme: id1 = (id1) op (id2), il existe une formulation
équivalente qui utilise un opérateur combiné: id1 op= id2.

__________________________________________________________________________
ISETMA 2010/2011
-3-
Atelier Programmation 1 ___________________________________________________________________________________________

7. Opérateurs conditionnels
C'est le seul opérateur ternaire.
Syntaxe : <expression1>? <expression2> : <expression3>
Cette expression vaut la valeur de <expression2> si <expression1> est vrai (entier, différent
de 0), et <expression3> si <expression1> est faux.
Exemples :
y = 100;
a = (y < 200) ? 3.14 : 25; => a = 3.14
b = (a > 3) ? ((y > 200) ? 10.1 : 5.0) : 123.0; => b = 5.0

8. Opérateurs séquentiels
Une expression peut être constituée d'une suite d'expressions séparées par des virgules. Cette
expression est alors évaluée de gauche à droite. Sa valeur finale sera la valeur de
l'expression de droite.
Syntaxe : <expression1>, <expression2>, ..., <expressionN> ;

Exemple :

#include <stdio.h>
void main(){
int a, b,c;
b = ((a = 3), (a + 2));
printf("b = %d \n",b); /* Affichage : b=5 */
c= (b++,b+12); /* incrémente b, effectue la somme b+12 puis affecte le
résultat à c */
printf("c = %d \n",c); /* Affichage : c=18 */
}

9. Opérateurs d’adressage
L'opérateur d'adresse & appliqué à une variable retourne l'adresse mémoire de cette variable.
Syntaxe : &identificateur

10. Opérateurs de taille

L'opérateur sizeof renvoie la taille en octets de son opérande. L'opérande est soit une
expression soit une expression de type.
Exemple :
sizeof (i); => 4
sizeof (int) => 4

__________________________________________________________________________
ISETMA 2010/2011
-4-
Atelier Programmation 1 ___________________________________________________________________________________________

II. Les conversions des types

1. La conversion implicite
Si un opérateur porte sur deux opérandes de types différents, il y a conversion du type le
plus faible dans le type le plus fort (nombre d'octets).
Voici les règles simples permettant de déterminer les conversions implicites utilisées en C.
Ces règles sont appliquées dans l'ordre cité :

Si l'un des opérandes est double, convertir l'autre en double.

Si l'un des opérandes est float, convertir l'autre en float.

Convertir les opérandes de type char et short en int.

Si l'un des opérandes est long, convertir l'autre en long.

2. La conversion explicite
Lorsqu’une conversion paraît logique (int float), le compilateur procède à une conversion.
Cependant, il est tout à fait possible de procéder à la conversion d'un float en un int par
exemple. Cette conversion est dite une conversion forcée ou explicite. Une conversion
forcée peut être effectuée en utilisant un cast.

Syntaxe : (type souhaité) <expression>

Exemple :

#include <stdio.h>
void main()
{/* Déclaration des variables */
char car;
int a,b,c,d;
float g;
a=4;
b=7;
c=0x41; /* Code Ascii de 'A' */
/* Conversion implicite de a et b en float */
g = (a + b) /100. ;
printf("g= %f\n",g);
/* Conversion explicite c en char */
car = (char) c +3;
/* c est de type entier et sera converti en char */
printf("car = %c\n",car);
d = (int)b/a ;
printf("d = %d\n",d);
}

Le résultat sera le suivant :

g = 0.110000
car = D
d=1
N.B : Dans l'affectation de g, a et b sont de type entier, on a ajouté un point (.) derrière 100
pour forcer le compilateur à effectuer l'évaluation en flottant.

__________________________________________________________________________
ISETMA 2010/2011
-5-