Plan! Plan! Langage C": historique! Langage C": caractéristiques! SELC-C 27/11/12. Page 2. Page 1 27/11/12. Page 4. Page 3 27/11/12 27/11/12

Dimension: px
Commencer à balayer dès la page:

Download "Plan! Plan! Langage C": historique! Langage C": caractéristiques! SELC-C 27/11/12. Page 2. Page 1 27/11/12. Page 4. Page 3 27/11/12 27/11/12"

Transcription

1 Plan Plan Première partie Deuxième partie Première partie Deuxième partie C après Java Pointeurs(2) C après Java Pointeurs(2) Structure d un programme Variables : allocation en mémoire Structure d un programme Variables : allocation en mémoire Préprocesseur Fonctions Préprocesseur Fonctions Variables Types de base Types composés Pile et arguments Fonctions d E/S Variables Types de base Types composés Pile et arguments Fonctions d E/S Pointeurs(1) Instructions Pointeurs (1) Instructions Quelques fonctions d E/S Quelques fonctions d E/S Page 1 Page 2 Langage C": historique Langage C": caractéristiques 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, 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 3 Page 4

2 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 Java et Eclipse: Environnement de développement (1/2) 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 5 Page 6 Environnement de développement (2/2) Plan 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 Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Quelques fonctions d E/S Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Page 7 Page 8

3 Structure d'un programme C ": un jeu de fonctions Structure d'un programme": C vs Java <directives pour le préprocesseur> <déclarations de variables globales> int main(){ 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. 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 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 */ int main(int argc, char* argv[]){ printf( coucou \n ); // Commentaire import java.io.*; public class coucou{ public static void main (String args []){ System.out.println( coucou ); Page 9 Page 10 Entrées-sorties : C vs Java Structure d'un programme : exemple Entrées-sorties : différences C/Java Le fichier stdio.h contient les signatures des fonctions d entréessorties 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); int main(int argc, char*argv[]) { int k = 5; float r = 7.0; printf("k = %d, r = %f\n", k, r): Le point d'entrée : la fonction main /****************************** main ******************************/ 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); 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 11 Page 12

4 " Plan Le préprocesseur": fonctionnement Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Quelques fonctions d E/S Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S 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; gcc -E essai.c int main(int argc, char*argv[]){ int i; short tab [128] ; for (i=0; i<128; i++)tab[i]=0; Page 13 Page 14 Le préprocesseur": #define Le préprocesseur": #ifdef, #endif #define effectue des substitutions de chaines de caractères. #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); 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)) 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 * ); k = (2 *( )); return 0 ; 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 */ int main(int argc, char*argv[]) printf("debut de main\n"); #ifdef DEBUG printf("fin de main\n"); #endif $ 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 16

5 /*** main.c ***/ #include "carre.h" int main(int argc, char*argv[]){ double x; Effet du préprocesseur x = carre(4); double carre (float); printf("x = %f\n", x); /* carre.c */ double carre(float var){ return (var * var); 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 : /*** carre.h ***/ double carre (float); int main(int argc, char*argv[]) { double x; x = carre(4); printf("x = %f\n", x); 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 = (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 = (conversion de 4 au format réel grâce au prototype) Page 17 Page 18 Plan Variables ": type, allocation mémoire, durée de vie Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Quelques fonctions d E/S Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S 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 19 Page 20

6 Variables": allocation en mémoire Types de base": les entiers 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 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 21 Page 22 Types : opérateur"sizeof () Types de base": le type char 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)); 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 Les char sont traités comme des entiers sur un octet, attention aux effets de bord: int main(int argc, char*argv[]){ char carac1; unsigned char carac2; 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); %c : format ASCII Résultats : carac1 = -1 carac2 = 255 carac1 = A carac2 = 1 carac1 = 65 carac2 = 49 %ld : format entier long /* Les char sont traitées comme des int */ carac1 = carac1 + 1; printf("carac1 = %c (%d)\n", carac1, carac1); carac1 = B (66) Page 23 Page 24

7 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 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] : tab tab[0] tab[1] tab[2] tab[3] char texte[10];... strcpy(texte, "coucou"); Contenu de texte après exécution de strcpy: c o u c o u '\0' Page 25 Page 26 Java et les chaînes de caractères Types composés": «" struct"» 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); 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; 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 27 Page 28

8 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 : : 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 : 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) ); ; Résultat : taille de point_t (sizeof(point_t)) : 24 taille de la somme des elements d un point : 13 complexe_t c1, c2 ; Page 29 Page 30 Plan Pointeurs": définition Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Quelques fonctions d E/S Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S 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 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 ptr_i 234 Page 31 Page 32

9 Pointeurs": opérateurs associés Pointeurs": syntaxe 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; ptr1 = ptr2; /* j reçoit la valeur 16 */ *ptr1 = 16; i j k k 2 j 16 ffaac ffaa8 0 0 ffaac ffaa8 ffaa8 ffaa8 ptr1 ptr2 ptr1 ptr2 ptr1 ptr2 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 33 Page 34 Retour sur les références en Java (1/2) Retour sur les références en Java (2/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+")"); 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) L objet de coordonnées (50,0) n'est plus référencé, le garbage collector pourra libérer P1: Point@eb42cbf P2: Point@eb42cbf 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.... coord. : (0, 10) coord. : (50, 0) P1: Point@eb42cbf P2: Point@56e5b723 Page 35 Page 36

10 Plan Expression vs instruction" Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Quelques fonctions d E/S Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S 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; /* suite à une erreur de frappe on a saisi k+5; au lieu de i=k+5; */ j>2; ; Page 37 Page 38 Instructions": syntaxe Instructions" : conditionnelles, itératives 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; 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 39 Page 40

11 Instructions": ruptures de séquence Instructions": switch 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 */ 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 41 Page 42 Instruction switch : exemple Opérateurs": opérateur d'affectation = Exemple : int main(int argc, char*argv[]) { 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 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); 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 43 Page 44

12 Opérateurs": autres opérateurs d'affectation Opérateurs": opérateurs de comparaison 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 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 45 Page 46 Opérateurs": opérateurs au niveau bit Opérateurs": opérateurs logiques 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) 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, Représentation binaire de 0xff Représentation binaire de j&0xff xxxx xxxx Page 47 Page 48

