Eric Magarotto

Licence EEA IE

Langage C

Support de cours de Langage C

Version provisoire du 27 septembre 2004

EEALICENCE EEA-IE
Responsable pdagogique du cours : Eric Magarotto
CM : E. Magarotto TD TP : E. Pigeon P. Dorleans J.M. Janik - E. Magarotto Dure approximative : 10 h de cours

Pour tout renseignements relatifs au cours :

e-mail : eric.magarotto@greyc.ismra.fr web : www.greyc.ismra.fr/EquipeAuto/EricM/EMWelcome.html tel : 02-31-45-27-09 (LAP-ISMRA)

Informatique Industrielle

Eric Magarotto
I.

Licence EEA IE

Langage C

ELEMENTS DE BASE.................................................................................................2
I.1 - Commentaires.........................................................................................................................2 I.2 - Dclarations & types de variables (C : langage typ).........................................................2 I.3 - Initialisation de variables ......................................................................................................3 I.4 - Assignations ............................................................................................................................4 I.5 - Entres / Sorties Conversationnelles : printf et scanf.........................................................5 I.6 - Oprateurs arithmtiques condenss +=, -=, *=, /=, %= ....................................................6 I.7 - Oprateurs squentiels : ; composition : , ................................................................6 I.8 - Oprateurs relationnels .........................................................................................................6 I.9 - Oprateurs logiques ...............................................................................................................6 I.10 - Oprateurs de traitement du bit (uniquement sur int, long et char) ..............................7 I.11 - Priorit des oprateurs ........................................................................................................7 I.12 - Oprations d'incrmentation et de dcrmentation .........................................................7

II.

STRUCTURES DE CONTROLE (BOUCLES)...........................................................8

II.1 - Condition SI ... ALORS ... SINON ...(IF ELSE) ...........................................................8 II.2 - Slection (SWITCH)...........................................................................................................10 II.3 - Boucle tant que (WHILE)..................................................................................................10 II.4 - Boucle faire .... tant que (DO WHILE).............................................................................11 II.5 - Boucle pour (FOR) .............................................................................................................11 II.6 - Ruptures de squence.........................................................................................................12

III.

LES TABLEAUX ........................................................................................................14

III.1 - Dclaration de tableau (Statique 1D = vecteur) ..........................................................14 III.2 - Accs aux lments du tableau.........................................................................................14 III.3 - Tableaux multidimensionnels (tableaux 2d)...................................................................15 III.4 - Chanes de caractres (string) .........................................................................................15

IV.

LES POINTEURS .......................................................................................................18

IV.1 - Introduction .......................................................................................................................18 IV.2 - Oprations arithmtiques sur les pointeurs....................................................................19 IV.3 - Pointeurs et tableaux.........................................................................................................20 IV.4 - tableau de pointeurs et pointeur de tableau ...................................................................23

V. VI.

ALLOCATION DYNAMIQUE ...................................................................................25 LES FONCTIONS ......................................................................................................27

VI.1 - Introduction .......................................................................................................................27 VI.2 - Passage d'arguments par adresse ....................................................................................29 VI.3 - Evolution de la pile lors de l'appel une fonction .........................................................31 VI.4 - Rsum (types)...................................................................................................................33 VI.5 - Porte, visibilit et classe dallocation.............................................................................33

Informatique Industrielle

ii

Eric Magarotto
VIII.

Licence EEA IE

Langage C

VII. PRE-PROCESSEUR...................................................................................................36 LES STRUCTURES ..............................................................................................38

VIII.1 - Dclaration d'une structure ..........................................................................................38 VIII.2 - Utilisation d'une structure ............................................................................................38 VIII.3 - Utilisation des types synonymes : TYPEDEF..............................................................39 VIII.4 - Imbrication de structures..............................................................................................40 VIII.5 - Transmission d'une structure en argument d'une fonction.......................................42 VIII.6 - Transmission d'une structure en valeur de retour d'une fonction............................43 VIII.7 - Porte dun structure.....................................................................................................44 VIII.8 - Structure et listes chanes ............................................................................................44

IX.

GESTION DE FICHIERS..........................................................................................45

IX.1 - Introduction .......................................................................................................................45 IX.2 - Fichiers niveau haut..........................................................................................................45 IX.3 - Action sur le pointeur de fichier ......................................................................................47

X.

LISTES CHAINEES...................................................................................................48
X.1 - Introduction.........................................................................................................................48 X.2 - Cration d'une liste chane...............................................................................................48 X.3 - Affichage de la liste.............................................................................................................49 X.4 - Recherche d'un lment .....................................................................................................50 X.5 - Rangement par ordre alphabtique ..................................................................................50

XI.

POUR ALLER PLUS LOIN ..................................................................................51

Informatique Industrielle

iii

Eric Magarotto

Licence EEA IE

Langage C

GENERALITES
: prsentation du C cre en 1972, langage de haut niveau compil ( interprt) progs C rutilisables, compilateurs respectent norme ANSI (88-90) : cration d'un programme en C (3 phases) dition d'un fichier source (nom.c) : diteur de texte compilation (nom.obj) : traduction du programme source en langage machine, gnre fichier objet (obj) dition de liens (linkage) : liaison entre obj, bibliothque standard et fonctions. Groupe fichier obj et bin pour cration d'un excutable exe xecutable dpendant du systme dexploitation (recompiler le fichier source si changement dOS) : un programme C se compose d'un ou plusieurs fichiers de la forme < directives prprocesseur > include (prprocesseur : prparation la compilation), < et > (resp. ) indique de rechercher hors (resp. dans) rpertoire actif < dfinition de types > < variables globales > < fonctions > structures des fonctions en norme ANSI : < type > nom_de_fonction (<dclaration des arguments>) { <dclaration locales> <instructions> } programme principal (main) ex : main(){Bloc dinstructions} void main(void) ne renvoie pas de valeur : principales caractristiques - programmation modulaire multi-fichier - jeu d'oprateurs trs riche - faible contrle des types de donnes - uniquement des fonctions

Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

I. On distingue :

ELEMENTS DE BASE

- les variables scalaires (entires, relles et pointeurs) - les variables structures (tableaux, strutures et unions) I.1 - Commentaires /* ceci est un commentaire */ tout commentaire comporte une ouverture et une fermeture I.2 - Dclarations & types de variables (C : langage typ) Toutes les variables doivent tre dclares avant utilisation (2 paramtres) <type> <identificateur> type de base char unsigned char int short long unsigned int unsigned long float double long double signification caractre caractre entier entier court entier long entier non sign entier long non sign rel rel double prcision rel double long taille (octets)
DOS - WINDOWS

valeurs limites
(DOS)

11 11 24 22 44 24 44 48 88 10 - 8

-128 127 0 255 -32768 32768 -32768 32768 2147483648 0 65535 0 4294967295 10-37 10+38 10-307 10+308 10-4932 10+4932

: noms de variables diffrents des mots rservs (instructions): break char case continue default do double else exit extern float for goto if int long register return short sizeof static struct switch typedef union unsigned while const enum void
Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

identificateur : - 32 caractres max lettres ou chiffres mais pas de caractres accentus (codes ASCII tendus) - diffrence entre majuscules et minuscules - noms de variables rservs type de base : - l'excution, une zone mmoire est rserve et contient la variable. La taille de la zone mmoire dpend du type

CHAR dfinit des variables de type caractre et ne stocke qu'un seul caractre chaque fois. Un caractre peut tre une lettre, un chiffre ou tout autre lment du code ASCII et peut tre un caractre non imprimable dit de contrle : 0 < ASCII <31. Un CHAR est cod sur 1 octet et ne peut prendre que des valeurs - positives entre 0 et 255 s'il est non sign - ngatives entre -127 et +127 s'il est sign INT : Selon la valeur que l'on est amen affecter un entier et la prsence ou non du signe, on peut opter pour INT, SHORT, UNSIGNED INT ... FLOAT : Selon la valeur que l'on est amen affecter un nombre virgule flottante simple ou double prcision, on peut opter pour FLOAT, DOUBLE, LONG DOUBLE I.3 - Initialisation de variables une valeur initiale peut tre spcifie ds la dclaration de la variable main() { int i, j=5; /* seul j est initialis */ int k=2*3; int h=0x0A; float x=1.5, y=2.3e-4; /* reprsentation scientifique */ char c='A'; char c='0x41'; long z=123L; }

Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

diffrentes reprsentations pour les variables : les littraux : entiers : codage syntaxe dcimal 123 octal 0777 hexadcimal 0xff ou 0Xff long 65538L non sign 255U Si un nombre est suprieur 65535, le programmeur peut demander que ce nombre soit cod sur un entier LONG par "L" (ex : 65538L). : rels : codage double prcision long double (ANSI) simple prcision (ANSI) syntaxe 3.14159 3.14159L 3.14159F

: caractres : caractres imprimables (chiffres - lettres ...) caractres non imprimables dit de contrle caractres de symbole signification contrle '\n' '\a' '\t' '\b' '\f' '\r' LF BEL HT BS FF CR saut de ligne (Line Feed) bip sonore (Bell) tabulation horizontale (Horizontal Tabulation) suppression arrire (Back Space) saut de page (Form Feed) retour chariot (Carriage Return)

I.4 - Assignations Le signe = dsigne l'opration d'assignation (affectation) Possibilit den enchaner plusieurs : i=j=2; (2 dans j puis dans i) Assignation des constantes : const int n=20; empche toute modification future de la variable n : variables lies un bloc
main() Informatique Industrielle

Eric Magarotto { int i=3; {

Licence EEA IE

Langage C

int i=2; }
}

