Cours de C GTR 2003/2004 1 COURS DE PROGRAMMATION EN LANGAGE C ALBERT Arnauld

Cours de C GTR 2003/2004 1

COURS DE PROGRAMMATION EN

LANGAGE C

ALBERT Arnauld


Introduction

● Le langage C est un langage interprété créé dans les années 70 par M. Ritchie et B.W. Kernighan

● Dédié au départ à la conception de sytème d'exploitation

● Démarrage de la formalisation en 1983 sous le nom ANSI C par l' « American National Standards Institute »


Mon premier Programme

#include <stdio.h>

int main() {/* premier prog en C */

printf(" bonjour le monde ! \n");

return 0;}

inclusion du fichier d'en-têtede la librairie stdio

inclusion du fichier d'en-têtede la librairie stdio

déclaration de la fonction main

déclaration de la fonction main

commentairecommentaire

appel de la fonction d'affichageappel de la fonction d'affichage

fin du programmefin du programme


Explications

● Les fichiers d'en-tête permettent d'utiliser un ensemble de fonctions prédéfinies et stockées dans des librairies

● la fonction main -> le programme pourra être executé

● les commentaires permettent de documenter votre code source


La compilation

● Le Langage C est un langage interprété, ce qui signifie qu'il doit d'abord être traité avant d'être executé

● Ce traitement comprend une compilation et l'édition des liens

fichiersourcefichiersource éxecutableéxecutable

CompilationCompilation

gcc -o executable fichier.cgcc -o executable fichier.c


Les élements de base

● Les mots-clés

● Les identificateurs

● Les commentaires

● Les types

● Les opérateurs


Les mots-clés

● Les mots clés sont des mots réservés au langage

● il ne peuvent pas être utilisés comme identificateur

auto break case char const

continue def ault do double else

enum extern fl oat f or goto

if int long register return

short signed sizeof static struct

switch typedef union unsigned void

volatile while


Les identificateurs

● servent à donner un nom à une entité du programme.

● formés d'une suite de caractères pouvant être des lettres, des chiffres ou le caractère souligné '_'.

● le premier caractère ne peut pas être un chiffre

● les caractères accentués comme à,é,ç,... sont proscrits

● respectent de la casse Toto, TOTO et toto sont 3 identificateurs différents


Les commentaires

● 2 types de commentaires sont disponibles

– commentaires sur une ligne aprés une instruction

– commentaires sur plusieurs lignes

instruction; // commentaireinstruction; // commentaire

instruction 1;/* commentaire1commentaire 3 */instruction 2;

instruction 1;/* commentaire1commentaire 3 */instruction 2;

ATTENTION!!!une erreur classique consisteà imbriquer les commentaires /* /* commentaire */ plus commentaire */

ATTENTION!!!une erreur classique consisteà imbriquer les commentaires /* /* commentaire */ plus commentaire */


Les types de base en CLes caractères

● le mot clé pour les caractères est char● les caractères sont défini selon un code dit

code ASCII

● il existe une correspondance entre les caractères et les entiers de 0 à 255

– ainsi soit c une variable de type char, c+1 correspond au caractère suivant dans le tableau des ASCII


Les types de base en C (2)les entiers

● le mot clé pour les entiers est int● posséde un attribut de précision : short ou long

● 3 types d'entier : int, short int et long int

– short int ou short : entier sur 2 octets– long int ou long : entier sur 4 octets– int: entier sur 2 ou 4 octets

● posséde un attribut de signature : unsigned

– par défaut, le compilateurs utilise les types signés


Les types de base en C (3)les flottants

● les flottants correspondent aux réels

● trois mots clés suivants la précision:● float (4 octets)

● double (8 octets)

● long double (10 octets)

type min maxfloat 3.4 E-38 3.4E+38double 1.7 E-308 1.7 E+308

long double 3.4 E-4932 1.1 E+4932


Les Variables

● Une variable posséde les attributs suivants:

– un identificateur

– un type

– une valeur

● l'identificateur et le type sont des données fixes

● la valeur peut être modifiée durant l'exécution du programme


Déclaration de variable

● on déclare une variable en donnant son type, son identificateur et eventuellement sa valeur

type identificateur = valeur;type identificateur = valeur;

● 2 types de déclaration:– globale : déclaration au début du fichier, initialisation à 0– locale : aprés l'accolade ouvrante d'une fonction. pas