13 Opérateurs": le «"cast operator «" Opérateurs": règles de conversion de type L'opérateur «cast», sert à forcer les conversions de type (permissivité du C), sa syntaxe est la suivante : (type voulu)expression 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 : Exemple d'utilisation de l'opérateur cast: int i = 20; int j = 7; float r; r = i/j ; resultat r = r = (float)(i/j); resultat r = r = (float)(i)/j; resultat r = r = 20/7; resultat r = r = 20/7.0; resultat r = 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 49 Page 50 Plan Bibliothèque d'e/s": saisies clavier Comment saisir des valeurs au clavier : Première partie C après Java Structure d un programme Préprocesseur Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Attention : / int main(int argc, char* argv[]){ int dim = 0; float x = 0.0; printf("donner dim (entier) "); scanf("%d", &dim); Variables Types de base Types composés Pointeurs(1) Pile et arguments Fonctions d E/S pointeurs printf("donner x (reel) "); scanf("%f", &x); printf("dim = %d et x = %f\n", dim, x); Instructions Quelques fonctions d E/S Exemple d exécution : Donner dim (entier) 3 Donner x (reel) 2 dim = 3 et x = Page 51 Page 52

14 Bibliothèque d'e/s": lire un fichier Lire un fichier : exemple 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) #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; Soit le fichier prog1.c (l exécutable va ouvrir et lire ce fichier source) : #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"); /**** 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 53 Page 54 Passer des valeurs sur la ligne de commande Plan Comment saisir des valeurs sur la ligne de commande: /*********** io2.c *********** / #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); 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 = Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Quelques fonctions d E/S Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Page 55 Page 56

15 Pointeurs": tableaux (1/3) Pointeurs": tableaux (2/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 : *( xsizeof(short)) = *(1004) Tab[0] Tab[1] Tab[2] Tab[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 57 Page 58 Pointeurs": tableaux (3/3) Pointeurs": les chaines de caractères 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; *Ptr1 = 1; *Ptr2 = 1; *(Tab + 1) = 0; 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 /* 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= *Ptr2= Page 59 *(Tab+1)=0 *(Ptr1+1)=2 Page 60

16 Pointeurs": résumé Pointeurs": utilisation de l'opérateur sizeof 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é Dans ce programme, on a : sizeof(tab1) = 128 sizeof(tab2) = 11 sizeof(tab3) = 512 sizeof(ptr) = 8 sizeof(ptr2) = 8 #include <string.h> int main(int argc, char *argv[]){ char tab1[128] ; char tab2[] = " "; int tab3[128] ; char *ptr = tab1; int * ptr2 = tab3; 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 61 Page 62 Plan Les zones mémoire associées à un programme"(unix) La partie dynamique : Partie dynamique Pile (stack) Première partie C après Java Structure d un programme Deuxième partie Pointeurs(2) Variables : allocation en mémoire 1. la pile 2. le tas où se trouvent les variables allouées par malloc (C), new(java), Pointeur de pile (stack pointer) Préprocesseur Fonctions La partie statique : Variables Types de base Types composés Pointeurs(1) Instructions Quelques fonctions d E/S Pile et arguments Fonctions d E/S 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 : Partie statique Tas (heap).bss et.data (données modifiables).rodata et.text (données en lecture seule et programme).rodata Page 63 Page 64

17 Allocation mémoire": variables locales Allocation mémoire": variables globales 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. Résultat : main : i = 10, j = 20 echange : i = 20, j = 10 main : i = 10, j = 20 /******* 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); /******* 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; 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 #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); 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 65 Page 66 Allocation mémoire": variable locale déclarée «"static"» Allocation mémoire": variables"dynamiques et statiques 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). 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. 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); 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 67 Page 68

18 Pointeurs": allocation dynamique de mémoire (1/2) 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 */ 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 69 Page 70 Allocation d'un tableau à deux dimensions (1/2) Allocation d'un tableau à deux dimensions (2/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]); Page 71 Résultat : Tab[0][0] = 0 adresse a0 Tab[0][1] = 1 adresse a4 Tab[0][2] = 2 adresse a8 Tab[0][3] = 3 adresse ac Tab[0][4] = 4 adresse b0 Tab[1][0] = 5 adresse c0 Tab[1][1] = 6 adresse c4 Tab[1][2] = 7 adresse c8 Tab[1][3] = 8 adresse cc Tab[1][4] = 9 adresse d0 Tab[2][0] = 10 adresse e0 Tab[2][1] = 11 adresse e4 Tab[2][2] = 12 adresse e8 Tab[2][3] = 13 adresse ec Tab[2][4] = 14 adresse f0 Au début, voici le contenu de Tab : Tab Effet du premier malloc() : Tab "...00 "...00 "...04 "...08 Effet du second malloc() : Tab Adresse A1 "...00 Adresse A2 Adresse A3 "...00 "...04 "...08 Page 72 Adresse A1 Adresse A2 Adresse A3

19 Plan Fonctions : utilisation de la pile Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Quelques fonctions d E/S Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S 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 73 Page 74 La pile": appel à la fonction main La pile": exemple de débordement La commande : exo 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 : e x o argv[2] argv[1] argv[0] 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 <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); argv 2 argc 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++; Page 75 Page 76

20 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), Syntaxe : retour = fonc(arguments){ Les fonctions variables locales à la fonction fonc instructions associées à la fonction fonc 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 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 77 Page 78 Fonctions": passage des arguments par valeur Passage d'adresses ou de valeurs (1/2) 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 79 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 80

21 Passage d'adresses ou de valeurs (2/2) Gestion de la pile 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 (Copie adresse de j) Adresse retour, Nbre arguments, 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 i j 20 i j 10 i j 20 i Page 81 Page 82 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(); /* 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 83 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 : 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); x = carre(4.0); printf("apres appel 4 : x=%f\n\n", x); Page 84 La fonction carre prend en entrée un argument du type double et renvoie un double: double carre (double r) { double x; x = r*r; printf("carre : entree r=%g, sortie x=%g\n", r, x); return (x);

22 Les fonctions": rôle du prototypage (2/2) Les fonctions": pile et appels récursifs 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 = carre : entree r = 4, sortie x = 16 apres appel 2 :x = carre : entree r = e-309, sortie x = 0 apres appel 3 :x = carre : entree r = 4, sortie x = 16 apres appel 4 : x = Exemple : calcul de factorielle 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) ; 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 = carre : entree r = 4, sortie x = 16 apres appel 2 :x = carre : entree r = 4, sortie x = 16 apres appel 3 :x = 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" carre : entree r = 4, sortie x = 16 apres appel 4 : x = Page 85. Page 86 Première partie C après Java Structure d un programme Préprocesseur Variables Types de base Types composés Pointeurs(1) Instructions Quelques fonctions d E/S Plan Deuxième partie Pointeurs(2) Variables : allocation en mémoire Fonctions Pile et arguments Fonctions d E/S Forme générale Clavier/ écran Zone mémoire Famille printf/scanf (E/S dites «"formattées"») Lecture fscanf (fichier, format, liste arguments) scanf(format, liste arguments ) équivalent à fscanf sur stdin: fscanf (stdin, format, liste arguments ) sscanf (adresse mémoire, format, liste arguments ) Fonctionnement des fonctions du type fscanf: Ecriture fprintf (fichier, format, liste arguments) printf (format, liste arguments ) équivalent à fprintf sur stdout : fprintf (stdout, format, liste arguments) sprintf (adresse mémoire, format, liste arguments ) A chaque directive (notation %) du format doit être associé une adresse, Ces fonctions renvoient le nombre d éléments reconnus et affectés ; Page 87 Page 88