affichage de i /* i=2 */ affichage de i /* i=3 */

: conversions automatiques lors d'assignations Entre char et int char int : le char se retrouve dans l'octet le - significatif (LSB) de int int char : perte de l'octet le plus significatif (MSB) de l'entier Entre int et long int long : conservation du bit de signe et donc la valeur de l'entier long int : rsultat tronqu, perte des 2 octets les plus significatifs Entre unsigned et long unsigned long: les 2 octets les plus significatifs du long passent 0 Entre int et float int float : 10 10.0 float int : perte partie dcimale : 3.53 (idem en ngatifs : -3.5 -3) Entre float et double float double : aucun problme double float : perte de prcision Exemple : int n, long p, float x ; valuer n*p+x ; Conversion de n en long, puis multiplication par p, rsultat de type long, conversion en float pour tre additionn x rsultat de type float. : conversions forces (oprateur cast)
int n=10, int p=3; (double) (n/p) : calcul de n/p en int conversion en double 10/3=3 (double) n/p: conversion n en double puis conversion (implicite) p en

double puis division en double 10/3=3.33 I.5 - Entres / Sorties Conversationnelles : printf et scanf printf permet de raliser un affichage format donc il faut spcifier - le nom de la variable - le format d'affichage avec caractres de contrle - le texte d'accompagnement syntaxe : printf("const char %format",nom_de_variable); exemple : printf("Leur somme est : %5d\n", somme) ;
5 espaces rservs, justification droite printf("Leur somme est : %.2f\n", somme) ; Informatique Industrielle

Eric Magarotto

Licence EEA IE 2 chiffres aprs le point printf("BONJOUR\n");

Langage C

%d : entier en dcimal %x ou %X : hexadcimal %o : octal %f : float (rel) %e ou %E : rel (scientifique) %u : entier non sign %g (rel selon longueur valeur dcimale) %lf : double %ld : long %Lf : long double %c : caractre %s : chane de caractres %% affiche % Rque : Action sur le gabarit daffichage et sur la prcision : voir TD Rque : la macro putchar(c) joue le mme rle que printf("%c",c). Excution plus rapide car pas d'appel au mcanisme de format.puts(string) scanf est analogue printf sauf lecture puis rangement. Pas de conversion automatique puisque largument transmis scanf est ladresse dun emplacement mmoire (utilsation de &). syntaxe : scanf("const char %format",adresse_variable); exemple : scanf("Leur somme est : %d\n", & somme) ; Rque : Action sur le gabarit max, espace dans le format, caractre invalide et arrt prmatur : voir TD Rque : macro getchar() joue le mme rle que scanf("%c",&), mais plus rapide. kbhit utilis en TD (trs utile pour boucle) I.6 - Oprateurs arithmtiques condenss +=, -=, *=, /=, %= Au lieu d'crire : i = i+20, on peut crire i+=20 de mme : i = i+k, on peut crire i+=k i = 3*i, on peut crire i*=3 I.7 - Oprateurs squentiels : ; composition : , ; plusieurs instructions la suite, terminaison dinstruction exemple : int x = 5 ; x = x + 1; ; instruction vide. Attention boucles ! ! ! , xcution la suite exemple : int x = 18, y; I.8 - Oprateurs relationnels == et != test d'galit et d'ingalit < et > infrieur et suprieur <= et >= (infrieur ou gal ) et (suprieur ou gal ) I.9 - Oprateurs logiques Le langage C dispose de 3 oprateurs logiques classiques && et || : ET et OU logiques (ex (x=1)&&(y=10) vrai et vrai=vrai)
Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

!:

non

I.10 - Oprateurs de traitement du bit (uniquement sur int, long et char) & ET (niveau binaire) (ex (x=1)&(y=10) ) 0001 & 1010=0000) | OU inclusif (niveau binaire) ^ OU exclusif (niveau binaire >> et << dcalages droite/gauche (division/multiplication par 2) ~ complment un I.11 - Priorit des oprateurs OPERATEURS ASSOCIATIVITE ( ) [ ] -> . + - ++ -- ! ~ * & Unaire (cast) sizeof * / % Arithmtique + Dcalage << >> < <= > >= Relationnels = = != Manipulation de bits &, ^, | && Logique || Conditionnel ? : = += -= *= /= %= Affectation &= ^= |= <<= >>= squentiel , Exemples : a+b*c a+(b*c) -a/-b+c ((-a)/(-b))+c a<b==c<d (a<b)==(c<d) I.12 - Oprations d'incrmentation et de dcrmentation i = i+1 peut s'crire i++ (postincrmentation) incrmentation aprs utilisation de la valeur ou ++i (princrmentation) incrmentation avant utilisation de la valeur i = i-1 peur s'crire i-- (postdcrmentation) ou --i (prdcrmentation) CATEGORIE Rfrence

Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

II.

STRUCTURES DE CONTROLE (BOUCLES) CONTROLE

II.1 - Condition SI ... ALORS ... SINON ...(IF ELSE) Instruction: si (expression conditionnelle vraie) alors {BLOC 1 D'INSTRUCTIONS} sinon {BLOC 2 D'INSTRUCTIONS} Organigramme:
oui non

condition vraie

bloc 1 d' instructions

bloc 2 d' instructions

suite du programme

Syntaxe :

if (expression) { ............; /* bloc 1 d'instructions */ ............; } else { ............; /* bloc 2 d'instructions */ ............; }

Dans le cas d'imbrication de plusieurs if, la clause else se rapporte au if le plus proche. Le bloc "sinon" est optionnel: si (expression vraie) alors {BLOC D'INSTRUCTIONS}

Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

oui

condition vraie

non

bloc d' instructions

suite du programme

Rque: les {} ne sont pas ncessaires lorsque les blocs ne comportent qu'une seule instruction. : Rappels des oprateurs logiques (pour test de condition) galit: non galit: relation d'ordre: ET LOGIQUE: if (a==b) si a gal b if (a!=b) si a diffrent de b if (a<b) if (a<=b) if (a>b) if (a>=b) if ((expression1) && (expression2)) si l'expression1 ET l'expression2 sont vraies if ((expression1) || (expression2)) si l'expression1 OU l'expression2 est vraie if (!(expression1)) si l'expression1 est fausse

OU LOGIQUE NON LOGIQUE

Toutes les combinaisons sont possibles entre ces tests. : incrmentations et dcrmentations dans une condition if (--i==5) /* i est d'abord dcrment et le test i==5 est effectu */ i=4; if (i++==5) printf("EGALITE (%d) ",i); else printf("INEGALITE (%d) ",i); /* le test i==5 est d'abord effectu, i est incrment avant mme d'excuter printf("INEGALITE (%d)",i); */

Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

II.2 - Slection (SWITCH)

mot rserv variable de contrle switch(i) { case 1 : instructions break; break; case 3 : instructions break; default : instructions } fait sortir du switch

branchement si i ni 1 ni 3

branchement si i = 3

C'est une instruction de choix multiples qui permet d'effectuer un aiguillage direct vers les instructions en fonction d'un cas (branchement conditionnel). Si la comparaison entre la variable de contrle (de type int, short, char ou long) et la valeur des constante de chaque cas russit alorslinstruction du case est effectue jusqu la premire instruction darrt rencontre (break). Dfault est une tiquette pour le cas ou aucune valeur nest satisfaisante. II.3 - Boucle tant que (WHILE) Instruction: tant que (expression vraie) faire{BLOC D'INSTRUCTIONS} Organigramme:
oui non

condition vraie

bloc d' instructions

Syntaxe :

while (expression) { ............; /* bloc d'instructions */ } 10

Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

La condition est examine avant. La boucle peut ne jamais tre excute. On peut rencontrer la construction suivante: while (expression); termine par un ; et sans la prsence du bloc d'instructions. Cette construction signifie: tant que l'expression est vraie attendre . II.4 - Boucle faire .... tant que (DO WHILE)
excuter cette instruction (ou ce groupe d'instructions) est excute tant que cette condition reste vrifie ou do instruction; while (condition); do { instruction 1; .... instruction N; } while (condition) ;

La diffrence avec le WHILE rside dans le fait que la boucle DO WHILE est excute au moins une fois. II.5 - Boucle pour (FOR)
for (expr 1; expr 2; expr 3) instructions; ce qu'il faut faire chaque fin de boucle (plusieurs instructions possibles, spares par des virgules) la boucle est effectue tant que cette condition est vrifie (valuation de la condition avant entre dans la boucle)

Instruction : Organigramme:

instructions de dmarrage (plusieurs initialisations possibles, spares par des virgules)

in itialisatio n

co n d itio n d e c o n tin u it v raie oui b lo c d 'in stru ctio n s

non

m o d ificatio n

su ite d u p ro g ram m e

Informatique Industrielle

11

Eric Magarotto

Licence EEA IE

Langage C

II.6 - Ruptures de squence break : - interruption de l'excution d'une boucle FOR, WHILE, DO.. - pour un FOR, la sortie s'effectue sans excuter les instructions de fin de boucle - fait galement sortir d'un SWITCH - ne fait pas sortir d'une structure conditionnelle IF continue : - permet de passer l'itration suivante d'une boucle break et continue ne s'appliquent qu' la boucle concerne exit (n) :sortie d'un programme et retour au systme d'exploitation. La valeur de retour est n. return (n) : sortie d'un sous-programme avec la valeur n goto (n) : branchement en un emplacement quelconque ( proscrire pour une bonne programmation ). Exemple 1 : rsoudre ax2 + bx +c = 0.
#include <stdio.h> #include <conio.h> #include <math.h> /* contient la fonction racine */ void main() { float a,b,c,delta,x1,x2; /* saisie de A,B,C */ printf("\t\t\tRESOLUTION DE L'EQUATION DU SECOND DEGRE\n"); printf("\t\t\t 2\n"); printf("\t\t\t AX +BX+C=0\n\n\n"); printf("SAISIR A B C SEPARES PAR RETURN\n"); printf("A = ");scanf("%f",&a); printf("B = ");scanf("%f",&b); printf("C = ");scanf("%f",&c); /* debut du calcul */ /* cas particuliers */ if((a==0)&&(b==0)&&(c==0))printf("INFINITE DE SOLUTIONS\n"); if((a==0)&&(b==0)&&(c!=0))printf("PAS DE SOLUTIONS\n"); if((a==0)&&(b!=0))printf("UNE SOLUTION: X= %f\n",-c/b); /*cas general */ if(a!=0) Informatique Industrielle

12

Eric Magarotto Licence EEA IE Langage C { delta = b*b-4*a*c; printf("DELTA= %f\n",delta); if(delta<0)printf("DELTA NEGATIF PAS DE SOLUTION\n");cc else { if(delta==0)printf("DELTA NUL, UNE SOLUTION X= %f\n",-b/2/a); else{ x1= (-b+sqrt(delta))/2/a; x2= (-b-sqrt(delta))/2/a; printf("DELTA POSITIF DEUX SOLUTIONS\n"); printf("X1= %f X2= %f\n",x1,x2); } } } /* calculs termines */ printf("\n\nPOUR CONTINUER FRAPPER UNE TOUCHE"); getch(); }

