3. Opérateurs et instructions

3. Opérateurs et instructions

• 

Opérateurs

• 

Expression et instruction

• 

Structures de contrôle

• 

structures alternatives

• 

structures répétitives

• 

Affectation: =

•  identificateur = résultat d’une expression arithmétique résultat d’une expression booléenne résultat retourné par une fonction

lvalue rvalue

•  réaffectation de droite à gauche :

i = j = k = 1 ;

• 

Opérateurs unaires + ^et -

•  -i est le négatif de i

•  +i est la valeur de i

Opérateurs

• 

Arithmétiques : + - / * %

•  il manque l ’exponentiation

*, / et % ont même priorité : a + et - ont même priorité : b

priorité a > priorité b

a + b * c => a + (b * c) c * d % e => (c * d) % e

• 

Incrémentation - décrémentation

•  addition ou soustraction de 1

•  x = x + 1

x++;

++x;

•  x = x – 1; x--

--x;

Opérateurs

• 

Relationnels : > < >= <=

==

!=

•  rend un résultat booléen : 1 ou 0 (vrai ou faux)

•  priorité inférieure à celle des opérateurs arithmétiques

a+b*c < d/f

(a+(b*c)) < (d/f)

•  opérateur de comparaison :

==

•  comparaison des réels

• 

Logiques : ! ^(not) && ^(and) || ^(or)

•  règles de l’algèbre de Boole

•  utilisé pour les évaluations des expressions logiques

•  VRAI et FAUX sont codés numériquement : faux = 0

•  vrai ≠ 0

Opérateurs

• 

Manipulation de bits : &

^|

^{^}

^~

•  particularité du C

•  ne s’applique pas aux réels

•  utilisation du & et du | : masques

a = 21 b = 3

a & b => 1

certain nombre de bits)

a | b => 23

0 0 0 1 0 1 0 1

0 0 0 0 0 0 1 1

0 0 0 0 0 0 0 1

0 0 0 1 0 1 1 1

Opérateurs

• 

Décalage : >>

<<

•  Exemples :

7 << 2

127 >> 3

•  le remplissage se fait par des zéros pour le décalage à gauche

•  dépend du compilateur pour le décalage à droite

0111 1111 0000 1111

0000 0111 0001 1100

Opérateurs

• 

Affectations compactées

•  On remplace les expressions de la forme

(exp1) = (exp1) op (exp2) par (exp1) op = (exp2)

•  Exemples :

i = i + 2 ; i += 2 ; j = j * 3 ; j *= 3 ;

•  plus près de la logique humaine

•  plus efficace

•  intéressant si expression complexe

tab[n*i-tab[3*n]] = tab[n*i-tab[3*n]] - 1;

•  incrémentation - décréméntation

Instructions

• 

Instruction simple

<

expression ;

combinaison d’identificateurs (var, fonction) et d’opérateurs

• 

Instruction composée

•  séquence d’instructions simples

•  délimitée par { et } (bloc)

•  syntaxiquement équivalent à 1 instruction simple

Structures de contrôle

•  Définissent la suite dans laquelle les instructions doivent être effectuées

•  2 types de structures :

•  alternatives

•  if … else

•  switch

•  répétitives

•  while

•  for

•  do … while

Structures de contrôle (alternatives)

• 

Alternatives

•  Permettent au programme de décider si oui ou non il exécute une séquence d’instructions, en fonction de la valeur d’une expression

•  En C la structure usuelle :

if … else …

if ( expression ) instruction 1 else instruction 2

Exemple : if (a >b)

max = a ; else

max = b ;

expression

Instr. 1

Instr. 2

faux

vrai

Structures de contrôle (alternatives)

• 

Alternatives

•  En C la structure usuelle :

if …

if ( expression ) instruction

Exemple : if (a >b)

max = a ; c=a+b

a>b

max =a

faux

vrai

c=a+b

Structures de contrôle (alternatives)

if ( expression ) instruction 1 else instruction 2

•  expression logique VRAIE ou FAUSSE ( ≠ 0 ou = 0), donc évaluée comme une valeur numérique.

•  typiquement des opérateurs relationnels

(Attention: la comparaison est == et non pas l’affectation = )

•  une instruction simple ou une instruction composée (bloc)

•  Exemple : if (a > b) différent de if (a > b) instr1 ; instr1 ; else else

instr2 ; { instr2 ; instr3 ; instr3 ; instr4 ; }

instr4 ;

void main()

