Chap1 Généralités V2

Mme Wiem Yaiche Elleuch chapitre 1 : Généralités Page 1

École Nationale d'Ingénieurs de Carthage A.U. 2015/2016

Cours programmation en langage C

Chapitre 1 : Généralités (21 pages)

1ère

année Ingénieur Informatique

Fondateurs du langage C: Brian W.kernighan et Denis M. Ritchie

La définition de la première version du langage C en 1988, au sein de l’institut

national américain de normalisation (ANSI: American National Standards Institute)

Exemple 1 :

printf(" premiere annee informatique ");

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

nommée printf.

Cette fonction reçoit un argument "premiere annee informatique"

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

Chaque instruction en langage C se termine par un point virgule « ; ».

#include<stdio.h>: permet d'utiliser toute une famille de fonctions précompilées (ex: printf )

void main(): c'est la fonction principale. elle doit être présente dans tout programme.

Exemple 2 :

\n : permet un retour à la ligne


Exemple 3 :

Dans cet exemple, il y a une réservation d’un espace mémoire pour la variable x, à une

adresse mémoire quelconque (2 octets)

printf( "la valeur de x est %d", x) ;

Ici, printf reçoit deux arguments : "la valeur de x est %d" et x.

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

« code de format ».

%d est remplacé par la valeur de x.

Il faut toujours veiller à accorder le code de format au type de la valeur

correspondante (%d pour int; %f pour float etc).

Exemple 4 :

Type entier : int ; %d

Type réel : float ; %f

Exemple 5 :


%p permet d’afficher une adresse mémoire

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

En C, il existe plusieurs types

En C, les déclarations des types de variables sont obligatoires et doivent être

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

Exemple 6 :

int x: // réservation de l’espace mémoire pour une variable x // sans initialisation

Pour lire des informations: la fonction scanf

scanf (« %d », &x);

C’est un appel de la fonction prédéfinie scanf dont le rôle est de lire des informations au

clavier.

Comme printf, la fonction scanf possède en premier argument un format exprimé sous

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

L’argument précise dans quelle variable on souhaite placer la valeur lue

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

signifiant « adresse de »)

Exemple 7 :

int x ; // réservation de l’espace mémoire pour une variable x de type entier, sans initialisation


float y ; //réservation de l’espace mémoire pour une variable y de type réel, sans initialisation

Exemple

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

2ème

version: sans utiliser les variables som et moy

Structure d’un programme (pgm) en C

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

principal (main)

Le pgm principal est délimité par des accolades

Les instructions situées entre accolades forment un « bloc ».

La fonction main est constituée d’un en tête et d’un bloc.

Il ira de même pour toute fonction C

Un bloc peut lui-même contenir d’autres blocs

Quelques règles d’écriture : Les identificateurs

Les identificateurs servent à désigner les différents « objets » manipulés par le programme

(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.


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

identificateur (lg_ligne; _total; _89)

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

Ligne).

Longueur des identificateurs: les 31 premiers caractères sont significatifs

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

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.

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

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

Le langage C autorise une mise en page parfaitement libre

une même ligne peut comporter plusieurs instructions: int x; float y;

Quelques règles d’écriture : les commentaires

Le langage C autorise la présence de commentaires dans les programmes

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

Les directives à destination du préprocesseur

#define NB 5 est une directive qui sera prise en compte avant la traduction

(compilation du programme).

