Introduction au Langage C

Slides:



Advertisements
Présentations similaires
Mais vous comprenez qu’il s’agit d’une « tromperie ».
Advertisements

Le Nom L’adjectif Le verbe Objectif: Orthogram
ORTHOGRAM PM 3 ou 4 Ecrire: « a » ou « à » Référentiel page 6
LES NOMBRES PREMIERS ET COMPOSÉS
Reporting de la Cellule Nationale Droit dOption Situation au 31 décembre 2011.
Licence pro MPCQ : Cours
Présentation de la circonscription Année 2011/2012 Jeudi 24 novembre 2011.
Rappels C.
Additions soustractions
Distance inter-locuteur
1 Plus loin dans lutilisation de Windows Vista ©Yves Roger Cornil - 2 août
Le château Clique le plus rapidement possible sur le numéro de la chambre du trésor : 6 ?
ACTIVITES NUMERIQUES Ranger les nombres Trouver le nombre manquant
7 juin 2012 DGAL.
Formation C débutant. Notion de compilation source.c executable Phase de compilation Fichier de texte brut, inexploitable directement par la machine Fichier.
Les nombres.
Les numéros 70 –
Les numéros
Les identités remarquables
Le, la, les words Possessive Adjectives MINE!!. 2 My in french is mon, ma,mes... Le word/ begins with a vowel: Mon La word: Ma Les word: Mes.
Xavier Mouranche Registre e-MUST Evaluation en Médecine dUrgence des Stratégies Thérapeutiques de lInfarctus du Myocarde.
Introduction à la logique
Algorithme et structure de données
LES TRIANGLES 1. Définitions 2. Constructions 3. Propriétés.
Données statistiques sur le droit doption au 31/01 8 février 2012.
Correspondances en Onco-Urologie - Vol. III - n° 3 – juillet-août-septembre VESSIE Daprès James ND et al., N Engl J Med 2012;366:16:
Technologies et pédagogie actives en FGA. Plan de latelier 1.Introduction 2.Les technologies en éducation 3.iPads 4.TNI 5.Ordinateurs portables 6.Téléphones.
Enquête sur le Rapport de la Commission Bouchard-Taylor Jack Jedwab Directeur général Association détudes canadiennes 11 juin 2008.
Révision (p. 130, texte) Nombres (1-100).
La législation formation, les aides des pouvoirs publics
1 7 Langues niveaux débutant à avancé. 2 Allemand.
La méthodologie………………………………………………………….. p3 Les résultats
1 Juin 2010 Sondage auprès des jeunes Marocains résidant en Europe ( France, Espagne, Italie, Belgique, Pays-Bas et Allemagne ) Juin 2010 Réf. : TL251.
Structure(djs)TéléphoneFax ADRA R049,96,03,21 CHLEF027,77,22,66 /77,49, LAGHOUAT029,90,41,08029,90,42,47 OUM EL BOUAGHI032,42,16,26032,42,45,32.
Jack Jedwab Association détudes canadiennes Le 27 septembre 2008 Sondage post-Olympique.
Le soccer & les turbans Sondage mené par lAssociation détudes canadiennes 14 juin 2013.
Présentation générale
Le drapeau canadien comme symbole de fierté nationale : une question de valeurs partagées Jack Jedwab Association détudes canadiennes 28 novembre 2012.
Les nombres.
Fierté envers les symboles et institutions canadiens Jack Jedwab Association détudes canadiennes 26 novembre 2012.
1 Les pointeurs et quelques rappels sur certains éléments du langage C.
Conseil Administration AFRAC – 2 décembre Toulouse 1 Fermes de références Palmipèdes à foie gras Synthèse régionale – Midi Pyrénées Exercice
La consommation de boissons alcooliques chez les jeunes LICEO SCIENTIFICO N. COPERNICO PRATO ELEVES (age ans): 342 F: 192 M: 150.
LES NOMBRES PREMIERS ET COMPOSÉS
CLL11 : chlorambucil (CLB) versus CLB + rituximab (R)
Les chiffres & les nombres
Les Monnaies et billets du FRANC Les Monnaies Euro.
RACINES CARREES Définition Développer avec la distributivité Produit 1
DUMP GAUCHE INTERFERENCES AVEC BOITIERS IFS D.G. – Le – 1/56.
Les maths en francais 7ième année.
Année universitaire Réalisé par: Dr. Aymen Ayari Cours Réseaux étendus LATRI 3 1.
Jean-Marc Léger Président Léger Marketing Léger Marketing Les élections présidentielles américaines.
Les pointeurs en C. valeur : main () { float valeur; void* pointeur; }
MAGIE Réalisé par Mons. RITTER J-P Le 24 octobre 2004.
1 INETOP
Les Nombres 0 – 100 en français.
Aire d’une figure par encadrement
Copyright 2011 – Les Chiffres Copyright 2011 –
P.A. MARQUES S.A.S Z.I. de la Moussière F DROUE Tél.: + 33 (0) Fax + 33 (0)
Les fondements constitutionnels
MAGIE Réalisé par Mons. RITTER J-P Le 24 octobre 2004.
Traitement de différentes préoccupations Le 28 octobre et 4 novembre 2010.
1/65 微距摄影 美丽的微距摄影 Encore une belle leçon de Macrophotographies venant du Soleil Levant Louis.
Certains droits réservés pour plus d’infos, cliquer sur l’icône.
LES PILES ET FILES.
Annexe Résultats provinciaux comparés à la moyenne canadienne
La formation des maîtres et la manifestation de la compétence professionnelle à intégrer les technologies de l'information et des communications (TIC)
IMPRESS : y a-t-il un bénéfice à poursuivre le géfitinib en association à la chimiothérapie lors de la résistance acquise ? Essai randomisé Patients Cisplatine.
Bienvenue.
Transcription de la présentation:

