Support de cours langage C : initiation de langage


Télécharger Support de cours langage C : initiation de langage

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Support de cours langage C - initiation de langage

formation informatique

1 Premiers Pas

1.1 Prologue

Ce cours utilise comme compilateur le Borland C 2.0. Celui-ci est disponible sur le Web.

1.2 Exemple de programme

main ()

{

puts ("Bonjour");

}

Voici pour exemple un premier programme qui fonctionne malgré le fait qu’il ne soit pas normalisé. Celui-ci affiche le mot bonjour à l’écran.

Une fois le texte du programme frappé, il faut le compiler (Compile), c’est à dire en analyser la syntaxe.

On remarquera plusieurs types de commandes dans le menu Compile :

  1. Compile qui compile le programme c’est à dire en analyse la syntaxe et produit un pseudo-code non interprétable par l’ordinateur (.obj)
  2. Make qui construit un exécutable .exe qui permet au programme d'être exécuter comme n'importe quel autre programme.
  3. Link qui permet de lier plusieurs pseudo-codes entre eux et d'en créer un
  4. Build all qui permet de retraduire tous les codes source d’un projet (ensemble de programmes liés les uns aux autres).

Code source : le code source représente le programme sous sa forme de langage C, c'est à dire ce que vous tapez dans l'éditeur de texte du compilateur.

Pour notre part, nous n’utiliserons que Compile, le reste se faisant durant la exe lors de l’exécution de la commande Run.

1.3 Exécution du programme (Run) On remarque que :

⎣ Pour voir ce qu’affiche le programme il est nécessaire d’utiliser la commande UserScreen dans le menu Windows.

⎣ L’exécution du programme de nombreuses fois fait apparaître le mot Bonjour plusieurs fois.

1.4 Correction du programme

Nous allons normaliser le programme. En fait, à sa base, le langage C n’est qu’un ensemble de bibliothèques à partir desquelles le compilateur trouve les fonctions et les applications qui lui permettent de créer un programme exécutable. Exactement ce que vous faites lorsque vous recherchez dans une encyclopédie.

Certaines bibliothèques sont inclues dans des compilateurs ce qui permet à notre programme de s’exécuter. Normalement, puts a besoin de la bibliothèque stdio.h. Pour ajouter une bibliothèque, il suffit d’ajouter #include en début de programme.

Le second point à corriger est l’absence de valeur de retour. La valeur de retour permet à un programme ou à l’utilisateur de savoir si le programme que l'on exécute s’est correctement terminé. 0 signifie une terminaison sans erreur.

formation informatique

1.5 Petit mot sur ce qu'est une bibliothèque

A l'instar de l'étudiant qui recherche dans des livres, on peut dire que le ".h" représente l'index du livre et le ".c" le contenu du chapitre concerné, le ".o" ou ".

Exemple

Lorsque le compilateur C rencontre le mot clrscr, il regarde dans chacun des ".h" déclaré par l'instruction #include si ce mot y est défini. Il trouve celui-ci dans la conio.h et remplace donc ce mot par le code qui lui est associé au moment de la compilation. A l'inverse, s'il ne le trouve pas, celui-ci émettra une erreur de syntaxe.

1.6 Un exemple de fichier bibliothèque

Vous trouverez ci-dessous, un extrait de la bibliothèque stdio.h. On y retrouve notamment la définition de puts que l'on voit dans ce cours et la définition de printf que l'on verra dans le 2nd cours.

... ... ...

Support de cours langage C : initiation de langage

Variables

Une variable est un emplacement de la mémoire dans lequel est stockée une valeur. Chaque variable porte une nom et c’est ce nom qui sert à identifier l’emplacement de la mémoire représentépar cette variable. Pour utiliser une variable, la première étape est la déclaration.

Déclaration

Déclarer une variable, c’est prévenir le compilateur qu’un nom va être utilisépour désigner un emplacement de la mémoire. En C, on déclare les variables juste après l’accolade suivant main() (pour le moment). On place les instructions à exécuter à la suite de la déclaration de variables.

main ( )

{

<declaration de variables> <instructions a executer>

}

Nous ne travaillerons pour le moment que sur les variables de type numérique entier. Le type qui y correspond, en C, est int. On déclare les variables entières de la manière suivante :

