A RECUPERER EN ENTRANT Le polycopié de Caml Partie 1 distribué ce matin Le polycopié de Caml Partie 2 Le polycopié de C

Dominique Rossin dominique.rossin@m4x.org Programmation C Dominique Rossin dominique.rossin@m4x.org

Généralités sur la syntaxe C Première partie Généralités sur la syntaxe C

Historique de C AT&T Bell Labs 1969 : Premiere Unix 1973 Unix écrit en C B.Kerninghan, D.Ritchie, The C programming Langage, Prentice Hall, 1978 C ANSI = C ISO (1990) = C« Standard » Kerningham & Ritchie, the C programming Langage second edition, Prentice Hall, 1988 SP Harbison, GL Stelle jr, C-A reference Manual, fourth edition, Prentice Hall 1995

Caractéristiques de C Compilé Typé avec des types structurés Limité à des primitives de base mais accompagné d’une librairie standard pour les copies complexes, les entrées/sorties, la gestion de la mémoire … Interfaçage possible avec tous les langages ATTENTION Langage laxiste à la compilation Débogage parfois difficile

Différences entre C et Java Java a repris une grande partie de C mais : C est compilé et utilise un préprocesseur Certains mots clés changent de définition Pas d’objets en C, juste des structures Gestion explicite de la mémoire en C En C on demande une taille n de mémoire En java new s’occupe de cette opération Il faut libérer la mémoire utilisée quand on utilise plus une structure de données En Java, le ramasseur de miettes (GC) s’en occupe En C il faut toujours déclarer avant d’utiliser