23 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; Lire un fichier texte : #define TAILLE_MOT 80 Famille printf/scanf": fscanf 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; sprintf(entete, "Paris, le %s %d %s ", jour, num, mois) Page 89 /***** 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); Page 90

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

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

Plus en détail

Introduction au langage C

Introduction au langage C Introduction au langage C Cours 1: Opérations de base et premier programme Alexis Lechervy Alexis Lechervy (UNICAEN) Introduction au langage C 1 / 23 Les premiers pas Sommaire 1 Les premiers pas 2 Les

Plus en détail

Cours d Algorithmique-Programmation 2 e partie (IAP2): programmation 24 octobre 2007impérative 1 / 44 et. structures de données simples

Cours d Algorithmique-Programmation 2 e partie (IAP2): programmation 24 octobre 2007impérative 1 / 44 et. structures de données simples Cours d Algorithmique-Programmation 2 e partie (IAP2): programmation impérative et structures de données simples Introduction au langage C Sandrine Blazy - 1ère année 24 octobre 2007 Cours d Algorithmique-Programmation

Plus en détail

1. Structure d un programme C. 2. Commentaire: /*..texte */ On utilise aussi le commentaire du C++ qui est valable pour C: 3.

1. Structure d un programme C. 2. Commentaire: /*..texte */ On utilise aussi le commentaire du C++ qui est valable pour C: 3. 1. Structure d un programme C Un programme est un ensemble de fonctions. La fonction "main" constitue le point d entrée pour l exécution. Un exemple simple : #include int main() { printf ( this

Plus en détail

INITIATION AU LANGAGE C SUR PIC DE MICROSHIP

INITIATION AU LANGAGE C SUR PIC DE MICROSHIP COURS PROGRAMMATION INITIATION AU LANGAGE C SUR MICROCONTROLEUR PIC page 1 / 7 INITIATION AU LANGAGE C SUR PIC DE MICROSHIP I. Historique du langage C 1972 : naissance du C dans les laboratoires BELL par

Plus en détail

Info0101 Intro. à l'algorithmique et à la programmation. Cours 3. Le langage Java

Info0101 Intro. à l'algorithmique et à la programmation. Cours 3. Le langage Java Info0101 Intro. à l'algorithmique et à la programmation Cours 3 Le langage Java Pierre Delisle, Cyril Rabat et Christophe Jaillet Université de Reims Champagne-Ardenne Département de Mathématiques et Informatique

Plus en détail

Chapitre 1 : La gestion dynamique de la mémoire

Chapitre 1 : La gestion dynamique de la mémoire Chapitre 1 : La gestion dynamique de la mémoire En langage C un programme comporte trois types de données : Statiques; Automatiques ; Dynamiques. Les données statiques occupent un emplacement parfaitement

Plus en détail

Le Langage C Version 1.2 c 2002 Florence HENRY Observatoire de Paris Université de Versailles florence.henry@obspm.fr

Le Langage C Version 1.2 c 2002 Florence HENRY Observatoire de Paris Université de Versailles florence.henry@obspm.fr Le Langage C Version 1.2 c 2002 Florence HENRY Observatoire de Paris Université de Versailles florence.henry@obspm.fr Table des matières 1 Les bases 3 2 Variables et constantes 5 3 Quelques fonctions indispensables

Plus en détail

Licence ST Université Claude Bernard Lyon I LIF1 : Algorithmique et Programmation C Bases du langage C 1 Conclusion de la dernière fois Introduction de l algorithmique générale pour permettre de traiter

Plus en détail

Programmation système I Les entrées/sorties

Programmation système I Les entrées/sorties Programmation système I Les entrées/sorties DUT 1 re année Université de Marne La vallée Les entrées-sorties : E/O Entrées/Sorties : Opérations d échanges d informations dans un système informatique. Les

Plus en détail

Structure d un programme et Compilation Notions de classe et d objet Syntaxe

Structure d un programme et Compilation Notions de classe et d objet Syntaxe Cours1 Structure d un programme et Compilation Notions de classe et d objet Syntaxe POO 1 Programmation Orientée Objet Un ensemble d objet qui communiquent Pourquoi POO Conception abstraction sur les types

Plus en détail

Programmation en langage C

Programmation en langage C Programmation en langage C Anne CANTEAUT INRIA - projet CODES B.P. 105 78153 Le Chesnay Cedex Anne.Canteaut@inria.fr http://www-rocq.inria.fr/codes/anne.canteaut/cours C 2 Table des matières 3 Table des

Plus en détail

Algorithmique et Programmation, IMA

Algorithmique et Programmation, IMA Algorithmique et Programmation, IMA Cours 2 : C Premier Niveau / Algorithmique Université Lille 1 - Polytech Lille Notations, identificateurs Variables et Types de base Expressions Constantes Instructions

Plus en détail

Bases de programmation. Cours 5. Structurer les données

Bases de programmation. Cours 5. Structurer les données Bases de programmation. Cours 5. Structurer les données Pierre Boudes 1 er décembre 2014 This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License. Types char et

Plus en détail

DE L ALGORITHME AU PROGRAMME INTRO AU LANGAGE C 51

DE L ALGORITHME AU PROGRAMME INTRO AU LANGAGE C 51 DE L ALGORITHME AU PROGRAMME INTRO AU LANGAGE C 51 PLAN DU COURS Introduction au langage C Notions de compilation Variables, types, constantes, tableaux, opérateurs Entrées sorties de base Structures de

Plus en détail

1/24. I passer d un problème exprimé en français à la réalisation d un. I expressions arithmétiques. I structures de contrôle (tests, boucles)

