SMC S4
Idrissi Yassine
Introduction
Historique
— En 1972, dans les ”Bell Laboratories”, Dennis M. Ritchie a con¸cu le Langage C pour d´evelopper une version portable du syst`eme d’exploitationUNIX.
— En1978, le duo Brian W. Kernighan et I Dennis M. Ritchie a publi´e la d´efinition classique du langage C(connue sous le nom de standard K &R-C).
— En 1983, le ”American National Standard Institute”(ANSI) chargeait une commission de mettre au point une d´efinition explicite et ind´ependante de la machine pour le langage C. Le r´esultat ´etait le standard AINSI-C.
Caract´ eristiques
C’est un langage :
— universel : C permet aussi bien la programmation syst`eme que la programmation de divers applications (scientifiques, de gestion,...).
— de haut niveau : C est un langage structur´e (offre plusieurs structures de contrˆole) et typ´e (d´eclarations obligatoires).
— pr`es de la machine : Offre des op´erateurs qui sont tr`es proches de ceux du langage machine et des fonctions qui permettent un acc`es simple et direct aux fonctions internes de l’ordinateur (par exemple : les op´erateurs de d´ecalage des bits et l’acc`es aux registres).
— ind´ependant de la machine :peut ˆetre utilis´e sur n’importe quel syst`eme en possession d’un compilateur C.
— portable : en respectant le standard ANSI-C, il est possible d’utiliser le mˆeme pro- gramme sur d’autres compilatuers.
— ...
Phases de la programmation en C
Il ya trois grandes ´etapes concernant la cr´eation d’un programme en langage C `a savoir :
´edition du programme, compilation et ´edition de liens.
L’´edition du programme (on dit aussi parfois«saisie») consiste `a cr´eer, `a partir d’un clavier, tout ou partie du texte d’un programme qu’on nomme programme source. En g´en´eral, ce texte sera conserv´e dans un fichier que l’on donnera un nom ”fichier source” et qui portera l’extension C.
La compilation permet de transformer notre code en un vrai programme ex´ecutable, Si le
code source contient des erreurs, le compilation ´echoue et les erreurs sont affich´e pour que le programmeur les corrige.
L’´edition des liens permet de rechercher dans la biblioth`eque standard les fonctions pr´ed´efinies (on dit aussi «fonctions standard») utilis´ees par votre programme. Le r´esultat de l’´edition de liens est ce que l’on nomme un programme ex´ecutable. Si ce programme ex´ecutable est rang´e dans un fichier, il pourra ult´erieurement ˆetre ex´ecut´e sans qu’il soit n´ecessaire de faire appel `a un quelconque composant de l’environnement de programmation en C.
Chapitre 1
Notion de Base
1.1 Premier programme en langgage
Ce programme affiche le message : ”Bonjour tout le monde”
/* Premier programme enC */
#include<stdio.h>
#include<stdlib.h>
main() {
printf(”Bonjour tout le monde\n”) ; system(”pause”) ;
}
— Les commentaires sont des textes explicatifs destin´es aux lecteurs du programme, ils n’ont aucune incidence sur sa compilation et sur son ex´ecution. Les commentaires d´ebutent par /* et se terminent par */. Si le commentaire est court et tient sur une seule ligne on peut taper un double slash (//) suivi de notre commentaire. Par exemple : // ceci est un commentaire.
— #include<stdio.h> informe le compilateur d’inclure le fichier stdio.h qui contient les fonctions d’entr´ees-sorties (i pour input et o pour output), dont la fonction printf et#in- clude<stdlib.h>informe le compilateur d’inclure le fichier stdlib.h (contient la fonction system) qui permet d’interagir avec le syst`eme d’exploitation sur lequel le programme s’ex´ecute.
— La fonction main est la fonction principale des programmes en C : Elle se trouve obliga- toirement dans tous les programmes.
— L’appel de printf avec l’argument ”Bonjour tout le monde\n” permet d’afficher sur l’´ecran : Bonjour et \n ordonne le passage `a la ligne suivante.
— En C, toute instruction simple est termin´ee par un point-virgule ;
1.2 Les types de base du langage C
Un type de donn´es repr´esente un ensemble de valeurs d’une mˆeme nature. Pour faire simple, on peut parler du type entier (qui repr´esente l’ensemble des valeurs num´eriques enti`ere et relative : par exemple : 1, 2, 3, 4, ...), du type flottant (3.1415926, 4.4, ...) .... Les types de base du langage
C se r´epartissent en trois grandes cat´egories en fonction de la nature des informations qu’ils permettent de repr´esenter :
— nombres entiers (mot cl´e int),
— nombres flottants (mot cl´e float ou double),
— caract`eres (mot cl´e char) ; nous verrons qu’en fait char apparaˆıt (en C) comme un cas particulier de int.
1.2.1 Le type entier
Les diff´erents types d’entiers
Le C pr´evoit que, sur une machine donn´ee, on puisse trouver jusqu’`a trois tailles diff´erentes d’entiers, d´esign´ees par les mots-cl´es suivants :
— short int (qu’on peut abr´eger en short),
— int,
— long int (qu’on peut abr´eger en long).
Caract´eristiques :
D´efinition Valeur minimale Valeur maximale Nombre d’octets
short -32768 32767 2
int -32768 32767 2
long -2147483648 2147483647 4
Le type short est en g´en´eral cod´e dans 2 octets. Comme une variable int occupe aussi 2 octets sur notre syst`eme, le type short devient seulement n´ecessaire, si on veut utiliser le mˆeme programme sur d’autres machines, sur lesquelles le type standard des entiers n’est pas forc´ement 2 octets.
Si on ajoute le pr´efixe unsigned `a la d´efinition d’un type de variables enti`eres, les domaines des variables sont d´eplac´es comme suit :
D´efinition Valeur minimale Valeur maximale Nombre d’octets
unsigned short 0 65535 2
unsigned int 0 65535 2
unsigned long 0 4294967295 4
Notation des constantes enti`eres : La fa¸con la plus naturelle d’introduire une constante enti`ere dans un programme est de l’´ecrire simplement sous forme d´ecimale, avec ou sans signe, comme dans ces exemples :
+533 48 −273
1.2.2 Les types flottants
Les types flottants permettent de repr´esenter, de mani`ere approch´e, une partie des nombres r´eels. Le C prevoit que, sur une machine donn´ee, on puisse trouver jusqu’`a trois types de r´eels : Le type float pour les nombres d´ecimaux en simple pr´ecision, double pour les nombres d´ecimaux en double pr´ecision et long double pour les r´eels de tr`es grande pr´ecision.
Chapitre 1. Notion de Base 5
D´efinition Plage de valeurs accept´ee Nombre d’octets float ±3.4×10−38 `a ±3.4×1038 4
double ±1.7×10−308 `a ±1.7×10308 8 long double ±3.4×10−4932 `a ±3.4×104932 10
1.2.3 Le type char
le type char permet de stocker des nombres compris entre −128 et 127. En pratique le type char sert surtout au stockage de lettres. Chaque lettre poss`ede son ´equivalent en code num´erique : c’est le code ASCII (American Standart Code for Information Interchange). Par exemple, 97 est l’´equivalent ASCII de la lettre a.
Le langage C permet de faire tr`es facilement la traduction lettre ←→nombre correspondant.
Pour obtenir le nombre associ´e `a une lettre, il suffit d’´ecrire cette lettre entre apostrophes, comme ceci : ’A’. `A la compilation, ’A’ sera remplac´e par la valeur correspondante.
Type de donn´ees sinyfication Nombre d’octets Plage des valeurs accept´ees
Char Caract`ere 1 -128`a 127
unsigned char Caract`ere non sign´e 1 0`a 255
1.3 Les variables
Une variable correspondra `a une portion de m´emoire, `a laquelle nous donnerons un nom. Ce nom permettra d’identifier notre variable. Nous allons ainsi pouvoir nommer les donn´ees que nous manipulons. En utilisant ce nom dans votre programme, vous adressez la donn´ee qui y est stock´ee.
1.3.1 Les noms de variable
Avant d’utiliser une variable dans votre programme, vous devez cr´eer un nom de variable qu’on appelle identificateurqui doit respecter plusieurs r`egles :
— Ce nom (=identificateur) peut contenir des lettres, des chiffres et le caract`ere .
— Le premier caract`ere doit ˆetre une lettre. Le caract`ere ( ) est aussi autoris´e, mais il n’est pas recommand´e.(les espaces ne sont pas autoris´es).
— Les lettres majuscules sont diff´erentes des minuscules. Par exemple, compte et Compte ne repr´esentent pas la mˆeme variable.
— Il ne faut pas utiliser les mots cl´es, ils font partie du langage C. Voici la liste compl`ete des 33 mots cl´es du C :
asm auto double int struct break else long switch case enum register typedef char extern return union continue for signed void do if static while default goto sizeof volatile const float short unsigned
— Il ne faut pas utiliser les caract`ere sp´eciaux : , < > . - ( ) ; $ : % [ ] # ? ’ & ” ˆ ! * / | - +
Nom de la variable Validit´e
Pourcent Correct
y2x5fg7h Correct
profit annuel Incorrect : contient espace 1990 Correct, mais d´econseill´e
compte#courant Incorrect : contient le caract`ere interdit # double Incorrect : double est un mot cl´e
9puits Incorrect : le premier caract`ere est un chiffre
1.3.2 D´ eclaration et initialisation des variables
En C, toute variable utilis´e dans un programme doit auparavant ˆetre d´efinie. La d´efinition d’une variable consiste `a la nommer et lui donner un type. C’est cette d´efinition qui r´eserve (on dira alloue) la place m´emoire n´ecessaire en fonction du type. Initialiser une variable consiste `a remplir, avec une constante, la zone m´emoire r´eserv´ee `a cette variable. Cette op´eration s’effectue avec l’op´erateur =.
Pour d´eclarer une variable, il suffit de :
— Indiquer le type de la variable `a cr´eer ;
— Ins´erer un espace ;
— Indiquer le nom (identificateur) attribu´e `a la variable, en respectant les r`egles de nomination concernant les identificateurs ;
— Enfin, de ne pas oublier le point-virgule, indispensable pour toute instruction en C.
Syntaxe : typeVariable nomVariable ;
On peut d´eclarer plusieurs variables du mˆeme type sur une seule ligne en les s´eparant par des virgules, par exemple :
— double z ; /* une seul variable double */
— int count, number, start ; /* trois variables enti`eres */
— float percent, total ; /* deux variables `a virgule flottante */
La d´eclaration de variable permet au compilateur de r´eserver l’espace m´emoire destin´e `a cette variable. La donn´ee qui sera stock´ee dans cet emplacement, la valeur de la variable, n’est pas encore d´efinie. Avant d’ˆetre utilis´ee, la variable d´eclar´ee doit ˆetre initialis´ee. Cela peut se faire en utilisant une instruction d’initialisation comme dans notre exemple :
— int count ; /* R´eservation de la m´emoire pour count */
— count = 0 ; /* Stocke 0 dans count */
Le signe ´egal fait partie des op´erateurs du langage C. En programmation, ce signe n’a pas le mˆeme sens qu’en alg`ebre. Si vous ´ecrivez : x = 12 dans une instruction alg´ebrique, vous ´enoncez un fait :
”x = 12”. En langage C, la signification est diff´erente : ”donner la valeur 12 `a la variable appel´ee x”. Vous pouvez initialiser une variable au moment de sa d´eclaration. Il suffit de faire suivre le nom de variable, dans l’instruction de d´eclaration, du signe ´egal suivi de la valeur initiale : Exemple des cas possibles :
— D´eclaration avec initialisation : int x=1 ;
— D´eclaration seule : double y ;
— D´eclaration de plusieurs variables de mˆeme type : char c, ch ;
— D´eclarations avec initialisations pour plusieurs variables de mˆeme type sur la mˆeme ligne s´epar´ees par une virgule : int a=2, b=6 ;
Chapitre 1. Notion de Base 7
Attention, il ne faut pas initialiser la variable avec une valeur qui ne correspond pas au type d´eclar´e. Voici deux exemples d’initialisations incorrectes :
— int poids = 100000 ;
— unsigned int valeur = -2500 ;
Le compilateur ne d´etecte pas ce genre d’erreur, et le programme pourrait vous donner des r´esul- tats surprenants.
Remarque
Il n’existe pas de valeur par d´efaut pour les variables en langage C. Lors d’une d´eclaration sans initialisation, la variable prend la valeur qui se trouvait l`a avant dans la m´emoire, et cette valeur peut ˆetre n’importe quoi ! Il est donc toujours recommand´e d’initialiser la variable d`es qu’on la d´eclare.
1.3.3 Les constantes
Le langage C poss`ede deux types de constantes qui ont chacune un usage sp´ecifique.
Les constantes litt´erales
Une constante litt´erale est une valeur qui est introduite directement dans le code source. Voici deux exemples :
— int count = 20 ;
— float tax rate = 0.28 ;
20 et 0.28 sont des constantes litt´erales. Ces deux instructions stockent ces valeurs dans les variables count et tax rate. La valeur qui contient un point d´ecimal (.) est une constante `a virgule flottante, l’autre est une constante enti`ere. Par exemple 3 est consid´er´e comme une constante enti`ere
Comme dans la plupart des langages, les constantes flottantes peuvent s’´ecrire indiff´eremment suivant l’une des deux notations : d´ecimale ou exponentielle. La notation d´ecimale doit com- porter obligatoirement un point (correspondant `a notre virgule). La partie enti`ere ou la partie d´ecimale peut ˆetre omise (mais, bien sˆur, pas toutes les deux en mˆeme temps !). En voici quelques exemples corrects :
12.43 −0.38 384. .27
La notation exponentielle utilise la lettre e (ou E) pour introduire un exposant entier (puissance de 10), avec ou sans signe. Voici quelques exemples corrects (les exemples d’une mˆeme ligne ´etant
´equivalents) :
4.25E4 −542.7e−33 48.0E13
Par d´efaut, toutes les constantes flottantes sont cr´e´es par le compilateur dans le type double. Pour imposer `a une constante flottante d’ˆetre du type float, on suit son ´ecriture de la lettre F (ou f).
Toute repr´esentation d’une constante `a virgule flottante doit inclure le point d´ecimal, par exemple 3 (sans le point d´ecimal) est consid´er´e comme une constante enti`ere, alors que 3. est consid´er´e comme une constante flottante.
Les constantes litt´erales de type caract`ere se note entre apostrophes : ’a’ ’2’.
1.3.4 Les constantes symboliques
Une constante symbolique est un emplacement m´emoire utilis´e par votre programme. `A l’in- verse d’une variable, la valeur stock´ee dans une constante symbolique ne peut changer pendant l’ex´ecution du programme. Les constantes symboliques permettent au programmeur de cr´eer un nom pour une constante et d’utiliser ce nom tout au long du programme. Les constantes symbo- liques se d´efinissent `a l’aide de la directive
#define Nom constante
Le Nom devient alors un nom symbolique qui peut ˆetre utilis´e partout o`u l’on veut faire figurer la constante. Par exemple,
#define PI 3.14159
Remarquez que cette instruction ne se termine pas par un point-virgule ( ;). La commande #define peut se trouver n’importe o`u dans le code source, mais son effet est limit´e `a la partie de code qui la suit. En g´en´eral, les programmeurs groupent tous les #define ensemble, au d´ebut du fichier, avant la fonction main().
Il est possible de d´eclarer que la valeur d’une variable ne doit pas changer lors de l’ex´ecution du programme. Par exemple, avec :
const int n = 20 ;
on d´eclare n de type int et de valeur (initiale) 20 mais, de surcroˆıt, les ´eventuelles instructions modifiant la valeur den seront rejet´ees par le compilateur.
On pourrait penser qu’une d´eclaration (par const) remplace avantageusement l’emploi de define. En fait, nous verrons que les choses ne sont pas aussi simples, car les variables ainsi d´eclar´ees ne pourront pas intervenir dans ce qu’on appelle des«expressions constantes»(notamment, elles ne pourront pas servir de dimension d’un tableau !).
1.4 Instructions, expressions et op´ erateurs
Les programmes C sont constitu´es d’instructions qui contiennent, pour la plupart, des expres- sions et des op´erateurs.
1.4.1 Les instructions
Une instruction repr´esente une tˆache `a accomplir par l’ordinateur. En langage C, on ´ecrit une instruction par ligne et elle se termine par un point-virgule (`a l’exception de #define et #include ). Par exemple :
x = 2 + 3 ;
est une instruction d’affectation. Elle demande `a l’ordinateur d’ajouter 2 et 3 et d’attribuer le r´esultat `a la variable x.
Quand le compilateur lit une instruction, il ignore absolument tous espace, tabulation ou ligne de blancs du code source. Par exemple, l’instruction :
x=2+3 ;
Chapitre 1. Notion de Base 9
est ´equivalente `a :
x = 2 + 3 ; ou mˆeme `a :
x = 2 + 3 ;
Cela nous laisse une grande libert´e pour la mise en page de notre code.
Un bloc (ou instructions compos´ees) est un groupe d’instructions entre accolades : {
printf(”Hello,”) ; printf(”world !”) ; }
Les accolades peuvent se positionner de diff´erentes fa¸cons. L’exemple suivant est ´equivalent au pr´ec´edent :
{printf(”Hello,”) ; printf(”world !”) ;}
En pla¸cant les accolades sur une ligne s´epar´ee, nous identifierons plus facilement le d´ebut et la fin du bloc, et nous ´eviterons d’en oublier une.
1.4.2 Les op´ erateurs
Les op´erateurs sont des symboles qui permettent de manipuler des variables, c’est-`a-dire ef- fectuer des op´erations sur les variables, les ´evaluer, etc. En langage C, les op´erateurs sont divis´ees en quatre cat´egories :
— l’op´erateur d’affectation ;
— les op´erateurs math´ematiques ;
— les op´erateurs de comparaison ;
— les op´erateurs logiques.
L’op´erateur d’affectation
L’op´eration la plus importante dans un langage de programmation est celle qui consiste `a donner une valeur `a une variable (ou un tableau). Cette op´eration est d´esign´ee par le symbole =.
Sa syntaxe est la suivante :
variable = expression
Le terme de gauche de l’affectation (variable) peut ˆetre une variable simple, un ´el´ement de tableau mais pas une constante. Cette op´eration a pour effet d’affecter la valeur de expression `a variable.
De plus, variable = expression poss´ede une valeur, qui est celle de expression. Ainsi, l’expression i = 5 vaut 5.
On rappelle que L’instruction d’affectation est l’op´eration qui consiste `a attribuer une valeur
`
a une variable, elle est diff´erentte de l’op´erateur ´egale : ==, A == B signifiera«est-ce que A est
´egal `a B»? Et la r´eponse sera alors soit vrai soit faux.
Les op´erateurs math´ematiques
Les op´erateurs math´ematiques de C r´ealisent des op´erations math´ematiques comme l’addition ou la soustraction. Il en existe deux unaires et cinq binaires.
Op´erateurs math´ematiques binaires
Les op´erateurs binaires du langage C travaillent avec deux composants.
Op´erateur Symbole Op´eration Exemple
Addition + Additionne les deux composant x + y
Soustraction - Soustrait la valeur du second composant `a la valeur du premier x-y
Multiplication * Multiplie les deux composant x * y
Division / Divise le premier composant par le second x / y
Modulo % Donne le reste de la division du premier composant par le second x % y
Une chose importante doit ˆetre pr´ecis´ee concernant la division : quand les deux nombres manipul´es sont de type entier, il s’agit d’une division enti`ere. Autrement dit, le quotient sera un entier et il peut y avoir un reste. Par exemple, 15/6, ne donnera pas 2,5 (division r´eelle), mais 2.
Le modulo est un peu le compl´ement de la division enti`ere : au lieu de donner le quotient, il renvoie le reste d’une division euclidienne. Par exemple, le modulo de 15 par 6 est 3, car 15 = 2
×6 + 3.
Avec les types flottants, la division se comporte autrement et n’est pas une division avec reste.
La division de deux flottants donnera un r´esultat«exact», avec potentiellement plusieurs chiffres apr`es la virgule.
Les op´erateurs math´ematiques unaires :
Les op´erateurs unaires op`erent sur une seule variable.
Op´erateur Symbole Op´eration Exemples
Incr´ementation ++ Augmente de 1 la valeur de la variable ++x, x++
D´ecr´ementation −− D´ecr´emente de 1 la valeur de la variable x −−x, x−−
Les op´erateurs d’incr´ementation ++ et de d´ecr´ementation −− s’utilisent aussi bien en suf- fixe (i++)/(i−−) qu’en pr´efixe (++i)/(−−i). Dans les deux cas la variable i sera incr´emen- t´ee/d´ecr´ement´ee. Toutefois dans le cas incr´ementation/d´ecr´ementation d’une variable et en mˆeme temps affecter sa valeur `a une autre variable, on doit choisir entre la notation suffixe et pr´efixe :
— X = I++ passe d’abord la valeur de I `a X et incr´emente apr`es.
— X = I−− passe d’abord la valeur de I `a X et d´ecr´emente apr`es.
— X = ++I incr´emente d’abord et passe la valeur incr´ement´ee `a X.
— X = −−I d´ecr´emente d’abord et passe la valeur d´ecr´ement´ee `a X.
Exemple
Supposons que la valeur de N est ´egal `a 5 :
— X = N++ ; R´esultat : N=6 et X=5.
— X = ++N ; R´esultat : N=6 et X=6.
Chapitre 1. Notion de Base 11
Les op´erateurs d’affectation compos´es
Ces op´erateurs compos´es permettent d’associer une op´eration math´ematique binaire avec une op´eration d’affectation. Pour, par exemple, augmenter la valeur de x de 5, il faut ajouter 5 `a x et stocker le r´esultat dans la variable x :
x = x + 5 ;
L’op´erateur compos´e permet d’´ecrire : x += 5 ;
Les op´erateurs d’affectation compos´es ont la syntaxe suivante (op repr´esente un op´erateur bi- naire) :
exp1 op= exp2 ;
qui est l’´equivalent de : exp1 = exp1 op exp2 ;
Nous pouvons cr´eer un op´erateur compos´e `a partir des cinq op´erateurs math´ematiques binaires.
Le Tableau suivant donne quelques exemples :
Expression Equivalent´ x *= y x = x * y a /= b a = a / b x += y / 8 x = x + y / 8
y %= 3 y = y % 3
Comme pour toutes les autres instructions d’affectation, ce type d’instruction est une expression dont la valeur est affect´ee `a la variable situ´ee `a gauche. Si vous ex´ecutez l’instruction suivante, les deux variables x et z auront la valeur 14 :
x = 12 ; z = x += 2 ;
Les op´erateurs de comparaison
Les op´erateurs de comparaison sont utilis´es pour comparer des expressions en posant des questions du type«x est-il plus grand que 100 ?»ou «y est-il ´egal `a 0 ?». Leur syntaxe est
expression-1 op expression-2
Les deux expressions sont ´evalu´ees puis compar´ees. La valeur rendue est de type int ; elle vaut 1 si la condition est vraie, et 0 sinon.
Op´erateur Symbole Question pos´ee Exemple
Egal´ == La premi`ere composante est-elle ´egal `a la seconde ? x == y Sup´erieur > Le premi`ere composante est-elle plus grand que la seconde ? x>y
Inf´erieur < La premi`ere composante est-elle plus petit que la seconde ? x<y Sup´erieur ou ´egal >= La premi`ere composante est-elle sup´erieur ou ´egal `a la seconde ? x>= y
Inf´erieur ou ´egal <= La premi`ere composante est-il inf´erieur ou ´egal `a la seconde ? x<= y Diff´erent != La premi`ere composante est-elle diff´erente de la seconde ? x != y
Exemples d’utilisations des op´erateurs de comparaison
Expression Signification Valeur
5 == 1 La valeur 5 est-elle ´egale `a 1 ? 0
5> 1 5est-elle plus grande que 1 ? 1
5 != 1 La valeur 5 est-elle diff´erente de 1 ? 1 (5 + 10) == (3 * 5) L’expression (5 + 10) est-elle ´egale `a (3 * 5) ? 1
Attention :
— Il faut Comprendre que le langage C interpr`ete une expression vraie comme ayant la valeur 1 et une expression fausse comme ayant la valeur 0.
— Attention `a ne pas confondre l’op´erateur de test d’´egalit´e == avec l’op´erateur d’affecta- tion=.
Les op´erateurs logiques
Les op´erateurs logiques de C permettent de v´erifier si plusieurs conditions sont vraies :
Expression Valeur
(exp1 && exp2) Vraie si exp1 et exp2 vraies. Sinon faux
(exp1 || exp2) Vraie si exp1 vraie ou exp2 vraie. Faux si les deux expressions sont fausses.
( !exp1) Faux si exp1 est vraie. Vraie si exp1 est fausse.
Exemples
Expression Valeur
(5 == 5) && (6 != 2) Vraie, car les deux composantes sont vrais (5> 1)|| (6 <1) Vraie, car un composant est vrai (2 == 1) && (5 == 5) Faux, car un composant est faux
!(5 == 4) Vrai, car le composant est faux
Comme pour les op´erateurs de comparaison, la valeur retourn´eee par ces op´erateurs est un int qui vaut 1 si la condition est vraie et 0 sinon.
l’´evaluation se fait de gauche `a droite et s’arrˆete d`es que le r´esultat final est d´etermin´e. Par exemple dans :
int i ; float p=12 ;
if ((i>= 0) && (i<= 9) && !(p == 0)) ...
la derni`ere clause ne sera pas ´evalu´ee si i n’est pas entre 0 et 9.
1.4.3 Expression
Une expression est une suite de composants ´el´ementaires syntaxiquement correcte, par exemple : i =0
i++
printf(” Bonjour !\n”) a=(5*x+10*y)*2 (a+b)>=100 position !=limite
Les constantes et les variables sont des expressions. Les expressions peuvent ˆetre combin´ees entre elles par des op´erateurs et former ainsi des expressions plus complexes.
La valeur d’une constante litt´erale est sa propre valeur. La valeur d’une constante symbolique est celle qui a ´et´e d´efinie au niveau de l’instruction #define. La valeur courante d’une variable est celle qui lui a ´et´e attribu´ee par le programme.
Chapitre 1. Notion de Base 13
En C toutes les expressions sont ´evalu´ees et retournent une valeur comme r´esultat : (3+2==5) retourne la valeur 1 (vrai)
A=5+3 retourne la valeur 8
Quand une expression contient plusieurs op´erateurs, son ´evaluation d´epend de l’ordre dans lequel les op´erations sont effectu´ees. Ce concept de hi´erarchie est expliqu´e plus loin dans le cha- pitre.
Une instruction est une expression suivie d’un point-virgule. Le point-virgule signifie en quelque sorte «´evaluer cette expression».
1.4.4 Priorit´ e et associativit´ e des op´ erateurs
Lors de l’´evaluation des diff´erentes parties d’une expression, les op´erateurs respectent certaines lois depriorit´e et d’associativit´e :
— Les exrpressions sont ´evalu´ees en fonction de l’ordre de priorit´e des op´erateurs.
— Dans une expression, les parehth`eses forcent la priorit´e. Elles permettent aussi une meilleure lisibilit´e des expressions.
— Les op´erateurs de plus grande priorit´e sont ´evalu´es en premier.
— En cas d’op´erateurs demˆeme priorit´e, c’est l’associativit´ede l’op´erateur qui d´etermine le sens d’´evaluation de l’expression.
— Un op´erateur a une associativit´e de droite `a gauche (←−) quand : a op b op c signifie a op ( b op c). (op= op´eration).
— Un op´erateur a une associativit´e de gauche `a droite (−→) quand : a op b op c signifie (a op b) op c.
Nous donnons ci-dessous le tableau des diff´erents op´erateurs avec leurs priorit´es class´es par ordre d´ecroissant, et leurs associativit´e.
Op´erateur Associativit´e
() [] -> . −→
! ˜ +(unaire) -(unaire) ++ – ∗ & ←−
∗ / % −→
+(binaire) -(binaire) −→
<< >> −→
< <= > >= −→
== != −→
&(et bit-`a-bit) −→
ˆ −→
| −→
&& −→
|| −→
? : ←−
= += -= *= /= %= &= ˆ= |= <<= >>= ←−
, −→
Exemples :
— La multiplication a la propri´et´e sur l’addition, l’expression x+y ∗c est ´evalu´e comme x+(y*z).
— La multiplication et l’addition ont la priorit´e sur l’affectation.
— L’op´erateur + ´etant associatif de gauche `a droite, l’expression x+y+z est ´evalu´e comme (x+y)+z.
8/4*6 8*6/4 28/(3*4)
↓ ↓ ↓
2*6 48/4 28/12
↓ ↓ ↓
12 12 12
Les op´erateurs * et / se situent au mˆeme niveau de priorit´e. L’op´erateur le plus `a gauche dans l’expression est d’abord trait´e. Dans le troisi`eme exemple, les parenth`eses sont d’abord trait´ees car elles sont prioritaires. Ainsi, 8/4*6 ne signifie pas qu’on divise 8 par 4*6, autrement dit, 8 par 24. Il faut appliquer syst´ematiquement les r`egles de priorit´e, mˆeme dans les cas apparement simples.
Remarque :
Op´erateur Traduction Exemple R´esultat
+(unaire) Signe positif +x la valeur de x
-(unaire) Signe n´egatif -x la n´egation arithm´etique de x [] El´ement de tableau t[i] L’´element du tableau t d’indice i.
˜-> . & << >> Hors du programme SMC S4
1.4.5 Les fonctions arithm´ etiques standard
Le fichier d’en-tˆete<math.h>d´eclare des fonctions math´ematiques. Pour pouvoir les utiliser, le programme doit contenir la ligne :
#include<math.h>
Tous leurs param`etres et r´esultat sont de type double
Commande en C En math´ematiques
exp(X) eX
log(X) ln(X), X >0
log10(X) log10(X), X > 0
pow(X,Y) XY
sqrt(X) √
X, X >0
f abs(X) |X|
f loor(X) arrondir en moins int(X)
ceil(X) arrondir en plus
f mod(X,Y) reste rationnel de X/Y (mˆeme signe que X) pour X diff´erent de 0
sin(X) cos(X) tan(X) sinus, cosinus, tangente deX
asin(X) acos(X) atan(X) arcsin(X), arccos(X), arctan(X) sinh(X) cosh(X) tanh(X) sinus, cosinus, tangente hyperboliques de X
Chapitre 1. Notion de Base 15
1.5 Les conversions de type
On appelle conversion de type de donn´ees le fait de modifier le type de donn´ee en une autre.
Elle a pour but de changer le type d’une valeur, sans changer cette valeur si c’est possible.
La grande souplesse du langage C permet de m´elanger des donn´ees de diff´erents types dans une expression. Avant de pouvoir calculer, les donn´ees doivent ˆetre converties dans un mˆeme type.
La plupart de ces conversions se passent automatiquement, sans l’intervention du programmeur, qui doit quand mˆeme pr´evoir leur effet. Parfois il est n´ecessaire de convertir une donn´ee dans un type diff´erent de celui que choisirait la conversion automatique ; dans ce cas, nous devons forcer la conversion `a l’aide d’un op´erateur sp´ecial (”cast”).
1.5.1 La conversion implicite ou automatique
Une conversion implicite consiste en une modification du type de donn´ee effectu´ee automati- quement par le compilateur.
Si on regroupe dans une mˆeme expression des types de donn´ees diff´erents, le compilateur proc`ede `a une conversion des types selon les r`egles suivantes :
— Le typeplus petit est converti eu type plus large.
— Ainsi un char en pr´esence d’un int sera converti en int ( la valeur correspondante sera alors le code ASCI du caract`ere correspondant), un int en pr´esence d’un float sera converti en float.
— Deux r´eel : il est choisit le plus large des deux types selon l’´echelle : float, double, long double.
— Il est aussi important de noter que dans une expression d’affectation le compilateur proc`ede `a une conversion implicite en changeant le type de la variable `a droite au type de la variable `a gauche.
Exemples
—
int x ; x=8.324 ;
x contiendra apr`es affectation la valeur 8.
—
char a=’A’ ; int b=32 ;
Alors a+b sera un int contenant 97 car le char a ´et´e convertit en int.
—
int a=12 ;
float b=a ; // b sera ´egal `a 12.0
int c=b ; // c sera ´egale a 12 et la valeur d´cimale est enlev´ee.
— Consid´erons le calcul suivant : int I = 8 ;
float X = 12.5 ; double Y ; Y = I * X ;
Pour pouvoir ˆetre multipli´e avec X, la valeur de I est convertie en float (le type le plus
large des deux). Le r´esultat de la multiplication est du type float, mais avant d’ˆetre affect´e a Y, il est converti en double. Nous obtenons comme r´esultat : Y = 100.00.
— Lors de l’appel d’une fonction, les param`etres sont automatiquement convertis dans les types d´eclar´es dans la d´efinition de la fonction. Par exemple, au cours des expressions suivantes, nous assistons `a trois conversions automatiques :
int A = 200 ; int RES ;
RES = pow(A, 2) ;
A l’appel de la fonction pow, la valeur de A et la constante 2 sont converties en double, parce que pow est d´efinie pour des donn´ees de ce type. Le r´esultat (type double) retourn´e par pow doit ˆetre converti en int avant d’ˆetre affect´e `a RES.
1.5.2 La conversion explicite ou forc´ ee
Nous avons vu que le compilateur proc`ede `a une conversion quand cette lui paraˆıt logique : int−→float par exemple.
Cependant il est tout `a fait possible de proc´eder `a la conversion d’un float en un int par exemple. Cette conversion est dite une conversion forc´ee ou explicite. On peut changer le type d’une variable vers un autre type en utilisant l’operateurcast(type) en le mettant devant l’iden- tificateur de variable `a convertir, la syntaxe d’un castest la suivante :
(type souhait´e) expression Exemple
Nous divisons deux variables du type entier. Pour avoir plus de pr´ecision, nous voulons avoir un r´esultat de type rationnel. Pour ce faire, nous convertissons l’une des deux composant en float.
Automatiquement C convertira l’autre composant en float et effectuera une division rationnelle : char A=3 ;
int B=4 ; float C ;
C = (float)A/B ;
La valeur de A est explicitement convertie en float. La valeur de B est automatiquement convertie en float. Le r´esultat de la division (type rationnel, valeur 0.75) est affect´e `a C. R´esultat : C=0.75.
Attention : Les contenus de A et de B restent inchang´es ; seulement les valeurs utilis´ees dans les calculs sont converties.
