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

LAL - Orsay

1

Introduction au Langage C

LAL - Orsay

2

Structure générale d'une application C

Fichier sourceFichier source



Fichier source

LAL - Orsay

3





Fichier source

Fichier source

déclaration

déclaration

...

fonction

fonction

...

LAL - Orsay

4


Fichier source

déclaration

déclaration

...

fonction

fonction

...

float Valeur;int Tableau [100];

Variables globales

typedef enum{

faux,vrai

} booleen;

typedef void* Pointeur;

Types

LAL - Orsay

5


fonctionFichier source

déclaration

déclaration

...

fonction

fonction

...

int division (int v1, int v2){

/* déclarations locales*/

/*instructions executables

*/}

LAL - Orsay

6

int addition (int v1, int v2){

int resultat;

resultat = v1 + v2;

return (resultat);}

fonction


Fichier source

déclaration

déclaration

...

fonction

fonction

...

LAL - Orsay

7


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

déclaration

...

fonction

fonction

...

LAL - Orsay

8

Fichier source

déclaration

déclaration

...

fonction «main»

fonction

...


int main (){}

fonction

LAL - Orsay

9

Déclarations : types et variables.

Type = modèle pour les objets

Variable = objet réalisé selon un des modèles

LAL - Orsay

10



charshortintlong

floatdoubletypes simples

LAL - Orsay

11


int valeur;

double nombre = 123.456;double autreNombre = nombre * 3;

float Pi = 3.1415926;

int largeur, hauteur;

char code = 'x';

valeur :

nombre : 123.456

autreNombre : 370.368

Pi : 3.1415926

largeur :

hauteur :

code : 'x'

LAL - Orsay

12


int valeur;


float Pi = 3.1415926;


char code = 'x';

valeur :

nombre : 123.456


Pi : 3.1415926

largeur :

hauteur :

code : 'x'

LAL - Orsay

13


int valeur;


float Pi = 3.1415926;


char code = 'x';

valeur :

nombre : 123.456


Pi : 3.1415926

largeur :

hauteur :

code : 'x'

LAL - Orsay

14


int valeur;


float Pi = 3.1415926;


char code = 'x';

valeur :

nombre : 123.456


Pi : 3.1415926

largeur :

hauteur :

code : 'x'

LAL - Orsay

15


int valeur;


float Pi = 3.1415926;


char code = 'x';

valeur :

nombre : 123.456


Pi : 3.1415926

largeur :

hauteur :

code : 'x'

LAL - Orsay

16


int valeur;


float Pi = 3.1415926;


char code = 'x';

valeur :

nombre : 123.456


Pi : 3.1415926

largeur :

hauteur :

code : 'x'

LAL - Orsay

17

Instructions exécutables.

assignations, expressions

controles

testsif

bouclesfor, do, while, break

fins de fonctionsreturn

blocs

appels de fonctions

LAL - Orsay

18


assignations , expressions

controles

testsif



blocs

appels de fonctions

void f (){

int nombre;float valeur;

nombre = 123;valeur = nombre * 3;

}

LAL - Orsay

19


Opérateurs

+ - * / %

! && ||

== >= <= !=

arithmétiques

logiques

comparaisons

<< >> & | ^ ~binaires

+= -= *= /= %=

<<= >>= &= |= ^= ~=

LAL - Orsay

20


Opérateurs

+ - * / %

! && ||

== >= <= !=

arithmétiques

logiques

comparaisons

<< >> & | ^ ~binaires

+= -= *= /= %=

<<= >>= &= |= ^= ~=

modulo

LAL - Orsay

21


Opérateurs

+ - * / %

! && ||

== >= <= !=

arithmétiques

logiques

comparaisons

<< >> & | ^ ~binaires

+= -= *= /= %=

<<= >>= &= |= ^= ~=

décalage (droite - gauche)

LAL - Orsay

22


Opérateurs

+ - * / %

! && ||

== >= <= !=

arithmétiques

logiques

comparaisons

<< >> & | ^ ~binaires

+= -= *= /= %=

<<= >>= &= |= ^= ~=

and - or - xor

LAL - Orsay

23


Opérateurs

+ - * / %

! && ||

== >= <= !=

arithmétiques

logiques

comparaisons

<< >> & | ^ ~binaires

+= -= *= /= %=

<<= >>= &= |= ^= ~=

bit-not

LAL - Orsay

24


Opérateurs

+ - * / %

! && ||

== >= <= !=

arithmétiques

logiques

comparaisons

<< >> & | ^ ~binaires

+= -= *= /= %=

<<= >>= &= |= ^= ~=

not

LAL - Orsay

25


Opérateurs

+ - * / %

! && ||

== >= <= !=

arithmétiques

logiques

comparaisons

<< >> & | ^ ~binaires

+= -= *= /= %=

<<= >>= &= |= ^= ~=

and - or

LAL - Orsay

26


Opérateurs

+ - * / %

! && ||

== >= <= !=

arithmétiques

logiques

comparaisons