Exemple 2 : Saisir une suite de caractres, compter et afficher le nombre de lettres e et d'espaces. Utiliser les proprits du tampon.
#include <stdio.h> #include <conio.h> void main() { char c,compt_espace= 0,compt_e= 0; printf("ENTRER UNE PHRASE:\n");/* l'utilisateur saisit la totalite de sa phrase */ while((c=getchar())!='\n') { if(c=='e')compt_e++; if(c==' ')compt_espace++; } printf("NOMBRE DE e: %d\n",compt_e); printf("NOMBRE D'ESPACE: %d\n",compt_espace); printf("POUR SORTIR FRAPPER UNE TOUCHE "); getch(); } /* lors du 1er passage, getchar ne prend */ /* en compte que le 1er caractere */ /* les autres sont ranges dans le tampon */ /* et recuperes par getchar lors */ /* des autres passages */

Informatique Industrielle

13

Eric Magarotto

Licence EEA IE

Langage C

III.

LES TABLEAUX

III.1 - Dclaration de tableau (Statique 1D = vecteur) <Type (int,char,etc> <Nom> <[nb lements]> : utiliser un mnmonique pour la taille du tableau #define Nbval 20 /*rservation mmoire pour 20*sizeof(int) = 40 octets */ int tab[Nbval]; float c[Nbval]; /*rservation mmoire pour 20*sizeof(float) = 80 octets */ char str[Nbval]; /*rservation mmoire pour 20*sizeof(char) = 20 octets */ III.2 - Accs aux lments du tableau Accs chaque lment du tableau par l'intermdiaire d'un indice L'indice 0 donne accs au premier lment L'indice Nbval-1 donne accs au dernier lment Il peut tre une valeur, une variable ou une expression arithmtique int i = 4; tab[i] = 2 tab[i*2-1] = 3; : aucun contrle de dpassement de bornes : tab[Nbval] ? : tous les lments doivent tre de mme type : aucune opration possible sur la totalit du tableau tab1=tab2 ne recopie pas le tableau tab2 dans le tableau tab1 tab1==tab2 ne compare pas le tableau tab2 et le tableau tab1 : initialisation des tableaux dclaration tableau = {v1, v2, ....} : liste de valeurs constantes qui initialise le tableau int tab[3] = {0,1,2} /* tableau de 3 entiers */ int tab[] = {0,1,2} int tab[5] = {0,1,2} /* tableau de 5 entiers dont les 3 premiers sont initialiss. Les 2 autres sont initialiss 0 si le tableau est dclar en global.*/

Informatique Industrielle

14

Eric Magarotto

Licence EEA IE

Langage C

: taille du tableau exemple pour obtenir la dimension du tableau en nombre d'lments :

int tab[10] = {1, 2, 3} for (i=0;i<sizeof tab / sizeof(int); i++) printf("%d\n ",tab[i]);

sizeof tab / sizeof tab[0] donne le mme rsultat : adresse d'implantation d'un tableau printf("%p\n",tab); affiche l'adresse d'implantation en mmoire &tab[0] ; donne ladresse de dpart du tableau On peut crire &tab(Nbval) pour des tests de bornes (boucles) mais ne pas accder sa zone mmoire. On peut additionner (ou soustraire un entier) aux adresses : Exemple : &tab[3]+2 quivalent &tab[5]. III.3 - Tableaux multidimensionnels (tableaux 2d) Descriptif : tableau de tableau Matrice Syntaxe : type identificateur [dim1] [dim2] ... [dimn] peu usit car prfrence pour les tableaux de pointeurs Exemple : int tab[2][3] ={{1,2,3},{4,5,6}} ; Le compilateur va rserver 2*3 places mmoire pour ce tableau. Limplantation en mmoire se fait de la manire suivante : t[0][0] t[0][1] t[0][2] t[1][0] t[1][1] t[1][2] Les colonnes sont places les une la suite des autres, ce qui peut permettre didentifier les lments avec un seul indice si lon utilise les adresses. III.4 - Chanes de caractres (string) chane de caractre = tableau de caractres ou d'octets temin par '\0'. La taille d'un tableau de caractre doit tre suffisante pour contenir la sentinelle (le \0). exemple : ch[10] ne peut que contenir au plus que 9 caractres. Saisie complte de la chane : Exemple : char ch[20]= bonjour; (8 caractres plus les autres 0)

Informatique Industrielle

15

Eric Magarotto

Licence EEA IE

Langage C

: comparaison de deux chanes de caractres Les oprateurs = et == ne permettent pas de copier une chane dans une autre ni de comparer le contenu de deux chanes. Il faut imprativement passer par une fonction de traitement de chane de caractres. strcmp(chane1, chane2) retourne 0 si les 2 chanes contiennent les mmes caractres y compris '\0' retourne un entier ngatif si chane1 < chane2 retourne un entier positif si chane1 > chane2 strncmp(chane1, chane2,lgmax) : limitation de la comparaison sur un nombre lgmax de caractres. stricmp(chane1, chane2) : pas de diffrence entre majuscules et minuscules. strncmp(chane1, chane2,lgmax) : idem plus contrle longueur max. : copie de chanes de caractres strcpy (cible, source) copie le contenu d'une chane (source) dans une autre (cible). Le second argument peut tre une variable de type chane de caractres ou une constante de ce type. : dtermination de la taille d'une chane de caractres strlen Cette fonction retourne le nombre de caractres prsents dans une chane sans la sentinelle. : lecture d'une chane de caractres gets(buf) Tous les caractres introduits au clavier sont copis dans buf jusqu'au retour chariot. Le caractre de retour chariot est remplac par la sentinelle. (pfrable scanf("%s",&buf) pour qui lespace est un caractre invalide)
Informatique Industrielle

16

Eric Magarotto

Licence EEA IE

Langage C

: affichage d'une chane de caractres puts(buf) Cette fonction non formate puts ajoute automatiquement le caractre \n de saut de ligne en fin d'affichage. Cest quivalent printf("%s\n",buf). : concatnation de 2 chanes de caractres strcat(destination,source) Cette fonction recopie la seconde chane (source) la suite de la premire (destination) aprs avoir effac le caractre '\0'. Il est donc ncessaire que l'emplacement rserv pour la premire chane soit suffisant pour y recevoir la partie lui concatner. strcat() est intressante pour les noms de fichier avec des extensions diffrentes. Strncat(destination,source,long) permet de contrler la longueur du nombre de caractre de la chane darrive : duplication de 2 chanes de caractres char strdup(source) La duplication cre la chane qui va recevoir la copie et va prvoir la place mmoire ncessaire. : recherche d'une chane strstr(chane1,chane2) Cette fonction entrane la recherche de la chane chane2 dans la chane chane1.

Informatique Industrielle

17

Eric Magarotto

Licence EEA IE

Langage C

I V.

LES POINTEURS

IV.1 - Introduction Pointeur = variable qui contient l'adresse d'un autre objet (variable ou fonction). Il est possible d'accder une variable par : - son nom ou identificateurc - son adresse en utilisant un pointeur Il est conseill mais pas obligatoire de faire commencer chaque identificateur de pointeur par ptr_ pour les distinguer des autres variables. : dclaration d'un pointeur ex 1 : int a; a=98; initialisation de la variable a
Mmoire adresse de la case mmoire valeur de a 98

adresse : &a=0x50 valeur : 98 ex 2 : int a, *ptr_p; a=98; a : variable alloue par le systme dont l'adresse est 0x50 par exemple ptr_p=&a; p : pointeur sur un entier dont l'adresse est 0x20 a dsigne le contenu de a &a dsigne l'adresse de a ptr_p dsigne l'adresse de a *ptr_p dsigne le contenu de a &ptr_p dsigne l'adresse du pointeur ptr_p *a est illgal (a n'est pas un pointeur)
&p 0x20
&a 0x50

Mmoire valeur de p &a (0x50)

&a 0x50

valeur de a 98