Exemple très simple en Java Fichier Bonjour.java public class Bonjour { public static void main(String args[]) { System.out.println("Bonjour "); } // fin de main } // fin de la classe On peut avoir plusieurs fonctions main l'exécution du programme commence par l'appel à la fonction main du programme appelé.

Un exemple très simple en C Fichier Bonjour.c (le nom importe peu) #include <stdio.h> int main(void) { printf("Bonjour\n"); return 0; } /* fin de main */ Il ne peut y avoir qu'une seule fonction main par programme Elle doit retourner un int (code d'erreur Unix)

Mise en œuvre En Java En C Compilation : javac Bonjour.java produit un fichier Bonjour.class (bytecode) commande java Bonjour : Interprétation de Bonjour.main(String args[]) En C prétrait., compilation, éd. de liens : gcc Bonjour.c produit un fichier a.out (code machine exécutable) commande ./a.out : exécution de la fonction main

Deuxième exemple Avec : formatage des impressions options de compilation

public class PGCD { public static void main(String args[]) { int a = 257, b = 381; if (a > 0 && b > 0) { System.out.println(" PGCD("+a+","+b+")"); while (a != b) { if (a < b) b = b-a; else a = a-b; System.out.println("=PGCD("+a+","+b+")"); } System.out.println("= "+a);

#include <stdio.h> int main(void) { int a= 257, b = 381; if (a > 0 && b > 0) { printf(" PGCD(%3d,%"d)\n",a,b); while (a != b) { if (a < b) b = b-a; else a = a-b; printf("=PGCD(%3d,%3d)\n",a,b); } printf("=%d\n",a); return 0;

Exemple de formatage avec printf PGCD(257,381) "PGCD(%3d,%3d)" =PGCD(257,124) =PGCD(133,124) =PGCD( 9,124) =PGCD( 9,115)

Options de compilation Prétraitement, compilation et édition de liens : gcc –Wall –g pgcd.o –lm –o pgcd l'option –Wall demande une compilation avec des diagnostics sur la propreté du code l'option –g demande que la table des symboles soit ajoutée à l'exécutable l'option –lm demande de lier la librairie mathématique l'option –o pgcd demande que le résultat (l'exécutable) soit nommé pgcd au lieu de a.out

Déclaration de variables Syntaxe, exemples: id_type id_variable; id_type id1,id2; id_type id = valeur; Les variables locales ne sont pas initialisées implicitement Les déclarations ne peuvent être qu'en début de bloc Des constructions comme for(int i = …) et similaires sont interdites

Types élémentaires La représentation n'est pas normalisée : char : entiers, codés sur 8 bits int : généralement codés sur 32 bits, float : généralement codés sur 32 bits (IEEE) double : généralement codés sur 64 bits En C, une affectation peut faire perdre implicitement de la précision. On a le droit d'écrire int i = 1.5;

Qualificatifs short et long short int (ou short simplement) : 16 bits long int (ou long simplement) : 32 ou 64 long long int : généralement 64 bits long double : au moins 64 bits

Conversion de types arithmétiques implicites En cas de +,*,<,… sur deux types différents: un opérant est long double => long double un opérant est double => conversion en double un opérant est float => conversion en float char et short int sont convertis en int En cas de = d'une valeur de mauvais type : conversion vers le type de la variable

sizeof pseudo-opérateur : sizeof(type) ou sizeof(expr) donne la taille en octets : sizeof(char)=1 nombre entier, calculé à la compilation "retourne" une valeur de type size_t (int ou long ?) incorrect : printf("%d\n",sizeof(…)); //suppose int printf("%ld\n",sizeof(…)); // suppose long correct printf("%ld\n",(long)sizeof(…));

Représentation des types numériques sizeof selon les systèmes C S I L LL F D LD cw/mac 1 2 4 8 gcc/hp gcc/pc 12 gcc/sun 16 gcc/alpha char, short, int,long, long long, float, double, long double

Qualificatifs signed et unsigned pour les types entiers seulement, modifient le domaine représenté mais pas la taille de la représentation, signed char : un octet : -128..127 unsigned char :un octet :0..255 char seul : signed ou unsigned ??? int est implicitement signed changent la sémantique des opérations et affectations

Valeurs booléennes En C, il n'y a pas de type spécifique aux booléens, on utilise les int false est représenté par 0 pas de valeur particulière pour true test indicateur : printf("%d\n",sizeof('a'=='b')==sizeof(int));

Tests, attention !!!! En C, on a le droit d'écrire : int i; … if (i = 0) … affecte 0 à i et vaut 0, ie. faux qui est très différent de : …if (i == 0) … compare 0 à i et vaut vrai ou faux selon le cas

Définition de constantes 3 moyens en C #define const enum

#define exemples Niveau préprocesseur = perte d'information #define N (1 << 4) #define DEUX_N ((N)+(N)) Niveau préprocesseur = perte d'information usage très répandu attention aux parenthèses

const Exemples : fondalementalement une déclaration de variable, const int N = 1 << 4; const int DEUX_N = N+N; fondalementalement une déclaration de variable, symboles utilisables par le débogueur l'affectation est en principe interdite, avec certains compilateurs, on a un simple warning

Enumérations Pour disposer de constantes symboliques entières sans #define Déclaration enum nom_d_enum { const1,const2,…}; Déclaration de variables enum nom_d_enum nom_de_variable

Fonctions Exemples : Déclaration obligatoire avant toute utilisation Récursivité à la Java void = absence d'argument ou de valeur en retour Exemples :

#include <stdio.h> #define DEBUT 0 #define FIN 10 static int carre(int); static int cube(int n) {return carre(n)*n;} static int carre(int n) {return n*n;} int main(void) { int i; for (i = DEBUT; i < FIN; i++) printf("%3d^2=%3d,%3d^3=%3d\n",i,carre(i),cube(i)); return 0; }

gcc –Wall –g carre.c –o carre 0^2= 0, 0^3= 0 … 5^2= 25, 5^3=125 6^2= 36, 6^3=216 7^2= 49, 7^3=343

Les boucles et tests Même syntaxe qu'en Java Les boucles for, while et do…while while (condition) {…} do {…} while (condition) for (i = 0; i < 10; i++) {…} Les structures de tests if (condition) {} else {}

Tableaux statiques et chaines de caractères Déclaration et allocation type_des_elements nom_tab[nombre]; Initialisation (+declaration et allocation) : int primes[]={2,3,5,7,11}; // int primes[6] char s[] = "abc"; /*char s[4]; s[0]='a'; s[1]='b';s[2]='c';s[3]='\0'*/ Les indices de tableau vont de 0 à N-1 mais IL N'Y A PAS DE VERIFICATION DE DEBORDEMENT

Copie d'un tableau ou d'une chaine void copie_tableau(char []t1,char []t2,int n) { while (n --> 0) t1[n]=t2[n]; } void copie_chaine(char []s1,char []s2) { int i=0; do s2=s1[i] while (s1[i++]!='\0');

Fonctions simples sur les chaines strlen(s) : retourne la longueur de la chaine s, sans compter le nul. Il faut mettre #include <string.h> strcmp(s1,s2): compare deux chaines et retourne un nombre <0,=0,>0. atoi(s),atol(s),atof(s) : conversion vers entier, long et double Librairie stdlib.h

Structures Déclaration struct nom {type1 c1; type2 c2;…}; Déclaration de variable : struct nom variable; Exemple struct evt {int jour,mois,annee; char evt[50]}; struct evt anniv; anniv.jour = 14; anniv.annee=1973; strcpy(anniv.evt,"Anniversaire de Dominique");

Exemple #include <stdio.h> #include <math.h> struct point {float x; float y} p10 = {0,10}; struct rect {struct point p1; struct point p2}; static double sqr(double x) { return x*x; } static double dist(struct point p1,struct point p2){ return sqrt(sqr(p1.x-p2.x)+sqr(p1.y-p2.y));

int main(void) { struct rect r = {{0,5},{25,20}}; return 0; }

Format d'affichage printf(format, arg1, arg2,…); format = chaine de caractères : %c : caractère %d : entier %f : float %s : chaine de caractères %u : entier non signé char msg_erreur[20][100]; void erreur(int no) { printf("erreur numero %d:%s",no,msg_erreur[no]); }

Divers Types synonymes : typedef type nom_nouveau_type; typedef struct {int re; int im;} Complexe; Complexe z;

Macros avec arguments #define mauvais_carre(x) x*x #define carre(x) ((x)*(x)) #define max(a,b) ((a)<(b)?(b): (a)) max(mauvais_carre(x+1),carre(x+1)); ((x+1*x+1)<(((x+1)*(x+1)))?…

Références La référence : Kerningham, Ritchie, The C Programming Language, second edition, Prentice Hall, 1988

Programmation C Deuxième Partie

Pointeurs et adresses Mémoire = Collection de cellules numérotées consécutivement et contenant chacun un octet Adresse = Localisation d'une variable dans la mémoire Pointeur = variable contenant l'adresse d'une variable Typage d'es pointeurs : T* est le type "adresse d'un objet de type T". Objectifs: Passage par référence pour modifier un paramètre efficacité dans la transmission des paramètres et du résultat référencer des objets dont la localisation est inconnue à la compilation

Référencement et déréférencement &var est l'adresse de (une référence à) la variable var *ptr est la variable pointée par le pointeur ptr. int age; printf("entrez votre age : "); scanf("%d",&age); int i=2,j=5; static void echanger(int *p1,int *p2) { int t=*p1; *p1 = *p2; *p2 = t; } echanger(&i,&j); /* i==5 et j==2*/

DEREFERENCER NULL provoque une erreur !!!! L'adresse NULL Un pointeur dont la valeur est ((void *) 0), noté par la constante symbolique NULL ne pointe vers aucune cellule mémoire DEREFERENCER NULL provoque une erreur !!!! int main(void) { int *p; printf("%p,%p\n",p,NULL); return 0; } 0xbffffc58,(nil)

int x = 1, y=2, z[4], *ip; ip = & x; /* ip pointe sur x*/ y = *ip; /* y==1*/ *ip = 0; /* x==0*/ *ip = *ip+10; /*x==10*/ ip = &z[2]; /*ip pointe sur z[2]*/ ip=&y; /*ip pointe sur y*/ ++*ip; /*y==2*/ (*ip)++; /*y==3*/ x y z[0] z[1] z[2] z[3] ip 100 104 108 112 116 120 124 1 2 0 1 100 1 1 100 1 2 100 10 2 104 10 1 104 10 1 100 10 1 116 10 3 104

Tableaux et pointeurs Ainsi,après int t[N], *p=t; /*p==&t[0]*/ on a : Le nom d'un tableau t s'évalue à l'adresse de t[0] Si un pointeur p pointe sur t[0], p+i pointe par définition sur t[i] Ainsi,après int t[N], *p=t; /*p==&t[0]*/ on a : p+i == &t[i], *(p+i) == t[i], et même t+i == &t[i], *(t+i) == t[i] Mais on ne peut pas affecter à un nom de tableau

Usage idiotique des pointeurs static int somme(int *t, int n) { int i,s; for(s=0,i=0; i < n; i++) s = s+t[i]; return s; } est équivalent à : int s = 0; while (n-- > 0) s+=*t++; /* lire *(t++) */

Déréférencements et type struct ptr->champ = (*ptr).champ typedef struct {int re; int im;} Complexe; Complexe *addition(Complexe *a,Complexe *b) { b->re=a->re+b->re; b->im=a->im+b->im; return b; } /* permet addition(u,addition(v,w)) */

Liste chaînées typedef struct cell { int val; struct cell *suivant; } cell,*liste; void affiche(liste l) { for (;l;l=l->suivant) printf("%d, ",l->val); }

Allocation dynamique malloc void *malloc(size_t) Permet la réservation de mémoire à l'exécution pour une variable inconnue à la compilation. malloc(n) renvoie: l'adresse de début d'un bloc de n octets NULL si plus aucune mémoire n'est disponible Schéma typique : /*typ p[N]; dynamique*/ typ *p=(typ *) malloc(N*sizeof(typ)); if (!p) erreur(…)

Constructeurs #include <stdio.h> #include <stdlib.h> typedef struct cell {int val; struct cell *next; } *List; List new_List(int v,List n) { List tmp = (List) malloc(sizeof(struct cell)); if (!tmp) { fprintf(stderr,"Plus de memoire "); exit(1); } tmp->val = v; tmp->next=n; return tmp; }

Constructeurs suite int main(int argc, char **argv) { int i; List l=NULL,v; for(i = 1,i < argc; i++) l = new_List(atoi(argv[i]),l); for (v=l;v;v=v->next) printf("%d\n",v->val); return 0; }

Désallocation void free(void *) Bloc perdu = plus aucun pointeur ne permet d'y accéder Pas de ramasseur de miettes  Il faut restituer explicitement les blocs qui ne sont plus utilisés l'argument doit être une adresse obtenue par malloc on ne doit restituer qu'une seule fois il ne faut plus utiliser aucune adresse vers ce bloc

Tableaux multidimensionnels Statiquement : type[N][M] réserve N*M variables, dans l'ordre T[0][0],…T[0][M-1],T[1][0],…,T[N-1][M-1] Dynamiquement : typ **T=(typ **)malloc(N*sizeof(typ*)); if (!T) erreur(); for(i=0; i<N;i++) { T[i] = (typ *) malloc(M*sizeof(typ)); if (!T[i]) erreur(); }

Taille 7 x 3 0 1 2 3 4 5 6 0,0 0,1 0,2 4,0 4,1 4,2 5,0 5,1 5,2 1,0 1,1 1,2 2,0 2,1 2,2 6,0 6,1 6,2 3,0 3,1 3,2

Tableau version deux int **t = (int **)malloc(N*sizeof(int*)); if (!t) erreur(); t[0] = (int *) malloc(N*M*sizeof(int)); for (i=1; i < N; i++) { t[i]=t[i-1]+M; if (!t[i]) erreur(); }

Fichiers et entrées / sorties FILE * = type de descripteur de fichier FILE *stdin,*stdout,*stderr sont ouverts automatiquement au début du programme exit (de n'importe ou) et return dans main font automatiquement fclose de tous les fichiers ouverts. (ce n'est pas le cas lors d'un plantage en cours du programme  utiliser fflush) /* Filtre ^M  ^J */ #include <stdio.h> int main(void) { int c; while ((c=getchar())!=EOF) putchar(c==13?10:c);

Ouverture et fermeture de fichier FILE *fopen(const char * nom,const char *mode); nom=chemin d'accès au fichier mode=="r" pour ouvrir en lecture mode=="w" pour ouvrir en écriture (création ou remplacement) mode=="a" opur ouvrir en écriture à la fin du fichier retourne NULL si erreur int fflush(FILE *); force l'écriture des tampons renvoie 0 ou EOF en cas d'erreur int fclose(FILE *); ferme le fichier après un fflush éventuel

Lecture de fichiers char getc(FILE *); lit un caractère et retourne sa valeur getchar() est équivalent à getc(stdin) renvoie EOF si fin de fichier ou erreur int fscanf(FILE *,const char *format,…); scanf(…) est équivalent à fscanf(stdin,…) char *fgets(char *line,int max,FILE *); lit une ligne dans le buffer line de taille max renvoie NULL si fin de fichier ou erreur int feof(FILE *); renvoie 1 si la fin de fichier est atteinte,0 sinon

Ecriture de fichiers int putc(int c,FILE *f); Ecrit le caractère c renvoie sa valeur ou EOF si problème putchar(c) est équivalent à putc(c,stdout) int fprintf(FILE *,const char *format,…); printf(…) est équivalent à fprintf(stdout,…) renvoie le nombre de caractères écrits ou EOF si erreur

Divers Arithmétique des pointeurs : typ t[20],*p1=t+13,*p2=t+17; int n=p2-p1; /* n==4*/ Pointeurs sur des fonctions : double x,y; double (*f)(double); f=sin; y=f(x); Permet le passage de fonctions en paramètre

static int add(int a, int b) { return a+b; } static int mul(int a, int b) { return a*b; static int reduce(int *t,int n,int v, int (*f)(int,int)) { int i; for (i = 0; i < n; i++) v=f(v,t[i]); return v; int main(void) { int t[] = {1,3,7}; printf("%d\n",reduce(t,3,0,add)); /* 11 */ printf("%d\n",reduce(t,3,1,mul)); /* 21 */ return 0;