1/24. I passer d un problème exprimé en français à la réalisation d un. I expressions arithmétiques. I structures de contrôle (tests, boucles) 1/4 Objectif de ce cours /4 Objectifs de ce cours Introduction au langage C - Cours Girardot/Roelens Septembre 013 Du problème au programme I passer d un problème exprimé en français à la réalisation d

Plus en détail

Java Licence Professionnelle CISII, 2009-10

Java Licence Professionnelle CISII, 2009-10 Java Licence Professionnelle CISII, 2009-10 Cours 4 : Programmation structurée (c) http://www.loria.fr/~tabbone/cours.html 1 Principe - Les méthodes sont structurées en blocs par les structures de la programmation

Plus en détail

Brefs rappels sur la pile et le tas (Stack. / Heap) et les pointeurs

Brefs rappels sur la pile et le tas (Stack. / Heap) et les pointeurs Brefs rappels sur la pile et le tas (Stack / Heap) et les pointeurs (exemples en C) v1.11 - Olivier Carles 1 Pile et Tas Mémoire allouée de manière statique Mémoire Allouée Dynamiquement variables locales

Plus en détail

Langage C. Patrick Corde. Patrick.Corde@idris.fr. 22 juin 2015. Patrick Corde ( Patrick.Corde@idris.fr ) Langage C 22 juin 2015 1 / 289

Langage C. Patrick Corde. Patrick.Corde@idris.fr. 22 juin 2015. Patrick Corde ( Patrick.Corde@idris.fr ) Langage C 22 juin 2015 1 / 289 Langage C Patrick Corde Patrick.Corde@idris.fr 22 juin 2015 Patrick Corde ( Patrick.Corde@idris.fr ) Langage C 22 juin 2015 1 / 289 Table des matières I 1 Présentation du langage C Historique Intérêts

Plus en détail

SUPPORT DE COURS. Langage C

SUPPORT DE COURS. Langage C Dpt Informatique 2010-2011 SUPPORT DE COURS Langage C Semestre 1 par : «CaDePe» Marie-Françoise Canut Marianne de Michiel André Péninou Table des Matières 1 Généralités...8 1.1 Introduction aux langages

Plus en détail

Rappels Entrées -Sorties

Rappels Entrées -Sorties Fonctions printf et scanf Syntaxe: écriture, organisation Comportement Données hétérogènes? Gestion des erreurs des utilisateurs 17/11/2013 Cours du Langage C ibr_guelzim@yahoo.fr ibrahimguelzim.atspace.co.uk

Plus en détail

INITIATION A LA PROGRAMMATION

INITIATION A LA PROGRAMMATION 2004-2005 Université Paris Dauphine IUP Génie Mathématique et Informatique INITIATION A LA PROGRAMMATION PROCEDURALE, A L'ALGORITHMIQUE ET AUX STRUCTURES DE DONNEES PAR LE LANGAGE C Maude Manouvrier La

Plus en détail

Cours de C. Petits secrets du C & programmation avancée. Sébastien Paumier

Cours de C. Petits secrets du C & programmation avancée. Sébastien Paumier Cours de C Petits secrets du C & programmation avancée Sébastien Paumier paumier@univ-mlv.fr Illustrations provenant du site http://tux.crystalxp.net/ 1 Affectations étendues a+=expression a=a+expression

Plus en détail

Le langage C. Séance n 4

Le langage C. Séance n 4 Université Paris-Sud 11 Institut de Formation des Ingénieurs Remise à niveau INFORMATIQUE Année 2007-2008 Travaux pratiques d informatique Le langage C Séance n 4 But : Vous devez maîtriser à la fin de

Plus en détail

Le prototype de la fonction main()

Le prototype de la fonction main() Le prototype de la fonction main() 1. Introduction...1 2. Paramètres et type de retour de la fonction main()...1 3. Exemple 1...2 4. La fonction exit() du C...2 5. Détecter le code de retour d un programme

Plus en détail

INTRODUCTION A JAVA. Fichier en langage machine Exécutable