d'initialisation● 3 attributs pour la déclaration:

– static: limite la visibilité de la variable au fichier courant– extern: déclare dans un fichier une variable définie dans un

autre– register: utilisé pour des variables accéder très fréquement

afin d'en optimiser l'accés.


Déclaration de variable (exemple)

/* exemple de déclaration et d'utilisation de variables */#include <stdio.h>int toto; // déclaration d'une variable globale de type entierextern char c; // variable définie dans un autre fichierint main(){ static float titi = 1.5; // variable locale initialisée à 1.5 register int temp; // variable accédée fréquement printf ( " toto = %i, titi = %f \n", toto, titi); return 0;}

/* exemple de déclaration et d'utilisation de variables */#include <stdio.h>int toto; // déclaration d'une variable globale de type entierextern char c; // variable définie dans un autre fichierint main(){ static float titi = 1.5; // variable locale initialisée à 1.5 register int temp; // variable accédée fréquement printf ( " toto = %i, titi = %f \n", toto, titi); return 0;}


Les constantes (1)

● Les constantes entières● trois notations

– décimale ex :12

– octale ex : 042 ( précéder par 0)

– hexadécimale : 0x1e54 ( précéder par 0x ou 0X)

● suffixes possibles par u ou U pour unsigned et l ou L pour long

● Les constantes entières ( par défaut en précision double)

● suffixes possibles f ou F pour float et l ou L pour long double


Les constantes (2)

● les constantes caractères

– s'écrit encadré par des apostrophes ex : 'c'

– cas particuliers: certain caractère n'ont pas de représentation imprimables. elles sont remplacées par une notation particulière

constante caractère signification\n passage à la ligne\t tabulation horizontale\v tabulation verticale\b backspace\r retour chariot\a bip\' apostrophe '\\ backslash \


constantes (3)

● les constantes nommées:

– déclarée par une commande pré-processeur #define

– déclarée à l'aide de l'enumeration

ex: #define identificateur valeurex: #define identificateur valeur