: affichage du contenu d'un pointeur affichage en hexadcimal par le format %p ou %x de printf. Exemple :
printf("VOICI p: %d\n",i); printf("VOICI SON ADRESSE EN HEXADECIMAL: %p\n",&ptr_p);

Informatique Industrielle

18

Eric Magarotto

Licence EEA IE

Langage C

: initialisation d'un pointeur la dfinition du pointeur l'excution par une affectation IV.2 - Oprations arithmtiques sur les pointeurs : incrmentation/dcrmentation d'un pointeur ptr_p++ : adresse avant l'incrmentation (valeur actuelle de p) ++ ptr_p : adresse aprs l'incrmentation ptr_p-- : adresse avant la dcrmentation (valeur actuelle de p) -- ptr_p : adresse aprs la dcrmentation L'unit d'incrmentation et de dcrmentation d'un pointeur est toujours la taille de la variable pointe (intrt pour les tableaux). Si ptr_p est un pointeur sur un entier, ptr_p++ entrane l'incrmentation de p de la taille d'un entier soit 4 octets. : comparaison de 2 pointeurs un pointeur est dfini la fois par une adresse mmoire et un type. On ne peut donc comparer que des pointeurs de mme type. : soustraction de 2 pointeurs La diffrence de 2 pointeurs (de mme type) fournit le nombre dlments du type en question situs entre les 2 adresses correspondantes. : pointeur nul Pour certains besoins, il peut tre utile de vouloir comparer un pointeur avec la valeur nulle. On utilisera alors la constante NULL prdfinie dans <stdio.h>. Exemple : int*ptr_n ;if (ptr_n==NULL) : conversion de pointeurs Il nexiste aucune conversion implicite dun type dans un autre pour les pointeurs oprateur cast mais danger ! Attention aux contraintes dalignement : un entier (4 octets) sera toujours plac une adresse paire tandis qun char (1 octet) pourra tre plac nimporte quelle adresse PB la conversion dun char* en int* ! ! !
Informatique Industrielle

19

Eric Magarotto

Licence EEA IE

Langage C

IV.3 - Pointeurs et tableaux Les pointeurs sont particulirement utiliss lors d'accs aux tableaux. adresse d'un tableau = nom du tableau = adresse du 1er lment main() { Mmoire
int tab[10]={1,2,3,4,5}, *p, x; p=&tab[0]; quivaut p=tab : x=*tab; valeur du 1er lment, x=1 x=*(tab+0); quivaut tab[0] cd x=1 x=*(tab+i); quivaut tab[i]

&tab

0x20

valeur de tab[0] 1 tab[1] 2 tab[4] 5

tab+i quivaut &tab[i] } : un tableau peut tre dclar de 2 faons type identificateur [dimension] /* vrai tableau */ type *identificateur /* pointeur seul */

Remarque : seule, la 1re mthode assure l'allocation mmoire du tableau exemple : affichage d'un tableau de rels - indices entiers #define dim 15 main() { int y;double x[dim]={1,2,3,4,5,6,7,8,9,10}; Cls();for (y=0;y<dim;y++) {printf("%lf \n",x[y]); /* ou bien */ printf("%lf \n",*(x+y));} } - indices pointeurs
#define dim 15 main() {double x[dim]={1,2,3,4,5,6,7,8,9,10},*ptr_p=NULL; Cls(); for (ptr_p=x;ptr_p<x+dim;ptr_p++)

printf("%lf \n", *ptr_p); for (ptr_p=x;ptr_p<x+dim;) printf("%lf \n", *ptr_p++); }

Informatique Industrielle

20

Eric Magarotto

Licence EEA IE

Langage C

Step0 : init

Step1 : 4me boucle

Step2 : 12me boucle

Step3 : init version2

Step4 : 7me boucle version2

Informatique Industrielle

21

Eric Magarotto

Licence EEA IE

Langage C

: pointeur, adresse de pointeur et variable pointe p dsigne le contenu du pointeur p &p dsigne l'adresse du pointeur p *p dsigne le contenu de la variable pointe par p : tableau multidimensionnel int tab [dim1],[dim2]; tab : adresse du tableau p tab[i] : adresse de la (i+1)me ligne *(p+i) attention : de (*p)+i qui rajoute i au contenu point par p tab[i][j] : lment i,j *(*(p+i)+j)
double x[dim]={1,2,3,4,5,6,7,8,9,10}; double *ptr_p=NULL; for (ptr_p=x;ptr_p<x+dim;ptr_p++) { printf("%x \t\t %x\n", ptr_p,x);

printf("%x \t\t %x\n", &ptr_p,&x); printf("%lf \t %lf\n", *ptr_p+3,x[3]); }

Informatique Industrielle

22

Eric Magarotto

Licence EEA IE

Langage C

IV.4 - tableau de pointeurs et pointeur de tableau tableau de pointeurs :

IV.4.1

type *nom[taille] : exemple : int tab[3]={1,5}; int *ptr_p[4] = {tab, tab+1, tab+2, tab+3};

size of tab : 12 octets size of tab[0] : 4 octets size of ptr_p : 16 octets size of ptr_p[0] : 4 octets, pointe sur 12 octets (3 lments) size of ptr_p[0][0] : 4 octets

Informatique Industrielle

23

Eric Magarotto

Licence EEA IE

Langage C

IV.4.2

pointeur de tableau :

type (*nom)[taille] : exemple : int tab[1][2]={5,2} ; int (*ptr_p[3]) [4] = {tab, tab+1, tab+2} ;

size of tab : 8 octets size of tab[0] : 8 octets size of tab[0][0] : 4 octets size of ptr_p : 12 octets size of ptr_p[0] : 4 octets, pointe sur 16 octets (4 lments) size of *ptr_p[0]) [0]: 4 octets
Informatique Industrielle

24

Eric Magarotto

Licence EEA IE

Langage C

V.

ALLOCATION DYNAMIQUE

La cration de donnes dynamiques ou leur libration s'effectuent lors de l'excution d'un programme. Intrt : allocation ou libration en fonction des besoins. : allocation d'un lment de taille dfinie Malloc reserve une zone mmoire et renvoie un pointeur de type indfini (pointeur gnrique ou universel void*). Mettre un cast si on veut forcer le type. Retourne pointeur NULL si lallocation na pas eu lieu. Syntaxe : (void*)malloc(size) alloue "size" octets et retourne le pointeur (adresse) du 1er octet allou. : allocation de plusieurs lments conscutifs (void*)calloc (nb, size) ralise l'allocation de "nb" lments de taille "size" Retourne l'adresse du 1er octet allou Initialise la mmoire 0.. Retourne un pointeur NULL si lallocation na pas eu lieu. remarque : p=calloc(152,sizeof(int)) quivaut p=malloc(152*sizeof(int)) : changement de taille d'un tableau allou dynamiquement realloc (pointeur sur le bloc mmoire modifier, size) permet de rallouer de la mmoire en conservant les valeurs initiales. Le nouveau bloc peut tre plus grand ou plus petit (attention la perte de donnes) que loriginal. : libration de l'espace mmoire L'un des intrts essentiels de la gestion dynamique est de pouvoir rcuprer des emplacements dont on n'a plus besoin. free(pointeur sur le 1er emplacement) libre une zone mmoire pralablement allou. Attention : vous devez possder une trace du pointeur ! : copie de blocs de mmoire memcpy(pointeur cible, pointeur source, nb octets) recopie les nb premiers octets de pointeur source sur les nb premiers octets de pointeur cible. Possible uniquement si les deux blocs ne se recoupent pas !
Informatique Industrielle

25

Eric Magarotto

Licence EEA IE

Langage C

Exemple (allocation dynamique)

#include <ansi_c.h> #include <utility.h> #include <stdio.h> #include <stdlib.h> /* Dclaration d'un pointeur d'entier */ int *ptr_p1, *ptr_p2; int taille = 3; main() { Cls(); /* Rservation mmoire pour un entier */ ptr_p1 = (int *) malloc(taille*sizeof(int)); ptr_p2 = (int *) calloc(taille,sizeof(int)); /* Test si l'allocation a eu lieu */ if (ptr_p1==NULL || ptr_p2==NULL) printf("Pas assez de mmoire\n"); else {/* Initialisation de valeur point par ptr_int */ *ptr_p1=6; *(ptr_p1+1)=15; /* *ptr_p2=*ptr_p1; */ memcpy(ptr_p2,ptr_p1,taille*sizeof(int)); /* Affichage de la valeur point par ptr_int */ printf("La valeur point par ptr_p2 est %d\n",*ptr_p2); /* Libration de la zone mmoire point par ptr_int */ free(ptr_p1); free(ptr_p2); } }

Informatique Industrielle

26

Eric Magarotto

Licence EEA IE

Langage C

VI . VI.1 - Introduction

LES FONCTIONS

