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

1 LAL - Orsay Introduction au Langage C. 2 LAL - Orsay Structure générale d'une application C Fichier source.

Présentations similaires


Présentation au sujet: "1 LAL - Orsay Introduction au Langage C. 2 LAL - Orsay Structure générale d'une application C Fichier source."— Transcription de la présentation:

1 1 LAL - Orsay Introduction au Langage C

2 2 LAL - Orsay Structure générale d'une application C Fichier source

3 3 LAL - Orsay Structure générale d'une application C Fichier source déclaration... fonction...

4 4 LAL - Orsay Structure générale d'une application C Fichier source déclaration... fonction... float Valeur; int Tableau [100]; Variables globales typedef enum { faux, vrai } booleen; typedef void* Pointeur; Types

5 5 LAL - Orsay Structure générale d'une application C fonction Fichier source déclaration... fonction... int division (int v1, int v2) { /* déclarations locales */ /* instructions executables */ }

6 6 LAL - Orsay int addition (int v1, int v2) { int resultat; resultat = v1 + v2; return (resultat); } fonction Structure générale d'une application C Fichier source déclaration... fonction...

7 7 LAL - Orsay Structure générale d'une application C int division (int v1, int v2) { int resultat = 0; if (v2 == 0) { printf ("erreur! \n"); } else { resultat = v1 / v2; } return (resultat); } fonction Fichier source déclaration... fonction...

8 8 LAL - Orsay Fichier source déclaration... fonction «main» fonction... Structure générale d'une application C int main () { } fonction

9 9 LAL - Orsay Déclarations : types et variables. Type= modèle pour les objets Variable= objet réalisé selon un des modèles

10 10 LAL - Orsay Déclarations : types et variables. Type= modèle pour les objets char short int long float double types simples

11 11 LAL - Orsay Déclarations : types et variables. int valeur; double nombre = ; double autreNombre = nombre * 3; float Pi = ; int largeur, hauteur; char code = 'x'; valeur : nombre : autreNombre : Pi : largeur : hauteur : code : 'x'

12 12 LAL - Orsay Déclarations : types et variables. int valeur; double nombre = ; double autreNombre = nombre * 3; float Pi = ; int largeur, hauteur; char code = 'x'; valeur : nombre : autreNombre : Pi : largeur : hauteur : code : 'x'

13 13 LAL - Orsay Déclarations : types et variables. int valeur; double nombre = ; double autreNombre = nombre * 3; float Pi = ; int largeur, hauteur; char code = 'x'; valeur : nombre : autreNombre : Pi : largeur : hauteur : code : 'x'

14 14 LAL - Orsay Déclarations : types et variables. int valeur; double nombre = ; double autreNombre = nombre * 3; float Pi = ; int largeur, hauteur; char code = 'x'; valeur : nombre : autreNombre : Pi : largeur : hauteur : code : 'x'

15 15 LAL - Orsay Déclarations : types et variables. int valeur; double nombre = ; double autreNombre = nombre * 3; float Pi = ; int largeur, hauteur; char code = 'x'; valeur : nombre : autreNombre : Pi : largeur : hauteur : code : 'x'

16 16 LAL - Orsay Déclarations : types et variables. int valeur; double nombre = ; double autreNombre = nombre * 3; float Pi = ; int largeur, hauteur; char code = 'x'; valeur : nombre : autreNombre : Pi : largeur : hauteur : code : 'x'

17 17 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions

18 18 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void f () { int nombre; float valeur; nombre = 123; valeur = nombre * 3; }

19 19 LAL - Orsay Instructions exécutables. Opérateurs + - * / % ! && || == >= <= != arithmétiques logiques comparaisons > & | ^ ~ binaires += -= *= /= %= >= &= |= ^= ~=

20 20 LAL - Orsay Instructions exécutables. Opérateurs + - * / % ! && || == >= <= != arithmétiques logiques comparaisons > & | ^ ~ binaires += -= *= /= %= >= &= |= ^= ~= modulo

21 21 LAL - Orsay Instructions exécutables. Opérateurs + - * / % ! && || == >= <= != arithmétiques logiques comparaisons > & | ^ ~ binaires += -= *= /= %= >= &= |= ^= ~= décalage (droite - gauche)

