Cours programmation en langage C

6

la valeur de y est 8.9, celle de x est 6

la valeur de x est 6, celle de y est 8.9

Exemple

Ecrire un programme qui lit 3 entiers au clavier, affiche leur somme et leur moyenne.

#include <stdio.h>

void main()

{

Mme Wiem Yaiche Elleuch

chapitre 1

Page 2

int x ; int y ; int z ; int som ;

float moy ; // ou bien int x, y, z ;

printf(« saisir 3 entiers ») ;

scanf(« %d%d%d » , &x, &y, &z) ;

som=x+y+z ;

moy=som/3 ;

printf(« la somme est %d, et la moyenne est %f », som, moy) ;

}

Exécution :

saisir 3 entiers 5

6

7

la somme est 18, et la moyenne est 6.0

Structure d’un programme (pgm) en C

(cid:131) main() : en-tête : Elle précise que ce qui sera décrit à sa suite est le programme

principal (main)

(cid:131) Le pgm principal est délimité par des accolades

(cid:131) Les instructions situées entre accolades forment un « bloc ».

(cid:131) La fonction main est constituée d’un en tête et d’un bloc.

(cid:131)

(cid:131) Un bloc peut lui-même contenir d’autres blocs

Il ira de même pour toute fonction C

Déclarations

int x,y,z ; float moy ; Ce sont des « déclarations ».

(cid:131)

(cid:131) La variable nommée x est de type int (destinée à contenir des nombres entiers relatifs).

(cid:131) En C, il existe plusieurs types d’entiers

(cid:131) En C, les déclarations des types de variables sont obligatoires et doivent être

regroupées au début du programme (fonction main).

Pour écrire des informations: la fonction printf

printf(« premiere annee \n informatique »);

(cid:131) Appelle une fonction prédéfinie (fournie avec le langage et qu’on n’a pas besoin d’écrire)

nommée printf.

(cid:131) Cette fonction reçoit un argument « premiere annee \n informatique »

(cid:131) Les guillemets servent à délimiter une « chaîne de caractères » (suite de caractères).

(cid:131)

\n représente un caractère de fin de ligne (passage à la ligne suivante).

printf(“la moyenne est %f “, moy) ;

(cid:131)

(cid:131) Le premier argument de printf est le « format » : il précise comment afficher les

Ici, printf reçoit deux arguments : “la moyenne est %f “ et moy.

informations qui sont fournies par les arguments suivants

(cid:131) Le % indique que le caractère suivant est, non plus du texte à afficher tel quel, mais un

« code de format ».

(cid:131) Il faut toujours veiller à accorder le code de format au type de la valeur

correspondante

Mme Wiem Yaiche Elleuch

chapitre 1

Page 3

Pour lire des informations: la fonction scanf

scanf (« %f », &x);

(cid:131) C’est un appel de la fonction prédéfinie scanf dont le rôle est de lire une information au

clavier.

(cid:131) Comme printf, la fonction scanf possède en premier argument un format exprimé sous

forme d’une chaine de caractère: « %f » (float)

(cid:131) L’argument précise dans quelle variable on souhaite placer la valeur lue

(cid:131) &x: la fonction scanf range la valeur lue à l’adresse de la variable. (& est un opérateur

signifiant « adresse de »)

Quelques règles d’écriture : Les identificateurs

(cid:131) Les identificateurs servent à désigner les différents « objets » manipulés par le programme

(cid:131)

(variables, fonction, etc).

Ils sont formés d’une suite de caractères choisis parmi les lettres ou les chiffres. Le

premier d’entre eux étant nécessairement une lettre.

(cid:131) Le caractère « _ » est considéré comme une lettre. Il peut apparaître au début d’un

identificateur (lg_ligne; _total; _89)

(cid:131) Les majuscules et les minuscules sont autorisées mais ne sont pas équivalentes (ligne ‡

Ligne).

(cid:131) Longueur des identificateurs: les 31 premiers caractères sont significatifs

Quelques règles d’écriture : Les mots clés

(cid:131) Certains mots-clés sont réservés par le langage à un usage bien défini et ne peuvent

pas être utilisés comme identificateurs.

(cid:131) Auto, break, case, char, const, continue, default, do, double, else, enum, extern, float,

for, goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch,

typedef, union, unsigned, void, volatile, while

Quelques règles d’écriture : Les séparateurs

(cid:131)

(cid:131)

int x,y; et non intx, y

int n,compte,total,p; ou bien plus lisiblement int n, compte, total, p;

Quelques règles d’écriture : le format libre

(cid:131) Le langage C autorise une mise en page parfaitement libre

(cid:131) Une instruction peut s’étendre sur un nombre quelconque de lignes, et une même ligne

peut comporter plusieurs instructions

Quelques règles d’écriture : les commentaires

(cid:131) Le langage C autorise la présence de commentaires dans les programmes

(cid:131)

Il s’agit de textes explicatifs destinés aux lecteurs du programme et qui n’ont aucune

