Cours programmation en langage C - Chapitre 2 : Opérateurs et expressions

(cid:1) Le compilateur convertit n en float; le résultat final en float

(cid:1)

int-> long -> float -> double -> long double

(cid:1) On peut convertir directement un int en double.

(cid:1) On ne peut pas convertir un double en float ou en int

Règles de conversion automatique

Conversions automatiques lors d'une opération avec :

(cid:1) deux entiers: D'abord, les types char et short sont convertis en int. Ensuite,

l'ordinateur choisit le plus large des deux types dans l'échelle suivante:

o int, unsigned int, long, unsigned long

(cid:1) un entier et un rationnel: Le type entier est converti dans le type du rationnel.

(cid:1) deux rationnels: L'ordinateur choisit le plus large des deux types selon l'échelle

suivante: float, double, long double

(cid:1) affectations et opérateurs d'affectation: Lors d'une affectation, le résultat est

toujours converti dans le type de la destination. Si ce type est plus faible, il peut y

avoir une perte de précision.

Exemple;

char A=3;

int B=4;

float C=4;

float D,E;

char F;

D = A/C;

E = A/B;

F = A/C;

Mme Wiem Yaiche Elleuch chapitre 2

2

(cid:1) Pour le calcul de D, A est converti en float (règle 2) et divisé par C. Le résultat (0.75)

est affecté à D qui est aussi du type float. On obtient donc: D=0.75

(cid:1) Pour le calcul de E, A est converti en int (règle 1) et divisé par B. Le résultat de la

division (type int, valeur 0) est converti en float (règle 4). On obtient donc: E=0.000

(cid:1) Pour le calcul de F, A est converti en float (règle 2) et divisé par C. Le résultat (0.75) est

retraduit en char (règle 4). On obtient donc: F=0

Le cas du type char

(cid:2) Il existe une conversion systématique de char en int

(cid:2) Une valeur de type caractère peut être considérée:

(cid:3) Comme le caractère concerné (a, z, \n)

(cid:3) Comme le code de ce caractère: ex: 1000001 => 65 => caractère A (en

ASCII)

#include<stdio.h>

void main()

{

char x = ‘A’;

printf(“ %c “, x);

}

=> Exécution : A

//

#include<stdio.h>

void main()

{

char x = ‘A’;

printf(“ %d “, x);

}

=> Exécution : 65

//

(cid:2) Tout argument de type char ou short est converti en int. Le code %c s’applique aussi

à un int. Il affichera le caractère ayant le code correspondant

#include<stdio.h>

void main()

{

int x=65;

printf("%c",x);

}

=> Exécution : A

#include <stdio.h>

Void main()

{

char x='A';

printf("le code ASCII de %c est %d ", x, x);

x=x+1;

printf("le code ASCII de %c est %d",x,x);

}

=> Exécution : le code ASCII de A est 65 le code ASCII de B est 66

‘0’ => code ASCII 48

‘1’ => code ASCII 49

…

Mme Wiem Yaiche Elleuch chapitre 2

3

‘A’ => code ASCII 65

‘B’ => code ASCII 66

…

‘a’ => code ASCII 97

‘b’ => code ASCII 98

etc

Les opérateurs relationnels

(cid:1) C permet de comparer des expressions à l’aide d’opérateurs classiques de comparaisons ( 2*a > b+5)

(cid:1) Le résultat de la comparaison est:

o 0 si le résultat de la comparaison est faux

o 1 si le résultat de la comparaison est vrai

(cid:1) Les opérateurs relationnels: <, <=, >, >=, ==, !=

(cid:1) Les quatre premiers sont de même de priorité (<, <=, >, >=). Les deux derniers (==, !=) sont de même

priorité, mais inférieure à celle des précédents

==

!=

<, <=, >, >=

égal à

différent de

plus petit que, ...

Opérateurs de comparaison

Une comparaison peut porter sur deux caractères

(cid:1) c1==c2 est vrai si c1 et c2 contiennent le même caractère

(cid:1) c1==‘e’ est vrai si c1 contient le caractère ‘e’ (code de c1 est égal au code de ‘e’)

(cid:1) c1<c2 est vrai si le code de c1 a une valeur inférieure au code de c2 (le résultat de

cette comparaison varie selon le codage employé)

#include <stdio.h>

void main()

{

char c1=’1’, c2=’a’;

if(c1< c2) printf(“ inferieur ”);

else printf (“ superieur ”);

}

=> Exécution : inferieur

(cid:1) L’ordre alphabétique est respecté pour les minuscules et majuscules ‘a’ < ‘b’

(cid:1) Les chiffres sont classés par ordre naturel ‘2’<‘ 3’

Les opérateurs logiques

(cid:1)

Il existe trois opérateurs logiques: et (noté &&), ou (noté ||), non (noté !). Ces

opérateurs produisent un résultat numérique (int)

o (a<b) && (c<d): prend la valeur 1 si les deux expressions sont vraies. 0 sinon

o (a<b) || (c<d): prend la valeur 1 si l’une des expressions est vraie. 0 sinon

o !(a<b): prend la valeur 1 si l’expression est fausse

