Programmation syst`eme I Les entr´ees/sorties

(1)

Programmation syst `eme I Les entr ´ees/sorties

DUT 1^reann ´ee

Universit ´e de Marne La vall ´ee

(2)

Les entr ´ees-sorties : E/O

Entr ées/Sorties :Op érations d’ échanges d’informations dans un syst ème informatique.

Les syst èmes d’exploitations ont des m écanismes/fonctions d’entr ées sorties, les langages de programmation aussi. Dans le langage C, la plupart de ces fonctionnalit és se situent dans la librairie<stdio.h>.

(stdio : standard input output).

Sans entr ´ees/sorties, il est impossible de produire des programmes

évolu és ayant de grands impacts sur l’environnement, le syst ème et la m émoire.

(3)

Les flux d’informations

Toutes interactions avec l’environnement et la m émoire (et leurs modifications) n écessite de r écup érer ou de constituer un flux d’informations.

Flux classiques :

I Texte tap ´e au clavier (entr ´ee)

I Mouvement de la souris et clic (entr ´ee)

I Fichiers sur le disque dur (entr ´ee/sortie)

I Position de la souris sur l’ ´ecran (entr ´ee/sortie)

I Texte affich ´e sur l’ ´ecran (sortie)

I R ´eseau (entr ´ee/sortie)

I Webcam (entr ´ee)

I ...

(4)

Les fichiers dans le langage C

Il est possible de manipuler (cr éer / lire / écrire / d étruire) des fichiers du disque dur via des fonctions d’Entr ées/Sorties de la librairie

<stdio.h>.

Dans le langage C, les fichiers sont manipulables via un pointeur sur une structureFILE.

Proc ´ed ´e de manipulation de fichier:

I Ouverture du fichier, constitution de l’objet (FILE *) et placement du pointeur.

I Fonctions d’Entr ées/Sorties du langage C pour modifier des caract ères sur le pointeur et d éplacer ce pointeur dans le fichier ouvert.

I Fermeture du fichier.

Le dernier caract `ere d’un fichier ouvert estEOFpour (End Of File).

(5)

Ouverture d’un fichier:fopen

Avant toute op ´eration sur un fichier, il est n ´ecessaire d’obtenir un pointeur de typeFILE *.

FILE *fopen(const char *path, const char *mode);

-pathcontient l’adresse du fichier `a ouvrir,-modepr ´ecise le mode d’ouverture.

I "r": mode lecture, pointeur au d ´ebut

I "w": mode écriture, pointeur au d ébut, cr éation du fichier si non existant, effacement sinon. (ChevronUNIX >)

I "r+": mode lecture- ´ecriture, pointeur au d ´ebut

I "w+": mode lecture- écriture, pointeur au d ébut, cr éation du fichier si non existant, effacement sinon.

I "a": mode écriture, pointeur à la fin, cr éation du fichier si non existant. (ChevronUNIX >>)

I "a+": mode lecture- écriture, pointeur à la fin, cr éation du fichier si non existant.

(6)

Fermeture d’un fichier:fclose

Une fois les modifications termin ´ees, il convient de fermer les fichiers ouverts.

int fclose(FILE *stream);

retourne 0 en cas de succ `es etEOFsinon.

R ´eouverture d’un fichier:freopen

R é-ouvre un fichier en fermant l’instance pr éc édemment ouverte.

FILE *freopen(const char *path, const char *mode, FILE

*stream);

A l’origine, cette fonction est conc¸ue pour permettre les redirections.

On l’utilisera rarement en pratique mais son recours est parfois contraint.

(7)

Les flux standards

Dans le langage C et pourUNIX(programm ´e en C), il existe des flux standards qui se comportent comme des fichiers pour lesquels l’utilisateur n’a pas `a se soucier de l’ouverture et fermeture.

I stdin: (standard input) est l’entr ée standard. Tout caract ère tap é au clavier durant l’ex écution d’un programme se retrouve dans ce flux.