définition: enum {liste d'identificateur}ex : enum {LUNDI, MARDI, MERCREDI};

donne les valeurs 0,1 et 2 aux différentes constantes ex2: enum {toto=2, tata =10, titi, tutu, tete=20};

donne les valeur 2,10,11,12 et 20 au différentes constantes

définition: enum {liste d'identificateur}ex : enum {LUNDI, MARDI, MERCREDI};

donne les valeurs 0,1 et 2 aux différentes constantes ex2: enum {toto=2, tata =10, titi, tutu, tete=20};

donne les valeur 2,10,11,12 et 20 au différentes constantes


Les opérateurs usuels (1)

● affectation : lvalue = expression;● affecte la valeur de expression à lvalue

● retourne la valeur affecté

● les opérateurs mathématiques : ● +, -, *, /

● l'operateur modulo % : retourne le reste de la division entière

● les opérateurs de comparaisons● >, >=, <, <=, ==, !, !=



● les opérateurs d'opération/affectation● +=, -=, *=, /=, %=, ++, --

– ex i+=1 ; <=> i = i+1;

– i++; <=> i+=1;

● les opérateurs logiques● ! (négation)

● || (ou logique)

● && (et logique)



● Les opérateurs bit à bit

– les opérateurs logiques● & (et), ^ (ou inclusif), | (ou exclusif)

– les opérateurs de décalages● >> (à droite) et << (à gauche)

● l'opérateur conditionnel ? :

expression ? instruction1 : instruction 2;expression ? instruction1 : instruction 2;


Les opérateurs usuels résumé

● ordre de priorité et associativité des opérateurs

● ordre décroissant de priorité

● les fléches indiquent l'associativitéopérateurs associativité description() [] -> . ->

! ~ ++ -- - + & * (cast) <- unaires (* pointeurs)* / % -> multiplicatifs+ - -> addit ion

>> << -> décalages< <= > >= -> relations d'ordre

== != -> égalité& -> binaire^ -> binaire| -> binaire

&& -> logique| | -> logique? : -> condit ionnel (ternaire)


Les instructions

● Une instruction peut être une déclaration de variable, une expression, un appel de fonction

● une instruction est toujours terminée par un point-virgule sauf lorqu'il s'agit d'instruction utilisant des blocs encadrés par des accolades ( comme l'instruction de test if)


L'instruction de test if

● utilisée pour effectuer

– une opération que si le résultat d'un test est vrai

– différentes opérations suivant le résultat d'un test

if ( expression ) {instruction1;}if ( expression ) {instruction1;}

if ( expression ) {instruction1;}

else {instruction2;}

if ( expression ) {instruction1;}

else {instruction2;}

expression est évaluée: si vrai, on exécute instruction1, sinon, on exécute soit instruction2, soit rien


L'instruction itérative FOR

● Permet de répeter n fois un même ensemble d'instruction

for ( expression1; expression2; expression3) {instructions;}for ( expression1; expression2; expression3) {instructions;}

InitialisationInitialisation

condition d'arretcondition d'arret

incrémentationincrémentation

Ex : for (i=0; i<10; i++) {printf (" bonjour à tous \n");}Ex : for (i=0; i<10; i++) {printf (" bonjour à tous \n");}


Les instructions itératives While et do ... while

● boucle répétitive avec condition d'arrét

while ( expression ) {instructions;}while ( expression ) {instructions;}

do {instructions;}while ( expression );do {instructions;}while ( expression );

différence entre while et do while : dans do while, les instructions sont éxécutées au moins une fois


les instructions break , continue et return, exit

● l'instruction break permet de provoquer l'arret de la premiére instruction for, while, do ...while rencontrée

● l'instruction continue permet de passer à la prochaine itération de la première instruction for, while, do .. while rencontrée

● l'instruction return permet de finir l'éxecution d'une fonction et de retourner le résultat d'une expression.

● L'instruction exit permet de finir l'éxecution d'un programme

return expression;return expression;


l'instruction switch

● il s'agit d'un if généralisé

switch (expression){ case expression 1 : liste instructions 1; break; case expression 2 : liste instructions 2; break;

.......

case expression n : liste instructions n; break; default : liste instructions; }

switch (expression){ case expression 1 : liste instructions 1; break; case expression 2 : liste instructions 2; break;

.......

case expression n : liste instructions n; break; default : liste instructions; }

évaluation de expression

comparaison de expression avec expression i

toutes les expressions i doivent avoir une valeur connue à la compilationtoutes les expressions i doivent avoir une valeur connue à la compilation

cas si aucune expression i n'est identique expression


La notion de fonction

● prototype

● définition

type identificateur ( liste de déclaration de paramètres){ liste de déclaration de variables; liste d'instructions; return expression;}

type identificateur ( liste de déclaration de paramètres){ liste de déclaration de variables; liste d'instructions; return expression;}

type de la valeur de retour de la fonction

nom de lafonction

liste de variables dont les valeurs seront initalisée à l'appel de la fonction

sortie de la fonction et renvoi de la valeur d'expression

déclaration des variables locales

type identificateur ( liste de déclaration de type de paramètres);type identificateur ( liste de déclaration de type de paramètres);


les fonctions (2)

● exemple: la fonction somme quadratique

int sum_square (int, int); // prototype de la fonction

int sum_square (int a, int b){ int c; // déclaration des variables locales c=a*a+b*b; // instructions de calcul return c; // retour de l'expression c}

int sum_square (int, int); // prototype de la fonction

int sum_square (int a, int b){ int c; // déclaration des variables locales c=a*a+b*b; // instructions de calcul return c; // retour de l'expression c}


Les fonctions (3)

● une fonction peut être appelé à tout moment dans une autre fonction si elle a été définie avant cette fonction, ou si son prototype a été déclaré avant cette fonction

● conseil: déclarer toutes vos fonctions avant la fonction main de votre programme

● les paramètres passés en arguments de la fonction sont initialisés à l'appel de cette fonction

exemple:int i=10,j=12,s;s=sum_square(i,j)printf ( "somme quadratique %i",s);

exemple:int i=10,j=12,s;s=sum_square(i,j)printf ( "somme quadratique %i",s);

les valeurs des paramètres a et b de la fonctions prennent resp les valeurs de i et j. la valeur de retour de la fonction est affecté à la variable s


fonctions et bibliothéques

● lorsque vous faite appel à la commande pré-processeur #include, vous insérer dans votre fichier source la liste des prototypes des fonctions disponibles dans ces librairies

– ex: #include <math.h> permet d'inclure les prototypes des fonctions mathématique comme

● double cos (double );

● vous avez la possibilité de créer vos propres libraires, ou de stocker vos fonctions dans des fichiers séparés.


Les arguments de la fonction main

● La fonction main, peut avoir des arguments lors de l'éxecution d'un programme en mode commande

int main (int argc, char* argv[])int main (int argc, char* argv[])

● int argc : correspond au nombre d'argument sur la ligne de commande, nom du programme inclus

● char * argv[] : c'est un tableau de chaine de caractères dans lequel on stockes les "argc" arguments

EX: programme totoshell: > toto 2 5 15

-> argc = 4 et argv[0] = toto, argv[1] = 2, argv[2] =5, argv[3] = 15

EX: programme totoshell: > toto 2 5 15

-> argc = 4 et argv[0] = toto, argv[1] = 2, argv[2] =5, argv[3] = 15


les tableaux

• définitions: les tableaux sont des ensembles finis et ordonnés de valeurs de même type

• la représentation en ligne ou en colonne n'as aucune importance en C de même que le choix ligne-colonne dans un tableau à deux dimensions

• déclaration d'un tableau

type identificateur[dimension];type identificateur[dimension];


Les tableaux (2)

● la taille d'un tableau doit toujours être fixée lors de la déclaration du tableau

● On accéde à la valeur de la ième case d'un tableau identificateur[i-1]

● le decompte des indices de case commence à 0

tab[0] est la première case du tableautab[0] est la première case du tableau

Ex: int tab[20]; // déclare un tableau d'entier de 20 cases

Ex: int tab[20]; // déclare un tableau d'entier de 20 cases

tab[10] =15; // affecte la valeur 15 à la 11ème case du tableautab[10] =15; // affecte la valeur 15 à la 11ème case du tableau


Les pointeurs

● pointeur est une variable permettant de stocker l'adresse mémoire d'une autre variable

● déclaration

● type de pointeur générique : void *p;

● pointeur vide : NULL

type *identificateur;type *identificateur;

int *p; // déclare un pointeur sur un entierdouble *d; // pointeur sur un flottant double précisionint *p; // déclare un pointeur sur un entierdouble *d; // pointeur sur un flottant double précision


utilisation des pointeurs

● opérateur adresse de : &

– fournit l'adresse d'une variable

● opérateur d'indirection : *

– permet d'accéder au contenu de la variable dont l'adresse est stockée dans le pointeur.

int i, *p; p=&i;int i, *p; p=&i;

int i, *p; p=&i;*p =2; equivaut à i=2;

int i, *p; p=&i;*p =2; equivaut à i=2;


opération sur les pointeurs

● les opérateurs + et – peuvent servir à faire la somme ou la différence d'un pointeur et d'un entier. cela n'as d'utilité que dans le cas d'un tableau

● les opérateurs ++ et –- permettent de passer d'une case à la suivante ou à la précédente

#define N 10int t[N];int *p,*q, *r, *s;p = &t[0]; // p repére le premier élément du tableauq = p+ (N-1); // q repére le dernier élément du tableaup++; // positionne p à le 2ème case du tableauq--; // positionne q à l'avant dernière case du tableau

#define N 10int t[N];int *p,*q, *r, *s;p = &t[0]; // p repére le premier élément du tableauq = p+ (N-1); // q repére le dernier élément du tableaup++; // positionne p à le 2ème case du tableauq--; // positionne q à l'avant dernière case du tableau


passage de paramètre à une fonction

● les besoins du programmeur sont de 2 types

– soit il désire passer une valeur à la fonction(dans la but de faire un calcul par exemple)

– soit il désire modifier le contenu d'une ou plusieurs variables dans la fonction

Passage par valeurPassage par valeur

Passage par adresse ou par référencePassage par adresse ou par référence


passage de paramètre par valeur

● effectue une affectation des valeurs passées en paramètre dans les variables arguments (internes à la fonction)

fonction int func (int a, int b){ ....}

appelint i,j;func (i,j); // copie le contenu de i et j dans a et b

fonction int func (int a, int b){ ....}

appelint i,j;func (i,j); // copie le contenu de i et j dans a et b

Rem: aucune possibilité de modifier le contenu de i et j dans la fonction


passage par adresse

● effectue une affectation des adresses des variables dans des arguments de type pointeurs, d'ou possibilité d'accéder dans la fonction au contenu des variables externes

fonction int func (int *a, int *b){ ....}

appelint i,j;func (&i,&j); // affecte les adresse de i et j dans les pointeurs a et b

fonction int func (int *a, int *b){ ....}

appelint i,j;func (&i,&j); // affecte les adresse de i et j dans les pointeurs a et b

Rem: la fonction peut accéder et modifier les variables i et j via leur adresse


relations pointeur-tableau

● le nom d'un tableau correspond à un pointeur sur la première case de ce tableau.

● int tab[10] tab == &tab[0];

● l'opérateur d'indexation [] n'effectue qu'une sommation de l'indice i à l'adresse de la première case du tableau

● tab[i] == *(tab +i)

● par contre, on ne peut pas affecter une nouvelle adresse au nom d'un tableau

● tab = p où p est un pointeur n'est pas valide


passage de tableau en paramètre

● soit un passage par pointeur en donnant l'adresse du tableau et sa taille

● prob: on ne fait pas la difference entre le passage d'un tableau et le passage d'un pointeur sur une vairable simple

● soit passage du tableau par son nom

● On indique comme argument le nom du tableau suivi des crochets et la taille de ce tableau

void imp_tab(int *t, int nb_elem)void imp_tab(int *t, int nb_elem)

void imp_tab(int t[], int nb_elem)void imp_tab(int t[], int nb_elem)


tableau et fonctions

● un tableau passé en paramètre d'une fonction peut avoir le contenu de ses cases modifié par la fonction.

– il n'existe pas de passage par valeur pour un tableau.

● pour empecher la modification, on utilise le mot clé const

● const permet de définir comme une constante le paramètre d'une fonction

void imp_tab(const int t[], int nb_elem)void imp_tab(const int t[], int nb_elem)


Les tableaux multi-dimensionnels

● déclaration

● c'est un tableau de tableau– tab2d est un tableau de 10 tableaux de 20 cases

– tab2d correspond au pointeur sur le premier tableau de 20 cases

– tabe2d[i] correspond au pointeur sur le iéme tableau de 20 cases

● accés aux éléments

● passage en paramètre

● toute les dimensions supplémentaires sont spécifiées lors de la déclaration de l'argument

int tab2d[10][20];int tab2d[10][20];

tab2d[i][j] = 5;tab2d[i][j] = 5;

void affiche_tableau (int tab2d[][20], int dim2)void affiche_tableau (int tab2d[][20], int dim2)


entrées/sorties standard (1)printf

● La fonction printf fait partie de la librairie stdio

● elle permet d'afficher de façon formaté du texte ou le contenu de variable à l'écran code:

int i=10; printf ( "bonjour le monde \n %s", i);affichagebonjour le monde10

code:int i=10; printf ( "bonjour le monde \n %s", i);affichagebonjour le monde10

printf (format, param1, param2, param3,...);printf (format, param1, param2, param3,...);

le format correspond à une chaine de caractère où les emplacements des valeurs des paramètres sont remplacés par des séquences spécifiques


les entrées/sorties standard (2)scanf

● la saisie au clavier s'effectue à l'aide de la fonction scanf

● cette fonction fait partie de la librairie stdio

code:float p; scanf (" %f ", &p);code:float p; scanf (" %f ", &p);

scanf ( format, adresse param1, adresse param2, ...);scanf ( format, adresse param1, adresse param2, ...);

le format correspond à la façon dont vont être affecté les caractères tapés au clavier. ces valeurs seront stockées dans les variables dont on fournit l'adresse à la fonction.


Les formats

● il peuvent comporter du texte, des espaces et des caractères d'échappement

● les séquences d'échappement permettent de décrire la manière dont doit être lu ou affiché param1, ... elles sont précédées du signe %

% [flags][largeur].[précision][{h|l|L}] type% [flags][largeur].[précision][{h|l|L}] type

nb de digits affichés nb de chiffre après la virgule

attribut de précision des int et float


les formats (2)

● les types

● les Flags

caractère type sortiec int affichage des caractèresd,i int entier signéu int entier non signéo int octal non signéx, X int hexa non signé (avec ou sans majuscule)e, E double notation scientifi quef double notation décimaleg, G double soit e,E ou f suivant le casn pointeur vers int nombre de caractères tapés (pour scanf )p pointeur affi che l'adresse sous la forme xxxx.yyyy

ou xxxx est le segment et yyyy l'off set

flag signification- alignement à gauche+ prefixe du signe0 ajouter des 0 afin de remplir la largeur choisie# avec o, x, X, aj oute 0,0x, 0X devant chaque valeur non nulle

avec e, E ou f , f orce l'affi chage du point décimalavec g ou G force l'affi chage du point et des 0 à la fin

[] et [̂] délimite l'espace des caractères disponible ou refusé pour une chaine* le champs est lu mais non stocké (pour scanf )


Les structures

● notion de structure:● il est interessant de pouvoir grouper ensembles des

données de type différents

● les tableaux ne repondent pas à ce besoin

solution: les structuressolution: les structures

les structures correpondent à l'enregistrement d'un ensemble d'élements de type différent repéré par un nom. Chaque élément de cet enregistrement correspond à un champ.


Les structures – définitions

– trois méthodes pour déclarer une structure ● 1ére méthode

struct personne{ char nom[20]; char prénom[20];int age;}struct personne p1,p2;

struct personne{ char nom[20]; char prénom[20];int age;}struct personne p1,p2;

2ème méthode struct { char nom[20]; char prénom[20];int age;} p1, p2;

struct { char nom[20]; char prénom[20];int age;} p1, p2;

3ème méthode

struct personne{ char nom[20]; char prénom[20];int age;} p1, p2;

struct personne{ char nom[20]; char prénom[20];int age;} p1, p2;

méthode recommandée

méthode recommandée

ne permet pas de déclarer d'autre variable de même type

!


les structures- utilisation

● initialisation

● accés au membres

● affectation de structures

● tableau de structure

struct personne p ={"Jean", "Dupont", 45}

struct personne p ={"Jean", "Dupont", 45}

p.nom renvoit le champ nom de la structure personne p

p.nom renvoit le champ nom de la structure personne p

struct personne p1,p2; p1=p2;struct personne p1,p2; p1=p2;

struct personne t[100];struct personne t[100];


les structures – fin

● pointeurs vers une structure

● accés au membres d'une structure via un pointeur

● passage de structure en paramètre● s'effectue de la même façon que pour une variable de

type de base

struct personne p, *d; d=&p;struct personne p, *d; d=&p;

1ére méthode (*p).nom;2ème méthode p->nom;

1ére méthode (*p).nom;2ème méthode p->nom;


Les chaines de caractères

● pas de type chaine de caractère en C

– chaine de caractère = tableau de caractère

– une chaine de caractère peut aussi être définie comme une char *

– il existe de nombreuses fonctions de manipulation de chaines de caractères définies dans la librairie <string.h>

● déclaration char t[]="hello;" ou char *p="hello"; ou char t[10]; strcpy(t,"hello");

b o n j o u r \0 caractère de terminaison


principales fonctions de manipulation de chaines

● char * strcpy (char* dest, char * source); // permet de copier source dans dest

● int strlen(const char * sl); // donne la taille de la chaine sl● int strcmp (char*s1, char*s2); // compare les 2 chaines et renvois un entier x donnant

l'écart entre les deux chaines en fonction de l'ordre alphabétique● int stricmp (char*s1, char*s2); // compare les 2 chaines et renvois un entier x donnant

l'écart entre les deux chaines en fonction de l'ordre alphabétique sans tenir compte de la

casse● char * strcat (char* s1, char* s2); //concaténe la chaine s2 à la fin de la chaine s1● char * strstr( const char* s1, const char* s2); // retourne le pointeur de la première

occurrence de s2 dans s1 ou NULL● char* strlwr (char* sl); // converti sl en minuscule et renvoit un pointeur sur sl● char* strupr (char* sl); // converti sl en majuscule et renvoit un pointeur sur sl


Gestion de la mémoire

● détermination de la taille d'un type : sizeof

● allocation de mémoire : malloc et calloc

● libération de mémoire : free

int sizeof (nom du type); Ex: int i = sizeof(float);int sizeof (nom du type); Ex: int i = sizeof(float);

● malloc renvoit un pointeur sur une zone d'espace de la taille passée en argument

void * malloc (int taille);● calloc renvoit un pointeur sur une zone d'espace pour un tableau dont la taille et le nombre de case sont passée en argument

void * calloc (int nb, int taille);

● malloc renvoit un pointeur sur une zone d'espace de la taille passée en argument

void * malloc (int taille);● calloc renvoit un pointeur sur une zone d'espace pour un tableau dont la taille et le nombre de case sont passée en argument

void * calloc (int nb, int taille);

void free (pointeur déclaré par malloc ou calloc)void free (pointeur déclaré par malloc ou calloc)


Les fichiers (1)ouverture et fermeture

● type FILE : caractèrise un accés à un fichier

● ouverture de fichier : fopen

● mode :

FILE * fopen (char * nom du fichier, char* mode);FILE * fopen (char * nom du fichier, char* mode);

mode signification le fichier existe le fichier n'existe pas"r" ouverture d'un fichier texte en lecture erreur"w" ouverture d'un fichier texte en écriture mise à blanc création"a" ouverture d'un fichier texte en écriture à la fin création"rb" ouverture d'un fichier binaire en lecture erreur"wb" ouverture d'un fichier binaire en écriture mise à blanc création"ab" ouverture d'un fichier binaire en écriture à la fin création"r+" ouverture d'un fichier texte en lecture/écriture erreur"w+" ouverture d'un fichier texte en lecture/écriture mise à blanc création"a+" ouverture d'un fichier texte en lecture/écriture à la fin création

"r+b" ou "rb+" ouverture d'un fichier binaire en lecture/écriture erreur"w+b" ou "wb+" ouverture d'un fichier binaire en lecture/écriture mise à blanc création"a+b" ou "ab+" ouverture d'un fichier binaire en lecture/écriture à la fin création


Lecture dans un fichier

● lecture par caractère : fgetc

● lecture par chaine de caractère : fgets

● lecture formatée : fscanf

int fgetc (flot de donnée) si erreur EOFint fgetc (flot de donnée) si erreur EOF

char* fgets (buffer, taille , flot de donnée) si erreur NULLchar* fgets (buffer, taille , flot de donnée) si erreur NULL

void fscanf(flot de donnée, format, liste d'adresse de variables)void fscanf(flot de donnée, format, liste d'adresse de variables)

le comportement de fscanf correspond à celui d'un scanf généralisé ( scanf == fscanf sur STDIN)


écriture dans un fichier

● écriture par caractère : fputc

● écriture par chaine de caractère : fputs

● écriture formatée : fprintf

int fputc (caractère, flot de donnée) si erreur EOFint fputc (caractère, flot de donnée) si erreur EOF

int fputs (chaine, flot de donnée) si erreur EOFint fputs (chaine, flot de donnée) si erreur EOF

int fsprintf(flot de donnée, format, liste de variables)int fsprintf(flot de donnée, format, liste de variables)

le comportement de fprintf correspond à celui d'un printf généralisé ( printf == fprintf sur STDOUT)


lecture écriture binaire

● lecture : read

● écriture : write

int read (FILE * flot de donnée, void * buffer, unsigned int nb d'octets)int read (FILE * flot de donnée, void * buffer, unsigned int nb d'octets)

pointeur de l'élément dans lequel on stocke ce qu'on lit

nb d'octets de ce qu'on va lire

int write (FILE * flot de donnée, void * buffer, unsigned int nb d'octets)int write (FILE * flot de donnée, void * buffer, unsigned int nb d'octets)

pointeur vers les données que l'on veut écrire

nb d'octets que l'on vas écrire


autres fonctions sur les fichiers

● fermeture de fichier

● test de fin de fichier

● test défaut sur le fichier

● déplacement dans le fichier

int fclose (FILE * fichier);int fclose (FILE * fichier);

int feof (FILE * fichier);int feof (FILE * fichier); retourne 0 si fin de fichier

int ferror (FILE * fichier);int ferror (FILE * fichier); retourne un entier différent de 0 si probleme d'accés au fichier

int fseek (FILE * fichier, long offset, int deb);int fseek (FILE * fichier, long offset, int deb);deb = SEEK_SET début

SEEK_CUR pos courante

SEEK_END fin


Le pré-processeur

● Les Macros : #DEFINE

– sans paramètres● exemple : #DEFINE NB_LIGNES 10

– avec paramètres ● exemple : #DEFINE min(a,b) ((a)<(b) ? (a) :

(b))

● compilation conditionnelle #if, #else, #elif

#define nom reste-de-la-ligne#define nom reste-de-la-ligne

#if expression ensemble de lignes#endif

#if expression ensemble de lignes#endif

#if expression ensemble de lignes1#else ensemble de lignes2#endif

#if expression ensemble de lignes1#else ensemble de lignes2#endif

#if expression1 ensemble de lignes1#elif expression2 ensemble de lignes2 ....#elif expression n ensemble de lignes n# else ensemble de ligne else#endif

#if expression1 ensemble de lignes1#elif expression2 ensemble de lignes2 ....#elif expression n ensemble de lignes n# else ensemble de ligne else#endif


Le pré-processeur (2)

● oter une définition : #UNDEF

● tester la définition d'une macro

– #ifndef -> si la macro n'est pas définie

– #ifdef -> si la macro est définie

● la déclaration d'un #include <fichier.h> entraine la création d'une macro FICHIER_H dont on peut tester la définition. (très utile pour la compilation modulaire)


compilation modulaire

● pourquoi la programmation modulaire?● reutilisabilité

● compilation fractionnée

● facilité de compréhension.

● rôle des fichiers d'en-tête● ces fichiers servent à préciser le prototype des

fonctions du fichiers source.

● pour éviter les multiples déclarations -> utilisation des commandes #ifdef et # ifndef


compilation modulaire (2)

● variables globales: pour utiliser dans un fichier une variable définie dans autre fichier il suffit de la redéfinir dans le fichier précédée du mot clé extern

● le mot clé static permet d'interdir l'export via l'éditeur de lien d'une variable dans d'autre fichier


la compilation modulaire (3)exemple

int add (int ,int)int add (int ,int)

add.h

int add (int a, int b){ return a+b;}int add (int a, int b){ return a+b;}

add.c

#include "add.h"int main(){ int a=2,b=5; printf("%i" ,add(a,b); return 0;}

#include "add.h"int main(){ int a=2,b=5; printf("%i" ,add(a,b); return 0;}

addmain.c

add.oadd.o addmain.oaddmain.o

addmainaddmain

fichiers objets

fichier éxecutable

gcc -c add.c gcc -c addmain.c

gcc -o addmain add.o addamain.o


Les listes chaînées

● permet de stocker un ensemble de données de même type.

● avantage sur les tableaux

– faciliter d'étendre la taille

– insertion sans avoir à décaler les éléments un par un

● les listes chainées utilisent des structures dont l'un des membres est un pointeur sur une structures de même type servant ainsi de chaines entres les éléments de la liste


les listes chainées (2)

● la définition de la structure de base d'une liste typedef struct personne

{ char[20] nom; char[20] prenom; int age; struct personne * psuivant;} pers;

typedef struct personne { char[20] nom; char[20] prenom; int age; struct personne * psuivant;} pers;

chaine entre les éléments

● le pointeur permet de stocker l'adresse de l'élément suivant dans la liste●le dernier élément posséde le pointeur NULL comme valeur du membre psuivant●il n'est alors nécessaire de stocker que l'adresse du premier élément


les listes chainées (3)représentation graphique

élement1

*psuivant

élement1

*psuivant

élement2

*psuivant

élement2

*psuivant

élement3

*psuivant

élement3

*psuivant

élement4

*psuivant

élement4

*psuivant

NULLNULLadresse débutadresse début

stocke l'adresse de 1 dans 21 2


méthodes d'insertion

par le débutpar le début

par la finpar la fin

au milieu de la chaîneau milieu de la chaîne


Les processus

● création d'un processus : fork

● obtenir le Process Identifier (PID) : getpid

● obtenir le PID du processus père : getppid

● il est nécessaire d'inclure la librairie unistd.h

pid_t fork ();pid_t fork ();

pid_t getpid ();pid_t getpid ();

pid_t getppid ();pid_t getppid ();


exécution de programme

● l'appel sans argument : system

● l'appel courant : execl

● l'appel courant (2) : execv

int execl (const char *path, const char *arg, ...);int execl (const char *path, const char *arg, ...);

int system (const char *path);int system (const char *path);

int execv (const char *path, const char *arg[], ...);int execv (const char *path, const char *arg[], ...);

Documents

Cours de C GTR 2003/2004 1 COURS DE PROGRAMMATION EN LANGAGE C ALBERT Arnauld