Les fonctions permettent de dcomposer un programme en entits plus limites et donc d'en simplifier la fois la ralisation et la mise au point. Une fonction peut : - se trouver dans le mme fichier que main() ou dans un autre - tre appele partir de main(), d'une autre fonction ou d'elle mme - admettre ou non des arguments (paramtres dentre) - retourner une valeur ou non (paramtres de sortie) - possder ses propres variables Mais on ne peut pas dfinir une fonction l'intrieur d'une autre fonction (toutes les fonctions sont "au mme niveau"). Chaque fonction doit avoir un prototype et une dclaration Remarque : main() n'est autre qu'une fonction qui joue un rle particulier (riguoureusement : void main(void)). Les variables dclares au dbut de la fonction principale main sont locales main !!! Exemple de programme faisant appel une fonction : int plus2 (int ); /* prototype (prsence du point virgule !)*/ main() /* dbut de la fonction main */ { int i,j; /* variables appartenant uniquement main() */ i=2; j=plus2(i); /* appel de la fonction appele plus2 */ j=plus2(4); /* nouvel appel de la fonction */ } int plus2(int nb) /* dclaration de la fonction et type d'argument */ {return(nb+2);} /* valeur entire retourne */ : prototypes de fonctions Un prototype donne la rgle d'usage de la fonction : nombre et type d'arguments ainsi que le type de la valeur retourne. En norme ANSI, un prototype s'crit : type identificateur (dclaration des paramtres) Un prototype permet au compilateur de vrifier le type et le nombre des arguments de la fonction. Les prototypes sont placs en dbut de programme et la porte du prototype s'tend tout le programme. Informatique Industrielle 27

Eric Magarotto

Licence EEA IE

Langage C

autres exemples de prototypes : - void f(int, float); f admet 2 arguments et ne retourne aucune valeur - float f(int, int); f admet 2 arguments entiers et retourne un rel - char *f(void); f n'admet aucun argument et retourne un pointeur sur un char (l'adresse d'un caractre ou d'une chane de caractres). : appel de fonction - appel de fonction par son identificateur et paramtres effectifs - attention : identificateur = adresse de la fonction : corps de la fonction - variables locales la fonction - instructions de la fonction - return provoque : valuation de lexpression conversion automatique du rsultat de lxpression dans le type de la fonction renvoi du rsultat terminaison de la fonction Remarque : un oubli de return provoque un rsultat indfini. Comment faire si une erreur se produit dans la fonction avant le return ? Remde : utiliser exit (biblio <stdlib>). Elle interrompt lexecution du programme en renvoyant un code derreur lenvironnement : Exemple : Double tangent(double x) {if (cos(x) !=0) return sin(x)/cos(x) else {printf("fonction tangent c : erreur division par 0 ! " \n) exit(-1) ; /* code erreur 1 */}} : dclaration de la fonction. Sa place : La tendance naturelle est de placer sa dclaration lintrieur des dclarations de fonctions lutilisant dclaration locale (porte limite la fonction qui lutilise). La dclaration globale est plus intressante (compilation spare, porte maximale,etc) : lextrieur (mme avant) du main ou des autres fonctions qui lutilise. : les arguments d'une fonction
Informatique Industrielle

28

Eric Magarotto

Licence EEA IE

Langage C

Les arguments (qui sont considrs comme des variables de la fonction), sont automatiquement initialiss aux valeurs passes en argument. Seul, l'ordre des arguments intervient, le nom des arguments ne jouant aucun rle. Les arguments sont toujours transmis par valeur : les valeurs des paramtres ne sont pas modifis par la fonction.Il y a promotion de constante variable lors du passage des paramtres par valeur. Il est en effet possible dappeler une fonction avec des constantes et dutiliser en interne de cette mme fonction des variables. Problme : Comment passer des structures et des tableaux en arguments ? Il est possible de passer un pointeur donc passage par leur adresse !!! VI.2 - Passage d'arguments par adresse Le passage d'arguments par adresse permet une fonction de modifier une ou des variables de la fonction appelante. Ce qui devient possible car nous allons passer en argument non pas la valeur d'une variable mais bien son adresse. Les adresses sont considres comme des pointeurs dans la fonction appele. Exemple : int plus2_val (int ); /* prototype */ int plus2_adr (int * ); /* prototype */ main() { int i=2, j; j = plus2_val(i); /* passage par valeur */ printf ("aprs passage d'arguments par valeur : %d \n", i); j = plus2_adr(&i); /* passage par adresse */ printf ("aprs passage d'arguments par adresse : %d\n", i); } int plus2_val(int nb) /*dclaration, argument : valeur d'un entier */ {return nb=nb+2;} int plus2_adr(int *nb)/*dclaration, argument : adresse d'un int */ {return *nb=(*nb)+2;} Rsultat : - aprs passage d'argument par valeur : i=2, j = 4 - aprs passage d'argument par adresse : i = 4, j = 4 Analyse : - nb de plus2_val n'a aucun rapport avec nb de plus2_adr. plus2_val travaille sur nb qui a t automatiquement initialis au contenu de i lors
Informatique Industrielle

29

Eric Magarotto

Licence EEA IE

Langage C

de l'appel de la fonction. plus2_adr travaille sur la variable i de main() par l'intermdiaire du pointeur. - En argument de plus2_adr, on trouve int *nb ce qui signifie que nb est de type pointeur sur un entier. En d'autres termes, nb est une variable locale plus2_adr contenant l'adresse de i. Une variable qui contient l'adresse d'une variable de type int est un pointeur sur un entier. - Lors de l'appel de la fonction plus2_adr, nb de plus2_adr est automatiquement initialis c'est dire l'adresse de i. nb de plus2_adr pointe sur i de main(). - L'instruction de la fonction est : *nb = *nb + 2 ce qui signifie ajouter 2 l'entier dont l'adresse se trouve en nb et placer le rsultat dans l'entier dont l'adresse se trouve en nb. : passage d'un tableau en argument Puisque l'identificateur d'un tableau correspond l'adresse du 1er lment du tableau, les tableaux sont toujours passs par adresse. La principale raison est qu'un passage d'argument implique une opration de copie sur la pile. Recopier tout un tableau aurait un effet dsastreux sur les performances et provoquerait (peut-tre ?) une saturation de la pile. Exemple : void affiche (int *); void affiche (int []); main() { int tab[10]; affiche (tab); } /* prototype */

/* appel de la fonction */

: passage d'une structure en argument (prochain cours) Il est possible de passer un autre type plus volu (une structure) par valeur mais il est prferable d'effectuer un passage par adresse s'il y a beaucoup de donnes dans la structure. Dans ce cas, seule l'adresse de dbut de la structure est recopie sur la pile. Voir prochain cours sur les structures. : rcursivit

Informatique Industrielle

30

Eric Magarotto

Licence EEA IE

Langage C

Toute fonction peut appeler toute fonction dont elle connat le nom. En particulier, elle peut sappeler elle-mme rcursivit. Exemple : factorielle (voir TD) Attention, la rcursivit est gourmande en temps et mmoire, il ne faut l'utiliser que si l'on ne sait pas facilement faire autrement VI.3 - Evolution de la pile lors de l'appel une fonction La pile est une zone mmoire dans laquelle sont cres les variables locales des fonctions. Ces variables locales apparaissent lors de l'entre dans les fonctions. La dernire variable introduite dans la pile sera la premire sortie. Etudions l'volution de la pile avec l'exemple prcdent : void plus2_val (int nb); void plus2_adr (int *nb );
i 2 2+2=4 nb 150 i 2+2=4 150 nb

pile

pile

Dans le premier cas o l'argument est pass par valeur, nb est place dans la pile avec la valeur de i c'est dire 2. La fonction plus2_val ajoute 2 la valeur qui est dans la pile soit 4. Lorsque l'on sort de la fonction, nb est efface puisque nb est une variable locale. Dans le second cas, l'argument pass est l'adresse de i soit 150. nb contient l'adresse de i. La fonction plus2_adr ajoute 2 la valeur pointe par le pointeur c'est dire le contenu l'adresse 150. i prend la valeur 4 Exemple : Dclaration : int plus(inta, int b){a=a+b; return(a);} Appel : int x=4,y=6,z1,z2; z1=plus(1,23), z2=plus(x,y); Dclaration :int myadd(int a,intb,int *c){*c=a+b; return(*c);} Appel : int x=5,y=7, *z; myadd(x,y,&z); myadd(43,4,&x) : bibliothque de fonctions

Informatique Industrielle

31

Eric Magarotto

Licence EEA IE

Langage C

Pour grer efficacement vos bibliothques de fonctions, il est conseill de maintenir des fichiers pas trop volumineux o les fonctions sont regroupes par thme. Pour construire une bibliothque, vous devrez crer deux fichiers: - Un fichier den-tte (avec lextension .h) qui sera utilis pour stocker les prototypes des fonctions. - Un fichier de dfinition (ayant le mme nom mais utilisant lextension .c ) qui contiendra les dclarations de ces fonctions. Il suffira ensuite de faire un #include du fichier ".h" dans votre programme principal. : utilisation de pointeurs sur des fonctions dclaration : exemple : int (*test)(double, int) (*test) est une fonction qui a 2 arguments et retournant un rsultat entier test est un pointeur sur une fonction Intrt programmer un appel de fonction variable (fonction appele varie au fil de lxecution du programme) Exemple : Soient 2 fonctions diffrentes possdant les prototypes suivants : int fonct1(double, int); int fonct2(double, int); Affectations possibles lors d'un bloc d'instructions test=fonct1; test=fonct2; Appel de la fonction test (*test)(5.35,4); /* va chercher l'adresse contenue dans test */ /*cette adresse est celle de fonct1 (ou bien de fonct2) */ /* test va transmettre les valeurs fonct1 (ou fonct2) */ /* c'est quivalent a xecuter fonct1(5.35,4) (ou fonct2(5.35,4)) */ : fonctions transmises en arguments exemple : fonction qui calcule "tang-1" d'une fonction.
float myarctan(float(*fonct)(float), int v2, float v3, )

(*fonct) est une fonction fonct est un pointeur sur une fonction recevant un argument de type float et fournissant un rsultat de type float. l'intrieur de myarctan, on pourra appeler cette fonction dont on aura reu l'adresse ainsi : (*fonct)(x) attention : fonct(x) dsigne un pointeur contenant l'adresse de la fonction et non pas directement l'adresse de la fonction !!!
Informatique Industrielle