I stdout: (standard output) est la sortie standard. Tout caract `ere

écrit dans ce flux sera affich é dans la console lors de l’ex écution d’un programme. ATTENTION A LA BUFFERISATION.

I stderr: (standard error) est la sortie d’erreur standard.

Les fonctions d’Entr ées/Sorties du langage C op érant sur les fichiers et flux standards sont tr ès li ées. (printf - fprintf, scanf - fscanf, ...).

(8)

Fonctions d’Entr ´ees/Sorties du langage C

Les fonctions d’entr ées/sorties servent à écrire et r écup érer des donn ées dans les fichiers ouverts et les flux standards.

int i;

char c;

...

fichier1mode lecture fichier2mode ´ecriture

stdin stdout fscanf

fprintf scanf

printf

Les fonctions primitives syst èmes sont tr ès difficiles à utiliser (open, close,read,write). Notamment, elles ne font que de la lecture octet par octet (8 bits). On utilisera les fonctions E/S format ées de

<stdio.h>.

(9)

scanf : lecture format ´ee sur l’entr ´ee standard

int scanf(const char *format, ...);

On remplace les ... par une liste d’adresses de conteneurs m ´emoires adapt ´es. Si on a une variableint i, l’adresse&ideiest un

conteneur m émoire adapt é à la lecture d’un entier.

Type Lettre

int %d

long %ld

float - double %f - %lf

char %c

string (char*) %s

1 char nom [ 5 0 ] ; 2 i n t age ;

3 p r i n t f ( ” S a i s i s s e z v o t r e nom , un espace , p u i s v o t r e age ” ) ; 4 s c a n f ( ”%s %d ” , nom , &age ) ;

scanfretourne le nombre de variables affect ées par la saisie, cela permet de v érifier le bon d éroulement de la saisie.

(10)

printf : ´ecriture format ´ee sur la sortie standard

int printf(const char *format, ...);

On remplace les ... par une liste de variables adapt ées aux diff érents types apparaissant dans le format. Encore une fois, il faut respect é l’ordre de lecture de gauche à droite.

Le texte format é avec les bonnes substitutions est ensuite affich é à l’ écran (modulo la bufferisation).

1 f l o a t t = 3 7 . 1 2 ; 2

3 p r i n t f ( ” La t e m p e r a t u r e de %s e s t %f ” , ” M a r t i n ” , f ) ;

En cas de succ ès,printfretourne le nombre de caract ères écrits sur la sortie standard (sans compter le caract ère de fin de chaˆıne).

(11)

fscanf : lecture format ´ee sur un flux

int fscanf(FILE *stream, const char *format, ...);

On remplace les ... par une liste d’adresses de conteneurs m émoires adapt és. On r écup ère ainsi des donn ées dans le flux qui se place en valeur des adresses de variables donn ées.

1 char nom [ 8 0 ] ; 2 i n t age ;

3 FILE ∗ f i c h i e r e n t r e e ; 4

5 f i c h i e r e n t r e e = fopen ( ” nom age . t x t ” , ” r ” ) ; 6 f s c a n f ( f i c h i e r e n t r e e , ”%s %d ” , nom , & f ) ;

fscanfretourne le nombre de variables affect ées par la saisie, cela permet de v érifier le bon d éroulement de la saisie.

Les flux standards se comportent comme des fichiers ouvert, ainsi : scanf(format, ...)est ´equivalent `afscanf(stdin, format, ...).

(12)

fprintf : ´ecriture format ´ee sur un flux

int fprintf(FILE *stream, const char *format, ...);

On remplace les ... par une liste de variables adapt ées aux diff érents types apparaissant dans le format. Encore une fois, il faut respect é l’ordre de lecture de gauche à droite.

Le texte format ´e avec les bonnes substitutions est ensuite ´ecrit sur le flux.

1 i n t age =12;

2 FILE ∗ f i c h i e r s o r t i e ; 3

4 f i c h i e r s o r t i e = fopen ( ” nom age . t x t ” , ”w” ) ; 5 f s c a n f ( f i c h i e r s o r t i e , ”%s %d ” , ” M a r t i n ” , age ) ;

En cas de succ ès,fprintfretourne le nombre de caract ères écrits sur le flux (sans compter le caract ère de fin de chaˆıne).