22 22 LAL - Orsay Instructions exécutables. Opérateurs + - * / % ! && || == >= <= != arithmétiques logiques comparaisons > & | ^ ~ binaires += -= *= /= %= >= &= |= ^= ~= and - or - xor

23 23 LAL - Orsay Instructions exécutables. Opérateurs + - * / % ! && || == >= <= != arithmétiques logiques comparaisons > & | ^ ~ binaires += -= *= /= %= >= &= |= ^= ~= bit-not

24 24 LAL - Orsay Instructions exécutables. Opérateurs + - * / % ! && || == >= <= != arithmétiques logiques comparaisons > & | ^ ~ binaires += -= *= /= %= >= &= |= ^= ~= not

25 25 LAL - Orsay Instructions exécutables. Opérateurs + - * / % ! && || == >= <= != arithmétiques logiques comparaisons > & | ^ ~ binaires += -= *= /= %= >= &= |= ^= ~= and - or

26 26 LAL - Orsay Instructions exécutables. Opérateurs + - * / % ! && || == >= <= != arithmétiques logiques comparaisons > & | ^ ~ binaires += -= *= /= %= >= &= |= ^= ~= égalité

27 27 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void f () { int nombre; enum {negatif, positif} signe; if (nombre >= 0) signe = positif; else signe = negatif; }

28 28 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void f () { int nombre; enum {negatif, nul, positif} signe; if (nombre > 0) signe = positif; else if (nombre < 0) signe = negatif; else signe = null; }

29 29 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void f () { int nombre = 1; int compteur; for (compteur = 0; compteur < 10; compteur++) nombre *= 3; }

30 30 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void f () { int nombre = 1; int compteur; compteur = 0; do { nombre *= 3; if (nombre > 100) break; compteur++; } while (compteur < 10); }