int <var_1>, <var_2>, ... , <var_n>;

Cette instruction déclare les variables var 1, var 2, ..., var n de type entier. Par exemple,

#include<stdio . h>

int main() {

int variable1 , variable2;

int autrevariable1 , autrevariable2;

return 0;

}

On appelle bloc le contenu des accolades du main.

Affectation

Si on souhaite affecter à la variable v une valeur, on utilise l’opérateur =. Par exemple,

int main()

{

int v ; v = 5;

return 0;

}

Ce programme déclare une variable de type entier que l’on appelle v, puis lui affecte la valeur 5. Comme vous venez de le voir, il est possible d’écrire directement dans le code une valeur que l’on donne à une variable. Notez l’abscence de include, ce programme n’effectue aucune entrée-sortie, il n’est donc pas nécessaire d’importer les bibliothèques d’entrées/sorties.

Les opérations arihmétiques disponibles sont l’addition (+), la soustraction (-), la multiplication (*), la division entière dans l’ensemble des entiers relatifs (quotient : /, reste : %).

int main() {

int v , w , z ;

v = 5;

w = v + 1;

z = v + w / 2;

v = z % 3;

v = v ∗ 2; return 0;

}

Saisie

Traduisons en C l’instruction Saisir <variable> que nous avons vu en algorithmique. Pour récupérer la saisie d’un utilisateur et la placer dans une variable <variable>, on utilise l’instruction suivante :

scanf ( ”%d” , &<variable >);

scanf suspend l’exécution du programme jusqu’àce que l’utilisateur ait saisi une valeur et presséla touche return. La valeur saisie est alors affetée à la variable <variable>. N’oubliez surtout pas le &, sinon des choses absurdes pourraient se produire!

Affichage

Traduisons maintenant l’instruction Afficher variable en C. Cette instruction permet d’afficher la valeur d’une variable.

printf ( ”%d” , <variable >);

Cette instruction affiche la valeur contenue dans la variable variable (ne vous laissez pas impressionner par l’apparente complexitéde cette instruction!). Nous avons étendu, en algorithmique, l’instruction Afficher en intercalant des valeurs de variables entre les messages affichés. Il est possible de faire de même en C :

printf (” la valeur de la variable v est %d” , v ) ;

Cette instruction substitue à %d la valeur de la variable v. Il est possible de l’étendre à volonté:

printf (” les valeurs des variables x , y et z sont %d , %d et %d” , x , y , z ) ;

Cette instruction substitue à chaque %d les valeurs des trois variables x, y et z. Par exemple, le programme suivant

#include<stdio . h>

int main() {

int a , b , c ;

a = 1;

b = 2;

c = 3

printf (”La valeur de a est %d , celle de b est %d , et celle de”

”c est %d . ” , a , b , c ) ;

return 0;

}

affiche

La valeur de a est 1, celle de b est 2, et celle de c est 3.

 Entiers

Trois types de base servent à représenter les entiers :

nom      taille (t)                nombre de valeurs (28t)              chaîne de format

short int long     1 octet

2 octets 4 octets              28 valeurs 216 valeurs 232 valeurs           %hd

%d %ld

Entiers non signés

Par défaut, les entiers permettent de stocker des valeurs de signe quelconque. Si on préfixe un type entier par unsigned, on le restreint à des valeurs uniquement positives. Dans ce cas, on a

nom      taille (t)                nombre de valeurs (28t)              valeur min          valeur max         format



unsigned short 1 octet  28 valeurs           0             28 − 1    %hu

unsigned int      2 octets               216 valeurs         0             216 − 1  %u

unsigned long   4 octets               232 valeurs         0             232 − 1  %lu

La plage de valeur d’un unsigned short, encodée en binaire, est

{0000 0000,0000 0001,0000 0010,0000 0011, ..., 1111 1110,1111 1111}

Entiers signés

Si par contre les données sont signées, on a comme plage de valeurs

nom      taille (t)                nombre de valeurs (28t)              plus petite valeur            plus grande valeur

short     1 octet  28 valeurs           −27        27 − 1

int          2 octets               216 valeurs         −215      215 − 1

long       4 octets               232 valeurs         −231      231 − 1

La plage de valeur d’un short, encodée en binaire, est aussi