printf(format, ...)est ´equivalent `afprintf(stdout, format, ...).

(13)

Il existe de nombreuse autre fonctions d’Entr ´ees/Sorties.

Lorsque l’on ne connaˆıt pas/plus une fonctionfooen langage C,LE SEUL R ´EFLEXE:on tapeman 3 foodans un terminal.

Autre fonctions: fgetc, fgets, getc, getchar, gets, ungetc, fputc, fputs, putc, putchar, puts, ...

man 3 fgetc

GETS(3) Linux Programmer’s Manual GETS(3)

NAME

fgetc, fgets, getc, getchar, gets, ungetc - input of characters and strings

SYNOPSIS

#include <stdio.h>

int fgetc(FILE *stream);

...

(14)

Soyez astucieux et perspicaces

Les noms de fonctions n’ont pas ´et ´e choisis au hasard.

I print-f: ´ecrire, format

I f-scan-f: flux, analyser, format

I f-get-c: flux, obtenir, caract `ere

I put-char: placer, caract `ere

I f-put-s: flux, placer, chaˆıne de caract `eres

I Lorsque le nom ne commence pas par unf, la fonction affecte les flux standards, sinon elle aura un flux parmi ses arguments.

I En fin de nom,cetchard ésigne des caract ères,sd ésigne une chaˆıne de caract ères,fque la fonction peut prendre des

écritures format ées (types diff érents).

(15)

Des param `etres dans la fonction main

Voici le prototype standard d’unmainacceptant des arguments:

int main(int argc, char* argv[])

I argcest un entier, il donne le nombre d’arguments pass és à l’ex écutable (en comptant le nom de l’ex écutable comme premier argument).

I argvest un tableau de chaˆınes de caract `eres.

I argv[0]: le nom de l’ex écutable (d épend du nom donn é à la compilation).

I argv[1]: le nom du premier argument.

I argv[2]: le nom du second argument.

I ...

Similarit ´e avec le langage dubash:

$#se comporte commeargc

$0se comporte commeargv[0]

$1se comporte commeargv[1]