INTRODUCTION A JAVA. Fichier en langage machine Exécutable INTRODUCTION A JAVA JAVA est un langage orienté-objet pur. Il ressemble beaucoup à C++ au niveau de la syntaxe. En revanche, ces deux langages sont très différents dans leur structure (organisation du

Plus en détail

Plan du cours. Historique du langage http://www.oracle.com/technetwork/java/index.html. Nouveautés de Java 7

Plan du cours. Historique du langage http://www.oracle.com/technetwork/java/index.html. Nouveautés de Java 7 Université Lumière Lyon 2 Faculté de Sciences Economiques et Gestion KHARKIV National University of Economic Introduction au Langage Java Master Informatique 1 ère année Julien Velcin http://mediamining.univ-lyon2.fr/velcin

Plus en détail

TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile

TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile Dans ce TP, vous apprendrez à définir le type abstrait Pile, à le programmer en Java à l aide d une interface

Plus en détail

UE C avancé cours 1: introduction et révisions

UE C avancé cours 1: introduction et révisions Introduction Types Structures de contrôle Exemple UE C avancé cours 1: introduction et révisions Jean-Lou Desbarbieux et Stéphane Doncieux UMPC 2004/2005 Introduction Types Structures de contrôle Exemple

Plus en détail

Programmation C. J.-F. Lalande. 15 novembre 2012

Programmation C. J.-F. Lalande. 15 novembre 2012 Programmation C J.-F. Lalande novembre 0 Ce cours est mis à disposition par Jean-François Lalande selon les termes de la licence Creative Commons Attribution - Pas d Utilisation Commerciale - Partage à

Plus en détail

Gestion de la mémoire

Gestion de la mémoire 433 43 3 Gestion de la mémoire + 1. Qu'est-ce que la mémoire? - Définitions, exemples 2. Allocation contiguë en mémoire - Partitions de taille fixe, de taille variable 3. Pagination et mémoire virtuelle

Plus en détail

Cours intensif Java. 1er cours: de C à Java. Enrica DUCHI LIAFA, Paris 7. Septembre 2009. Enrica.Duchi@liafa.jussieu.fr

Cours intensif Java. 1er cours: de C à Java. Enrica DUCHI LIAFA, Paris 7. Septembre 2009. Enrica.Duchi@liafa.jussieu.fr . Cours intensif Java 1er cours: de C à Java Septembre 2009 Enrica DUCHI LIAFA, Paris 7 Enrica.Duchi@liafa.jussieu.fr LANGAGES DE PROGRAMMATION Pour exécuter un algorithme sur un ordinateur il faut le

Plus en détail

IN 102 - Cours 1. 1 Informatique, calculateurs. 2 Un premier programme en C

IN 102 - Cours 1. 1 Informatique, calculateurs. 2 Un premier programme en C IN 102 - Cours 1 Qu on le veuille ou non, les systèmes informatisés sont désormais omniprésents. Même si ne vous destinez pas à l informatique, vous avez de très grandes chances d y être confrontés en

Plus en détail

Cours d initiation à la programmation en C++ Johann Cuenin

Cours d initiation à la programmation en C++ Johann Cuenin Cours d initiation à la programmation en C++ Johann Cuenin 11 octobre 2014 2 Table des matières 1 Introduction 5 2 Bases de la programmation en C++ 7 3 Les types composés 9 3.1 Les tableaux.............................

Plus en détail

Introduction à Java. Matthieu Herrb CNRS-LAAS. Mars 2014. http://homepages.laas.fr/matthieu/cours/java/java.pdf

Introduction à Java. Matthieu Herrb CNRS-LAAS. Mars 2014. http://homepages.laas.fr/matthieu/cours/java/java.pdf Introduction à Java Matthieu Herrb CNRS-LAAS http://homepages.laas.fr/matthieu/cours/java/java.pdf Mars 2014 Plan 1 Concepts 2 Éléments du langage 3 Classes et objets 4 Packages 2/28 Histoire et motivations

Plus en détail

Claude Delannoy. 3 e édition C++

Claude Delannoy. 3 e édition C++ Claude Delannoy 3 e édition Exercices Exercices C++ en en langage langage delc++ titre 4/07/07 15:19 Page 2 Exercices en langage C++ AUX EDITIONS EYROLLES Du même auteur C. Delannoy. Apprendre le C++.

Plus en détail

Analyse de sécurité de logiciels système par typage statique

Analyse de sécurité de logiciels système par typage statique Contexte Modélisation Expérimentation Conclusion Analyse de sécurité de logiciels système par typage statique Application au noyau Linux Étienne Millon UPMC/LIP6 Airbus Group Innovations Sous la direction

Plus en détail

Programmer en JAVA. par Tama (tama@via.ecp.fr( tama@via.ecp.fr)

Programmer en JAVA. par Tama (tama@via.ecp.fr( tama@via.ecp.fr) Programmer en JAVA par Tama (tama@via.ecp.fr( tama@via.ecp.fr) Plan 1. Présentation de Java 2. Les bases du langage 3. Concepts avancés 4. Documentation 5. Index des mots-clés 6. Les erreurs fréquentes

Plus en détail

Programmation en langage C Eléments de syntaxe

Programmation en langage C Eléments de syntaxe Programmation en langage C Eléments de syntaxe Université Paul Sabatier IUP Systèmes Intelligents L2 Module Informatique de base 2 Initiation à la programmation en langage C Isabelle Ferrané SOMMAIRE I-

Plus en détail

Seance 2: En respectant la méthode de programmation par contrat, implémentez les autres fonctions de jeu.

Seance 2: En respectant la méthode de programmation par contrat, implémentez les autres fonctions de jeu. Seance 2: Complétion du code de jeu. (durée max: 2h) Mot clé const et pointeurs: En respectant la méthode de programmation par contrat, implémentez les autres fonctions de jeu. Implémentez jeu_recupere_piece

Plus en détail

Cours de programmation avancée. Le langage C. Université du Luxembourg 2005 2006

Cours de programmation avancée. Le langage C. Université du Luxembourg 2005 2006 Université du Luxembourg 2005 2006 Cours de programmation avancée. Le langage C Sébastien Varrette Version : 0.4 Nicolas Bernard 2 Table des matières

Plus en détail

Conventions d écriture et outils de mise au point

Conventions d écriture et outils de mise au point Logiciel de base Première année par alternance Responsable : Christophe Rippert Christophe.Rippert@Grenoble-INP.fr Introduction Conventions d écriture et outils de mise au point On va utiliser dans cette

Plus en détail

MISE A NIVEAU INFORMATIQUE LANGAGE C - EXEMPLES DE PROGRAMMES. Université Paris Dauphine IUP Génie Mathématique et Informatique 2 ème année

MISE A NIVEAU INFORMATIQUE LANGAGE C - EXEMPLES DE PROGRAMMES. Université Paris Dauphine IUP Génie Mathématique et Informatique 2 ème année 2003-2004 Université Paris Dauphine IUP Génie Mathématique et Informatique 2 ème année MISE A NIVEAU INFORMATIQUE LANGAGE C - EXEMPLES DE PROGRAMMES Maude Manouvrier La reproduction de ce document par

Plus en détail

Cours 1: Java et les objets

Cours 1: Java et les objets Ressources Les interface homme-machine et le langage Java DUT première année Henri Garreta, Faculté des Sciences (Luminy) Cyril Pain-Barre & Sébastien Nedjar, IUT d Aix-Marseille (Aix) Cours 1: infodoc.iut.univ-aix.fr/~ihm/

Plus en détail

Les structures. Chapitre 3

Les structures. Chapitre 3 Chapitre 3 Les structures Nous continuons notre étude des structures de données qui sont prédéfinies dans la plupart des langages informatiques. La structure de tableau permet de regrouper un certain nombre

Plus en détail

Introduction à l algorithmique et à la programmation M1102 CM n 3

Introduction à l algorithmique et à la programmation M1102 CM n 3 Introduction à l algorithmique et à la programmation M1102 CM n 3 DUT Informatique 1 re année Eric REMY eric.remy@univ-amu.fr IUT d Aix-Marseille, site d Arles Version du 2 octobre 2013 E. Remy (IUT d

Plus en détail

Programmation système de commandes en C

Programmation système de commandes en C Programmation système de commandes en C Cours de Programmation système Tuyêt Trâm DANG NGOC Université de Cergy-Pontoise 2012 2013 Tuyêt Trâm DANG NGOC Programmation système de commandes

Plus en détail

Compression de Données - Algorithme de Huffman Document de Conception

Compression de Données - Algorithme de Huffman Document de Conception ROLLET Samuel SALLE Jennifer Compression de Données - Algorithme de Huffman Document de Conception Projet d'algorithmique et Structure des Données 1 SOMMAIRE 1. Domaine d application....4 1.1 Objectifs

Plus en détail

Généralités sur le Langage Java et éléments syntaxiques.

Généralités sur le Langage Java et éléments syntaxiques. Généralités sur le Langage Java et éléments syntaxiques. Généralités sur le Langage Java et éléments syntaxiques....1 Introduction...1 Genéralité sur le langage Java....1 Syntaxe de base du Langage...

Plus en détail

TP, première séquence d exercices.

TP, première séquence d exercices. TP, première séquence d exercices. Benoît Valiron benoit.valiron@lipn.univ-paris13.fr 7 novembre 2010 Introduction Vous écrirez les réponses aux questions courtes sur une feuille à rendre à la fin de la

Plus en détail

Programmation en C. École Nationale Supérieure de Techniques Avancées. Pierre-Alain Fouque et David Pointcheval

Programmation en C. École Nationale Supérieure de Techniques Avancées. Pierre-Alain Fouque et David Pointcheval École Nationale Supérieure de Techniques Avancées Programmation en C Pierre-Alain Fouque et David Pointcheval E-mail : Pierre-Alain.Fouque@ens.fr Web : http://www.di.ens.fr/~fouque/ Table des matières

Plus en détail

Programmation en langage C d un µcontrôleur PIC à l aide du compilateur C-CCS Sommaire

Programmation en langage C d un µcontrôleur PIC à l aide du compilateur C-CCS Sommaire Programmation en langage C d un µcontrôleur PIC à l aide du compilateur C-CCS CCS Sommaire Généralités sur le langage. 2 Structure d un programme en C.. 3 Les constantes et équivalences.. 4 Les variables...

Plus en détail

INF111. Initiation à la programmation impérative en C http://ama.liglab.fr/ amini/cours/l1/inf111/ Massih-Reza Amini

INF111. Initiation à la programmation impérative en C http://ama.liglab.fr/ amini/cours/l1/inf111/ Massih-Reza Amini Initiation à la programmation impérative en C http://ama.liglab.fr/ amini/cours/l1// Massih-Reza Amini Université Joseph Fourier Laboratoire d Informatique de Grenoble 2/52 Introduction Structures de contrôle

Plus en détail

Centre CPGE TSI - Safi 2010/2011. Algorithmique et programmation :

Centre CPGE TSI - Safi 2010/2011. Algorithmique et programmation : Algorithmique et programmation : STRUCTURES DE DONNÉES A. Structure et enregistrement 1) Définition et rôle des structures de données en programmation 1.1) Définition : En informatique, une structure de

Plus en détail

EPREUVE OPTIONNELLE d INFORMATIQUE CORRIGE

EPREUVE OPTIONNELLE d INFORMATIQUE CORRIGE EPREUVE OPTIONNELLE d INFORMATIQUE CORRIGE QCM Remarque : - A une question correspond au moins 1 réponse juste - Cocher la ou les bonnes réponses Barème : - Une bonne réponse = +1 - Pas de réponse = 0

Plus en détail

COMPARAISONDESLANGAGESC, C++, JAVA ET

COMPARAISONDESLANGAGESC, C++, JAVA ET REPUBLIQUE DU BENIN *******@******* MINISTERE DE L ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE(MESRS) *******@******* UNIVERSITE D ABOMEY CALAVI(UAC) *******@******* ECOLE POLYTECHNIQUE D ABPOMEY

Plus en détail

Programmation Classique en langage C

Programmation Classique en langage C DI GALLO Frédéric Programmation Classique en langage C Cours du Cycle d Approfondissement CNAM ANGOULEME 2000-2001 DI GALLO Frédéric Page 1 01/04/01 PROGRAMMATION CLASSIQUE : LANGAGE C DI GALLO Frédéric

Plus en détail

3IS - Système d'exploitation linux - Programmation système

3IS - Système d'exploitation linux - Programmation système 3IS - Système d'exploitation linux - Programmation système 2010 David Picard Contributions de : Arnaud Revel, Mickaël Maillard picard@ensea.fr Environnement Les programmes peuvent être exécutés dans des

Plus en détail

Algorithmique, Structures de données et langage C

Algorithmique, Structures de données et langage C UNIVERSITE PAUL SABATIER TOULOUSE III Algorithmique, Structures de données et langage C L3 IUP AISEM/ICM Janvier 2005 J.M. ENJALBERT Chapitre 1 Rappels et compléments de C 1.1 Structures Une structure

Plus en détail

Cours 1 : Introduction. Langages objets. but du module. contrôle des connaissances. Pourquoi Java? présentation du module. Présentation de Java

Cours 1 : Introduction. Langages objets. but du module. contrôle des connaissances. Pourquoi Java? présentation du module. Présentation de Java Langages objets Introduction M2 Pro CCI, Informatique Emmanuel Waller, LRI, Orsay présentation du module logistique 12 blocs de 4h + 1 bloc 2h = 50h 1h15 cours, 45mn exercices table, 2h TD machine page

Plus en détail

Cours d Algorithmique et de Langage C 2005 - v 3.0

Cours d Algorithmique et de Langage C 2005 - v 3.0 Cours d Algorithmique et de Langage C 2005 - v 3.0 Bob CORDEAU cordeau@onera.fr Mesures Physiques IUT d Orsay 15 mai 2006 Avant-propos Avant-propos Ce cours en libre accès repose sur trois partis pris

Plus en détail

Les chaînes de caractères

Les chaînes de caractères Les chaînes de caractères Dans un programme informatique, les chaînes de caractères servent à stocker les informations non numériques comme par exemple une liste de nom de personne ou des adresses. Il

Plus en détail

as Architecture des Systèmes d Information

as Architecture des Systèmes d Information Plan Plan Programmation - Introduction - Nicolas Malandain March 14, 2005 Introduction à Java 1 Introduction Présentation Caractéristiques Le langage Java 2 Types et Variables Types simples Types complexes

Plus en détail

Travaux pratiques. Compression en codage de Huffman. 1.3. Organisation d un projet de programmation

Travaux pratiques. Compression en codage de Huffman. 1.3. Organisation d un projet de programmation Université de Savoie Module ETRS711 Travaux pratiques Compression en codage de Huffman 1. Organisation du projet 1.1. Objectifs Le but de ce projet est d'écrire un programme permettant de compresser des

Plus en détail

Chap III : Les tableaux

Chap III : Les tableaux Chap III : Les tableaux Dans cette partie, on va étudier quelques structures de données de base tels que : Les tableaux (vecteur et matrice) Les chaînes de caractères LA STRUCTURE DE TABLEAU Introduction

Plus en détail

Java Licence Professionnelle CISII, 2009-2010

Java Licence Professionnelle CISII, 2009-2010 Licence Professionnelle CISII, 2009-2010 Cours 1 : Introduction à Java A. Belaïd abelaid@loria.fr Cours disponible sur le site : http://www.loria.fr/~abelaid puis Teaching 1 Fonctionnement 12 séances :

Plus en détail

Le langage C. Introduction, guide de reference

Le langage C. Introduction, guide de reference Le langage C Introduction, guide de reference Ce document est une présentation du langage de programmation C, de sa syntaxe et de ses spécificités. Il est destiné essentiellement à servir de mémo-guide

Plus en détail

Cours Langage C/C++ Programmation modulaire

Cours Langage C/C++ Programmation modulaire Cours Langage C/C++ Programmation modulaire Thierry Vaira BTS IRIS Avignon tvaira@free.fr «v0.1 Rappel Programmation modulaire (1/2) Le découpage d'un programme en sous-programmes est appelée programmation

Plus en détail

03/04/2007. Tâche 1 Tâche 2 Tâche 3. Système Unix. Time sharing

03/04/2007. Tâche 1 Tâche 2 Tâche 3. Système Unix. Time sharing 3/4/27 Programmation Avancée Multimédia Multithreading Benoît Piranda Équipe SISAR Université de Marne La Vallée Besoin Programmes à traitements simultanés Réseau Réseau Afficher une animation en temps

Plus en détail

Programmation système en C/C++

Programmation système en C/C++ Programmation système en C/C++ Jean-Baptiste Vioix (jb.vioix@free.fr) LE2I - ENESAD http://jb.vioix.free.fr 1-41 Programmation en C/C++ sous Unix Il existe des très nombreux outils de développement sous

Plus en détail

TD3: tableaux avancées, première classe et chaînes

TD3: tableaux avancées, première classe et chaînes TD3: tableaux avancées, première classe et chaînes de caractères 1 Lestableaux 1.1 Élémentsthéoriques Déclaration des tableaux Pour la déclaration des tableaux, deux notations sont possibles. La première

Plus en détail

Introduction au Langage de Programmation C

Introduction au Langage de Programmation C Faculté Polytechnique de Mons Service d'informatique Introduction au Langage de Programmation C Mohammed Benjelloun 1 ère Candidature Année académique 2003-2004 Avant-propos Ces notes permettent de se

Plus en détail

UE Programmation Impérative Licence 2ème Année 2014 2015

UE Programmation Impérative Licence 2ème Année 2014 2015 UE Programmation Impérative Licence 2 ème Année 2014 2015 Informations pratiques Équipe Pédagogique Florence Cloppet Neilze Dorta Nicolas Loménie prenom.nom@mi.parisdescartes.fr 2 Programmation Impérative

Plus en détail

PROGRAMMATION PAR OBJETS

PROGRAMMATION PAR OBJETS PROGRAMMATION PAR OBJETS Java Environnement et constructions spécifiques Walter Rudametkin Maître de Conférences Bureau F011 Walter.Rudametkin@polytech-lille.fr B. Carré Polytech Lille 2 Java (Sun 1995)

Plus en détail

BTS IRIS Cours et Travaux Pratiques. Programmation C. A. Lebret, TSIRIS, Lycée Diderot, 1995/06. en conformité avec le référentiel du BTS IRIS

BTS IRIS Cours et Travaux Pratiques. Programmation C. A. Lebret, TSIRIS, Lycée Diderot, 1995/06. en conformité avec le référentiel du BTS IRIS BTS IRIS Cours et Travaux Pratiques Programmation C A. Lebret, TSIRIS, Lycée Diderot, 1995/06 en conformité avec le référentiel du BTS IRIS Activité Codage et Réalisation Tâches T3.3, T3.4 et T3.5 Temps

Plus en détail

Initiation. àl algorithmique et à la programmation. en C

Initiation. àl algorithmique et à la programmation. en C Initiation àl algorithmique et à la programmation en C Initiation àl algorithmique et à la programmation en C Cours avec 129 exercices corrigés Illustration de couverture : alwyncooper - istock.com Dunod,

Plus en détail

Programmation impérative

Programmation impérative Programmation impérative Cours 4 : Manipulation des fichiers en C Catalin Dima Organisation des fichiers Qqs caractéristiques des fichiers : Nom (+ extension). Chemin d accès absolu = suite des noms des

Plus en détail

Cours de C++ François Laroussinie. 2 novembre 2005. Dept. d Informatique, ENS de Cachan

Cours de C++ François Laroussinie. 2 novembre 2005. Dept. d Informatique, ENS de Cachan Cours de C++ François Laroussinie Dept. d Informatique, ENS de Cachan 2 novembre 2005 Première partie I Introduction Introduction Introduction Algorithme et programmation Algorithme: méthode pour résoudre

Plus en détail

Dans le chapitre 1, nous associions aux fichiers ouverts des descripteurs de fichiers par lesquels nous accédions aux fichiers.

Dans le chapitre 1, nous associions aux fichiers ouverts des descripteurs de fichiers par lesquels nous accédions aux fichiers. I Présentation : Dans le chapitre 1, nous avons vu comment utiliser les appels-systèmes de bas niveau pour créer et accéder à des fichiers sur le disque. Nous avons notamment mis en évidence leur dépouillement

Plus en détail

Anis ASSÈS Mejdi BLAGHGI Mohamed Hédi ElHajjej Mohamed Salah Karouia

Anis ASSÈS Mejdi BLAGHGI Mohamed Hédi ElHajjej Mohamed Salah Karouia Ministère de l Enseignement Supérieur, de la Recherche Scientifique et de la Technologie Direction Générale des Etudes Technologiques Institut Supérieur des Etudes Technologiques de Djerba SUPPORT DE COURS

Plus en détail

Algorithmes et Programmes. Introduction à l informatiquel. Cycle de vie d'un programme (d'un logiciel) Cycle de vie d'un programme (d'un logiciel)

Algorithmes et Programmes. Introduction à l informatiquel. Cycle de vie d'un programme (d'un logiciel) Cycle de vie d'un programme (d'un logiciel) Algorithmes et Programmes Introduction à l informatiquel! Vie d'un programme! Algorithme! Programmation : le langage! Exécution et test des programmes Chapitre : Algorithmes et Programmes 2 Cycle de vie