31 31 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void f () { int nombre = 1; int compteur; compteur = 0; while (compteur < 10) { nombre *= 3; if (nombre > 100) break; compteur++; }

32 32 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void f () { int nombre = 1; int compteur; for (compteur = 0; compteur < 10; compteur++) { nombre *= 3; if (nombre > 100) return; }

33 33 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions int f () { int nombre = 1; int compteur; for (compteur = 0; compteur < 10; compteur++) { nombre *= 3; if (nombre > 100) break; } return (nombre); }

34 34 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void f () { int nombre; enum {negatif, nul, positif} signe; if (nombre > 0) signe = positif; else if (nombre < 0) { signe = negatif; nombre = - nombre; } else signe = negatif; }

35 35 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void f () { int nombre = 1; int compteur; for (compteur = 0; compteur < 10; compteur++) { nombre *= 3; if (nombre > 100) break; }

36 36 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions int addition (int val1, int val2); void f () { int nombre; nombre = addition (12, 34); }

37 37 LAL - Orsay Le prototypage des fonctions. Permet de déclarer les fonctions : leur type le type de leurs arguments Necessaire avant toute utilisation des fonctions. Exemple : int affiche (char* message);

38 38 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions double sin (double angle); void f () { float valeur; valeur = sin (PI/6); }

39 39 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void* get_next_item (); void f () { void* reference; reference = get_next_item (); }

40 40 LAL - Orsay Instructions exécutables. assignations, expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions void start (int parametre); void stop (); void f () { start (10); stop (); }

41 41 LAL - Orsay Fichier source déclaration... fonction... Visibilité des définitions. Définitions globales : visibles (accessibles) à partir des autres fichiers.

42 42 LAL - Orsay Visibilité des définitions. Définitions locales : Les arguments des fonctions. Tout ce qui est défini à l'interieur d'un bloc. int addition (int v1, int v2) { int resultat; resultat = v1 + v2; if (resultat) { int temp; temp = -resultat; resultat = temp; } return (resultat); }

43 43 LAL - Orsay Déclarations : types et variables. Type= modèle pour les objets enum booleen { faux, vrai } types simples : énumérations

44 44 LAL - Orsay Déclarations : types et variables. enum booleen { faux, vrai } valeur; enum { bleu, blanc, rouge } couleur = rouge; valeur : couleur : rouge

45 45 LAL - Orsay Déclarations : types et variables. Type= modèle pour les objets int x[100]; char string[80]; float valeur[10][5] types complexes : les tableaux

46 46 LAL - Orsay Déclarations : types et variables. void f() { float valeur[2][5]; valeur[1][2] = 10; } valeur [0][0]: valeur [1][0]: valeur [0][1]: valeur [1][1]: valeur [0][2]: valeur [1][2]: valeur [0][3]: valeur [1][3]: valeur [0][4]: valeur [1][4]:

47 47 LAL - Orsay Déclarations : types et variables. void f() { float valeur[2][5]; valeur[1][2] = 10; } valeur [0][0]: valeur [1][0]: valeur [0][1]: valeur [1][1]: valeur [0][2]: valeur [1][2]: 10 valeur [0][3]: valeur [1][3]: valeur [0][4]: valeur [1][4]:

48 48 LAL - Orsay Déclarations : types et variables. Type= modèle pour les objets struct point { int x; int y; } types complexes : les structures

49 49 LAL - Orsay Déclarations : types et variables. struct Point { int x; int y; } sommet = {12, 23}; sommet.x : 12 sommet.y : 23

50 50 LAL - Orsay Déclarations : types et variables. struct Point { int x; int y; } sommet = {12, 23}; sommet.x : 12 sommet.y : 23 struct Point p[4]; p[0].x : p[0].y : p[1].x : p[1].y : p[2].x : p[2].y : p[3].x : p[3].y :

51 51 LAL - Orsay Déclarations : types et variables. struct Point { int x; int y; } image[100]; struct { float hauteur; float largeur; enum couleur fond; } rectangle; image [0].x : image [0].y : rectangle.hauteur : rectangle.largeur : rectangle.fond : image [1].x : image [1].y : image [2].x : image [2].y :...

52 52 LAL - Orsay Déclarations : types et variables. struct quadrilatere { struct Point sommet[4]; enum couleur fond; } rectangle, carre; carre.sommet[0].x : carre.sommet[0].y : carre.sommet[1].x : carre.sommet[1].y : carre.sommet[2].x : carre.sommet[2].y : carre.sommet[3].x : carre.sommet[3].y : carre.fond :

53 53 LAL - Orsay Déclarations : types et variables. Type= modèle pour les objets struct Point* void* les pointeurs char* double* enum booleen*

54 54 LAL - Orsay Les pointeurs en C. float valeur; void* pointeur; pointeur : valeur :

55 55 LAL - Orsay Les pointeurs en C. pointeur : void f () { float valeur; void* pointeur; pointeur = &valeur; } valeur :

56 56 LAL - Orsay Les pointeurs en C. void f () { int nombre; float valeur; void* pointeur; pointeur = &valeur; } pointeur : valeur : nombre :

57 57 LAL - Orsay Les pointeurs en C. void f () { int nombre; float valeur; void* pointeur; pointeur = &valeur; pointeur = &nombre; } pointeur : valeur : nombre :

58 58 LAL - Orsay Les pointeurs en C. void f () { int nombre; int* p1 = &nombre; nombre = 10; *p1 = 10; } Ecritures équivalentes

59 59 LAL - Orsay Allocation de mémoire en C : malloc et free. typedef struct { int x, y; } Point; main () { Point* p1; p1 = (Point*) malloc (sizeof(Point)); free (p1); } Définition du type Point.

60 60 LAL - Orsay typedef struct { int x, y; } Point; main () { Point* p1; Point* p2; p1 = (Point*) malloc (sizeof(Point)); free (p1); } Allocation de mémoire en C : malloc et free. Déclaration de deux pointeurs sur des types Point.

61 61 LAL - Orsay typedef struct { int x, y; } Point; main () { Point* p1; p1 = (Point*) malloc (sizeof(Point)); free (p1); } Allocation de mémoire en C : malloc et free. Allocation d'une structure Point : p1 la désigne.

62 62 LAL - Orsay typedef struct { int x, y; } Point; main () { Point* p1; p1 = (Point*) malloc (sizeof(Point)); free (p1); } Allocation de mémoire en C : malloc et free. Libération de la mémoire. p1 ne désigne plus rien.

63 63 LAL - Orsay typedef struct { int x, y; } Point; main () { Point* p1; Point* p2; p1 = (Point*) malloc (sizeof(Point)); free (p1); } Allocation de mémoire en C : malloc et free. p1 : p2 :

64 64 LAL - Orsay Allocation de mémoire en C : malloc et free. typedef struct { int x, y; } Point; main () { Point* p1; Point* p2; p1 = (Point*) malloc (sizeof(Point)); free (p1); } p1 : 0x p2 : p1->x : p1->y :

65 65 LAL - Orsay Allocation de mémoire en C : malloc et free. typedef struct { int x, y; } Point; main () { Point* p1; Point* p2; p1 = (Point*) malloc (sizeof(Point)); free (p1); } p1 : 0x p2 :

66 66 LAL - Orsay Allocation de mémoire en C : malloc et free. typedef struct { int x, y; } Point; main () { Point* p1; p1 = (Point*) malloc (sizeof(Point)); p1->x = 10; p1->y = p1->x * 2; free (p1); }

67 67 LAL - Orsay Les tableaux de pointeurs Des objets alloués en mémoire : main () { Point* p; p = (Point*) malloc (sizeof(Point)); }

68 68 LAL - Orsay Les tableaux de pointeurs main () { Point* p[10]; int i; for (i = 0; i < 10; i++) p[i] = NULL; }

69 69 LAL - Orsay Les tableaux de pointeurs main () { Point* p[10]; p[0] = malloc (sizeof(Point)); }

70 70 LAL - Orsay Les tableaux de pointeurs main () { Point* p[10]; p[0] = malloc(sizeof(Point)); p[1] = malloc(sizeof(Point)); }

71 71 LAL - Orsay Des ensembles : tableaux et listes. #include "list.h" main () { List liste; liste = ListCreate (); } liste :.first :.last :

72 72 LAL - Orsay Des ensembles : tableaux et listes. p : liste :.first :.last : #include "list.h" main () { List liste; Point* p; liste = ListCreate (); p = malloc (sizeof(Point)); }

73 73 LAL - Orsay Des ensembles : tableaux et listes. #include "list.h" main () { List liste; Point* p; liste = ListCreate (); p = malloc (sizeof(Point)); ListAddEntry (liste, p); } liste : p :.first :.last :.reference :

74 74 LAL - Orsay Des ensembles : tableaux et listes. #include "list.h" main () { List liste; Point* p; liste = ListCreate (); p = malloc (sizeof(Point)); ListAddEntry (liste, p); } liste : p :.first :.last :.reference :

75 75 LAL - Orsay Des ensembles : tableaux et listes. #include "list.h" main () { List liste; Point* p; liste = ListCreate (); p = malloc (sizeof(Point)); ListAddEntry (liste, p); p = malloc (sizeof(Point)); } liste : p :.first :.last :.reference :

76 76 LAL - Orsay Des ensembles : tableaux et listes. #include "list.h" main () { List liste; Point* p; liste = ListCreate (); p = malloc (sizeof(Point)); ListAddEntry (liste, p); p = malloc (sizeof(Point)); ListAddEntry (liste, p); } liste : p :.first :.last :.reference :

77 77 LAL - Orsay Des ensembles : tableaux et listes. #include "list.h" main () { List liste; Point* p; liste = ListCreate (); p = malloc (sizeof(Point)); ListAddEntry (liste, p); p = malloc (sizeof(Point)); ListAddEntry (liste, p); } liste : p :.first :.last :.reference :

78 78 LAL - Orsay Des ensembles : tableaux et listes. liste :.first :.last :.reference : #include "list.h" main () { List liste; Point* p; int i; liste = ListCreate (); for (i=0; i < 4; i++) { p = malloc (sizeof(Point)); ListAddEntry (liste, p); }

80 80 LAL - Orsay Des ensembles : tableaux et listes. main () { List liste; Point* p; liste =...; ListStartLoop (liste); }.first :.last : current :.reference : next : next : 0

81 81 LAL - Orsay Des ensembles : tableaux et listes..first :.last : current :.reference : next : next : 0 main () { List liste; Point* p; liste =...; ListStartLoop (liste); while (( p = ListGetNextEntry(liste) )) { p->x = 0; p->y = 10; }

82 82 LAL - Orsay Une liste multiforme. main () { List liste; Point* p; Ligne* l; liste = ListCreate (); p = malloc (sizeof(Point)); ListAddEntry (liste, p); l = malloc (sizeof(Ligne)); ListAddEntry (liste, l); } liste : p :.first :.last :.reference : l :

83 83 LAL - Orsay Une liste multiforme : problème PolygonePointLigne x, y x1, y1 x2, y2 x1, y1 x2, y2 x1, y1 x2, y2... xn, yn

84 84 LAL - Orsay Une liste multiforme : construction PolygonePointLigne x, y x1, y1 x2, y2 x1, y1 x2, y2 x1, y1 x2, y2... xn, yn.ref

85 85 LAL - Orsay Une liste multiforme. PolygonePointLigne x, y x1, y1 x2, y2 x1, y1 x2, y2 x1, y1 x2, y2... xn, yn.ref.next.first.last

86 86 LAL - Orsay Une liste multiforme..ref.next.first.last ????

87 87 LAL - Orsay Une liste multiforme..ref.next.first.last.type:

88 88 LAL - Orsay Une liste multiforme..ref.next.first.last.type: Point.x,.y:.type: Ligne.x1,.y1:.x2,.y2:.type: Ligne.x1,.y1:.x2,.y2:.type: Polygone.x1,.y1:.x2,.y2:....xn,.yn:

89 89 LAL - Orsay Une liste multiforme..ref.next.first.last.type: Point.x,.y:.type: Ligne.x1,.y1:.x2,.y2:.type: Ligne.x1,.y1:.x2,.y2:.type: Polygone.x1,.y1:.x2,.y2:....xn,.yn:

90 90 LAL - Orsay Une liste multiforme..x,.y:.x1,.y1:.x2,.y2:.x1,.y1:.x2,.y2:.x1,.y1:.x2,.y2:....xn,.yn:.type:

91 91 LAL - Orsay Une liste multiforme..figure:.x,.y:.figure:.x1,.y1:.x2,.y2:.figure:.x1,.y1:.x2,.y2:.figure:.x1,.y1:.x2,.y2:....xn,.yn:.type:

92 92 LAL - Orsay Une liste dans une structure..figure: FigurePolygone.x1,.y1:.x2,.y2:....xn,.yn: main () { Polygone* poly; poly = malloc (sizeof(Polygone)); poly->figure.type = FigurePolygone; poly->x1 =...; etc... }

93 93 LAL - Orsay Une liste dans une structure..figure: FigurePolygone.lignes: main () { Polygone* poly; poly = malloc (sizeof(Polygone)); poly->figure.ident = FigurePolygone; poly->lignes = ListeCreate (); }.first.last

94 94 LAL - Orsay Une liste dans une structure..figure: FigurePolygone.lignes: main () { Polygone* poly; Ligne* ligne; poly = malloc (sizeof(Polygone)); poly->figure.ident = FigurePolygone; poly->lignes = ListeCreate (); ligne = malloc (sizeof(Ligne)); ListAddEntry (poly->lignes, ligne); }.first.last.figure: Ligne.x1,.y1:.x2,.y2:

95 95 LAL - Orsay Une liste dans une structure..figure: FigurePolygone.lignes: main () { Polygone* poly; Ligne* ligne; poly = malloc (sizeof(Polygone)); poly->figure.ident = FigurePolygone; poly->lignes = ListeCreate (); ligne = malloc (sizeof(Ligne)); ListAddEntry (poly->lignes, ligne); ligne = malloc (sizeof(Ligne)); ListAddEntry (poly->lignes, ligne); }.first.last.figure: Ligne.x1,.y1:.x2,.y2:.figure: Ligne.x1,.y1:.x2,.y2:


Télécharger ppt "1 LAL - Orsay Introduction au Langage C. 2 LAL - Orsay Structure générale d'une application C Fichier source."

Présentations similaires


Annonces Google