32

Eric Magarotto

Licence EEA IE

Langage C

VI.4 - Rsum (types) exemple avec le type int int int int int int int int int int int pointeur sur int fonction nom retournant un rsultat int tableau de n lments int fonction nom retournant un pointeur sur un int pointeur sur des fonctions retournant un int tableau nom de n pointeurs sur int pointeur sur un tableau de n lments de type int tableau de n pointeurs sur des f retournant un int tableau de n pointeurs sur des f retournant un pointeur int *(*nom[ n ]) ( ) sur un int VI.5 - Porte, visibilit et classe dallocation : Porte des variables Variables locales : les variables dclares lintrieur dun bloc dinstructions (entre {}) sont uniquement visibles lintrieur de ce bloc (variables locales ce bloc). Elles sont cres lors de l'entre dans la fonction puis dtruites lors de la sortie de la fonction (sur instruction return ou aprs excution de la dernire instruction). Elles ne sont pas initialises (sauf si on le fait dans le programme) et elles perdent leur valeur chaque appel la fonction. On peut allonger la dure de vie d'une variable locale en la dclarant static. Lors d'un nouvel appel la fonction, la variable garde la valeur obtenue la fin de l'excution prcdente. Une variable static est initialise 0 lors du premier appel la fonction : Exemple: int i; devient static int i ; Variables globales : les variables dclares au dbut du fichier, lextrieur de toutes les fonctions sont disponibles toutes les fonctions du programme. Ce sont les variables globales. En gnral, dclares immdiatemment aprs les #include et initialises 0 au dbut de l'excution du programme, sauf si on les initialise une autre valeur : Classe dallocation
Informatique Industrielle

Dclaration nom *nom nom( ) nom[ n ] *nom( ) (*nom) ( ) *nom[ n ] (*nom) [ n ] (*nom[ n ]) ( )

Description du type de nom

33

Eric Magarotto

Licence EEA IE

Langage C