(cid:1) On rencontre fréquemment if (!n) (cid:4) if (n==0)

(cid:1)

! est prioritaire: !a==b => (!a)==b et non !(a==b)

(cid:1)

|| est moins prioritaire que &&. Tous deux sont de priorité inférieure aux opérateurs

arithmétiques et relationnels.

a<b && c<d (cid:4) (a<b) && (c<d)

Mme Wiem Yaiche Elleuch chapitre 2

4

(cid:1) On évalue a<b si le résultat est faux, on s’arrête

Opérateurs logiques

&&

||

!

et logique (and)

ou logique (or)

négation logique (not)

L’opérateur d’affectation ordinaire

i=5; => Affectation de la valeur 5 à i

(cid:1)

(cid:1) La valeur de i après affectation: 5

(cid:1) c=b+3 ; (cid:4) c=(b+3) ;

(cid:1) La priorité de l’opérateur d’affectation est faible par rapport aux opérateurs

arithmétiques et de comparaison

(cid:1) c+5=x; n’a pas de sens

L’opérateur d’affectation possède une associativité de droite à gauche

i=j=5;

Il est possible de fournir à l’opérateur d’affectation des opérandes de types différents.

(cid:1)

(cid:1)

(cid:1) Dans ce cas une conversion systématique de la valeur de l’expression (droite) est

effectuée dans le type de la variable (gauche)

(cid:1) Une telle conversion imposée ne respecte plus nécessairement la hiérarchie des

types

Opérateurs d’incrémentation et de décrémentation

(cid:1)

i=i+1; (cid:4) i++; (cid:4) ++i;

(cid:1) n=n-1; (cid:4) n-- ; (cid:4) --n ;

#include<stdio.h>

void main()

{

int n, i=5;

n= ++i -5 ;

printf("i: %d et n: %d",i,n); / affichage i:6 et n: 1/

i=5;

n= i++ -5 ;

printf("\n i: %d et n : %d",i,n); /affichage i:6 et n: 0/

}

Les opérateurs d’affectation élargie

(cid:1)

i++; remplace i=i+1;

(cid:1)

i=i+k; remplace i+=k;

(cid:1) a=ab; remplace a=b;

(cid:1) +=; -=; *=; /=; %=; ces opérateurs permettent de condenser l’écriture de certaines

instructions

Mme Wiem Yaiche Elleuch chapitre 2

5

Les conversions forcées par une affectation (casting)

(cid:1) Lors d’une affectation, toutes les conversions sont acceptées par le compilateur (pb

de perte de précision)

(cid:1) La conversion d’un int en char sera satisfaisante si la valeur de l’entier correspond à

un code d’un caractère

#include<stdio.h>

void main()

{

int n;

float x=2.3;

n=x+5.3;

printf("%d", n);

}

Exécution: 7

Casting

(cid:1) Le programmeur peut forcer la conversion d’une expression quelconque dans un

type de son choix

int n=5, p=2; (double) (n/p);

(cid:1)

(cid:1) Aura comme valeur celle de n/p convertie en double

#include<stdio.h>

void main()

{

int x=2, y=3;

printf("la somme est %f", float (x+y));

}

Exécution: 5.00000

//

#include<stdio.h>

void main()

{

#include<stdio.h>

void main()

{

char A=3;

int B=4;

float C;

C = A/B;

printf("%f",C);

}

=> Exécution 0.000000

char A=3;

int B=4;

float C;

C = (float) A/B;

printf("%f",C);

}

=> Exécution 0.7500000

(cid:2) Les contenus de A et de B restent inchangés; seulement les valeurs utilisées dans les calculs sont

converties

Classes de priorité

Priorité 1 (la plus forte):

Priorité 2:

Priorité 3:

Priorité 4:

Priorité 5:

Priorité 6:

Priorité 7:

( )

! ++ --

• / %

+ -

< <= > >=

== !=

&&

Mme Wiem Yaiche Elleuch chapitre 2

6

Priorité 8:

Priorité 9 (la plus faible):

||

= += -= *= /= %=

L’opérateur conditionnel

If (a>b) max=a; else max=b;

(cid:1)

(cid:1) max= a>b ? a:b;

Quelques fonctions prédéfinies de la bibliothèque math.h

fonction exponentielle

logarithme naturel

logarithme à base 10

X exposant Y

racine carrée de X

valeur absolue de X

arrondir en moins

arrondir en plus

reste rationnel de X/Y (même signe que X) pour X différent de 0

eX

ln(X), X>0

log10(X), X>0

XY

pour X>0

|X|

int(X)

COMMANDE C EXPLICATION

exp(X)

log(X)

log10(X)

pow(X,Y)

sqrt(X)

fabs(X)

floor(X)

ceil(X)

fmod(X,Y)

sin(X) cos(X) tan(X)

asin(X) acos(X) atan(X)

sinh(X) cosh(X) tanh(X)

sinus, cosinus, tangente de X

arcsin(X), arccos(X), arctan(X)

sinus, cosinus, tangente hyperboliques de X

Mme Wiem Yaiche Elleuch chapitre 2

7