<< >> & | ^ ~binaires

+= -= *= /= %=

<<= >>= &= |= ^= ~=

égalité

LAL - Orsay

27



controles

testsif



blocs

appels de fonctions

void f (){

int nombre;enum {negatif, positif} signe;

if (nombre >= 0) signe = positif;else signe = negatif;

}

LAL - Orsay

28



controles

testsif



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;

}

LAL - Orsay

29



controles

testsif



blocs

appels de fonctions

void f (){

int nombre = 1;int compteur;

for (compteur = 0; compteur < 10; compteur++)

nombre *= 3;}

LAL - Orsay

30



controles

testsif



blocs

appels de fonctions

void f (){


compteur = 0;do{

nombre *= 3;if (nombre > 100) break;compteur++;

} while (compteur < 10);}

LAL - Orsay

31



controles

testsif



blocs

appels de fonctions

void f (){


compteur = 0;while (compteur < 10){

nombre *= 3;if (nombre > 100) break;compteur++;

}}

LAL - Orsay

32



controles

testsif



blocs

appels de fonctions

void f (){


for (compteur = 0; compteur < 10; compteur++){

nombre *= 3;if (nombre > 100) return;

}}

LAL - Orsay

33



controles

testsif



blocs

appels de fonctions

int f (){



nombre *= 3;if (nombre > 100) break;

}

return (nombre);}

LAL - Orsay

34



controles

testsif



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;

}

LAL - Orsay

35



controles

testsif



blocs

appels de fonctions

void f (){



nombre *= 3;if (nombre > 100) break;

}}

LAL - Orsay

36



controles

testsif



blocs

appels de fonctions

int addition (int val1, int val2);

void f (){

int nombre;

nombre = addition (12, 34);}

LAL - Orsay

37

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

38



controles

testsif



blocs

appels de fonctions

double sin (double angle);

void f (){

float valeur;

valeur = sin (PI/6);}

LAL - Orsay

39



controles

testsif



blocs

appels de fonctions

void* get_next_item ();

void f (){

void* reference;

reference = get_next_item ();}

LAL - Orsay

40



controles

testsif



blocs

appels de fonctions

void start (int parametre);void stop ();

void f (){

start (10);stop ();

}

LAL - Orsay

41

Fichier source

déclaration

déclaration

...

fonction

fonction

...

Visibilité des définitions.

Définitions globales :

visibles (accessibles) à

partir des autres fichiers.

LAL - Orsay

42

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

43



enum booleen{

faux,vrai

}

types simples : énumérations

LAL - Orsay

44


enum booleen{

faux,vrai

} valeur;

enum {

bleu,blanc,rouge

} couleur = rouge;

valeur :

couleur : rouge

LAL - Orsay

45



int x[100];char string[80];float valeur[10][5]

types complexes : les tableaux

LAL - Orsay

46


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

47


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]: 10valeur [0][3]:valeur [1][3]:valeur [0][4]:valeur [1][4]:

LAL - Orsay

48



struct point{

int x;int y;

}

types complexes : les structures

LAL - Orsay

49


struct Point{

int x;int y;

} sommet = {12, 23};

sommet.x : 12sommet.y : 23

LAL - Orsay

50


struct Point{

int x;int y;

} sommet = {12, 23};

sommet.x : 12sommet.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 :

LAL - Orsay

51


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 :



...

LAL - Orsay

52


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 :

LAL - Orsay

53



struct Point*void*

les pointeurs

char*double*enum booleen*

LAL - Orsay

54

Les pointeurs en C.

float valeur;void* pointeur;

pointeur :

valeur :

LAL - Orsay

55

Les pointeurs en C.

pointeur :

void f (){

float valeur;void* pointeur;

pointeur = &valeur;}

valeur :

LAL - Orsay

56

Les pointeurs en C.

void f (){

int nombre;float valeur;void* pointeur;

pointeur = &valeur;}

pointeur :

valeur :

nombre :

LAL - Orsay

57

Les pointeurs en C.

void f (){

int nombre;float valeur;void* pointeur;

pointeur = &valeur;pointeur = &nombre;

}

pointeur :

valeur :

nombre :

LAL - Orsay

58

Les pointeurs en C.

void f (){

int nombre;int* p1 = &nombre;

nombre = 10;*p1 = 10;

}

Ecritures équivalentes

LAL - Orsay

59

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

60

typedef struct{

int x, y;} Point;

main (){

Point* p1;Point* p2;


}


Déclaration de deux pointeurssur des types Point.

LAL - Orsay

61

typedef struct{

int x, y;} Point;

main (){

Point* p1;


}


Allocation d'une structure Point : p1 la désigne.

LAL - Orsay

62

typedef struct{

int x, y;} Point;

main (){

Point* p1;


}


Libération de la mémoire. p1 nedésigne plus rien.

LAL - Orsay

63

typedef struct{

int x, y;} Point;

main (){



}


p1 :

p2 :

LAL - Orsay

64


typedef struct{

int x, y;} Point;