{0000 0000,0000 0001,0000 0010,0000 0011, ..., 1111 1110,1111 1111}

Même si les codages sont les mêmes, la signification ne l’est pas, les nombres entiers positifs sont codés sur l’intervalle :

{0000 0000,0000 0001,0000 0010,0000    0011, ...,              0111      1100,0111           1101,0111           1110,0111           1111}

Et les nombres négatifs sur l’intervalle                                                                               

{1000 0000,1000 0001,1000 0010,1000    0011, ...,              1111      1100,1111           1101,1111           1110,1111           1111}

Les nombres négatifs sont disposés du plus grand jusqu’au plus petit, l’intervalle précédent code les valeurs :

{−27, −(27 − 1),−(27 − 2),−(27 − 3), ... , −4,−3, −2, −1}

Les opérations arithmétiques sont exécutées assez bêtement, si vous calculez 0111 1111 + 0000 0001, ce qui correspond à (27 − 1) + 1, le résultat mathématique est 27, ce qui se code 1000 0000, ce qui est le codage de −27. Soyez donc attentifs, en cas de dépassement de capacitéd’un nombre entier, vous vous retrouverez avec des nombres qui ne veulent rien dire. Si vous souhaitez faire des calculs sur des réels, un type flottant sera davantage adapté.

Flottants

Les flottants servent à représenter les réels. Leur nom vient du fait qu’on les représente de façon scien¬tifique : un nombre décimal (àvirgule) muni d’un exposant (un décalage de la virgule). Trois types de base servent à représenter les flottants :

nom      taille      chaîne de format

float double

long double       4 octet 8 octets 10 octets            %f %f %Lf

Il est conventionel d’écrire des littéraux flottants avec un point, par exemple l’approximation à 10−2 près de π s’ecrit 3.14. Il est aussi possible d’utiliser la notation scientifique, par exemple le décimal 1 000 s’écrit 1e3, à savoir 1.103.Nous nous limiterons à la description du type float, les autres types obéissent à des règles similaires.

Représentation en mémoire d’un float

Le codage d’un nombre de type float (32 bits) est découpéen trois parties :

partie    taille

le bit de signe   1 bit

l’exposant          8 bits

la mantisse         23 bits

Le nombre est positif si le bit de signe est à 0, négatif si le bit de signe est à 1. La mantisse et l’exposant sont codés en binaire, la valeur absolue d’un flottant de mantisse m et d’exposant e est 223 .2'. Le plus

m

(2 23 − 1)

grand entier qu’il est possible de coder sur 23 octets est             223 , le plus grand exposant est 27 , donc

(2 23 − 1) 27       (2 23 − 1) 27