Plus en détail

Support de Cours de Langage C. Christian Bac

Support de Cours de Langage C. Christian Bac Support de Cours de Langage C Christian Bac 15 février 2013 ii Table des matières Avant-propos xi 1 Historique et présentation 1 1.1 Historique........................................... 1 1.2 Présentation

Plus en détail

INF 321 : mémento de la syntaxe de Java

INF 321 : mémento de la syntaxe de Java INF 321 : mémento de la syntaxe de Java Table des matières 1 La structure générale d un programme 3 2 Les composants élémentaires de Java 3 2.1 Les identificateurs.................................. 3 2.2

Plus en détail

Le Langage C Licence Professionnelle Qualité Logiciel Pr. Mouad BEN MAMOUN ben_mamoun@fsr.ac.ma Année universitaire 2011/2012

Le Langage C Licence Professionnelle Qualité Logiciel Pr. Mouad BEN MAMOUN ben_mamoun@fsr.ac.ma Année universitaire 2011/2012 Le Langage C Licence Professionnelle Qualité Logiciel Pr. Mouad BEN MAMOUN ben_mamoun@fsr.ac.ma Année universitaire 2011/2012 2011/2012 Pr. Ben Mamoun 1 Plan du cours (1) 1. Introduction 2. Types, opérateurs