incidence sur sa compilation.

Ils sont placés entre / et / ou bien //

Ils peuvent apparaître à tout endroit du programme

(cid:131)

(cid:131)

Mme Wiem Yaiche Elleuch

chapitre 1

Page 4

Les directives à destination du préprocesseur

#include<stdio.h>

#define NB 5

(cid:131) Ces premières lignes sont des directives qui seront prises en compte avant la

traduction (compilation du programme).

(cid:131) Ces directives doivent être écrites à raison d’une par ligne et elles doivent

obligatoirement commencer en début de ligne.

(cid:131) D’une manière générale, il est préférable de placer les directives au début.

(cid:131) Ces directives demandent d’introduire (avant compilation) des instructions situées

dans le fichier stdio.h et de remplacer le symbole NB par 5

(cid:131) Lors de l’appel d’une fonction prédéfinie, il est nécessaire d’incorporer un tel fichier,

nommé « fichier en-tête », qui contient des déclarations appropriées concernant cette

fonction stdio.h pour printf et scanf.

(cid:131) Ces déclarations permettront au compilateur d’effectuer des contrôles sur le nombre et

le type des arguments mentionnés lors de l’appel de la fonction

(cid:131) Un même fichier en-tête contient des déclarations relatives à plusieurs fonctions

(cid:131) En général, il est indispensable d’incorporer stdio.h

(cid:131) #define NB 5 demande de remplacer systématiquement, dans toute la suite du

programme, le symbole NB par 5.

(cid:131) #define sert à définir la valeur d’un symbole

Création d’un programme (pgm) en langage C

Suit les étapes suivantes :

(cid:131) Édition du programme

(cid:131) Compilation

(cid:131) Édition de liens

Création d’un programme en langage C : Édition du programme

(cid:131) Ou « saisie » consiste à créer à partir d’un clavier du texte d’un programme (pgm)=>

programme source

(cid:131) Ce texte sera conservé dans un fichier=> fichier source

(cid:131) Chaque système possède ses propres conventions de dénomination des fichiers

(cid:131) Un fichier: nom+extension

Création d’un programme en langage C : La compilation

(cid:131) Elle consiste à traduire le pgm source (ou le contenu du fichier source) en langage

machine en faisant appel à un programme nommé compilateur

(cid:131) L’opération de compilation se fait en deux étapes:

o Traitement par le préprocesseur: qui exécute les directives qui le concerne