... (et tout est, a priori, chaˆınes de caract `eres)

(16)

Pour le programme suivant :test.c

1 # include <s t d i o . h>

2

3 i n t main (i n t argc , char∗ argv [ ] ){ 4 i n t i ;

5

6 f o r ( i =0 ; i<argc ; i + + ){ 7 p r i n t f ( ”%s\n ” , argv [ i ] ) ;

8 }

9 r e t u r n 0 ; 10 }

nicolas@lancelot:˜/test$ gcc -o test test.c -Wall -ansi nicolas@lancelot:˜/test$ ./test fich1.txt fich2.txt 23 ./test

fich1.txt fich2.txt 23

(17)

Les arguments des ex écutables pass és par la console sont des chaˆınes de caract ères. Toutefois, le langage C poss ède des fonctions de conversions entre ces types.

int atoi(const char *nptr);

retourne un entier `a partir d’une chaˆıne de caract `eres.

2 # include <s t d l i b . h>

3

4 i n t main (void){

5 char∗ nombre= ” 12543 ” ; 6

7 p r i n t f ( ”%d\n ” , a t o i ( nombre ) ) ; 8 r e t u r n 0 ;

9 }

nicolas@lancelot:˜/test$ gcc -o test test.c -Wall -ansi nicolas@lancelot:˜/test$ ./test

12543

(18)

Comment alors faire un ex ´ecutable en console qui attend des entiers en arguments et retourne la somme de ces derniers.

2 # include <s t d l i b . h>

3

4 i n t main (i n t argc , char∗ argv [ ] ){ 5 i n t i , somme= 0 ;

6

7 f o r ( i =1 ; i<argc ; i + + ){ 8 somme += a t o i ( argv [ i ] ) ;

9 }

10 p r i n t f ( ”%d\n ” , somme ) ; 11 r e t u r n 0 ;

12 }

0

nicolas@lancelot:˜/test$ ./test 1 2 3

nicolas@lancelot:˜/test$ ./test 1 2 5 5 13

nicolas@lancelot:˜/test$ ./test foo bla 0

(19)

L’œuf ou la poule, UNIX ou le langage C ?

Le syst ème d’exploitationUNIXet le langage C ont ét é conçu de mani ère relativement conjointe. Notamment, les flux standards (stdin, stdout, stderr) SONT LES M ÊMES!

Un ex écutable compil é à partir de source écrite en C bien programm é peut s’enchaˆıner dans des pipesUNIX à volont é.

cons ´equences:

Toutes les donn ées r écup ér ées sur l’entr ée standard (scanf, getchar, ...) peuvent en fait être envoy é au programme via un chevron entrant<d’UNIXou un pipe|.

(20)

2

3 i n t main (void){ 4 char nom [ 5 0 ] ; 5 i n t age ; 6

7 p r i n t f ( ” Donner v o t r e nom e t v o t r e age !\n ” ) ; 8 s c a n f ( ”%s %d ” , nom , &age ) ;

9 p r i n t f ( ” Ok , vous e t e s %s e t vous avez %d ans\n ” , nom , age ) ; 10 r e t u r n 0 ;

11 }

nicolas@lancelot:˜/test$ gcc -o test test.c -Wall -ansi nicolas@lancelot:˜/test$ echo "Dupont 45"

Dupont 45

nicolas@lancelot:˜/test$ echo "Dupont 45" | ./test Donner votre nom et votre age!

Ok, vous etes Dupont et vous avez 45 ans nicolas@lancelot:˜/test$ ./test < nom_age.txt Donner votre nom et votre age!

Ok, vous etes Durant et vous avez 78 ans

(21)

2

3 i n t main (void){ 4 i n t c= g e t c h a r ( ) ; 5

6 \ ∗ Recopiage de l e n t r e e s t a n d a r d s u r l a s o r t i e s t a n d a r d ∗ \ 7 while ( c ! = EOF ){

8 p u t c h a r ( c ) ; 9 c = g e t c h a r ( ) ;

10 }

11 r e t u r n 0 ; 12 }

nicolas@lancelot:˜/test$ gcc -o test test.c -Wall -ansi nicolas@lancelot:˜/test$ echo "pouet fou bla" > fichier nicolas@lancelot:˜/test$ echo "une seconde ligne" >> fichier nicolas@lancelot:˜/test$ ./test < fichier

pouet fou bla une seconde ligne

nicolas@lancelot:˜/test$ ./test < fichier | ./test pouet fou bla

une seconde ligne

(22)

Bufferisation

La sortie standard est bufferis ´ee: Les fonctions d’Entr ´ees/Sortie de

<stdio.h>n’envoient pas directement les él éments sur l’ écran.

UNIXincite à l’enchaˆınement de commandes ou ex écutables via des pipes. Mais la communication entre les processus a un co ût. Surtout si l’on perd son temps à communiquer sans arr êt des messages tout petits.

printf écrit sur le buffer de la sortie standard (de taille 8192 Octets par d éfaut) et une fois le buffer plein (ou un retour à ligne, ou un flush, ou ...), on sollicite le processus d’affichage à l’ écran.

Note: La sortie d’erreur n’est pas bufferis é et affiche les caract ères d ès l’ajout dans le flux.

(23)

2

3 i n t main (void){ 4 char∗ nom= ” Jean ” ; 5

6 p r i n t f ( ”Ou e s t l ’ e r r e u r de segment ation ” ) ; 7 nom [ 3 4 ] = 123;

8 r e t u r n 0 ;

9 }

Ce programme donne le comportement suivant

Erreur de segmentation (core dumped)

O `u est pass ´e leprintf? l’erreur de segmentation se trouve avant ?

(24)

Solution 1:

2

6 /∗ Un s a u t de l i g n e f o r c e l a vidange du b u f f e r ∗/ 7 p r i n t f ( ”Ou e s t l ’ e r r e u r de segment ation\n ” ) ; 8 nom [ 3 4 ] = 123;

9 r e t u r n 0 ; 10 }

Solution 2:

2

6 /∗ Drapeau de debogage s u r l a s o r t i e d ’ e r r e u r ∗/ 7 f p r i n t f ( s t d e r r , ”Ou e s t l ’ e r r e u r de segment ation ” ) ; 8 nom [ 3 4 ] = 123;

9 r e t u r n 0 ; 10 }