le plus grand flottant est \ 223  .2( ~, donc le plus petit est − \ 223          .2( ~.

Caractères

Un char sert à représenter le code ASCII d’un caractère, il est donc codésur 1 octet. Il est possible d’affecter à une telle variable toute valeur du code ASCII entourée de simples quotes. Par exemple, l’affectation suivante place dans a le code ASCII du caractère ’B’.

char a ; a = ’B ’ ;

De la même façon que l’on code des nombres entiers sur 1 octet avec un short, un char contient avant tout un nombre codésur 1 octet. Pour afficher le caractère corrspondant au code ASCII stockédans un char, on utilise la chaîne de format %c, et pour afficher le code ASCII lui-même on utilise la chaîne de format %d. Si on souhaite manipuler des char comme des nombres, le type unsigned char permet de coder des valeurs positives sur 1 octet, alors que char code aussi bien des nombres positifs que négatifs. Par conséquent, les caractères de code ASCII 255 et 128 correspondent aux unsigned char de valeurs 255 et 128 et aux char de valeurs −1 et −128.

Constantes

Une constante est une valeur portant un nom, contrairement aux variables, elles ne sont pas modifiables. Les constantes en C sont non typées, on les définit dans l’entête de la source, juste en dessous des #include. La syntaxe est #define <NOM CONSTANTE> <valeurConstante>, par exemple #define N 25 définit une constante N qui a la valeur 25. Au début de la compilation, un programme appelépréprocesseur effectue un rechercher/remplacer et substitue à toutes les occurences de <NOM CONSTANTE> la valeur <valeurConstante>. Faites donc très attention au fait que dans l’exemple présent, le préprocesseur va remplacer tous les N par des 25. Donc si une variable s’appelle N, le préprocesseur va le remplacer par un 25! Si par exemple vous écrivez

 #include<stdio . h> #define N 25

int main()

{

int N ;

N = 12;

printf (”N = %d” , N ) ;

return 0;

}

Le préprocesseur va le transformer en

#include<stdio . h> #define N 25

int main()

{

int 25;

25 = 12;

printf (”N = %d” , 25);

return 0;

}

Vous remarquez que les seules exceptions sont les valeurs délimitées par des ".

 Opérateurs

Généralités

Opérandes et aritéLorsque vous effectuez une opération, par exemple 3 + 4, le + est un opérateur, 3 et 4 sont des opérandes.

Si l’opérateur s’applique à 2 opérandes, on dit qu’il s’agit d’un opérateur binaire, ou bien d’arité2. Un opérateur d’arité1, dit aussi unaire, s’applique à un seul opérande, par exemple -x, le x est l’opérande et le - unaire est l’opérateur qui, appliquéà x, nous donne l’opposéde celui-ci, c’est-à-dire le nombre qu’il faut additionner à x pour obtenir 0. Il ne faut pas le confondre avec le - binaire, qui appliquéà x et y, additionne à x l’opposéde y.

En C, les opérateurs sont unaires ou binaires, et il existe un seul opérateur ternaire.

Associativité

Si vous écrivez une expression de la forme a + b + c, oùa, b et c sont des variables entières, vous appliquez deux fois l’opérateur binaire + pour calculer la somme de 3 nombres a, b et c. Dans quel ordre ces opérations sont-elles effectuées ? Est-ce que l’on a (a + b) + c ou a + (b + c) ? Cela importe peu, car le + entier est associatif, ce qui signifie qu’il est possible de modifier le parenthèsage d’une somme d’entiers sans en changer le résultat. Attention : l’associativitéest une rareté! Peu d’opérateurs sont associatifs, une bonne connaissance des règles sur les priorités et le parenthèsage par défaut est donc requise.

Formes préfixes, postfixes, infixes

Un opérateur unaire est préfixe s’il se place avant son opérande, postfixe s’il se place après. Un opérateur binaire est infixe s’il se place entre ses deux opérandes (a + b), préfixe s’il se place avant (+ a b), postfixe s’il se place après (a b +). Vous rencontrez en C des opérateurs unaires préfixes et d’autres postfixes (on imagine difficilement un opérateur unaire infixe), par contre tous les opérateurs binaires seront infixe.



Priorités

Les règles des priorités en C sont nombreuses et complexes, nous ne ferons ici que les esquisser. Nous appelerons parenthèsage implicite le parenthèsage adoptépar défaut par le C, c’est à dire l’ordre dans lequel il effectue les opérations. La première règle à retenir est qu’un opérateur unaire est toujours prioritaire sur un opérateur binaire.

Les opérateurs unaires Négation arithmétique

La négation arithmétique est l’opérateur - qui à une opérande x, associe l’opposéde x, c’est-à-dire le nombre qu’il faut additionner à x pour obtenir 0.

Négation binaire

La négation binaire ~ agit directement sur les bits de son opérande, tous les bits à 0 deviennent 1, et vice-versa. Par exemple, ~127 (tous les bits à 1 sauf le premier) est égal à 128 (le premier bit à 1 et tous les autres à 0).

Priorités

Tous les opérateurs unaires sont de prioritééquivalente, le parenthèsage implicite est fait le plus à droite possible, on dit que ces opérateurs sont associatifs à droite. Par exemple, le parenthèsage implicite de l’expression ~-~i est ~(-(~i)). C’est plutôt logique: si vous parvenez à placer les parenthèses différement, prevenez-moi parce que je ne vois pas comment faire...

Les opérateurs binaires

Opérations de décalages de bits

L’opération a >> 1 effectue un décalage des bits de la représentation binaire de a vers la droite. Tous les bits sont décalés d’un cran vers la droite, le dernier bit disparaît, le premier prend la valeur 0. L’opération a << 1 effectue un décalage des bits de la représentation binaire de a vers la gauche. Tous les bits sont décalés d’un cran vers la gauche, le premier bit disparaît et le dernier devient 0. Par exemple, 32 << 2 associe à 0010 0000 << 2 la valeur dont la représentation binaire 1000 0000 et 32 >> 3 associe à 0010 0000 >> 3 la valeur dont la représentation binaire 0000 0100.

Opérations logiques sur la représentation binaire

L’opérateur & associe à deux opérandes le ET logique de leurs représentations binaires par exemple 60 & 15 donne 12, autrement formulé0011 1100 ET 0000 1111 = 0000 1100. L’opérateur | associe à deux opérandes le OU logique de leurs représentations binaires par exemple 60 | 15 donne 63, autrement

formulé0011 1100 OU 0000 1111 = 0011 1111. L’opérateur " associe à deux opérandes le OU exclusif logique de leurs représentations binaires par exemple 60 " 15 donne 51, autrement formulé0011 1100 OU EXCLUSIF 0000 1111 = 0011 0011. Deux " successifs s’annulent, en d’autres termes a"b"b=a.

Affectation

Ne vous en déplaise, le = est bien un opérateur binaire. Celui-ci affecte àl’opérande de gauche (appelée Lvalue par le compilateur), qui doit être une variable, une valeur calculée à l’aide d’une expression, qui est l’opérande de droite. Attention, il est possible d’effectuer une affectation pendant l’évaluation d’une expression. Par exemple,

a = b + (c = 3);

Cette expression affecte à c la valeur 3, puis affecte à a la valeur b + c. Priorités

Tous les opérateurs binaires ne sont pas de priorités équivalentes. Ceux de prioritéla plus forte sont les opérateurs arithmétiques (*, /, %, +, -), puis les opérateus de décalage de bit (<<, >>), les opérateurs de bit (&, ", |), et enfin l’affectation =. Représentons dans une tableau les opérateurs en fonction de leur priorité, plaçons les plus prioritaire en haut et les moins prioritaires en bas. Parmi les opérateurs arithmétiques, les multiplications et divisions sont prioritaires sur les sommes et différence :

noms    opérateurs

produit *,            /, %

sommes              +,            -

Les deux opérateurs de décalage sont de prioritééquivalente :

noms    opérateurs

décalage binaire              >>, <<

L’opérateur & est assimiléà un produit, | à une somme. Donc, & est prioritaire sur |. Comme " se trouve entre les deux, on a

noms    opérateurs

ET binaire            &

OU Exlusif binaire           "

OU binaire          |

Il ne nous reste plus qu’àassembler les tableaux :

noms

opérateurs

produit somme                *, /,

+, ¬        %

décalage binaire              >>,         <<

ET binaire

OU Exlusif binaire OU binaire    &

affectation         =            

Quand deux opérateurs sont de même prioritéle parenthèsage implicite est fait le plus à gauche pos¬sible, on dit que ces opérateurs sont associatifs à gauche. Par exemple, le parenthèsage implicite de l’expression a - b - c est

(a − b) − c

et certainement pas a - (b - c). Ayez donc cela en tête lorsque vous manipulez des opérateurs non associatifs! La seule exception est le =, qui est associatif à droite. Par exemple,

a = b = c ;

se décompose en b = c suivi de a = b.

1.3.4 Formes contractées

Le C étant un langage de paresseux, tout à étéfait pour que les programmeurs aient le moins de caractères possible à saisir. Je vous préviens : j’ai placéce chapitre pour que soyez capable de décrypter la bouillie que pondent certains programmeurs, pas pour que vous les imitiez! Alors vous allez me faire le plaisir de faire usage des formes contractées avec parcimonie, n’oubliez pas qu’il est très important que votre code soit lisible.

Unaires

Il est possible d’incrémenter (augmenter de 1) la valeur d’une variable i en écrivant i++, ou bien ++i. De la même façon on peut décrémenter (diminuer de 1) i en écrivant i-- (forme postfixe), ou bien --i (forme préfixe). Vous pouvez décider d’incrémenter (ou de décrémenter) la valeur d’une variable pendant un calcul, par exemple,

a = 1;

b = (a++) + a ;

évalue successivement les deux opérandes a++ et a, puis affecte leur somme à b. L’opérande a++ est évaluée à 1, puis est incrémentée, donc lorsque la deuxième opérande a est évaluée, sa valeur est 2. Donc la valeur de b après l’incrémentation est 3. L’incrémentation contractée sous forme postfixe s’appelle une post-incrémentation. Si l’on écrit,

a = 1;

b = (++a) + a ;

On opère une pré-incrémentation, ++a donne lieu à une incrémentation avant l’évaluation de a, donc la valeur 4 est affectée à b. On peut de façon analogue effectuer une pré-decrémentation ou a post¬decrémentation. Soyez très attentifs au fait que ce code n’est pas portable, il existe des compilateurs qui évaluent les opérandes dans le désordre ou diffèrent les incrémentations, donnant ainsi des résultats autres que les résultats théoriques exposés précédement. Vous n’utiliserez donc les incrémentation et decrémentation contractées que lorsque vous serez certain que l’ordre d’évaluation des opérandes ne pourra pas influer sur le résultat.

 Binaires

Toutes les affectations de la forme variable = variable operateurBinaire expression peuvent être contractées sous la forme variable operateurBinaire= expression. Par exemple,

avant    après

a = a + b               a += b

a = a - b                a -= b

a = a * b               a *= b

a = a / b               a /= b

a = a % b              a %= b

a = a & b              a &= b

a = a^ b                a ^= b

a = a | b               a |= b

Vous vous douterez que l’égaliténe peut pas être contractée...

1.3.5 Opérations hétérogènes Le fonctionnement par défaut

Nous ordonnons de façon grossière les types de la façon suivante : long double > double > float > unsigned long > long > unsigned int > int > unsigned short > short > char. Dans un cal

cul oùles opérandes sont de types hétérogènes, l’opérande dont le type T est de niveau le plus élévé(conformément à l’ordre énoncéci-avant) est sélectionnéet l’autre est converti dans le type T.

Le problème

Il se peut cependant que dans un calcul, cela ne convienne pas. Si par exemple, vous souhaitez calculer

int i = 4;

printf ( ”L ’ inverse de %d est %d” , i , 1/i ) ;

Vous constaterez que résultat est inintéressant au possible. En effet, comme i et 1 sont tout deux de type entier, c’est la division entière est effectuée, et de toute évidence le résultat est 0. Changer la chaîne de format



int i = 4;

printf ( ”L ’ inverse de %d est %f \n” , i , 1/i ) ;

se révèlera aussi d’une inefficaciténotoire : non seulement vous vous taperez un warning, mais en plus printf lira un entier en croyant que c’est un flottant. Alors comment on se sort de là? Ici la bidouille est simple, il suffit d’écrire le 1 avec un point :

int i = 4;

printf (”L ’ inverse de %d est %f \n” , i , 1./i ) ;

Le compilateur, voyant un opérande de type flottant, convertit lors du calcul l’autre opérande, i, en flottant. De ce fait, c’est une division flottante et non entière qui est effectuée. Allons plus loin: comment faire pour appliquer une division flottante à deux entiers ? Par exemple :

int i = 4 , j= 5;

printf ( ”Le quotient de %d et %d est %f \n” , i , j , i/j ) ;

Cette fois-ci c’est inextricable, vous pouvez placer des points oùvous voudrez, vous n’arriverez pas à vous débarasser du warning et ce programme persistera à vous dire que ce quotient est -0.000000 ! Une solution particulièrement crade serait de recopier i et j dans des variables flottantes avant de faire la division, une autre méthode de bourrin est de calculer (i + 0.)/j. Mais j’espère que vous réalisez que seuls les boeufs procèdent de la sorte.

 Le cast

Le seul moyen de vous sortir de làest d’effectuer un cast, c’est à dire une conversion de type sur com¬mande. On caste en plaçant entre parenthèse le type dans lequel on veut convertir juste avant l’opérande que l’on veut convertir. Par exemple,

int i = 4 , j= 5;

printf ( ”Le quotient de %d et %d est %f \n” , i , j , ( float ) i/j ) ;

Et là, ça fonctionne. La variable valeur contenue dans i est convertie en float et de ce fait, l’autre opérande, j, est aussi convertie en float. La division est donc une division flottante. Notez bien que le cast est un opérateur unaire, donc prioritaire sur la division qui est un opérateur binaire, c’est pour ça que la conversion de i a lieu avant la division. Mais si jamais il vous vient l’idée saugrenue d’écrire

int i = 4 , j= 5;

printf ( ”Le quotient de %d et %d est %f \n” , i , j , (float ) ( i/j ) ) ;

Vous constaterez très rapidement que c’est une alternative peu intelligente. En effet, le résulat est flottant, mais comme la division a lieu avant toute conversion, c’est le résultat d’une division entière qui est converti en flottant, vous avez donc le même résultat que si vous n’aviez pas du tout casté.

Les priorités

Ajoutons le cast au tableau des priorités de nos opérateurs :

noms    opérateurs

opérateurs unaires        cast, -, ~, ++, -¬

produit somme                *, /, %

+, ¬

décalage binaire              >>, <<

ET binaire

OU Exlusif binaire OU binaire    &

^

|

affectation         =

Traitements conditionnels

On appelle traitement conditionnel un portion de code qui n’est pas exécutée systématiquement, c’est à dire des instructions dont l’exécution est conditionnée par le succès d’un test.

Si ... Alors

Principe

En algorithmique un traitement conditionnel se rédige de la sorte :

Si condition alors instructions

fin si

Si la condition est vérifiée, alors les instructions sont exécutées, sinon, elles ne sont pas exécutées. L’exécution de l’algorithme se poursuit alors en ignorant les instructions se trouvant entre le alors et le finSi. Un traitement conditionnel se code de la sorte :

i f (<condition>)

{

<instructions>

}

Notez bien qu’il n’y a pas de point-virgule après la parenthèse du if.

Comparaisons

La formulation d’une condition se fait souvent à l’aide des opérateurs de comparaison. Les opérateurs de comparaison disponibles sont :

{ == :égalité

!= : non-égalité <,

<= : inférieur à, respectivement strict et large

{ >,>= : supérieur à, respectivement strict et large

Par exemple, la condition a == b est vérifiée si et seulement si a et b ont la même valeur au moment oùle test est évalué. Par exemple,

#include<stdio . h>

int main()

{

int i ;

printf ( ” Saisissez une valeur : ” ) ;

scanf(”%d” , &i ) ;

i f (i = 0)

{

printf (”Vous avez saisi une valeur nulle \n. ” ) ;

}

printf ( ”Adios ! ” ) ;

return 0;

}

Si au moment oùle test i == 0 est évalué, la valeur de i est bien 0, alors le test sera vérifiéet l’instruction printf("Vous avez saisi une valeur nulle\n.") sera bien exécutée. Si le test n’est pas vérifié, les instructions du bloc ... suivant le if sont ignorées.

 Si ... Alors ... Sinon

Il existe une forme étendue de traitement conditionnel, on la note en algorithmique de la façon suivante :

Si condition alors instructions

sinon

autresinstructions

fin si

Les instructions délimitées par alors et sinon sont exécutées si le test est vérifié, et les instructions délimitées par sinon et finSi sont exécutées si le test n’est pas vérifié. On traduit le traitement condi¬tionnel étendu de la sorte :

i f (<condition>)

{

<instructions1>

}

else

{

<instructions2>

}

Par exemple,

#include<stdio . h>

int main()

{

int i ;

printf ( ” Saisissez une valeur : ” ) ;

scanf(”%d” , &i ) ;

i f (i == 0)

{

printf (”Vous avez saisi une valeur nulle \n. ” ) ;

}

else

{

printf (”La valeur que vous saisi , ”

”a savoir %d , n ’ est pas nulle .\n” , i ) ;

}

return 0;

}

Notez la présence de l’opérateur de comparaison ==. N’utilisez jamais = pour comparer deux va¬leurs!.

Connecteurs logiques

On formule des conditions davantage élaborées en utilisant des connecteurs et et ou. La condition A et B est vérifiée si les deux conditions A et B sont vérifiées simultanément. La condition A ou B est vérifiée si au moins une des deux conditions A et B est vérifiée. Le et s’écrit && et le ou s’écrit ||. Par exemple, voici un programme C qui nous donne le signe de i x j sans les multiplier.

#include<stdio . h>

int main() {

int i , j ;


386