Introduction au Langage C

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

Fichier source Fichier source Fichier source déclaration ... fonction Fichier source Fichier source Fichier source Fichier source Fichier source LAL - Orsay

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

fonction Fichier source int division (int v1, int v2) { /* déclarations locales */ instructions executables } déclaration ... fonction LAL - Orsay

fonction Fichier source int addition (int v1, int v2) { int resultat; resultat = v1 + v2; return (resultat); } déclaration ... fonction LAL - Orsay

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

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

Type = modèle pour les objets char short int long float double types simples LAL - Orsay

valeur : int valeur; double nombre = ; double autreNombre = nombre * 3; float Pi = ; int largeur, hauteur; char code = 'x'; nombre : autreNombre : Pi : 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

valeur : enum booleen { faux, vrai } valeur; enum bleu, blanc, rouge } couleur = rouge; couleur : rouge LAL - Orsay

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

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

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

Type = modèle pour les objets types complexes : les structures struct point { int x; int y; } LAL - Orsay

sommet.x : 12 sommet.y : 23 struct Point { int x; int y; } sommet = {12, 23}; LAL - Orsay

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

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

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

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

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

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

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

typedef struct { int x, y; } Point; main () Point* p1; Point* p2; p1 = (Point*) malloc (sizeof(Point)); free (p1); } p1 : p2 : LAL - Orsay

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 : LAL - Orsay

typedef struct { int x, y; } Point; main () Point* p1; Point* p2; p1 = (Point*) malloc (sizeof(Point)); free (p1); } p1 : 0x p2 : LAL - Orsay

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

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

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

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

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

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

#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

#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

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

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

.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

? ? ? ? LAL - Orsay

.type: .type: .type: .type: LAL - Orsay

.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

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

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

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

Introduction au Langage C

Présentations similaires

Présentation au sujet: "Introduction au Langage C"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Introduction au Langage C

Présentations similaires

Présentation au sujet: "Introduction au Langage C"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back