INF 104 (SELC) 2012-2013 Introduction au langage C

INF 104 (SELC) 2012-2013 Introduction au langage C

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Quelques fonctions d E/S Page 2

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs (1) Instructions Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Quelques fonctions d E/S Page 3

Langage C : historique Le langage C a été créé par B. Kernighan et D. Ritchie dans les années 1970 et formalisé en 1978 (The C Programming Language, 2nd ed., by Kernighan and Ritchie, Prentice Hall), à cette époque le système UNIX a été écrit en C. Les créateurs du langage le caractérisent ainsi : Économie d'expression, Absence de restrictions, Ni de très haut niveau, ni très riche, Objectif : efficace et adapté à la programmation système (par exemple : systèmes embarqués) Si le langage remplit bien le rôle qui lui a été assigné, une des conséquences de ces hypothèses d'extrême simplicité est la suivante : Pas de contrôle à l'exécution (exemples : pas de gestion de la mémoire, pas de gestion d'exceptions), le comportement des applications va dépendre du système sous-jacent, Page 4

Langage C : caractéristiques Peu de constructions à connaître pour l utiliser, Langage très concis, les contraintes syntaxiques sont faibles et peuvent être levées (le cast operator), un programme est donc vite écrit, De plus, le compilateur est «permissif» (avec gcc : il faut utiliser l option -Wall) on obtient donc facilement un exécutable, mais: 1. la plus grande partie de la mise au point se fera durant l exécution (pas de contrôle sur la taille des tableaux, typage par défaut (en entier) des fonctions et de leur arguments, ) 2. Le programmeur doit savoir comment fonctionne le langage pour l'utiliser correctement, L'aspect simple du C masque le fait qu'il faut plus de connaissances sur le système qu'en Java pour l'utiliser Page 5

Quelques différences C/Java Niveau développement : objet vs fonctionnel. En simplifiant : Java : les objets encapsulent les données et leur traitement, l application doit respecter une structure hiérarchique (packages, classes) ; C : les données sont séparées de leur traitement, la fonction est le moyen d'organisation de l'application, pas d'obligation de structuration, elle doit être volontaire, Niveau chaîne de production, pour passer du fichier source à une exécution : En java : fichier source bytecode exécution par la JVM En C : fichier source fichier objet fichier exécutable par la machine, Niveau support d'exécution : Gestion mémoire : le GC de la JVM gère automatiquement la mémoire en Java, en C ce travail est à la charge du programmeur Page 6