La classe dallocation dune donne indique comment celle-ci est range en mmoire. En C, le programmeur peut spcifier au compilateur de quelle manire il souhaite voir manipuler une donne. On dispose alors de plusieurs spcificateurs : static : Allocation mmoire (adresse) fixe pendant toute lexcution du programme. On peut initialiser une variable statique (par dfaut, elle est initialise 0). Les donnes globales sont forcment statiques (elles existent au dmarrage). Dclarer une variable locale comme statique permet de retrouver sa valeur antrieure. Si une variable globale apparat dans un autre fichier source, elle sera accepte l'dition de liens (pas d'interfrence avec la variable de mme nom du premier fichier source). Trs utile pour dvelopper un ensemble de fonctions gnrales qui doivent partager des variables globales! auto : Variable dynamique, cre lors de sa dclaration et dtruite la sortie de sa zone de porte. Les variables locales sont auto par dfaut. On utilise donc trs peu ce spcificateur const : la donne est constante. Elle ne peut pas tre modifie. Elle peut tre initialise lors de sa dclaration. register : Sapplique uniquement aux variables dynamiques.Demande au compilateur doptimiser le traitement sur une variable en utilisant (ventuellement) un registre du processeur.On ne peutplus accder son adresse (par &). volatile : Le contenu de la variable est susceptible dtre modifi tout seul, indpendamment du programme (interruption, priphrique en entre). Le compilateur devra valuer sa valeur chaque accs. extern : aucune rservation mmoire, mais on prcise seulement que la variable globale est dfinie ailleurs et on en prcise le type. Supposons que nous avons 2 fichiers sources. Dans le premier est dclar la variable int x et dans le second extern int x. Aprs compilation, cration de 2 modules objets. L'diteur de liens a pour but de rassembler les modules objet. Il va faire correspondre au symbole x du second fichier source l'adresse effective de la variable x dfinie dans le premier fichier source. Aprs compilation du fichier source , on trouve une indication qui associe le symbole x et son adresse dans le module objet correspondant. Contrairement aux variables locales (pour lesquelles il ne reste aucune trace du nom aprs compilation), le nom des variables globales extern continue exister au niveau des modules objet (mcanisme identique celui des fonctions pour lesquelles leur nom subsiste afin que l'diteur de liens puisse retrouver les modules objet correspondants).
Informatique Industrielle

34

Eric Magarotto

Licence EEA IE

Langage C

RAM

CPU registre registre variables static extern registre registre variables register

DATA SEGMENT (segment de donnes)

CODE SEGMENT (segment de code) STACK (pile, tas)

codes sources variables auto

: Rsum porte & allocation variables globales (avant le main, dans un fichier) : classe validit allocation localisation dure de vie initialisation extern (dfaut) fichier la dclaration segment data tche autorise static fichier la dclaration segment data tche autorise extern (importe) fichier non importe importe interdite

variables locales ( un bloc ou dans une fonction) : extern (importe) validit bloc / fonction bloc / fonction bloc / fonction bloc / fonction la allocation lentre lentre non dclaration localisation pile segment data pile importe dure de vie bloc / fonction tche bloc / fonction importe initialisation autorise autorise autorise interdite classe auto (dfaut) static register

Informatique Industrielle

35

Eric Magarotto

Licence EEA IE

Langage C

PREVII. PRE-PROCESSEUR
Le prprocesseur : traite le fichier source avant le compilateur. ne manipule que des chanes de caractres. retire les parties commentaires (entre /* et */). prend en compte les lignes commenant par un # pour crer le code que le compilateur analysera. Ses possibilits sont de 4 ordres : inclusion de fichier : #include nom de fichier. Par convention, les fichiers inclure ont des noms termins par .h (header). Il existe 3 faons de nommer un fichier inclure. Ces faons dterminent l'endroit o le prprocesseur va chercher le fichier. - par son chemin absolu : #include "/users/chris/essai/header.h" - partir du rpertoire courant si le nom de fichier est entour par des guillemets : #include "header.h" - partir d'un rpertoire prdfini correspondant l'installation du compilateur, si le nom de fichier est entour par un infrieur et un suprieur. #include < stdio:h >. Il est possible de demander au prprocesseur d'ajouter d'autres rpertoires sa recherche en utilisant une option de compilation l'appel de l'enchaneur de passes (UNIX). dfinition de variables de prprocessing : - #define NOM valeur - #undef NOM dfinition de macrofonction ou macro-expression : #define m(x) (128*(x)+342*(x)*(x)) - Une macro est une dfinition de symbole avec paramtres et ressemble une fonction : #define max(x,y) (x<y ? y : x) /* maximum de x et y */ #define min(x,y) (x>y ? y : x) /* minimum de x et y */ #define carre(x) x*x /* carr de x */ - Une fois dfinie, une macro est appele comme une fonction, en mentionnant son nom et la liste des paramtres effectifs. Cependant, leffet nest pas le mme : un appel de macro est remplac par le texte de sa dfinition o chaque paramtre formel est remplac par le paramtre effectif correspondant.
Informatique Industrielle

36

Eric Magarotto

Licence EEA IE

Langage C

Appel de macro ------------------carre(z) max(t,12) max(8.65,y+9.1) min(carre(a),carre(b))

Texte gnr par le prprocesseur --------------------------------z*z (t<12 ? 12 : t) (8.65<y+9.1 ? y+9.1 : 8.65) (a*a>b*b ? b*b : a*a)

- On insiste sur la spcificit du pr-traitement des programmes C : il nest ralis aucune interprtation du texte (programme source), mais seulement du remplacement/recopie/concatnation. En particulier, il y a 2 diffrences importantes entre fonction et macro : une macro vite le cot de lappel de fonction lexcution ; une macro est polymorphe, cest--dire quelle fonctionne pour tout type de donnes. Dans lexemple prcdent, les macros min et max sont adaptes pour tous les types de nombres du C. slection du code en fonction des variables du prprocesseur : - #if - #ifdef - #ifndef - #else - #endif La slection de code permet de gnrer partir d'un mme fichier source des fichiers excutables pour des machines et des systmes diffrents. Le principe de base consiste passer ou supprimer des parties de code suivant des conditions fixes partir des variables de prcompilation. Ceci permet d'avoir un mme fichier source destin tre compil sur plusieurs machines, ou plusieurs systmes, en tenant compte des diffrences entre ces machines. La slection est aussi utilise pour avoir un source avec des instructions qui donnent des informations sur les variables (traces), et pouvoir gnrer le fichier excutable avec ou sans ces traces.

Informatique Industrielle

37

Eric Magarotto

Licence EEA IE

Langage C

VI I I .

LES STRUCTURES

VIII.1 - Dclaration d'une structure Une structure est un ensemble d'lments de types diffrents runis sous un mme nom. La syntaxe est : struct caract { int numero; /* membre */ int qte; float prix; }; struct caract art1,art2 ; Ceci dfinit un modle de structure dont le nom est caract et prcise le nom et le type de chacun des membres (ou champs) constituant la structure (numero, qte et prix). art1 et art2 sont des variables structures de type caract. Ecriture compacte : (attention dfinir toutes les variables dun coup) struct caract { int numero; int qte; float prix; } art1,art2; VIII.2 - Utilisation d'une structure Utilisation d'une structure de 2 manires diffrentes : en travaillant individuellement sur chacun des champs en travaillant de manire globale sur l'ensemble de la structure : utilisation des champs d'une structure Chaque champ d'une structure peut tre manipul comme n'importe quelle variable du type correspondant. On peut avoir accs un membre d'une structure par : nom_variable_structure.nom_membre Exemples : art1.numero = 15; affecte la valeur 15 au champ numero de la srtucture art1 printf("%d",art1.prix); scanf("%d",&art2.prix); lit une valeur affecte au champ prix de struct art2 art1.numero++ incrmente de 1 la valeur du champ numero de art1
Informatique Industrielle

38

Eric Magarotto

Licence EEA IE

Langage C

: utilisation globale d'une structure Affectation dune structure une autre structure dfinie avec le mme modle.Par exemple, si les structures art1 et art2 ont t dclares suivant le modle caract dfini prcdemment, on peut crire : art1=art2. (rflchir sur la possibilit daffecter un tableau un autre tableau si ils sont contenus dans une structure !!!) Oprateur & (adresse) : initialisations d'une structure On retrouve pour les structures les rgles d'initialisation qui sont en vigueur pour tous les types de variables, savoir : en l'absence d'initialisation explicite, les strutures "statique" sont par dfaut initialises zro, les automatiques sont indfinies. initialisation possible lors de sa dclaration mais on ne peut utiliser que des constantes ou des expressions constantes struct caract art1 = {100, 285, 2000}; Attention : pour afficher une variable struct, il faut afficher chacun des champs simples, un la fois. La taille dune variable struct nest pas forcment gale la somme des tailles de ses champs (raligenement de la mmoire : espaces vide entre les champs de types, donc de longueur, diffrents. Eviter memcmp pour comparer 2 struct : comparaison champ par champ VIII.3 - Utilisation des types synonymes : TYPEDEF Pour simplifier la dclaration de types, on peut utiliser la dclaration typedef. Elle s'applique tous les types et pas seulement aux structures. Exemples d'utilisation : typedef int toto; toto n,p; /* quivalent int n,p*/ typedef int * ptr; /* signifie ptr est synonyme de int* */ ptr p1,p2; /* quivalent int *p1, *p2 */ typedef int vecteur[3]; vecteur v, w; /* quivalent int v[3], w[3] */ Exemples d'utilisation et des structures :
Informatique Industrielle

39

Eric Magarotto

Licence EEA IE

Langage C

struct caract { int numero; int qte; float prix; }; typedef struct caract titi titi art1,art2; quivalent : typedef struct caract { int numero; int qte; float prix; } titi ; titi art1,art2; VIII.4 - Imbrication de structures Chaque champ d'une structure peut tre d'un type absolument quelconque : pointeur, structure, tableau .... : structure comportant des tableaux Soit la dclaration suivante : struct personne { char nom[30]; char prenom[20]; float heures [31]; } employe1, employe2; Celle-ci rserve les emplacements pour 2 structures nommes employe1 et employe2 qui comportent 3 champs : - nom qui est un tableau de 30 caractres - prenom qui est un tableau de 20 caractres - heures qui est un tableau de 31 rels La notation employe1.heures[4] dsigne le 5ime lment du tableau heures de la structure employe1. De mme, employe2.nom[0] reprsente le 1er caractre du champ nom de la structure employe2. &employe2.heures[4] dsigne ladresse du 5ime lment du tableau heures de la structure employe2. employe2.nom dsigne le champ nom de la structure employe2, cest dire ladresse du tableau nom.
Informatique Industrielle

40

Eric Magarotto

Licence EEA IE

Langage C

Exemple dinitialisation : Struct personne employe1 = {"dupont","jean",{8,7,8,6,0,0,1}}; : tableaux de structures Soit la dclaration suivante : struct point { char nom; int x; int y; }; struct point courbe [50]; point est un nom de modle de struture et courbe reprsente un objet de type "tableau de 50 lments du type point". La structure point pourrait servir par exemple reprsenter un point d'un plan, point qui serait dfini par son nom (caractre) et ses coordonnes. Elle pourrait servir reprsenter un ensemble de 50 points du type ainsi dfini. Soit i un entier. La notation courbe[i].x dsigne la valeur du champ x de l'lment de rang i du tableau courbe. courbe[i].nom reprsente le nom (du type char) du point de rang i du tableau courbe Exemple d'initialisation de la variable courbe : struct point courbe[50] = { {'A', 10, 25}, {'M', 12, 28} } : structure comportant dautres structures Reprenons lexemple du modle de structure personne. struct personne { char nom[30]; char prenom[20]; float heures [31]; } employe1, employe2 ; Cette structure doit servir la gestion du personnel dune entreprise. On doit alors ltendre en prcisant les dates dembauche et dentre dans le dernier poste occup. Ces dates peuvent alors tre reprsentes par des structures comportant 3 champs (jour, mois, anne) : struct date { int jour ; int mois ; int annee; }; 41

Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

struct personne { char nom[30]; char prenom[20]; float heures [31]; struct date date_embauche; struct date date_poste; } employe1, employe2; VIII.5 - Transmission d'une structure en argument d'une fonction : transmission de la valeur d'une structure #include <stdio.h> struct caract { int a; float b; }; void fct (struct caract y); main() {struct caract x; x.a=1; x.b=12.5; printf("\n avant appel fct : %d %e", x.a, x.b); fct(x); printf("\n au retour dans main : %d %e", x.a, x.b); } void fct (struct caract &tata) { s.a=0; s.b=1; printf("\n dans fct : %d %e", s.a, s.b); } avant appel fct : 1 1.2500e+01 dans fct : 0 1.0000e+00 au retour dans main : 1 1.2500e+01 Les valeurs de la structure x sont recopies localement dans la fonction fct. : transmission de l'adresse d'une structure : oprateur -> On modifie le programme prcdent pour que la fonction fct reoive l'adresse d'une structure et non plus sa valeur d'o la dclaration fct(&x). Cela signifie que son en-tte sera de la forme void fct (struct caract * tata).
Informatique Industrielle

42

Eric Magarotto

Licence EEA IE

Langage C

Le problme se pose alors d'accder chacun des champs de la structure d'adresse tata (le point "." suppose un nom de structure pour premier oprande et pas une adresse). On fait alors appel un nouvel oprateur "->" lequel permet d'accder aux diffrents champs d'une structure partir de son adresse de dbut (en toute rigueur, on pourrait aussi y accder par (*tata).a et (*tata).b). Voyons sur un exemple lutilisation de ce nouvel oprateur : #include <stdio.h> struct caract { int a; float b; }; void fct (struct caract *); main() {struct caract x; x.a=1; x.b=12.5; printf("\n avant appel fct : %d %e", x.a, x.b); fct(&x); printf("\n au retour dans main : %d %e", x.a, x.b); } void fct (struct caract s) { tata->a=0; tata->b=1; printf("\n dans fct : %d %e", tata->a, tata->b); } avant appel fct : 1 dans fct : 0 au retour dans main : 0 1.2500e+01 1.0000e+00 1.0000e+00

VIII.6 - Transmission d'une structure en valeur de retour d'une fonction struct caract fct () {struct caract employez; return employez; } La fonction renvoie la valeur de employez, mais employez est de type structure locale la fonction fct.. employez nest pas obligatoirement cre lintrieur de la fonction. Elle aurait pu tre reue en argument.
Informatique Industrielle

43

Eric Magarotto

Licence EEA IE

Langage C

VIII.7 - Porte dun structure La porte dune structure peut tre locale ( une fonction) ou globale (accessible par toutes les fonctions dun mme fichier source) selon lendroit de sa dclaration. Elle ne peut pas en revanche tre dclare extern (accessible par dautre fichier .c). La dclaration extern sapplique des noms susceptibles dtre remplacs par une adresse au niveau de ldition de liens. Un modle de structure na de sens quau moment de la compilation du fichier source o il se trouve. On peut toutefois placer les dclaration de modles dans un fichier que lon incorpore par des #include. Rappel de lordre de fonctionnement : prprocesseur (macros : directives#, C pur ) compilation (obj, langage machine) dition de liens(exe, fonctions standards) VIII.8 - Structure et listes chanes Voir prochain cours sur les listes chanes remarque : Matlab 6.0 (et au del) utilise les structures et listes chanes pour la reprsentation de ses objets systmes !!!.

Informatique Industrielle

44

Eric Magarotto

Licence EEA IE

Langage C

I X.

GESTION DE FICHIERS

IX.1 - Introduction L'accs des fichiers, pour lire ou modifier des fiches, peut se faire grce des fonctions standard que l'on rencontre avec tous les compilateurs. Ces fonctions se situent diffrents niveaux : - au niveau bas, les fonctions d'accs sont directement calques sur les possibilits du systme d'exploitation - au niveau haut o la notion de mmoire tampon est introduite IX.2 - Fichiers niveau haut Au niveau haut, les caractres ne sont pas transmis directement dans le fichier, ils sont stocks temporairement dans un tampon et ce n'est que lorsqu'il est rempli que la transmission a lieu. : dclaration de fichier Au niveau haut, les fichiers sont dsigns par un pointeur sur une structure baptise FILE (majuscule obligatoire) dfinie dans le fichier stdio.h. Dans cette structure FILE, on trouve des informations telles que l'adresse du tampon, la position actuelle dans le tampon, le nombre de caractres qui y ont dj t crits ou qui restent lire. La dclaration s'effectue par : FILE *fp, fp est l'identificateur du pointeur (pointeur sur une objet (structure) de type FILE. Rservation mmoire uniquement pour un pointeur. : ouverture de fichier La fonction fopen ouvre un fichier spcifi par un nom soit en lecture, soit en criture et de n'importe quel type. La structure de cette fonction s'crit : FILE *fopen(char *fp,char *mode) Le paramtre *fp est le pointeur sur la chane de caractres qui contient le nom du fichier (il est possible de spcifier un chemin d'accs). Fournit en retour un "flux" (pointeur sur sune structure de type prdfini FILE) ou un pointeur NULL si l'ouverture a choue (problme d'existence ou bien de droit d'accs : chemin erron, saturation de l'espace mmoire, etc) et un code d'erreur est stock dans la variable entire globale erno Le paramtre *mode pointe sur une chane de caractres qui spcifie comment le programme accdera au fichier. Les principaux modes disponibles sont :