Plus en détail

Arguments d un programme

Arguments d un programme Arguments d un programme L2 SPI, Bruno Jacob 1 Arguments Quand on appelle un programme dans un environnement UNIX ou MS- DOS, on compose une ligne de commandes de la forme : nom-du-programme argument1

Plus en détail

Les fichiers. Chapitre 4

Les fichiers. Chapitre 4 Chapitre 4 Les fichiers Jusqu à maintenant tous les programmes que nous avons conçus travaillaient sur des données qui étaient perdues après chaque session de travail. On peut cependant, c est bien naturel,

Plus en détail

OS Réseaux et Programmation Système - C5

OS Réseaux et Programmation Système - C5 OS Réseaux et Programmation Système - C5 Rabie Ben Atitallah rabie.benatitallah@univ-valenciennes.fr RPC - XDR Rappel RPC: Remote Procedure Call Besoin d un environnement de haut niveau pour le développement

Plus en détail

Programme Compte bancaire (code)

Programme Compte bancaire (code) using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; Programme Compte bancaire (code) namespace compte_bancaire /// Classe Program public

Plus en détail

Notions fondamentales du langage C# Version 1.0

Notions fondamentales du langage C# Version 1.0 Notions fondamentales du langage C# Version 1.0 Z 2 [Notions fondamentales du langage Csharp] [Date : 25/03/09] Sommaire 1 Tout ce qu il faut savoir pour bien commencer... 3 1.1 Qu est ce qu un langage