Environnement de développement (1/2) Java et Eclipse: Pendant les TP Java, l'utilisation d'eclipse a masqué les étapes intermédiaires qui permettent de passer du fichier source à l'exécution de l'application par la JVM. Pour passer, par exemple, du fichier source exo.java à une exécution sur la JVM, vous auriez pu utiliser les deux commandes suivantes: 1- javac exo.java (appel au compilateur java et production d'un fichier bytecode appelé exo.class) 2- java exo (exécution du fichier exo.class par la JVM) Pendant les TP langage C, pour comprendre les différentes étapes qui font passer du fichier source au fichier exécutable on utilisera le langage de commandes, (cf. page suivante) Page 7

Environnement de développement (2/2) Comment passer d'un fichier source C à une exécution : 1. Produire un fichier exécutable (compilation et édition de liens) à partir du fichier source exo.c : $gcc -Wall exo.c -o exo -Wall (Warnings all), pour que le compilateur (par défaut très permissif) indique toutes les fautes, même si elles n empèchent pas la production d un fichier exécutable. -o (output), le fichier exécutable s'appelera exo au lieu de a.out, appelation historique 2. Lancer l exécution : $exo Page 8

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Quelques fonctions d E/S Page 9

Structure d'un programme C : un jeu de fonctions La structure d'un programme C est la suivante : un fonction main et, généralement, plusieurs autres fonctions qui peuvent être réparties dans plusieurs fichiers. <directives pour le préprocesseur> <déclarations de variables globales> int main(){ variables locales à la fonction main instructions associées à la fonction main fonc_1(){ variables locales à la fonction fonc_1 fonc_n(){ instructions associées à la fonction fonc_1 variables locales à la fonction fonc_n instructions associées à la fonction fonc_n Page 10

Structure d'un programme : C vs Java Ci-contre, l'affichage du message «coucou! «écrit en C (puis en Java). Ce que l'on observe : 1. Des commentaires inclus entre /* et */ 2. Une ligne qui commence par le caractère #, cette ligne est traitée par le préprocesseur, particularité du langage C, 3. Un nom de fonction, main, point d entrée du système dans le programme, mais en C : main accepte en C deux arguments argc: nombre de mots argv. : tableau contenant ces mots 4. Pour les E/S : printf vs System.out.println /* Commentaire */ #include <stdio.h> int main(int argc, char* argv[]){ printf( coucou!\n ); return 0; // Commentaire import java.io.*; public class coucou{ public static void main (String args []){ System.out.println( coucou! ); Page 11

Entrées-sorties : C vs Java Entrées-sorties : différences C/Java #include <stdio.h> Le fichier stdio.h contient les signatures des fonctions d entréessorties int main(int argc, char*argv[]) { int k = 5; float r = 7.0; printf("k = %d, r = %f\n", k, r): import java.io.*; import java.util.formatter; public static void main(string args[]){ Formatter fmt = new Formatter(); int k = 5; float r = 7.0F; fmt.format("k = %d, r = %f", k, r); System.out.println(fmt); // equivalent à : System.out.println("k = " + k + "r = "+ r); Page 12

Structure d'un programme : exemple Le point d'entrée : la fonction main /****************************** main ******************************/ #include <stdio.h> int main(int argc, char*argv[]) { int k; float r, s; float somme(float, float ); int carre(int); s = 3.0; r = somme(s, 2.0); k = carre(3); printf("k = %d, r = %f\n", k, r); return 0; Le rôle de cette ligne sera expliqué dans la section «préprocesseur» Exemple de jeu de fonctions : /****************************** Somme de deux réels ******************************/ float somme(float x, float y){ float z; z = x + y; return z; /****************************** Carre d un entier ******************************/ int carre(int j){ return (j * j); Page 13

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Quelques fonctions d E/S Page 14

Le préprocesseur : fonctionnement Les lignes commençant par #, appelées directives, sont traitées par le préprocesseur AVANT la compilation Nous allons voir quelques une de ces directives : #define #include #ifdef et #endif Remarque : l'option E de gcc permet de voir l'effet du préprocesseur sur le fichier source /* essai.c */ #define DIM 128 int main(int argc, char*argv[]){ int i; short tab [DIM ] ; for (i=0; i<dim ; i++)tab[i]=0; return 0; gcc -E essai.c int main(int argc, char*argv[]){ int i; short tab [128] ; for (i=0; i<128; i++)tab[i]=0; return 0; Page 15

Le préprocesseur : #define #define effectue des substitutions de chaines de caractères. Par exemple, dans l'exemple suivant, les occurrences des caractères MAX sont remplacées par les caractères 100 Attention aux effets de bord, ici, les parenthèses qui encadrent le symbole «x «les évitent : #define double1(x) (2*x) #define double2(x) (2*(x)) #define MAXIMUM 100 #define double1(x) (2*x) #define double2(x) (2*(x)) int main(int argc, char*argv[]){ long int i,j, k; i = MAXIMUM ; j = 0; k = double1(1+2); k = double2(1+2); return 0; double1(1+2) donne 4 (* est prioritaire sur +), double2(1+2) donne 6, Effet du préprocesseur int main(int argc, char*argv[]){ long int i, j,k; i = 100; j = 0 ; k = (2 * 1 + 2 ); k = (2 *( 1 + 2 )); return 0 ;

Le préprocesseur : #ifdef, #endif Si la variable suivant ifdef n'est pas définie, les instructions comprises entre ce ifdef et le endif suivant ne sont pas incluses dans le fichier à compiler. On donne ci-dessous un exemple (utilisation avec gcc et l option D) : /* essai.c */ #include <stdio.h> int main(int argc, char*argv[]) printf("debut de main\n"); #ifdef DEBUG printf("fin de main\n"); #endif return 0; $ gcc -Wall essai.c -o essai $ essai Debut de main $ gcc -Wall -DDEBUG essai.c -o essai $ essai Debut de main Fin de main Page 17

Le préprocesseur : #include Cette directive demande au préprocesseur d'ajouter le contenu d'un fichier dans le fichier courant, Elle sert en général à inclure les prototypes des fonctions utilisées, mais non définies, dans un programme : /*** main.c ***/ #include <stdio.h> #include "carre.h" /*** carre.h ***/ double carre (float); int main(int argc, char*argv[]){ double x; x = carre(4); printf("x = %f\n", x); return 0; /* carre.c */ double carre(float var){ return (var * var); Effet du préprocesseur double carre (float); int main(int argc, char*argv[]) { double x; x = carre(4); printf("x = %f\n", x); return 0; Page 18

Le préprocesseur : #include Effet d'une exécution avec et sans inclusion du fichier carre.h : Sans #include "carre.h" dans le fichier essai.c : $gcc main.c carre.c -o essai $essai x = 0.000000 (la conversion de 4 au format réel n a pas été faite) Avec #include "carre.h " dans le fichier essai.c : $gcc main.c carre.c -o essai $essai x = 16.000000 (conversion de 4 au format réel grâce au prototype) Page 19

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Quelques fonctions d E/S Page 20

Variables : type, allocation mémoire, durée de vie Le type d une variable définit : l'encombrement mémoire de la variable (sa taille, mesurée en octets), les règles d utilisation de cette variable (entier, pointeur, ), la zone mémoire (pile, ) où est placée la variable, La place (le bloc, délimité par { ) de sa déclaration détermine : sa durée de vie, qui peut être celle : du programme, de la fonction, sa visibilité (variables globales ou locales, à une fonction, à un fichier, ), Page 21

Variables : allocation en mémoire L'espace d'adressage alloué pour les variables utilisées par une application est divisé en deux parties : l'une dite statique, l'autre dynamique : Partie dynamique : 1. la pile qui contient les variables locales, 2. Le tas (heap), qui abrite les variables allouées en utilisant malloc en C, new en Java, Partie statique : 1. Une zone accessible en lecture et écriture : variables globales déclarées static ou non, variables locales déclarées static, 2. Une zone accessible en lecture seule Page 22

Types de base : les entiers Plusieurs types d'entiers : char, short, int et long. La coutume veut que int soit implanté sur le mot machine et short sur 2 octets. int ne devrait donc pas être utilisé parce qu il est dépendant du matériel, le qualificatif unsigned indique qu on n utilise pas le bit de signe, ce qui double la dynamique des positifs, Implantation mémoire de facto : taille (char) = un octet (8 bits), taille (short) = deux octets, taille (char) < taille (short) <= taille (int ) <= taille (long) Remarque : C est faiblement typé : pas de (vrai) type caractère, ni de type tableau Page 23

Types : opérateur sizeof ()! L opérateur sizeof() renvoie, en octets, la taille d une variable ou d un type : #int main (void){ long k; int i; short l; char car; printf("sizeof(long) : %ld\n", sizeof(long)); printf("sizeof(int) : %ld\n", sizeof(int)); printf("sizeof(short) : %ld\n", sizeof(short)); printf("sizeof(char) : %ld\n", sizeof(char)); printf("sizeof(k) : %ld\n", sizeof(k)); printf("sizeof(i) : %ld\n", sizeof(i)); printf("sizeof(l) : %ld\n", sizeof(l)); printf("sizeof(car) : %ld\n", sizeof(car)); return 0; Résultats (sur une machine 64bits) : sizeof(long) : 8 sizeof(int) : 4 sizeof(short) : 2 sizeof(char) : 1 sizeof(k) : 8 sizeof(i) : 4 sizeof(l) : 2 sizeof(car) : 1 %ld : format entier long Page 24

Types de base : le type char Les char sont traités comme des entiers sur un octet, attention aux effets de bord: #include <stdio.h> int main(int argc, char*argv[]){ char carac1; unsigned char carac2; %c : format ASCII carac1 = 255; carac2 = 255; printf("carac1 = %d carac2 = %d\n", carac1, carac2); carac1 = 'A'; carac2 = '1'; printf("carac1 = %c carac2 = %c\n", carac1, carac2); printf("carac1 = %d carac2 = %d\n", carac1, carac2); /* Les char sont traitées comme des int!!!! */ carac1 = carac1 + 1; printf("carac1 = %c (%d)\n", carac1, carac1); return 0; Résultats : carac1 = -1 carac2 = 255 carac1 = A carac2 = 1 carac1 = 65 carac2 = 49 carac1 = B (66) Page 25

Tableaux Exemples : déclarations d un tableau de 20 entiers et d un tableau de 8 réels : int tab1[20]; /* tab1[0] à tab1[19] */ float tab2[8]; /* tab2[0] à tab2[7] */ Il n'y a pas à proprement parler de type tableau en C : le nom d un tableau est un pointeur constant sur l adresse de début du tableau. Exemple : soit la déclaration : short tab[4]; Si on suppose que le tableau est implanté à l'adresse 1000, la case dont le nom est tab contient la valeur 1000. tab 1000 1000 1002 1004 1006 tab[0] tab[1] tab[2] tab[3] Page 26

Tableaux de char et chaînes de caractères C donne un support minimal pour le traitement des chaines de caractères, il n'y a pas de type char ou String comme en Java, Une chaîne de caractères est un simple tableau d'octets ( byte en Java) auquel est ajoutée une propriété : Le caractère «NULL» (noté '\0 ) indique la fin de chaîne, Ceci a de nombreuses conséquences, en particulier : On ne peut pas copier une chaine dans une autre par affectation (=), il faut utiliser la fonction strcpy qui copie une chaine y compris le «NULL». Il n'y a pas de vérification sur la taille de la chaine destinataire. Exemple, le programme suivant copie 7 octets à partir de texte[0] : char texte[10];... strcpy(texte, "coucou"); Contenu de texte après exécution de strcpy: c o u c o u '\0' Page 27

Java et les chaînes de caractères En Java, les caractères sont codés sur un ou deux octets (byte : un octet) : #public static void main(string[] args) { Formatter fmt = new Formatter(); String chaine1 = new String("año : année"); System.out.println(chaine1); byte[] octets = chaine1.getbytes(); // taille du tableaux d octets : System.out.println("taille du tableau d octets : " + octets.length); // Contenu du tableau d octets : for (int k = 0; k < octets.length; k++) fmt.format("0x%x, ", octets[k]); System.out.println(fmt); // Re-conversion des octets en string : String chaine2 = new String(octets); System.out.println("chaine2 = " + chaine2); Les caractères ñ et é sont codés sur 2 octets, les autres sur un seul : Résultat : año : année taille du tableau d octets : 13 0x61, 0xc3, 0xb1, 0x6f, 0x20, 0x3a, 0x20, 0x61, 0x6e, 0x6e, 0xc3, 0xa9, 0x65, chaine2 = año : année Page 28

Types composés : «struct» On peut composer les types de base pour créer des types plus élaborés, appelés struct. La déclaration ci-contre créé le type «struct complexe» Pour accéder à un élément d une composition «struct» on utilise le point (.) L'opérateur = est le seul qui s'applique aux struct, int main(int argc, char*argv[]){ struct complexe { float reel; float imagine; ; struct complexe c1; struct complexe c2; c1.reel = 2.0; c1.imagine = 3.0; c2 = c1; return 0; Page 29

Types composés : struct et typedef L'instruction typedef permet d'associer un raccourci à un nom de type, la syntaxe est la suivante : typedef <type> <nom> ; Si on reprend l 'exemple précédent, on pourrait définir un raccourci complexe_t : typedef struct complexe complexe_t; On aurait pu le définir directement, sans utiliser l intermédiaire complexe : typedef struct { float reel; float imagine; complexe_t; Dans tous les cas, on déclare ensuite : : complexe_t c1, c2 ; Page 30

Types composés : taille (en mémoire) des variables Attention : la taille d un type composé est supérieure à la somme de la taille de chacun de ses éléments : #include <stdio.h> typedef struct{ int x; long y; char couleur; point_t ; int main (void){ printf("sizeof(point_t) : %d\n", (int)sizeof(point_t)); printf("sizeof(int) + sizeof(long) + sizeof(char) : %d\n", sizeof(int) + sizeof(long) + sizeof(char) ); return 0; ; Résultat : taille de point_t (sizeof(point_t)) : 24 taille de la somme des elements d un point : 13 Page 31

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Pointeurs(1) Instructions Quelques fonctions d E/S Page 32

Pointeurs : définition Un pointeur est une variable contenant l'adresse (la référence) d'une autre variable : Ici, la variable i contient la valeur 5, la variable ptr_i contient l'adresse de i (rappel : i est le nom symbolique de la cellule mémoire d'adresse 234) i 5 234 ptr_i 234 Prendre le contenu d'un pointeur pour accéder à l'information qui se trouve à cette adresse s'appelle un déréférencement ; en C, cette opération est notée * Exemple : *ptr_i = 17 ; a l'effet suivant: i 17 234 ptr_i 234 Page 33

Pointeurs : opérateurs associés L'opérateur * déréférence le pointeur (prend sa valeur et s'en sert comme adresse), L'opérateur & renvoie la référence (l'adresse) d'une variable, Exemple : int i = 2, j = 4, k = 8; /* déclaration et allocation mémoire pour les pointeurs */ int * ptr1, * ptr2; /* initialisation des pointeurs*/ ptr1 = &i; ptr2 = &j; /* k reçoit la valeur de l entier pointé par ptr1 */ k = *ptr1; i 2 j 4 k 8 k 2 ffaac ffaa8 0 0 ffaac ffaa8 ptr1 ptr2 ptr1 ptr2 ptr1 = ptr2; ffaa8 ptr1 /* j reçoit la valeur 16 */ *ptr1 = 16; j 16 ffaa8 ptr2 Page 34

Pointeurs : syntaxe Le type d'un pointeur est celui de l'objet pointé suivi d'un astérisque (*), Le programme ci-contre indique comme sont déclarés et initialisés deux pointeurs, l'un sur des réel, l'autre sur des entiers. Attention : Tous les pointeurs sont implantés sur le même nombre d'octets, quel que soit le type de l'élément pointé, Le type d'un pointeur va jouer sur son arithmétique (sera vue en partie 2) int i ; float r ; /* declaration */ int * ptr1 ; float * ptr2; /* initialisation */ ptr1 = &i; ptr2 = &r; Page 35

Retour sur les références en Java (1/2) Dans le programme ci-contre, P1 et P2 sont des références vers deux objets du type Point : Elles référencent d abord deux objets différents P1 et P2 Puis elles pointent toutes deux sur le point P1... Point P1 = new Point(0, 10); Point P2 = new Point(50, 0); P1.affiche(); P2.affiche(); System.out.println("P1: "+P1+" P2: "+P2); P2 = P1; P2.affiche(); System.out.println("P1: "+ P1+" P2: "+P2); class Point{ int x, y; Point(int x, int y){ this.x = x; this.y = y; void affiche(){ System.out.println( coord.: (" +x+", "+ y+")"); Page 36

Retour sur les références en Java (2/2) Exécution du programme précédent : P1 et P2 sont maintenant des références vers le même objet de type Point.... coord. : (0, 10) coord. : (50, 0) L objet de coordonnées (50,0) n'est plus référencé, le garbage collector pourra libérer la mémoire qu il occupe P1 et P2 ne sont pas à proprement parler le nom des objets. On pourrait ajouter un champ nom du type String et les appeler A et B, par exemple. P1: Point@eb42cbf P2: Point@56e5b723 coord. : (0, 10) P1: Point@eb42cbf P2: Point@eb42cbf Page 37

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Pointeurs(1) Instructions Quelques fonctions d E/S Page 38

Expression vs instruction Une expression utilise des opérateurs appliqués à des variables ou constantes et renvoie une valeur, exemples : j*2 /* renvoie 2xj, pas d affectation */ i=j<<1 /* valeur de j décalée d un bit vers la gauche, puis rangée dans i (i=2xj), renvoie cette valeur */ i<j /* si vrai l expression renvoie 1 sinon 0 */ Une instruction peut se réduire à une expression suivie d un point virgule, donc les instructions suivantes ne provoquent pas d'erreur, au plus des avertissements, un fichier exécutable sera produit : k+5; j>2; ; /* suite à une erreur de frappe on a saisi k+5; au lieu de i=k+5; */ Page 39

Instructions : syntaxe Les instructions : sont terminées par un point virgule ( ; ), sont comprises dans un bloc d instructions c est à dire une liste d instructions encadrées par des accolades ( { ), peuvent se réduire à une expression suivie d un point virgule, à la différence des expressions qui renvoient une valeur, elles provoquent une action, Remarque : une expression peut modifier une case mémoire si elle fait une affectation (opérateurs =, ++, par exemple), Exemples : k=j*2; i=j<<1; if(i<j)k=2; Page 40

Instructions : conditionnelles, itératives Instructions conditionnelles : if ( expression ) instruction(s) if ( expression ) instruction(s) else instruction(s) Instructions d itération : for(expression1; expression2; expression3;) instruction(s) Avec : expression1: initialisations, expression2: conditions d arrêt, expression3: incréments, Exemple : for(i=0; i<10; i=i+1) tab[i] = 0 ; Instruction while et do while : 1.while (expression) instruction(s) l'expression est évaluée, si sa valeur est nulle, on sort du while, 2.do instruction(s) while (expression) l expression est évaluée, si sa valeur est nulle, on sort du while, les instructions sont exécutées au moins une fois, Page 41

Instructions : ruptures de séquence Instructions de rupture de séquence : break : fait sortir du bloc d instructions de la boucle (for, while, do while) ou du switch dans lequel il est inclus, vérifier s il peut être remplacé par un while, continue fait passer à l itération suivante du for, while, do while dans lequel il est inclus, goto (!!) Exemples : while (<expression>) { <instructions> if (<condition>) break; <instructions> /* le break fait sortir ici */ while (<expression>) { <instructions> if (<condition>) continue; <instructions> /* le continue conduit ici */ Page 42

Instructions : switch Fonctionnement : l expression expression-switch est évaluée et donne une valeur V, le flot de contrôle passe au case dont la valeur est égale à V, ou à default si aucune ne correspond. On continue dans le switch à partir de cette entrée. Les sources d erreurs : default est optionnel, break est optionnel, sans break on passe au case suivant, cette instruction doit être vue comme une table à plusieurs points d entrée : on entre dans la table et on exécute tout ce qui suit switch (expression-switch) { case expression-constante1 : instruction break case expression-constante2 : instruction case expression-constante3 : case expression-constante4 : instruction break; default : instruction Page 43

Instruction switch : exemple Exemple : Résultat : var vaut 0, entree default var vaut 1, entree 1 var vaut 2, entree 2 var vaut 2, entree 3 var vaut 2, entree 4 var vaut 3, entree 3 var vaut 3, entree 4 var vaut 4, entree 4 var vaut 5, entree default #include <stdio.h> int main(int argc, char*argv[]) { int var = 0 ; for (var = 0; var < 6; var++) { switch (var) { case 1 : printf("var vaut %d, entree 1\n", var); break; case 2 : printf("var vaut %d, entree 2\n", var); /* cas " et 4 identiques */ case 3 : printf("var vaut %d, entree 3\n", var); case 4 : printf("var vaut %d, entree 4\n", var); break; /* option default facultative */ default: printf("var vaut %d, entree default\n", var); return 0; Page 44

Opérateurs : opérateur d'affectation = Opérateur = à gauche de cet opérateur, il faut mettre une variable modifiable, ce qu on appelle une lvalue, Remarque : une lvalue peut être le résultat d une expression, Cet opérateur copie la valeur retournée par la partie droite dans la lvalue, Si la valeur à déposer n est pas du même type que la lvalue, il y a conversion de type automatique, Remarque : en tant que membre d une expression, cet opérateur renvoie la valeur déposée dans la variable, Attention, c est pour cette dernière raison que : if(i == 0) et if(i = 0) sont syntaxiquement correctes et sources de multiples erreurs! si on utilise des constantes, écrire if (4 == x) au lieu de if (x == 4) Page 45

Opérateurs : autres opérateurs d'affectation Les opérateurs unaires : ++, -- en post ou pré incrément/décrément sont des opérateurs d'affectation : i++ signifie i=i+1, ne pas confondre : j = i+1 : mettre la valeur de i incrémentée de un dans j, seule la variable j est modifiée, j = i++ : ranger la valeur de i dans j ; puis incrémenter i de un,les deux variables i et j sont modifiées, Exemple, soit : j = 0 ; i = 2 ; Après j = i++ ; (post-incrément) : i = 3, j = 2 Après j = ++i ; (pré-incrément) : i = 3, j = 3! Page 46

Opérateurs : opérateurs de comparaison Ces opérateurs (<, >, == ) travaillent sur des opérandes entiers ou réels et renvoient les entiers 1 (vrai) ou 0 (faux), Il n'y a pas de type booléen (même si la norme C99 introduit _bool), Attention : La syntaxe du if est : if( expression ). Lors de son exécution : 1. L'expression est évaluée, si sa valeur est 0, elle est considérée fausse, 2. Sinon elle est considérée comme vraie (tout ce qui n'est pas faux est vrai), Conséquence, en C : if( i=-1 )est vrai Page 47

Opérateurs : opérateurs au niveau bit Ces opérateurs sont plutôt utilisés sur des variables du type unsigned Opérateurs de décalage : >> (à droite), << (à gauche) Exemple : j=j<<2 ; (revient à multiplier j par 4) Opérateurs bit à bit : ~ (NOT), & (AND), (OR), ^ (XOR) Ne pas les confondre avec les opérateurs logiques && et qui renvoient 1 ou 0 Exemple (0x précédant une constante veut dire base 16) : j=j&0xff ; (pour garder l'octet de poids faible de la variable j) Représentation binaire de 0xff Représentation binaire de j&0xff 0000 0000 0000 0000 0000 0000 1111 1111 0000 0000 0000 0000 0000 0000 xxxx xxxx Page 48

Opérateurs : opérateurs logiques Les opérateurs logiques sont notés :! (NON), &&(ET), (OU), Ils traitent les variables comme des entiers en appliquant la règle : 0 est faux, tout le reste est vrai, Ils renvoient 1 si le résultat est vrai, 0 sinon, ils acceptent n importe quel opérande numérique, attention : l évaluation se fait de gauche à droite, et seulement si nécessaire : Dans l expression : if ((i++>j) && (k++>l)), la sous-expression (k++>l)n est pas évaluée si (i++>j) est fausse, Page 49

Opérateurs : le «cast operator «L'opérateur «cast», sert à forcer les conversions de type (permissivité du C), sa syntaxe est la suivante : (type voulu)expression Exemple d'utilisation de l'opérateur cast: int i = 20; int j = 7; float r; r = i/j ; resultat r = 2.000000 r = (float)(i/j); resultat r = 2.000000 r = (float)(i)/j; resultat r = 2.857143 r = 20/7; resultat r = 2.000000 r = 20/7.0; resultat r = 2.857143 Page 50

Opérateurs : règles de conversion de type L opérande de type le plus faible est converti dans le type de l opérande le plus fort. Le résultat est du type de l opérande le plus fort, Voici comment se font les conversions de type dans une expression arithmétique : char,int short char, int short unsigned long float double int unsigned long double unsigned unsigned unsigned long double long long long long double float double double double double double Page 51

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Quelques fonctions d E/S Page 52

Bibliothèque d'e/s : saisies clavier Comment saisir des valeurs au clavier : /#include <stdio.h> int main(int argc, char* argv[]){ int dim = 0; float x = 0.0; Attention : pointeurs printf("donner dim (entier) "); scanf("%d", &dim); printf("donner x (reel) "); scanf("%f", &x); printf("dim = %d et x = %f\n", dim, x); return 0; Exemple d exécution : Donner dim (entier) 3 Donner x (reel) 2 dim = 3 et x = 2.000000 Page 53

Bibliothèque d'e/s : lire un fichier Pour travailler sur un fichier, on associe à son nom une variable. On accède ensuite au fichier en donnant le nom de cette variable. Fonctions utiles pour les TP : Ouverture d'un fichier : fopen, Lire (écrire) un texte dans un fichier : fscanf (fprintf),! Format %s pour lire une chaine de caractères (un mot) #include <stdio.h> #define NMOTS 10 int main(int argc, char*argv[]){ FILE *fichier; char mot[30]; int i, ret_lec; / **** ouverture du fichier en lecture ****/ fichier = fopen("prog1.c", "r"); /**** lire des mots dans le fichier et les afficher ****/ for(i=0; i<=nmots; i++){ ret_lec = fscanf(fichier, "%s", mot); return 1; Page 54

Lire un fichier : exemple Soit le fichier prog1.c (l exécutable va ouvrir et lire ce fichier source) : #include <stdio.h> #define NMOTS 10 int main(int argc, char*argv[]){ FILE *fichier; char mot[30]; int i, ret_lec; / **** ouverture du fichier en lecture ****/ fichier = fopen("prog1.c", "r"); if(fichier == NULL){ printf("le fichier n'existe pas\n"); return 0; /**** lire des mots dans le fichier et les afficher ****/ for(i=0; i<=nmots; i++){ ret_lec = fscanf(fichier, "%s", mot); if(ret_lec!= 1) printf ("i = %d : pb lecture\n", i); printf ("mot %d : %s \n", i, mot ); return 1; Résultat: mot 0 : #include mot 1 : <stdio.h> mot 2 : #define mot 3 : NMOTS mot 4 : 10 mot 5 : int mot 6 : main(int mot 7 : argc, mot 8 : char*argv[]){ mot 9 : FILE mot 10 : *fichier; Page 55

Passer des valeurs sur la ligne de commande Comment saisir des valeurs sur la ligne de commande: /*********** io2.c *********** / #include <stdio.h> #include <stdlib.h> int main(int argc, char* argv[]){ int dim = 0; float x = 0.0; if (argc!= 3 ){ printf("utilisation : %s dim (entier x(reel)\n, argv[0]); return 1; dim = atoi(argv[1]); x = atof(argv[2]); printf("dim = %d et x = %f\n", dim, x); return 0; Exemple d exécution du programme : $ gcc -Wall io2.c -o monprog $ monprog Utilisation :./monprog dim (entier x(reel) $ monprog 34 2 Dim = 34 et x = 2.000000 Page 56

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Quelques fonctions d E/S Page 57

Pointeurs : tableaux (1/3) Il n'y a pas de type tableau en C : le nom d un tableau est un pointeur constant sur l adresse de début du tableau. Il ne peut donc pas être modifié. Exemple : soit la déclaration : short Tab[4]; On suppose que le tableau est implanté à l'adresse 1000, La case dont le nom est Tabcontient donc 1000 L arithmétique des pointeurs se fait en fonction de la taille de l objet pointé. Par exemple, ici : Tab[i]étant équivalent à : *(Tab+i); On a, par exemple, pour i=2 : Tab[2] équivalent à *(Tab+2); c est à dire : *(1000 + 2xsizeof(short)) = *(1004) 1000 1002 1004 1006 Tab[0] Tab[1] Tab[2] Tab[3] Page 58

Pointeurs : tableaux (2/3) Si on a déclaré : int Tab[100]; int * Ptr; Ptr = Tab; Alors les notation suivantes sont équivalentes : Tab[i] *(Tab + i) Ptr[i] (Ptr + i) Page 59

Pointeurs : tableaux (3/3) Les deux instructions suivantes sont équivalentes : Tab [1] = 0 ; et Ptr1 [1] = 0 Soit les instructions : short * Ptr1; char * Ptr2; Ptr1 = (short *)Tab; Ptr2 = (char *)Tab; 1000 1002 1004 1006 0 *Ptr1 = 1; *Ptr2 = 1; *(Tab + 1) = 0; 0 1 1 1 /* valeur de Ptr1 après l'instruction suivante : 1000 */ *(Ptr1 + 1) = 2; /* valeur de Ptr1 après l'instruction suivante : 1002 */ *(Ptr1 ++) = 2; /* Instruction suivante incorrecte : on ne peut modifier un pointeur constant */ *(Tab++) = 0; *Ptr1=1 0 1 0 0 *Ptr2=1 0 1 0 2 Page 60 *(Tab+1)=0 *(Ptr1+1)=2

Pointeurs : les chaines de caractères Il n'y a pas, comme en java, de type String : Une chaine de caractère est implantée sous forme d'un tableau de char, La fin d un tableau de caractères est indiquée par le caractère NULL : '\0' (la valeur 0), Une bibliothèque de fonctions fournit les opérations classiques sur les chaines de caractères (strcpy, strle, strcat, ) mais la vérification du bon usage de la mémoire reste à la charge du programme Page 61

Pointeurs : résumé 1. Opérateurs spécifiques : & : pour obtenir l'adresse d'une variable * : déréférencement : aller chercher une valeur à l'adresse contenue dans la pointeur Attention : * sert aussi à déclarer une variable pointeur, par exemple : int * ptr ; 2. Arithmétique : Les opérations + et - se font suivant le type de l'objet pointé : Si on a : TYPE * ptr ; alors ptr + k désigne la case mémoire d'adresse : (valeur de ptr) + k*sizeof (TYPE) ; 3. Allocation mémoire : en fonction du type de l'objet pointé 4. C traite les pointeurs comme des tableaux et vice-versa, on peut donc utiliser la notation «pointeur» ou «indexée» sur un tableau ou un pointeur variable. Page 62

Pointeurs : utilisation de l'opérateur sizeof Dans ce programme, on a : sizeof(tab1) = 128 sizeof(tab2) = 11 #include <stdio.h> #include <string.h> int main(int argc, char *argv[]){ char tab1[128] ; char tab2[] = "0123456789"; sizeof(tab3) = 512 sizeof(ptr) = 8 sizeof(ptr2) = 8 int tab3[128] ; char *ptr = tab1; int * ptr2 = tab3; return 0; Page 63

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Quelques fonctions d E/S Page 64

Les zones mémoire associées à un programme (Unix) La partie dynamique : 1. la pile 2. le tas où se trouvent les variables allouées par malloc (C), new(java), La partie statique : 1. Une zone accessible à la fois en lecture et en écriture (on y trouve les variables globales et celles de type static): a).bss, zone initialisée à zéro, b).data, 2. Une zone accessible en lecture seule :.rodata Partie dynamique Pointeur de pile (stack pointer) Partie statique Pile (stack) Tas (heap).bss et.data (données modifiables).rodata et.text (données en lecture seule et programme) Page 65

Allocation mémoire : variables locales Résultat : Les variables locales à une fonction sont allouées sur la pile. L'espace mémoire alloué est rendu à la sortie de la fonction. Dans l'exemple ci-contre, les variables i et j de main ne sont pas modifiées. main : i = 10, j = 20 echange : i = 20, j = 10 main : i = 10, j = 20 #include <stdio.h> /******* main *******/ int main(int argc, char*argv[]){ int i, j; void echange(int, int); i = 10; j = 20; printf ("main : i = %d, j = %d\n",i, j); echange(i, j); printf ("main : i = %d, j = %d\n",i, j); return 0; /******* echange *******/ void echange(int i, int j){ int k; k = i; i = j; j = k; printf("echange : i = %d, j = %d\n",i, j); return; Page 66

Allocation mémoire : variables globales Ici une variable globale est utilisée par la fonction main et par une fonction se trouvant dans un autre fichier : Elle est déclarée et initialisée dans le fichier contenant main, Cette variable est référencée dans l'autre fichier : extern indique au compilateur que la variable est implantée dans un autre fichier #include <stdio.h> #define DIM 10 int table_glob[dim]; void echange(int, int); int main (int argc, char*argv[]){ int i; for(i=0; i < DIM; i++) table_glob[i] = i ; echange(2, 5); return 0; extern int table_glob[]; void echange (int i, int j){ int k; k=table_glob[i]; table_glob[i]=table_glob[j]; table_glob[j]=k; Page 67

Allocation mémoire : variable locale déclarée «static» Une variable qualifiée de static : Est implantée dans un espace mémoire qui lui est alloué lors de la compilation dans la partie statique de la région de données :.data ou.bss (respectivement : variables initialisées ou non), Donc : elle n'est pas implantée sur la pile pendant l'exécution de la fonction où elle est déclarée, elle est référencée par une adresse fixe, elle n est pas réinitialisée à chaque appel à la fonction où elle a été déclarée, Un exemple d utilisation : compter dans un fonction le nombre d'appels à la fonction elle-même (voir exemple suivant). Page 68

Allocation mémoire : variables dynamiques et statiques Rappel : une variable locale est implantée sur la pile : à la sortie du bloc d'instructions dans lequel elle est utilisée l'espace alloué sur la pile est rendu. Conséquence : Ici, dans la fonction somme la variable compteur est réallouée sur la pile à chaque appel, ce qui n est pas la cas dans carre. RESULTAT : somme : compteur = 1 somme : compteur = 1 carre : compteur = 1 carre : compteur = 2. #include <stdio.h> int main(void) { float somme(float x, float y); int carre(int ); int i; float r; r = somme(1.0, 2.0); r = somme(10, 0.75); i = carre (3); i = carre (5); return 0; float somme(float x, float y){ int compteur = 0; compteur ++; printf("somme : compteur = %d\n", compteur); float z; z = x + y; return z; int carre(int j){ static int compteur = 0; compteur ++; printf("carre : compteur = %d\n", compteur); return (j*j); Page 69

Pointeurs : allocation dynamique de mémoire (1/2) Les trois fonctions les plus utilisées pour gérer la mémoire sont les suivantes : malloc() : allocation, renvoie un void *, free() : libération, renvoie un void *, realloc() : réallocation, renvoie un void *, Pour demander l'allocation d'une zone en mémoire, on donne sa taille en octets, par exemple : int * ptr, * tab ; int dim = 100 ; /* demande d'allocation d'un entier */ ptr = (int *) malloc (sizeof(int)); /* demande d'allocation d'un tableau de 100 entiers */ tab = (int *) malloc (dim *sizeof(int)); /* tableau de 100 int */ Page 70

Pointeurs : allocation dynamique de mémoire (1/2) int * ptr; /* ptr va pointer vers une zone de 24 entiers * alloues sur le tas */ ptr = (int *) malloc (24*sizeof(int));... /* realloc change la taille de cette zone allouee sur le tas * en la copiant à une nouvelle adresse, les eventuels * octets supplémentaires ne sont pas initialises */ ptr = (int *) realloc (ptr, 48*sizeof(int)); Exemple d'utilisation des trois fonctions précédentes : /* on libère cette zone qui pourra etre réutilisée par le système*/ free (ptr); Page 71

Allocation d'un tableau à deux dimensions (1/2) Exemple pour un tableau à deux dimensions : Un tableau à deux dimensions est un tableau à une dimension dont chaque élément est lui-même un tableau Le premier tableau est donc un tableau de pointeurs! int main(int argc, char*argv[]){ int ** Tab; int i, j; int nlig = 3; int ncol = 5; /* Allocation des pointeurs vers chaque ligne */ Tab = (int **)malloc(nlig * sizeof(int *)); /* Allocation memoire pour chaque lignes */ for (i = 0; i < ncol ; i++) Tab[i] = (int *)malloc(ncol * sizeof (int)); /* Initialisation du tableau */ for (i = 0 ; i < nlig ; i++) for (j = 0; j < ncol; j++){ Tab[i][j] = i * ncol + j; printf("tab[%d][%d] = %d adresse %08x\n", i,j,tab[i][j],(int)&tab[i][j]); return 0; Page 72 Résultat : Tab[0][0] = 0 adresse 001000a0 Tab[0][1] = 1 adresse 001000a4 Tab[0][2] = 2 adresse 001000a8 Tab[0][3] = 3 adresse 001000ac Tab[0][4] = 4 adresse 001000b0 Tab[1][0] = 5 adresse 001000c0 Tab[1][1] = 6 adresse 001000c4 Tab[1][2] = 7 adresse 001000c8 Tab[1][3] = 8 adresse 001000cc Tab[1][4] = 9 adresse 001000d0 Tab[2][0] = 10 adresse 001000e0 Tab[2][1] = 11 adresse 001000e4 Tab[2][2] = 12 adresse 001000e8 Tab[2][3] = 13 adresse 001000ec Tab[2][4] = 14 adresse 001000f0

Allocation d'un tableau à deux dimensions (2/2) Au début, voici le contenu de Tab : Tab XXX Effet du premier malloc() : Tab XXX...00 XXX XXX Effet du second malloc() :...00...04...08 XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX Adresse A1 Adresse A2 Adresse A3 Tab...00 Adresse A1 Adresse A2...00...04 XXX XXX XXX XXX XXX Adresse A3...08 Page 73

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Quelques fonctions d E/S Page 74

Fonctions : utilisation de la pile C est une zone mémoire dédiée, de taille limitée dont le début est repéré par un registre spécial (le pointeur de pile ou stack pointer), Elle abrite les variables dites «dynamiques» : arguments des fonctions et procédures, variables locales, A propos de la fonction main : main admet des arguments qui peuvent être initialisés sur la ligne de commande (exemple : int main(int argc, char *argv[]) : argc, un entier : le nombre de mots donnés sur la ligne de commande, argv[ ], un tableau de chaines de caractères contenant la liste de ces mots, arge [ ], un tableau de chaines de caractères, rarement utilisé, contenant les d'environnement, Remarque : en Java main prend un seul argument : args[] Page 75

La pile : appel à la fonction main La commande : exo1 1234 a été entrée au clavier, donc les mots exo1 et 1234 ont été rangés respectivement dans argv[0]et argv[1]), Voici un schéma illustrant l'utilisation de la pile par le système lors de l'appel à la fonction main : 2010 4 0 0 1 2 3 2020 e x o 1 0 2025 2020 argv[2] argv[1] argv[0] 2000 2000 2010 argv 2 argc Page 76

La pile : exemple de débordement Exemple de débordement : on a involontairement copié un texte sur le premier mot de ceux passés à main (texte copié en argv[0] au lieu de l inverse)../a.out mot1 mot2 234 message : bonjour tout le monde! texte : bonjour tout le monde! #include <stdio.h> #include <string.h> int main(int argc, char *argv[] { int i =0; char message[] ="bonjour tout le monde!"; char texte [80]; char * ptr; printf("message : %s\n", message); ptr = message; strcpy(texte, message); printf("texte : %s\n", texte); printf("ptr : %s\n", ptr); /* au lieu de strcpy(texte, argv[0]): */ strcpy(argv[0], texte); ptr : bonjour tout le monde! argv[0] : bonjour tout le monde! argv[1] : tout le monde! argv[2] : le monde! argv[3] : nde! while (argv[i]!= 0) { printf("argv[%d] : %s\n",i, argv[i]); i++; return 0; Page 77

La pile : appel à la fonction main Dans le programme suivant, on affiche : la valeur (format %x) des pointeurs (argv[i] et arge[i) passés sur la pile à main, le contenu des chaines de caractères repérées par ces pointeurs (format %s), int main(int argc, char* argv[], char* arge[]){ short i; for(i=0; argv[i]!= 0; i++) printf("argv[%d](0x%x) : %s\n", i, argv[i], argv[i]); for(i=0; i < 3; i++) printf("arge[%d](0x%x) : %s\n", i, arge[i], arge[i]);... Résultat : argv[0](0x5fbffbb0) :./a.out arge[0](0x5fbffbb8) : TERM_PROGRAM=Apple_Terminal arge[1](0x5fbffbd4) : TERM=xterm-color arge[2](0x5fbffbe5) : SHELL=/bin/bash Page 78

Les fonctions Syntaxe : retour = fonc(arguments){ variables locales à la fonction fonc instructions associées à la fonction fonc Mots clés : arguments : passage par valeur et utilisation de la pile : les valeurs des arguments sont évaluées lors de l appel à la fonction et copiées sur la pile, la fonction travaille en utilisant ces copies, valeur de retour : une fonction renvoie une valeur, si elle ne renvoie rien elle est de type void (c est une procédure), variables locales : «static» ou non Page 79

Fonctions : passage des arguments par valeur Le passage des arguments se fait par valeur : On donne le nom des variables et, à l'exécution du programme, lors de l'appel à la fonction, ce sont leurs valeurs qui sont copiées sur la pile, Ainsi les fonctions appelée et appelante ne partagent pas de mémoire, Si on veut que la fonction appelée modifie des variables dans la fonction appelante, il faut en passer les références (ou utiliser des variables globales), (On passe la valeur de la référence) Certains langages passent les références de façon transparente, en C il faut le faire explicitement en utilisant les pointeurs ou les opérateurs associés (l'opérateur & qui renvoie une adresse) Page 80

Passage d'adresses ou de valeurs (1/2) Pour affecter la valeur de variables depuis une fonction, on passe leur adresse sur la pile, Dans l'exemple ci-contre : la fonction echange1 modifie les valeurs déposées sur la pile, donc ne modifie pas x et y dans main, La fonction echange2 utilise les adresses de ces variables déposées sur la pile et modifie le contenu des variables en utilisant des pointeurs (cf. schéma page suivante), Resultat : i : 20, j : 10 i : 10, j : 20 int main(int argc, char*argv[]) { void echange1 (int, int ); void echange2 (int *, int *); int i = 20, j = 10; echange1 (i, j); printf(" i : %d, j : %d\n", i, j); echange2 (&i, &j); printf(" i : %d, j : %d\n", i, j); return; void echange1 (int x, int y){ int temp; temp = x; x = y; y = temp; return ; void echange2 (int *x, int *y){ int temp; temp = *x; *x = *y; *y = temp; return ; Page 81

Passage d'adresses ou de valeurs (2/2) Etat de la pile après exécution de temp=x dans echange1 et temp=*x dans echange2 temp 10 y x Cas de echange1 : Cas de echange2 : 20 (Copie valeur de j) 10 (Copie valeur de i) x 1000 (Copie adresse de i) Adresse retour, Nbre arguments, temp y 10 1004 (Copie adresse de j) Adresse retour, Nbre arguments, j 10 1004 j 20 1004 i 20 1000 i 10 1000 Page 82

Gestion de la pile Etat de la pile après retour dans main : echange 1 10 Zone réutilisable 20 (durée de vie des variables = 10 durée de vie de la fonction) Ad. ret...., Stack pointer echange2 10 Zone réutilisable 1004 (&j) (durée de vie des variables = 1000 (&i) durée de vie de la fonction) Ad. ret...., Stack pointer j 10 1004 j 20 1004 i 20 1000 i 10 1000 Page 83

Fonctions ou procédure? # (passer une valeur ou une adresse) : exemple Exemple d'initialisation de struct, avec deux modes d'initialisation des variables : par une fonction : une fonction peut renvoyer la valeur d une struct, par une procédure, dans ce cas il faut passer les variables par adresse : typedef struct{ complexe_t ; float reel; float imagine; int main(int argc, char*argv[]){ void init_1(complexe_t *ptr); complexe_t init_2(void); complexe_t c1; /* initialisation par passage d adresse */ init_1(&c1); /* initialisation par retour de valeur */ c1=init_2(); return 0; /* fonction */ complexe_t init_2(void){ complexe_t x; x.reel = 1.0; x.imagine = 1.0; return x; /* procedure */ void init_1(complexe_t *ptr){ (*ptr).imagine = 1.0; ptr->reel = 1.0; return; Page 84

Les fonctions : rôle du prototypage (1/2) La fonction main ci-dessous fait un appel à la fonction carre avec ou sans prototypage de cette fonction carre : #include <stdio.h> int main(int argc, char*argv[]) { #ifdef PROTO double carre (double r); #endif int i; double x; i = 4 ; x = carre(i); printf("apres appel 1 : x=%f\n\n", x); x = carre((double)i); printf("apres appel 2 :x=%f\n\n", x); x = carre(4); printf("apres appel 3 :x=%f\n\n", x); La fonction carre prend en entrée un argument du type double et renvoie un double: #include <stdio.h> double carre (double r) { double x; x = r*r; printf("carre : entree r=%g, sortie x=%g\n", r, x); return (x); x = carre(4.0); printf("apres appel 4 : x=%f\n\n", x); return 0; Page 85

Les fonctions : rôle du prototypage (2/2) Sans prototypage, le compilateur suppose que les arguments en entrée et la valeur de retour sont des entiers. Les résultats ne sont pas corrects, comme on peut le voir ci-contre : SANS PROTOTYPAGE : carre : entree r = 0, sortie x = 0 apres appel 1 : x = 0.000000 carre : entree r = 4, sortie x = 16 apres appel 2 :x = 0.000000 carre : entree r = 1.38526e-309, sortie x = 0 apres appel 3 :x = 0.000000 carre : entree r = 4, sortie x = 16 apres appel 4 : x = 0.000000 Avec prototypage (commande gcc -DPROTO), les conversions de type sont faites et les résultats sont corrects : AVEC PROTOTYPAGE : carre : entree r = 4, sortie x = 16 apres appel 1 : x = 16.000000 carre : entree r = 4, sortie x = 16 apres appel 2 :x = 16.000000 carre : entree r = 4, sortie x = 16 apres appel 3 :x = 16.000000 carre : entree r = 4, sortie x = 16 apres appel 4 : x = 16.000000 Page 86

Les fonctions : pile et appels récursifs Exemple : calcul de factorielle 3. 1- On commence par une première phase d empilement des appels : Appel à factorielle (3) Appel à 3 * factorielle (2) Appel à 2 * factorielle (1) Appel à 1 * factorielle (0) On arrive à la condition de fin, la fonction renvoie la valeur, on passe en phase 2 int factorielle (int n){ int i; if (n == 0) i= 1; else i = n * factorielle (n-1); return (i) ; 2- Phase de dépilement des appels :. on sort de factorielle (0) par return(1), on dépile, on retourne dans factorielle (1) qui renvoie 1*1, on sort factorielle (2) qui renvoie 2*1, on sort de factorielle (3) qui renvoie 3*2, et on revient dans main Page 87

Plan Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Pointeurs(1) Instructions Quelques fonctions d E/S Page 88

Famille printf/scanf (E/S dites «formattées») Forme générale Clavier/ écran Lecture fscanf (fichier, format, liste arguments) scanf(format, liste arguments ) équivalent à fscanf sur stdin: fscanf (stdin, format, liste arguments ) Ecriture fprintf (fichier, format, liste arguments) printf (format, liste arguments ) équivalent à fprintf sur stdout : fprintf (stdout, format, liste arguments) Zone mémoire sscanf (adresse mémoire, format, liste arguments ) sprintf (adresse mémoire, format, liste arguments ) Fonctionnement des fonctions du type fscanf: A chaque directive (notation %) du format doit être associé une adresse, Ces fonctions renvoient le nombre d éléments reconnus et affectés ; Page 89

Famille printf/scanf : sprintf Exemple d'écriture «formattée» en mémoire : /* construire un entete du type : Paris, le lundi 1 avril */ char entete[128]; char jour[] ="lundi", mois[] ="avril"; int num = 1; sprintf(entete, "Paris, le %s %d %s ", jour, num, mois) Page 90

Famille printf/scanf : fscanf Lire un fichier texte : #include <stdio.h> #define TAILLE_MOT 80 int main (int argc, char *argv[]){ FILE *fichier; int ret_sc=0; char mot_lu[taille_mot]; if(argc!= 2){ printf("utilisation : %s nom de fichier\n", argv[0]); return 1; /***** ouvrir le fichier *****/ fichier = fopen(argv[1], "r"); if(fichier == NULL){ printf("pb ouverture %s\n", argv[1]); return 1; /***** lire mot par mot dans le fichier texte *****/ while((ret_sc!= EOF)) { ret_sc=fscanf(fichier, "%s", mot_lu); if(ret_sc == 1) printf("on a lu : %s\n", mot_lu); fclose(fichier); return 0; Page 91