Algorithmique et Langage C

Algorithmique et Langage C

www.polytech.unice.fr/žvg/index-xidian.html

Granet Vincent - Vincent.Granet@univ-cotedazur.fr

Xi’an - Octobre 2019 - Avril 2020

44/214

Expressions

45/214

Définition

composition d’opérandes et d’opérateurspour former des expressions.

opérateursunaires,binaires,trinaires, ...n-aires notationinfixe, préfixe,postfixe

évaluation⇒résultat (unique ?) règles de priorité

a b + c e t (a b) + c

46/214

Expressions en C (1)

opérateurs arthimétiques

Entiers Réels

Unaire + − + −

Binaire + − / % + − /

+ no overflow checking opérateurs relationnels

== !=

> >= < <=

+ type des opérandes : arithmétique ou pointeur type du résultat : int (0 ou 1)

opérateurs logiques

|| && !

+ type des opérandes : tous types scalaires type du résultat : int (0 ou 1)

+ le second opérande n’est pas évalué, si le résultat peut être déduit à partir du 1er opérande

47/214

Expressions en C (2)

opérateurs bit à bit ž | Ž &

+ type des opérandes : int opérateurs de décalages

<< >>

+ décalage gauche is 0-filled

+ décalage droit remplit avec 0 si son 1er opérande estunsigned, sinon remplit (maybe) avec une copie du bit de signe

opérateur conditionnel

+ le seul opérateur trinaire du langage condition ?expr₁:expr₂

min = a < b ? a : b;

48/214

Expressions en C (3)

opérateurs d’affectation affectation simple

=

types des opérandes : arithmétique, pointeurs, struct or union + type résultat : (non converti) type opérande gauche

affectation composée

aop=b⇔a=aopb (a n’est évalué qu’une seule fois)

+= −= = /= %=

&= Ž= |=

<<= >>=

incrémentation - décrémentation (de 1) x++ x−−(postfixe)

+ le résultat est la valeur dexavantl’incrémentation (ou la décrémentation)

++x −−x(préfixe)

+ le résultat est la valeur dexaprèsl’incrémentation (ou la décrémentation)

49/214

Expressions en C (4)

opérateur sizeof

sizeof expror sizeof(type) i n t a;

printf("%d %d\n",s i z e o f a, s i z e o f(i n t));

+ expr n’est pas évaluée, et la taille de l’objet doit être calculable à la compilation

opérateur virgule

expr1,expr2,...exprn

+ le résultat est la valeur de la dernière expression (i.e. exprn) utilisée quand plusieurs expressions doivent être évaluées à un endroit où une seule expression est autorisée

f o r(i=0, j=MAX ; i<j ; i++, j−−) { / .... /

}

50/214

Priorité et ordre d’évaluation

16 () function call

16 [] ^indexation

16 . field selection

16 -> indirect field selection

15 ++ – postfixed incr/decr

14 ++ – prefixed incr/decr

14 sizeof ^size

14 (type) ^casting

14 ~ bitwise negation

14 ! ^negation

14 - ^opposite

14 & ^{address of}

14 * indirection

13 G * / % multiplicative operators

12 G + - additive operators

11 G « » shifts operators

10 G < <= > >= relational operators

9 G == != equality operators

8 G & bitwise and

7 G ^ bitwise exclusive or

6 G | ^{bitwise or}

5 G && ^and

4 G || ^or

3 D ?: conditional

2 D = += -= *= /= %= assignments 2 D «= »= &= ^= |=

1 G , ^comma

51/214

Conversions implicites de type (1)

Elles se produisent quand les types des opérandes d’une expression sont différents

En C, les règles sont complexes

conversions unaires

integer types shorter than_int ⇒ int signed integer types same size as_int ⇒ int unsigned integer types same size as int ⇒ int

oat⇒double(K&R)

52/214

Conversions implicites de type (2)

conversions binaires

1 if operands are not arithmetic

or same types ⇒ pas de conversion

2 if one oplong double ⇒ long double

3 if one opdouble ⇒ double

4 if one op oat ⇒ oat

5 if one opunsigned long ⇒ unsigned long

6 if one oplong ⇒ long

7 if one opunsigned int ⇒ unsigned int 8 else operand types areint ⇒ no conversion

u n s i g n e d i n t x = 0;

printf("%d\n", x > −1); //0 => faux

printf("%d\n", (i n t) x > −1); //1 => vrai !

53/214

Conversions implicites de type (3)

conversions pour l’affectation

le type de la partie gauche et droite sont identiques ⇒ pas de conversion

partie gauche partie droite all arithmetic types all arithmetic types all pointer types integer constant 0 all pointer types void

pointer to T array T pointer to function function

conversions des paramètres fonctions les conversions unaires sont appliquées

float ⇒double

54/214

Conversions explicites (cast)

convertir le résultat d’uneexpressiondans une valeur de type T (T) expression

(i n t) 2.0 / convertit 2.0 en int (i.e. 2) /

3 / (f l o a t) 4 / = 0.75 alors que 3/4 = 0 /

pas de conversion explicite versstructouunion integer ⇒ integer

real ⇒ integer

pointer ⇒ integer

real ⇒ real

integer ⇒ real pointer ⇒ pointer

integer ⇒ pointer (0 andvoid ) array ⇒ pointer (implicit) function ⇒ pointer (implicit) any type ⇒ void(mais unitilisable)