(commençant par #include, #define)

o La compilation: traduction en langage machine du texte en langage C fourni

par le préprocesseur

(cid:131) Le résultat de la compilation porte le nom de module objet

Mme Wiem Yaiche Elleuch

chapitre 1

Page 5

Création d’un programme en langage C : Édition de lien

(cid:131) Le module objet créé par le compilateur n’est pas directement exécutable

(cid:131)

Il lui manque les différents modules objet correspondant aux fonctions prédéfinies

utilisées par le pgm (printf, scanf, etc).

(cid:131) C’est le rôle de l’éditeur de lien d’aller rechercher dans la bibliothèque standard les

modules objets nécessaires

(cid:131) Le résultat de l’édition de liens est un programme exécutable, càd un ensemble

autonome d’instructions en langage machine

(cid:131) Si ce programme exécutable est rangé dans un fichier, il pourra ultérieurement être

exécuté sans qu’il soit nécessaire de faire appel à un quelconque composant de

l’environnement de pgmt en C

Le préprocesseur

(cid:131) C’est un pgm qui est exécuté automatiquement avant la compilation et qui transforme

un fichier source à partir d’un certain nombre de directives

(cid:131) Les directives sont écrites sur des lignes distinctes du reste du programme, elles sont

introduites par #: #include, #define

(cid:131) Les diverses possibilités offertes par le préprocesseur:

o Incorporation de fichiers source (#include)

o Définition de symboles et de macros (#define)

o Compilation conditionnelle

La notion de type

(cid:131) La mémoire centrale est un ensemble de positions binaires nommées bits.

(cid:131) Les bits sont regroupés en octets (8 bits), et chaque octet est repéré par ce qu’on

nomme son adresse

(cid:131) L’ordinateur représente et traite les informations exprimées (codées) sous forme

binaire.

(cid:131) Une séquence binaire peut représenter un nombre entier, nombre réel, caractère,

(cid:131)

instruction, etc)

Il n’est pas possible d’attribuer une signification à une information binaire tant que

l’on ne connaît pas la manière dont elle a été codée.

(cid:214) la notion de type permet de régler ce problème

Types de base

Les types de base du langage C se répartissent en trois grandes catégories:

(cid:131) Nombres entiers (int, short , long)

(cid:131) Nombres flottants (float, double, long double)

(cid:131) Caractères (char)

Mme Wiem Yaiche Elleuch

chapitre 1

Page 6

Catégorie des entiers :

(cid:131) char : caractère : Une variable du type char peut contenir une valeur entre -128 et 127 et

(cid:131)

elle peut subir les mêmes opérations que les variables du type short, int ou long.

int : entier standard : Sur chaque machine, le type int est le type de base pour les calculs

avec les entiers. Le codage des variables du type int est donc dépendant de la machine.

Sur les IBM-PC sous MS-DOS, une variable du type int est codée dans deux octets.

(cid:131) short : entier court : Le type short est en général codé dans 2 octets. Comme une variable

int occupe aussi 2 octets sur notre système, le type short devient seulement nécessaire, si

on veut utiliser le même programme sur d'autres machines, sur lesquelles le type standard

des entiers n'est pas forcément 2 octets.

définition

description

domaine min

domaine max nombre d'octets

char

caractère

-128

short

entier court

-32768

int

entier standard

-32768

127

32767

32767

long

entier long

-2147483648

2147483647

1

2

2

4

Chacun de ces trois types peut être qualifié de unsigned (non signé) (pas de bit réservé au

signe, des nombres positifs seulement)

définition

description

domaine min domaine max nombre d'octets

unsigned char

caractère

unsigned short

entier court

unsigned int entier standard

unsigned long

entier long

0

0

0

0

255

65535

65535

4294967295

1

2

2

4

Catégorie des flottants

(cid:131) Les types flottants permettent de représenter, de manière approchée, une partie des

nombres réels.

(cid:131) Notation: M.BE Avec M: mantisse ; E: exposant; B:base

(cid:131) Exemple: 1.5 1022 0.472 10-8

(cid:131) 1.5 et 0.472: mantisses ; 22 et -8: exposants

(cid:131) Un nombre réel sera représenté en flottant.

(cid:131) Le C prévoit trois types de flottants: float, double et long double

(cid:131) Les constantes flottantes peuvent s’écrire indifféremment suivant l’une des deux

notations:

o Décimale

o Exponentielle

Mme Wiem Yaiche Elleuch

chapitre 1

Page 7

(cid:131) La notation décimale doit comporter obligatoirement un point (~ virgule). La partie

entière ou décimale peut être omise 12.43 -0.38 -.38 4. .27

(cid:131) La notation exponentielle utilise la lettre e (ou E) pour introduire un exposant entier

(puissance de 10), avec ou sans signe

(cid:131) 4.25E4 4.25e+4 42.5E3 54.27E-32 542.7E-33 5427e-34

définition précision mantisse domaine min domaine max nombre d'octets

float

simple

double

double

long double

suppl.

6

15

19

3.4 * 10-38

3.4 * 1038

1.7 * 10-308

1.7 * 10308

3.4 10-4932 1.1 104932

4

8

10

Catégorie des caractères

(cid:131) Un caractère est codé sur un octet en mémoire

(cid:131)

il existe des caractères non imprimables: caractères de changement de ligne (\n),

tabulation (\t), etc

(cid:131) Constantes de type caractère (imprimable): ‘A’ ‘+’ ‘9’

(cid:131) Certains caractères non imprimables utilisent le caractère « \ » (antislash, backslash)

(cid:131)

\a: bip; \b:retour arrière; \f: saut de page; \n: saut d ligne; \r: retour chariot; \t:

tabulation horizontale; \v: tabulation verticale, etc;

\a

\b

\t

\n

\r

\0

sonnerie

curseur arrière

tabulation

nouvelle ligne

retour au début de ligne

NUL

\\

\?

\'

\"

\f

\v

trait oblique

point d'interrogation

apostrophe

guillemets

saut de page (imprimante)

tabulateur vertical

(cid:131)

Il est possible d’utiliser directement le code du caractère en l’exprimant à la suite du

caractère antislash:

o Soit sous forme octale

o Soit sous forme hexadécimale précédée de x

o ‘A’ ‘\x41’ ‘\101’

Initialisation et constantes

(cid:135) #define: permet de donner une valeur à un symbole. Dans ce cas, le préprocesseur

effectue le remplacement correspondant avant la compilation

#include<stdio.h>

#define NB 5

void main()

{

int i=7;

if (i<NB) printf(“ inférieur”);

else printf(“ supérieur ”);

Mme Wiem Yaiche Elleuch

chapitre 1

Page 8

}

=> Ce programme affiche supérieur

Il est possible d’initialiser une variable lors de sa déclaration: int n=15;

(cid:131)

(cid:131) Cette valeur initiale évolue lors de l’exécution du programme (pgm)

(cid:131)

Il est possible de déclarer que la valeur d’une variable ne doit pas changer lors de

l’exécution du pgm

(cid:131) const int n=20;

(cid:131) Les éventuelles instructions modifiant la valeur de n seront rejetées par le compilateur

#include<stdio.h>

void main()

{

const int i=5;

printf (“%d “,i);

i=i+1; // erreur, i est déclaré const, il ne faut pas essayer de modifier sa valeur

printf (“%d “,i);

}

Mme Wiem Yaiche Elleuch

chapitre 1

Page 9