Introduction au Langage C LAL - Orsay

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Instructions exécutables. 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; assignations , expressions controles tests if boucles for, do, while, break fins de fonctions return blocs appels de fonctions 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; } 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); } 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); LAL - Orsay

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

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

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

Visibilité des définitions. Définitions globales : visibles (accessibles) à partir des autres fichiers. Fichier source déclaration ... fonction 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); LAL - Orsay

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

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

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

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

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

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

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

Déclarations : types et variables. 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 : struct quadrilatere { struct Point sommet[4]; enum couleur fond; } rectangle, carre; LAL - Orsay

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

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

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

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

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

Les pointeurs en C. void f () { int nombre; int* p1 = &nombre; } Ecritures équivalentes 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. 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); } Déclaration de deux pointeurs sur des types Point. 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); } Allocation d'une structure Point : p1 la désigne. 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); } Libération de la mémoire. p1 ne désigne plus rien. 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 : p2 : 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 : 0x12345678 p2 : p1->x : p1->y : 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 : 0x12345678 p2 : 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); } LAL - Orsay

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

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

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

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

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

Des ensembles : tableaux et listes. #include "list.h" main () { List liste; Point* p; liste = ListCreate (); p = malloc (sizeof(Point)); } liste : .first : .last : p : 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 : .first : .last : p : .reference : 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 : .first : .last : p : .reference : 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 : .first : .last : p : .reference : 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 : .first : .last : p : .reference : .reference : 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 : .first : .last : p : .reference : .reference : LAL - Orsay

Des ensembles : tableaux et listes. #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); } liste : .first : .last : .reference : .reference : .reference : .reference : LAL - Orsay

Des ensembles : tableaux et listes. .first : .last : current : Chaînage dans les listes. next : .reference : next : .reference : next : .reference : next : 0 .reference : LAL - Orsay

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

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

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

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

Une liste multiforme : construction .ref .ref .ref .ref Polygone Point Ligne Ligne x1, y1 x2, y2 x1, y1 x2, y2 x, y x1, y1 x2, y2 ... xn, yn LAL - Orsay

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

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

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

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

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

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

Une liste multiforme. .type: .figure: .x1, .y1: .x2, .y2: ... .xn, .yn: .figure: .x, .y: .figure: .x1, .y1: .x2, .y2: .figure: .x1, .y1: .x2, .y2: 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... } 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 LAL - Orsay

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

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