{ int i=2, k=3;

if (i == 1)

printf("i vaut 1\n");

else

printf("i differe de 1\n");

if (k != 3)

printf("k differe de 3\n");

if (k > i && k < 0)

{ printf("k negatif\n");

printf ("k sup a i\n");

}

}

Sortie écran:

-

i differe de 1

-

- -

Note : utiliser ((k>i) && (k<0)) plutôt que ( k>i && k<0 )

Structures de contrôle (alternatives)

•  Lorsqu’il y a plus de 2 possibilités, utilisation de

if

•  ou la structure

switch

switch ( expression )

{ case label1 : instruction1 case label2 : instruction2 …

}

•  l’expression est évaluée et convertie en un entier

•  on se branche à l’instruction correspondant au label (1 constante: entier, char) et on exécute les instructions séquentiellement

•  si aucun label ne correspond, on passe à l’instruction suivant le bloc switch

expression =

instruction 1

instruction 2

label1 label2

sinon

Structures de contrôle (alternatives)

switch ( expression )

{ case label1 : instruction1 break;

case label2 : instruction2 break;

…

default : instructionD }

•  break : sort du switch immédiatement -> instruction suivante du switch ignorées

•  default : indique l’instruction à exécuter par défaut, si aucun label ne correspond.

A mettre après tous les case.

•  Si par défaut aucune instruction , on ne met rien après default : (idem pour un label)

expression =

instruction 1

label1

label2 instruction 2 instruction D

sinon

Structures de contrôle (alternatives)

switch (i) {

case 1:

printf("i=1!\n");

case 2:

printf("i=2!\n");

break;

case 3:

printf("i=3!\n");}

break;

default: printf("bad");

}

Sortie écran:

pour i=2:

i=2!

pour i=3:

i=3!

pour i=4:

bad

pour i=1:

i=1!

i=2!

• 

Répétitives

•  Des boucles permettent d’exécuter une séquence d’opérations de façon répétitive, jusqu’à ce qu’une condition soit remplie.

•  En C une structure possible :

while

while ( expression ) instruction

Exemple :

int i = 1 ; while (i < 5)

{ printf(‘‘ %i \n’’, i);

i++ ; }

Instruction expression

faux vrai

Sortie écran:

1 2 3 4

Note: idem sans l’instruction i++; è boucle infinie d’affichage de 1 !

•  Autre structure répétitive :

for

for ( expression1 ; expression2 ; expression3 ) instruction 1) expression1 est évaluée la première fois uniquement 2) expression2 est évaluée

§ si expression2 est vraie alors instruction est exécutée et expression3 est évaluée

§ sinon sortie de la boucle

•  équivalant à : expression1;

while ( expression2) {

instruction;

expression3;

}

Instruction;

expression3;

expression2

faux vrai

expression1

•  Le plus utilisé de tous pour une boucle simple ! :

for

(écriture concise)

≈ for ( initialisation ; condition ; incrémentation ) instruction

Exemple:

int i;

for (i=1 ; i<5 ; i++)

{ printf(’’%i \n ’’, i);}

Note: 1 seule instruction élémentaire à répéter è { } facultatives

Sortie écran:

1 2 3 4

• 

for

Exemple: somme des éléments d’un tableau

void main()

{ int i, somme=0;

int tab[4]={1,5,-3,7};

for (i=0 ; i<4 ; i++) somme +=tab[i];

printf("somme du tableau : %d\n", somme);

}

•  while et for testent la condition au début de la boucle

•  Autre structure répétitive :

do … while

do instruction while (expression) ;

•  la condition est évaluée en fin de boucle

è exécution de l’instruction au moins 1 fois ! Exemple

:

i = 1 ; do

{ printf(‘‘ % i \ n ’’, i);

i++ ;

} while ( i < 5) ;

Instruction

expression

vrai

faux

Sortie écran:

1 2 3 4

•  do instruction while (expression)

Exemple

:

do

{ printf(‘‘ Entrer un nombre positif:\n’’);

scanf(“%i“, &c);

} while ( c < 0) ; printf(“merci\n“);

Exemple de bug : Boucle infinie while (i<10) ;

{ printf(“ok“); i++;}

Divers

• 

break

•  sortie du

switch

•  dans une boucle for , while ou do…while , le

break

(a n’utiliser que si on ne peut faire autrement)

• 

continue

•  proche de l’instruction

break

•  dans une boucle, le

continue

Divers

• 

goto label ;

•  retourne à la ligne de code où se trouve le label choisi, label : instruction;

et reprendre l’exécution de là.

•  A utiliser en dernier recours