La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

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

Présentations similaires


Présentation au sujet: "Cours de C GTR 2003/2004 1 COURS DE PROGRAMMATION EN LANGAGE C ALBERT Arnauld."— Transcription de la présentation:

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

2 Cours de C GTR 2003/ 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 »

3 Cours de C GTR 2003/ Mon premier Programme #include int main() { /* premier prog en C */ printf(" bonjour le monde ! \n"); return 0; } inclusion du fichier d'en-tête de la librairie stdio inclusion du fichier d'en-tête de la librairie stdio déclaration de la fonction main commentaire appel de la fonction d'affichage fin du programme

4 Cours de C GTR 2003/ 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

5 Cours de C GTR 2003/ 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 fichier source fichier source éxecutable Compilation gcc -o executable fichier.c

6 Cours de C GTR 2003/ Les élements de base Les mots-clés Les identificateurs Les commentaires Les types Les opérateurs

7 Cours de C GTR 2003/ 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

8 Cours de C GTR 2003/ 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

9 Cours de C GTR 2003/ Les commentaires 2 types de commentaires sont disponibles – commentaires sur une ligne aprés une instruction – commentaires sur plusieurs lignes instruction; // commentaire instruction 1; /* commentaire1 commentaire 3 */ instruction 2; instruction 1; /* commentaire1 commentaire 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 */

10 Cours de C GTR 2003/ Les types de base en C Les 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

11 Cours de C GTR 2003/ 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

12 Cours de C GTR 2003/ 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)

13 Cours de C GTR 2003/ 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

14 Cours de C GTR 2003/ Déclaration de variable on déclare une variable en donnant son type, son identificateur et eventuellement sa 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.

15 Cours de C GTR 2003/ Déclaration de variable (exemple) /* exemple de déclaration et d'utilisation de variables */ #include int toto; // déclaration d'une variable globale de type entier extern char c; // variable définie dans un autre fichier int 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 int toto; // déclaration d'une variable globale de type entier extern char c; // variable définie dans un autre fichier int 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; }

16 Cours de C GTR 2003/ 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

17 Cours de C GTR 2003/ 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

18 Cours de C GTR 2003/ 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 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

19 Cours de C GTR 2003/ 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 >, >=, <, <=, ==, !, !=

20 Cours de C GTR 2003/ Les opérateurs usuels (2) 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)

21 Cours de C GTR 2003/ Les opérateurs usuels (3) 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;

22 Cours de C GTR 2003/ 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é

23 Cours de C GTR 2003/ 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)

24 Cours de C GTR 2003/ 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;} 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

25 Cours de C GTR 2003/ L'instruction itérative FOR Permet de répeter n fois un même ensemble d'instruction for ( expression1; expression2; expression3) {instructions;} Initialisation condition d'arret incrémentation Ex : for (i=0; i<10; i++) {printf (" bonjour à tous \n");}

26 Cours de C GTR 2003/ 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

27 Cours de C GTR 2003/ 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;

28 Cours de C GTR 2003/ 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 compilation cas si aucune expression i n'est identique expression

29 Cours de C GTR 2003/ 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 la fonction 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);

30 Cours de C GTR 2003/ 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 }

31 Cours de C GTR 2003/ 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

32 Cours de C GTR 2003/ 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 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.

33 Cours de C GTR 2003/ 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 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 toto shell: > toto > argc = 4 et argv[0] = toto, argv[1] = 2, argv[2] =5, argv[3] = 15 EX: programme toto shell: > toto > argc = 4 et argv[0] = toto, argv[1] = 2, argv[2] =5, argv[3] = 15

34 Cours de C GTR 2003/ 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];

35 Cours de C GTR 2003/ 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 tableau 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 tableau

36 Cours de C GTR 2003/ 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; int *p; // déclare un pointeur sur un entier double *d; // pointeur sur un flottant double précision int *p; // déclare un pointeur sur un entier double *d; // pointeur sur un flottant double précision

37 Cours de C GTR 2003/ 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; *p =2; equivaut à i=2; int i, *p; p=&i; *p =2; equivaut à i=2;