main (){



}

p1 : 0x12345678

p2 :

p1->x :p1->y :

LAL - Orsay

65


typedef struct{

int x, y;} Point;

main (){



}

p1 : 0x12345678

p2 :

LAL - Orsay

66


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

67

Les tableaux de pointeurs

Des objets alloués en mémoire :

main (){

Point* p;

p = (Point*) malloc (sizeof(Point));p = (Point*) malloc (sizeof(Point));p = (Point*) malloc (sizeof(Point));p = (Point*) malloc (sizeof(Point));p = (Point*) malloc (sizeof(Point));

}

LAL - Orsay

68


main (){

Point* p[10];int i;

for (i = 0; i < 10; i++) p[i] = NULL;}

LAL - Orsay

69


main (){

Point* p[10];

p[0] = malloc (sizeof(Point));}

LAL - Orsay

70


main (){

Point* p[10];

p[0] = malloc(sizeof(Point));p[1] = malloc(sizeof(Point));

}

LAL - Orsay

71

Des ensembles : tableaux et listes.

#include "list.h"

main (){

List liste;

liste = ListCreate ();}

liste :

.first :

.last :

LAL - Orsay

72


p :

liste :

.first :

.last :

#include "list.h"

main (){

List liste;Point* p;

liste = ListCreate ();p = malloc (sizeof(Point));

}

LAL - Orsay

73


#include "list.h"

main (){


liste = ListCreate ();p = malloc (sizeof(Point));ListAddEntry (liste, p);

}

liste :

p :.first :.last :

.reference :

LAL - Orsay

74


#include "list.h"

main (){


liste = ListCreate ();p = malloc (sizeof(Point));ListAddEntry (liste, p);

}

liste :

p :.first :.last :

.reference :

LAL - Orsay

75


#include "list.h"

main (){


liste = ListCreate ();p = malloc (sizeof(Point));ListAddEntry (liste, p);p = malloc (sizeof(Point));

}

liste :

p :.first :.last :

.reference :

LAL - Orsay

76


#include "list.h"

main (){


liste = ListCreate ();p = malloc (sizeof(Point));ListAddEntry (liste, p);p = malloc (sizeof(Point));ListAddEntry (liste, p);

}

liste :

p :.first :.last :

.reference :

.reference :

LAL - Orsay

77


#include "list.h"

main (){


liste = ListCreate ();p = malloc (sizeof(Point));ListAddEntry (liste, p);p = malloc (sizeof(Point));ListAddEntry (liste, p);

}

liste :

p :.first :.last :

.reference :

.reference :

LAL - Orsay

78


liste :

.first :

.last :

.reference :

.reference :

.reference :

.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);

}}

LAL - Orsay

79

.first :

.last :current :

.reference :

.reference :

.reference :

.reference :next :

next :

next :

next : 0


Chaînage dans les listes.

LAL - Orsay

80


main (){


liste = ...;ListStartLoop (liste);

}

.first :

.last :current :

.reference :

.reference :

.reference :

.reference :next :

next :

next :

next : 0

LAL - Orsay

81


.first :

.last :current :

.reference :

.reference :

.reference :

.reference :next :

next :

next :

next : 0

main (){


liste = ...;ListStartLoop (liste);while (( p = ListGetNextEntry(liste) )){

p->x = 0;p->y = 10;

}}

LAL - Orsay

82

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 :

.reference :

l :

LAL - Orsay

83

Une liste multiforme : problème

Polygone Point Ligne Ligne

x, y x1, y1x2, y2

x1, y1x2, y2x1, y1

x2, y2...xn, yn

LAL - Orsay

84

Une liste multiforme : construction


x, y x1, y1x2, y2

x1, y1x2, y2x1, y1

x2, y2...xn, yn

.ref .ref .ref .ref

LAL - Orsay

85



x, y x1, y1x2, y2

x1, y1x2, y2x1, y1

x2, y2...xn, yn

.ref.ref .ref .ref.next .next .next .next

.first

.last

LAL - Orsay

86



.first

.last

? ? ? ?

LAL - Orsay

87



.first

.last

.type: .type: .type: .type:

LAL - Orsay

88



.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:

LAL - Orsay

89



.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:

LAL - Orsay

90


.x, .y: .x1, .y1:.x2, .y2:

.x1, .y1:

.x2, .y2:.x1, .y1:.x2, .y2:....xn, .yn:

.type: .type: .type: .type:

LAL - Orsay

91


.figure:

.x, .y:.figure:.x1, .y1:.x2, .y2:

.figure:

.x1, .y1:

.x2, .y2:

.figure:

.x1, .y1:

.x2, .y2:

...

.xn, .yn:

.type:

LAL - Orsay

92

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

93



.lignes:

main (){

Polygone* poly;

poly = malloc (sizeof(Polygone));poly->figure.ident = FigurePolygone;poly->lignes = ListeCreate ();

}.first.last

LAL - Orsay

94



.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:

LAL - Orsay

95



.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



Documents

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