Les directives (#include<stdio.h> #include<conio.h> #define NB 5) doivent être

écrites à raison d’une par ligne et elles doivent obligatoirement commencer en début

de ligne.

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

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


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 les

fonctions printf et scanf.

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

Un même fichier en-tête contient des déclarations relatives à plusieurs fonctions

En général, il est indispensable d’incorporer stdio.h

#define NB 5 demande de remplacer systématiquement, dans toute la suite du

programme, le symbole NB par 5.

#define sert à définir la valeur d’un symbole

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

Suit les étapes suivantes :

Édition du programme

Compilation

Édition de liens

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

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

programme source

Ce texte sera conservé dans un fichier=> fichier source

Chaque système possède ses propres conventions de dénomination des fichiers

Un fichier: nom+extension

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

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

machine en faisant appel à un programme nommé compilateur

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

Le résultat de la compilation porte le nom de module objet

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

Le module objet créé par le compilateur n’est pas directement exécutable

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

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

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

modules objets nécessaires

Le résultat de l’édition de liens est un programme exécutable, càd un ensemble

autonome d’instructions en langage machine


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

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

Les directives sont écrites sur des lignes distinctes du reste du programme, elles sont

introduites par #: #include, #define

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

La mémoire centrale est un ensemble de positions binaires nommées bits.

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

nomme son adresse

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

binaire.

Une séquence binaire peut représenter un nombre entier, nombre réel, caractère,

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.

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:

Nombres entiers (int, short , long)

Nombres flottants (float, double, long double)

Caractères (char)

Catégorie des entiers :

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

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.

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 127 1

short entier court -32768 32767 2

int entier standard -32768 32767 2

long entier long -2147483648 2147483647 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 0 255 1

unsigned short entier court 0 65535 2

unsigned int entier standard 0 65535 2

unsigned long entier long 0 4294967295 4

Catégorie des flottants

Les types flottants permettent de représenter, de manière approchée, une partie des

nombres réels.

Notation: M.BE Avec M: mantisse ; E: exposant; B:base

Exemple: 1.5 1022

0.472 10-8

1.5 et 0.472: mantisses ; 22 et -8: exposants

Un nombre réel sera représenté en flottant.

Le C prévoit trois types de flottants: float, double et long double

Les constantes flottantes peuvent s’écrire indifféremment suivant l’une des deux

notations:

o Décimale

o Exponentielle

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

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

(puissance de 10), avec ou sans signe

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 6 3.4 * 10-38 3.4 * 1038 4

double double 15 1.7 * 10-308 1.7 * 10308 8


long double suppl. 19 3.4 * 10-4932 1.1 * 104932 10

Catégorie des caractères

Un caractère est codé sur un octet en mémoire

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

tabulation (\t), etc

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

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

\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 sonnerie \\ trait oblique

\b curseur arrière \? point d'interrogation

\t tabulation \' apostrophe

\n nouvelle ligne \" guillemets

\r retour au début de ligne \f saut de page (imprimante)

\0 NUL \v tabulateur vertical

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

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

effectue le remplacement correspondant avant la compilation

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

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

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

l’exécution du pgm

const int n=20;

Les éventuelles instructions modifiant la valeur de n seront rejetées par le compilateur


Les opérateurs arithmétiques en C

C dispose d’opérateurs classiques « binaires » (portant sur deux opérandes ): +, -, *, /, et des

opérateurs unaires (portant sur une opérande) : - (opposé), + (identité) (exemple : -a ; +a)

En C, ces opérateurs peuvent porter sur des opérandes de type différent, en appliquant le jeu de

conversion implicite (exemple : pour additionner un entier et un réel, l’entier est converti en réel,

le résultat est un réel).

Il existe un opérateur de modulo noté % qui ne peut porter que sur des entiers et qui fournit le

reste de la division de son premier opérande par son second

Le quotient de deux entiers fournit un entier (5/2) vaut 2 (5.0/2.0) vaut 2.5

+ addition

- soustraction

* multiplication

/ division (entière et rationnelle!)

% modulo (reste d'une division entière)


Les priorités relatives des opérateurs

Lorsque plusieurs opérateurs apparaissent dans une même expression, il est nécessaire de

savoir dans quel ordre ils sont mis en jeu.

Opérateurs unaires + (identité) et –(opposé) sont prioritaires, ensuite *, /, % et enfin

opérateurs binaires: + et –

En cas de priorité identique, les calculs s’effectuent de gauche à droite

Les parenthèses permettent de changer ces règles de priorité.

Les conversions implicites pouvant intervenir dans un calcul d’expression En C, ces opérateurs peuvent porter sur des opérandes de type différent

int n, p;

float x;

n*x+p;

Le compilateur convertit n en float; le résultat final en float

int-> long -> float -> double -> long double

On peut convertir directement un int en double.

On ne peut pas convertir un double en float ou en int

Règles de conversion automatique Conversions automatiques lors d'une opération avec :

deux entiers: D'abord, les types char et short sont convertis en int. Ensuite, l'ordinateur choisit le

plus large des deux types dans l'échelle suivante:

int, unsigned int, long, unsigned long

un entier et un rationnel: Le type entier est converti dans le type du rationnel.

deux rationnels: L'ordinateur choisit le plus large des deux types selon l'échelle suivante: float,

double, long double

affectations et opérateurs d'affectation: Lors d'une affectation, le résultat est toujours converti

dans le type de la destination. Si ce type est plus faible, il peut y avoir une perte de précision.

Exemple 1 :

int x;

float a=12.48;

char b=4;

x=a/b;

B est converti en float (règle 2). Le résultat de la division est du type float (valeur 3.12) et sera

converti en int avant d'être affecté à x (règle 4), ce qui conduit au résultat x=3.

Exemple 2 :

char A=3;

int B=4;

float C=4;

float D,E;

char F;

D = A/C;

E = A/B;

F = A/C;


Pour le calcul de D, A est converti en float (règle 2) et divisé par C. Le résultat (0.75) est affecté à

D qui est aussi du type float. On obtient donc: D=0.75

Pour le calcul de E, A est converti en int (règle 1) et divisé par B. Le résultat de la division (type

int, valeur 0) est converti en float (règle 4). On obtient donc: E=0.000

Pour le calcul de F, A est converti en float (règle 2) et divisé par C. Le résultat (0.75) est retraduit

en char (règle 4). On obtient donc: F=0

Le cas du type char Il existe une conversion systématique de char en int

Une valeur de type caractère peut être considérée:

o Comme le caractère concerné (a, z, \n)

o Comme le code de ce caractère: ex: 1000001 => 65 => caractère A (en ASCII)

/**********************************************/

Tout argument de type char ou short est converti en int. Le code %c s’applique aussi à un int. Il

affichera le caractère ayant le code correspondant


‘0’ => code ASCII 48

‘1’ => code ASCII 49

…

‘9’

‘A’ => code ASCII 65

‘B’ => code ASCII 66

…

‘a’ => code ASCII 97

‘b’ => code ASCII 98

etc

Les opérateurs relationnels

C permet de comparer des expressions à l’aide d’opérateurs classiques de comparaisons ( 2*a >

b+5)

Le résultat de la comparaison est:

o 0 si le résultat de la comparaison est faux

o 1 si le résultat de la comparaison est vrai

Les opérateurs relationnels: <, <=, >, >=, ==, !=

Les quatre premiers sont de même de priorité (<, <=, >, >=). Les deux derniers (==, !=) sont de

même priorité, mais inférieure à celle des précédents

== égal à

!= différent de

<, <=, >, >= plus petit que, ...

Opérateurs de comparaison Une comparaison peut porter sur deux caractères

o c1==c2 est vrai si c1 et c2 contiennent le même caractère

o c1==‘e’ est vrai si c1 contient le caractère ‘e’ (code de c1 est égal au code de ‘e’)

o c1<c2 est vrai si le code de c1 a une valeur inférieure au code de c2 (le résultat de cette

comparaison varie selon le codage employé)


L’ordre alphabétique est respecté pour les minuscules et majuscules ‘a’ < ‘b’

Les chiffres sont classés par ordre naturel ‘2’<‘ 3’

Les opérateurs logiques

Il existe trois opérateurs logiques: et (noté &&), ou (noté ||), non (noté !). Ces opérateurs

produisent un résultat numérique (int)

o (a<b) && (c<d): prend la valeur 1 si les deux expressions sont vraies. 0 sinon

o (a<b) || (c<d): prend la valeur 1 si l’une des expressions est vraie. 0 sinon

o !(a<b): prend la valeur 1 si l’expression est fausse

On rencontre fréquemment if (!n) if (n==0)

! est prioritaire: !a==b => (!a)==b et non !(a==b)

|| est moins prioritaire que &&. Tous deux sont de priorité inférieure aux opérateurs arithmétiques

et relationnels.

a<b && c<d (a<b) && (c<d)

On évalue a<b si le résultat est faux, on arrête

Opérateurs logiques

&& et logique (and)

|| ou logique (or)

! négation logique (not)

L’opérateur d’affectation ordinaire

i=5; => Affectation de la valeur 5 à i

La valeur de i après affectation: 5

c=b+3 ; c=(b+3) ;

La priorité de l’opérateur d’affectation est faible par rapport aux opérateurs arithmétiques et de

comparaison

c+5=x; n’a pas de sens

L’opérateur d’affectation possède une associativité de droite à gauche

i=j=5;

Il est possible de fournir à l’opérateur d’affectation des opérandes de types différents.


Dans ce cas une conversion systématique de la valeur de l’expression (droite) est effectuée dans le

type de la variable (gauche)

Une telle conversion imposée ne respecte plus nécessairement la hiérarchie des types

Opérateurs d’incrémentation et de décrémentation

int i=5; x = i++; passe d'abord la valeur de i à x et incrémente après (x :5 ; i :6)

int i=5; x = i-- ; passe d'abord la valeur de i à x et décrémente après (x :5, i :4)

int i=5; x = ++i ; incrémente d'abord et passe la valeur incrémentée à x (i :6, x :6)

int i=5; x = --i ; décrémente d'abord et passe la valeur décrémentée à x (i :4, x :4)

Remarque :

i=i+1; i++; ++i;

n=n-1; n-- ; --n ;

void main()

{

int n, i=5;

n= ++i -5 ;

printf("i: %d et n: %d",i,n); /* affichage i:6 et n: 1*/

i=5;

n= i++ -5 ;

printf("\n i: %d et n : %d",i,n); /*affichage i:6 et n: 0*/

}

Les opérateurs d’affectation élargie

i++; remplace i=i+1;

i=i+k; remplace i+=k;

a=a*b; remplace a*=b;

+=; -=; *=; /=; %=; ces opérateurs permettent de condenser l’écriture de certaines instructions

Les conversions forcées par une affectation (casting)

Lors d’une affectation, toutes les conversions sont acceptées par le compilateur (pb de perte de

précision)

La conversion d’un int en char sera satisfaisante si la valeur de l’entier correspond à un code d’un

caractère

#include<stdio.h>

void main()

{

int n;

float x=2.3;

n=x+5.3;

printf("%d", n);

}

ce programme affiche 7


Casting

Le programmeur peut forcer la conversion d’une expression quelconque dans un type de son choix

int n=5, p=2; (double) (n/p);

Aura comme valeur celle de n/p convertie en double

#include<stdio.h>

void main()

{

int x=2, y=3;

printf("la somme est %f", float (x+y));

}

#include<stdio.h>

void main()

{

char A=3;

int B=4;

float C;

C = A/B;

printf("%f",C);

}

=> ce programme affiche 0.000000

Les contenus de A et de B restent inchangés; seulement les valeurs utilisées dans les

calculs sont converties

Classes de priorité

Priorité 1 (la plus forte): ()

Priorité 2: ! ++ --

Priorité 3: * / %

Priorité 4: + -

Priorité 5: < <= > >=

Priorité 6: == !=

Priorité 7: &&

Priorité 8: ||

Priorité 9 (la plus faible): = += -= *= /= %=

L’opérateur conditionnel

If (a>b) max=a; else max=b; max= a>b ? a:b;

#include<stdio.h>

void main()

{

char A=3;

int B=4;

float C;

C = (float) A/B;

printf("%f",C);

}

=> ce programme affiche 0.7500000


Quelques fonctions prédéfinies de la bibliothèque math.h

COMMANDE C EXPLICATION

exp(X) fonction exponentielle eX

log(X) logarithme naturel ln(X), X>0

log10(X) logarithme à base 10 log10(X), X>0

pow(X,Y) X exposant Y XY

sqrt(X) racine carrée de X pour X>0

fabs(X) valeur absolue de X |X|

floor(X) arrondir en moins int(X)

ceil(X) arrondir en plus

fmod(X,Y) reste rationnel de X/Y (même signe que X) pour X différent de 0

sin(X) cos(X) tan(X) sinus, cosinus, tangente de X

asin(X) acos(X) atan(X) arcsin(X), arccos(X), arctan(X)

sinh(X) cosh(X) tanh(X) sinus, cosinus, tangente hyperboliques de X

Les entrées sorties

La bibliothèque standard <stdio > contient un ensemble de fonctions qui assurent la

communication de la machine avec le monde extérieur

printf() : écrire (afficher) des informations à l’écran

scanf() : lire (saisir) des informations au clavier

putchar() : écrire un seul caractère

getchar() : lire un seul caractère au clavier

Le tableau ci après, présente les principaux codes de conversion

SYMBOLE TYPE IMPRESSION COMME

%d ou %i int entier relatif

%u int entier naturel (unsigned)

%o int entier exprimé en octal

%x int entier exprimé en hexadécimal

%c int caractère

%f double rationnel en notation décimale

%e double rationnel en notation scientifique

%s char* chaîne de caractères

%ld long

%lu unsigned long

Action sur le gabarit d’affichage :

Par défaut, les entiers sont affichés avec le nombre de caractères nécessaires (sans espaces

avant ou après). Les flottants sont affichés avec six chiffres après le point.


Un nombre placé après % dans le code de format précise un gabarit d’affichage, càd un

nombre de caractères à utiliser. Si le nombre peut s’inscrire avec moins de caractères, printf

le fera précéder d’un nombre suffisants d’espaces ; en revanche, si le nombre ne peut

s’afficher convenablement dans le gabarit imparti, printf utilisera le nombre de caractères

nécessaires.

le signe (-) placé après le symbole % (ex : %-4d), demande de cadrer l’affichage à gauche au

lieu de le cadrer (par défaut) à droite.

Le caractère * figurant à la place d’un gabarit ou d’une précision signifie que la valeur

effective est fournie dans la liste des arguments de printf.


scanf("<format>",<AdrVar1>,<AdrVar2>, ...)

"<format>" : format de lecture des données

<AdrVar1>,... : adresses des variables auxquelles les données seront

attribuées

La fonction scanf reçoit ses données à partir du fichier d'entrée standard stdin (par défaut

le clavier).

La chaîne de format détermine comment les données reçues doivent être interprétées.

Les données reçues correctement sont mémorisées successivement aux adresses indiquées

par <AdrVar1>,... .

L'adresse d'une variable est indiquée par le nom de la variable précédé du signe &.

Pour tous les spécificateurs, nous pouvons indiquer la largeur maximale du champ à

évaluer pour une donnée.

Les chiffres qui passent au-delà du champ défini sont attribués à la prochaine variable qui

sera lue


Lecture d'un caractère: getchar; Écriture d’un caractère: putchar

Exemple:

Ecrire un pgm qui lit un caractere au clavier, et affiche « Caractere majuscule », si le caractère

est majuscule, « Caractere minuscule » si le caractère est minuscule, « AUTRE » sinon.


Documents

Chap1 Généralités V2