38 Cours de C GTR 2003/ 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 10 int t[N]; int *p,*q, *r, *s; p = &t[0]; // p repére le premier élément du tableau q = p+ (N-1); // q repére le dernier élément du tableau p++; // positionne p à le 2ème case du tableau q--; // positionne q à l'avant dernière case du tableau #define N 10 int t[N]; int *p,*q, *r, *s; p = &t[0]; // p repére le premier élément du tableau q = p+ (N-1); // q repére le dernier élément du tableau p++; // positionne p à le 2ème case du tableau q--; // positionne q à l'avant dernière case du tableau

39 Cours de C GTR 2003/ 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 valeur Passage par adresse ou par référence

40 Cours de C GTR 2003/ 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){....} appel int i,j; func (i,j); // copie le contenu de i et j dans a et b fonction int func (int a, int b){....} appel int 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

41 Cours de C GTR 2003/ 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){....} appel int 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){....} appel int 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

42 Cours de C GTR 2003/ 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

43 Cours de C GTR 2003/ 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)

44 Cours de C GTR 2003/ 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)

45 Cours de C GTR 2003/ 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]; tab2d[i][j] = 5; void affiche_tableau (int tab2d[][20], int dim2)

46 Cours de C GTR 2003/ 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); affichage bonjour le monde 10 code: int i=10; printf ( "bonjour le monde \n %s", i); affichage bonjour le monde 10 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

47 Cours de C GTR 2003/ 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,...); 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.

48 Cours de C GTR 2003/ 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 nb de digits affichés nb de chiffre après la virgule attribut de précision des int et float

49 Cours de C GTR 2003/ les formats (2) les types les Flags

50 Cours de C GTR 2003/ 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 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.

51 Cours de C GTR 2003/ 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 ne permet pas de déclarer d'autre variable de même type !

52 Cours de C GTR 2003/ les structures- utilisation initialisation accés au membres affectation de structures tableau de structure struct personne p ={"Jean", "Dupont", 45} p.nom renvoit le champ nom de la structure personne p struct personne p1,p2; p1=p2; struct personne t[100];

53 Cours de C GTR 2003/ 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; 1ére méthode (*p).nom; 2ème méthode p->nom; 1ére méthode (*p).nom; 2ème méthode p->nom;

54 Cours de C GTR 2003/ 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 déclaration char t[]="hello;" ou char *p="hello"; ou char t[10]; strcpy(t,"hello"); caractère de terminaison

55 Cours de C GTR 2003/ 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

56 Cours de C GTR 2003/ 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); 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)

57 Cours de C GTR 2003/ 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);

58 Cours de C GTR 2003/ 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 EOF char* fgets (buffer, taille, flot de donnée) si erreur NULL 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)

59 Cours de C GTR 2003/ é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 EOF int fputs (chaine, flot de donnée) si erreur EOF 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)

60 Cours de C GTR 2003/ lecture écriture binaire lecture : read écriture : write 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) pointeur vers les données que l'on veut écrire nb d'octets que l'on vas écrire

61 Cours de C GTR 2003/ 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 feof (FILE * fichier); retourne 0 si fin de 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); deb = SEEK_SET début SEEK_CUR pos courante SEEK_END fin

62 Cours de C GTR 2003/ 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 #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

63 Cours de C GTR 2003/ 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 entraine la création d'une macro FICHIER_H dont on peut tester la définition. (très utile pour la compilation modulaire)

64 Cours de C GTR 2003/ 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

65 Cours de C GTR 2003/ 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

66 Cours de C GTR 2003/ la compilation modulaire (3) exemple 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.o addmain.o addmain fichiers objets fichier éxecutable gcc -c add.c gcc -c addmain.c gcc -o addmain add.o addamain.o

67 Cours de C GTR 2003/ 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

68 Cours de C GTR 2003/ 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

69 Cours de C GTR 2003/ les listes chainées (3) représentation graphique élement1 *psuivant élement1 *psuivant élement2 *psuivant élement2 *psuivant élement3 *psuivant élement3 *psuivant élement4 *psuivant élement4 *psuivant NULL adresse début stocke l'adresse de 1 dans 2 1 2

70 Cours de C GTR 2003/ méthodes d'insertion par le début par la fin au milieu de la chaîne

71 Cours de C GTR 2003/ 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 getpid (); pid_t getppid ();

72 Cours de C GTR 2003/ 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 system (const char *path); int execv (const char *path, const char *arg[],...);


Télécharger ppt "Cours de C GTR 2003/2004 1 COURS DE PROGRAMMATION EN LANGAGE C ALBERT Arnauld."

Présentations similaires


Annonces Google