Plus en détail

Une introduction à Java

Une introduction à Java Une introduction à Java IFT 287 (Semaine 1) UNIVERSITÉ DE SHERBROOKE 1 Java - Historique Développé par Sun Microsystems en 1994 Inventeur James Gosling (canadien!) Objectif langage sûr (fortement typé)

Plus en détail

Langage Éric Guérin 5 octobre 2010

Langage Éric Guérin 5 octobre 2010 Langage Éric Guérin 5 octobre 2010 Langage C TABLE DES MATIÈRES Table des matières 1 Introduction 7 1.1 Historique........................................... 7 1.2 Architecture matérielle....................................

Plus en détail

Cours Programmation Système

Cours Programmation Système Cours Programmation Système Filière SMI Semestre S6 El Mostafa DAOUDI Département de Mathématiques et d Informatique, Faculté des Sciences Université Mohammed Premier Oujda m.daoudi@fso.ump.ma Février

Plus en détail

Le système de gestion des fichiers, les entrées/sorties.

Le système de gestion des fichiers, les entrées/sorties. Le système de gestion des fichiers, les entrées/sorties. Luigi Santocanale Laboratoire d Informatique Fondamentale, Centre de Mathématiques et Informatique, 39, rue Joliot-Curie - F-13453 Marseille 19

Plus en détail

Les structures de données. Rajae El Ouazzani

Les structures de données. Rajae El Ouazzani Les structures de données Rajae El Ouazzani Les arbres 2 1- Définition de l arborescence Une arborescence est une collection de nœuds reliés entre eux par des arcs. La collection peut être vide, cad l

Plus en détail

I. Introduction aux fonctions : les fonctions standards

I. Introduction aux fonctions : les fonctions standards Chapitre 3 : Les fonctions en C++ I. Introduction aux fonctions : les fonctions standards A. Notion de Fonction Imaginons que dans un programme, vous ayez besoin de calculer une racine carrée. Rappelons

Plus en détail

MICROINFORMATIQUE NOTE D APPLICATION 1 (REV. 2011) ARITHMETIQUE EN ASSEMBLEUR ET EN C

MICROINFORMATIQUE NOTE D APPLICATION 1 (REV. 2011) ARITHMETIQUE EN ASSEMBLEUR ET EN C Haute Ecole d Ingénierie et de Gestion Du Canton du Vaud MICROINFORMATIQUE NOTE D APPLICATION 1 (REV. 2011) ARITHMETIQUE EN ASSEMBLEUR ET EN C Programmation en mode simulation 1. DOCUMENTS DE RÉFÉRENCE...

Plus en détail

Algorithmique & Langage C IUT GEII S1. Notes de cours (première partie) cours_algo_lgc1.17.odp. Licence

Algorithmique & Langage C IUT GEII S1. Notes de cours (première partie) cours_algo_lgc1.17.odp. Licence Licence Algorithmique & Langage C Paternité - Pas d'utilisation Commerciale Partage des Conditions Initiales à l'identique 2.0 France Vous êtes libres : * de reproduire, distribuer et communiquer cette

Plus en détail

Pour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère

Pour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère L'héritage et le polymorphisme en Java Pour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère En java, toutes les classes sont dérivée de la

Plus en détail

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE UNIVERSITE M HAMED BOGARA DE BOUMERDES

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE UNIVERSITE M HAMED BOGARA DE BOUMERDES REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE MINISTERE DE L ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE UNIVERSITE M HAMED BOGARA DE BOUMERDES FACULTE DES SCIENCES - DEPARTEMENT PHYSIQUE

Plus en détail

Pensez à vous inscrire... si ce n est pas encore fait

Pensez à vous inscrire... si ce n est pas encore fait Sommaire UE C avancé cours 1: introduction Jean-Lou Desbarbieux et Stéphane Doncieux LI215 Licence Informatique UMPC 2013/2014 Introduction Présentation Évaluation Calendrier Biblio Intro au C Types Types

Plus en détail