Informatique Industrielle

45

Eric Magarotto

Licence EEA IE

Langage C

mode "r" "w"

"a" "r+" "w+" "a+"

signification ouverture en mode lecture seulement (pas de cration de nouveau fichier)) ouverture en mode criture seulement. Si le fichier existe dj, sa longueur est ramene 0 c'est dire que toutes les donnes prcdentes du fichier sont crases. Par contre s'il n'existe pas, il sera cre ouverture en mode ajout seulement (cration si besoin est). les donnes supplmentaires seront ajoutes la fin du fichier sans craser les donnes prcdentes. ouverture en mode lecture plus criture (pas de cration). autorise effectuer des mises jour dans un fichier existant (lecture, modification, agrandissement) ouverture en mode criture plus lecture (cration si besoin est). si le fichier existe, la fonction le vide ouverture en mode ajout plus lecture (cration si besoin est). les ajouts sont raliss la fin du fichier. Le fichier peut tre lu.

remarque : idem pour les fichiers binaires en ajoutant "b". Il peut contenir des donnes qui sont transfres sans interprtation par les fonctions de la bibliothque. : fermeture de fichier int fclose(FILE *fp) ferme le fichier (de n'importe quel type) pralablement ouvert par fopen (vide le tampon associ au flux concern, dsalloue l'espace mmoire attribu ce tampon et ferme le fichier correspondant). fclose renvoie la valeur 0 si l'opration est un succs et dans le cas contraire renvoie la valeur -1 indiquant que le numro de l'erreur a t stocke dans la variable erno. : destruction de fichier int remove(char *fp) dtruit le fichier et retourne 0 en cas de succs. : renommer un fichier int rename(char *oldname, char *newname) renomme le fichier en "newname" et retourne 0 en cas de succs. : lecture de fichier binaire int fread(void *p, int size, int n, FILE *fp) effectue une opration de lecture de n objets ayant chacun une longueur de size octets sur des fichiers binaires.
Informatique Industrielle

46

Eric Magarotto

Licence EEA IE

Langage C

*p correspond une zone mmoire o l'on veut stocker les donnes. Retourne la valeur correspondant au nombre d'lments lus ou crits en cas de succs et retourne 0 en cas d'erreur, ou si la fin du fichier est atteinte. : criture d'un fichier binaire int fwrite(p, size, n, fp) effectue une opration d'criture de n objets ayant chacun une longueur de size octets dans le fichier fp. Les donnes crire sont prsentes dans une zone mmoire repre par p. Retourne le nombre de blocs crits. : lecture de fichier texte int fscanf(FILE *fp, format, adresse de la variable) lit des caractres depuis le flux spcifi (fp) et les fait correspondre au format voulu. Retourne le nombre de champs d'entre correctement lus, convertis et mmoriss. : criture de fichier texte int fprintf(fp, format, variable) crit nb paramtres selon le format spcifi sur le fichier texte pralablement ouvert par fopen. Cette fonction utilise les mmes spcifications de format que printf. Mais fprintf crit les sorties dans le flux spcifi par le pointeur de fichier. Elle retourne le nombre d'octets crits. Si ce nombre est infrieur nb, il y a erreur. : dtection fin de fichier int feof(FILE *fp) (End Of File en anglais) retourne 0 si la fin de fichier n'a pas t dtecte et une valeur diffrente de 0 si la fin de fichier a t dtecte. IX.3 - Action sur le pointeur de fichier : FSEEK int fseek(FILE *fp, long nbo, int org) place le pointeur du flux indiqu (fp) un endroit dfini comme tant situ nbo octets de "l'origine" spcifie par org. org=SEEK_SET correspond au dbut du fichier, SEEK_CUR la position actuelle du pointeur et SEEK_END la fin du fichier. : FTELL long ftell(FILE *fp) retourne la position courante du pointeur du flux indiqu (exprime en octets par rapport au dbut du fichier. remarque : pour les fichiers textes, FSEEK n'autorise que 0 ou la valeur retourne par FTELL pour l'argument nbo.
Informatique Industrielle

47

Eric Magarotto

Licence EEA IE

Langage C

X. X.1 - Introduction

LISTES CHAINEES

Le concept de liste chane utilise les notions de pointeurs, d'allocation dynamique et de structures !! Au dpart, aucune variable n'est alloue. Ds qu'il est ncessaire d'enregistrer un lment, une allocation de mmoire est faite. Aprs apparition d'un nouveau besoin, une nouvelle demande est faite. toutefois l'adresse sera conserve dans l'lment prcdent (plutt que de conserver cette adresse dans un pointeur particulier). on cre ainsi une "chane". Chaque lment contient un pointeur sur un lment de mme type (rcursivit). Exemple : rpertoire tlphonique struct Repertoire { char nom[MAX]; char numeros[16]; struct Repertoire *suivant; }; Il faut conserver un pointeur struct Repertoire * adresse, celui qui conserve l'adresse du dbut de la liste. Rservation mmoire d'1 pointeur espace pour structure. Parcours squentiel : pour trouver un lment, il faut avoir lu tous les prcdents ! test d'arrt : par convention, le dernier lment de la liste ne pointe aucun lment : il doit contenir NULL. X.2 - Cration d'une liste chane 2 mthodes : nouvel lment ajout la fin de la liste (parcours ordre chronologique) Introduction en tte de liste (+rapide) : lifo les tapes : - dfinir un type pointeur de rpertoire (Adresse) - le programme principal rserve un pointeur (Premier de type Adresse) qui conserve l'adresse de dbut - appel de la fonction de Cration avec le passage du paramtre "l'adresse du pointeur Premier" : la fonction crit l'adresse du dbut de la liste. 48

Informatique Industrielle

Eric Magarotto

Licence EEA IE

Langage C

- la fonction Cration dclare un autre pointeur Nouveau sur un lment de type article (variable temporaire) - initialiser le contenu de *Debut NULL pour viter tout parcours intempestif de la mmoire. - cration de la liste lment par lment dans une boucle for (par exemple). Il y a une rservation pour chaque lment. Les adresses des zones alloues sont stockes successivement dans Nouveau. - remplissage des diffrents champs. - dplacement du pointeur de champs : "Nouveau->Suivant=*Debut" crit dans le champ Suivant de la variable pointe, l'adresse de l'lment "accroch" sa suite. Il s'agit en fait de l'lment rserv et initialis au tour prcdent de la boucle for. - Prciser que le nouvel lment devient nouveau point de dpart de la liste. exemple : cration d'une liste de 6 lments de type rpertoire : void Creation (Adresse * Debut) { int i; Adresse Nouveau; *Debut=NULL; for (i=0;i<6;i++) {Nouveau=(Adresse)malloc(sizeof(*Nouveau)); gets (Nouveau->nom); gets (Nouveau->numeros); Nouveau->suivant=*Debut; *Debut=Nouveau; } } void main(void) { Adresse Premier; Creation(&Premier); } X.3 - Affichage de la liste void Affiche (Adresse Debut) {while(Debut) { printf()"%s -> %s | /n",Debut->nom,Debut->numeros); Debut=Debut->Suivant;}} void main(void) { Adresse Premier; Creation(&Premier); Affiche(Premier);}
Informatique Industrielle

49

Eric Magarotto

Licence EEA IE

Langage C

Affiche possde comme argument d'entre un pointeur sur une variable de type Repertoire. Elle affiche les lments les uns aprs les autres tant qu'elle n'est pas la fin de la liste (fin=valeur du pointeur nulle). L'instruction Debut=Debut->Suivant permet de pointer (donc de passer) l'lment suivant de la liste (on affecte, dans le pointeur Debut la valeur qui est crite dans le champ Suivant de l'objet point actuel). X.4 - Recherche d'un lment exemple : void Detection(Adresse Selection, int Choix, Adresse* Debut) { char Test[MAX]; Adresse Precedent; printf("n donnez le nom a rechercher: "); gets(Test);
while((strcmp(Selection->nom,Test))&&(Selection->Suivant))

{Precedent=Selection; Selection=Selection->Suivant;} } void main(void) { Adresse Premier; Creation(&Premier); . . . . Detection(premier,choix,&Premier); } X.5 - Rangement par ordre alphabtique exemple : Programmer un algorithme de tri sur les lments de la liste

Informatique Industrielle

50

Eric Magarotto

Licence EEA IE

Langage C

XI .

POUR ALLER PLUS LOIN

Manipulations et oprations de bits Ensembles (partie1) - tableaux, listes : runion, intersection, complexit Ensembles (partie2) - piles et files : hachage, tri par distribution Arbres et ensembles ordonns : - reprsentation, dfinition, oprations - insertion, suppression, parcours Graphes : orients, non orients - chemin, chanes, circuits, cycles Tri : relations d'ordre, algorithmes, complexit - selection - par tas (ou tri maximier sur arbre binaire) - bulles - par insertion - shellsort (par insertion spcifique) - par fusion - rapide (quicksort) Calcul numrique et programmation de fonctions mathmatiques Vers la programmation oriente objet

Informatique Industrielle

51