Fichiers Rappel entrées sorties C standard Flots entrée, sortie

Rappel entrées sorties C standard
Fichiers
Wieslaw Zielonka
October 25, 2014
Flots entrée, sortie, erreur standards
stdin
stdout
stderr
le flot – le fichier ouvert en lecture/écriture
Ouvrir un flot:
FILE ∗ f o p e n ( const char ∗ chemin , const char ∗mode ) ;
mode
’’r’’
’’w’’
’’a’’
’’w+’’
’’r+’’
’’a+’’
en lecture
en écriture, la taille ramenée à 0
append, en écriture
lecture et écriture, la taille ramenée à 0
lecture et écriture
lecture et écriture avec append
Lecture écriture binaire avec des flots
s i z e t f r e a d ( v o i d ∗tampon , s i z e t t , s i z e t nb ,
FILE ∗ f l o t )
s i z e t f w r i t e ( v o i d ∗ tampon , s i z e t t , s i z e t nb ,
FILE ∗ f l o t )
fread lit dans le tampon le nombre nb d’éléments, chaque
élément de taille t.
La fonction retourne le nombre le nombre d’octets transférés. Si la
fonction retourne 0 alors soit la fin de fichier soit erreur.
Test de fin fichier/erreur
fread et fwrite ne distinguent pas la fin de fichier d’une erreur.
i n t f e o f ( FILE ∗ f l o t )
i n t f e r r o r ( FILE ∗ f l o t )
v o i d c l e a r e r r ( FILE ∗ f l o t )
feof() > 0 si fin de fichier
ferror() > 0 si erreur
clearerr() – efface les marqueurs de fin de fichier et d’erreur
Input/output caractère par caractère
i n t g e t c ( FILE ∗ f p )
i n t f g e t c ( FILE ∗ f p )
i n t g e t c h a r ( void )
i n t p u t c ( i n c , FILE ∗ f p )
i n t f p u t c ( i n t c , FILE ∗ f p )
int putchar ( int c )
Les trois première fonctions retournent EOF à la fin de fichier et en
cas d’erreur.
Les trois dernières fonctions retournent EOF en cas d’erreur.
Tampon d’un flot
char ∗ f g e t s ( char ∗ buf , i n t n , FILE ∗ f p )
Le flot possède un tampon interne.
i n t f p u t s ( char ∗ s t r , FILE ∗ f p )
Le flot non-mémorisé ( unbuffered ) – les octets transmis dans le
fichier ou sur le terminal immédiatement
i n t p u t s ( char ∗ s t r )
mémorisé (fully buffered) – transmission dans le fichier quand le
tampon est plein
fgets met dans buf le caractère de nouvelle ligne à la fin de la
ligne lue.
mémorisé par ligne (line buffered) – transmis dans le fichier quand
le caractère ’\n’ est mis dans le tampon.
i n t f f l u s h ( FILE ∗ f l o t )
force l’écriture de données qui se trouvent dans le tampon.
Gestion de tampon de flot
Indicateur de position
long f t e l l ( FILE ∗ f p )
i n t s e t v b u f ( FILE ∗ f l o t , char ∗tampon , i n t mode ,
size t taille )
i n t f s e e k ( FILE ∗ f p , long o f f s e t , i n t a p a r t i r )
v o i d r e w i n d ( FILE ∗ f p )
mode
_IOFBF
_IOLBF
_IONBF
pleinement mémorisé
mémorisé par ligne
non mémorisé
i n t f g e t p o s ( FILE ∗ f p , f p o s t ∗ pos )
i n t f s e t p o s ( FILE ∗ f p , const f p o s t ∗ pos )
apartir SEEK_SET, SEEK_CUR, SEEK_END
ftell retourne offset courant et fseek retourne 0 si tout OK.
fgetpos stocke la position courante à l’adresse passée comme
deuxième paramètre, cette valeur pourra être utilisée par fsetpos.
Interactions entre le haut et bas niveau
Liens symboliques
Commande UNIX:
l n −s c h a i n e d e c a r a c t e r e s
FILE ∗ f d o p e n ( i n t f d , const char ∗ t y p e )
fdopen — crée un flot pour un descripteur ouvert. Le deuxième
paramètre type est le même que le deuxième paramètre de fopen.
i n t f i l e n o ( FILE ∗ f l o t )
fileno() retourne le descripteur de fichier utilisé par le flot.
lien symbolique
Fonction C:
i n t s y m l i n k ( const char ∗ c h a i n e d e c a r a c t e r e s ,
const char ∗ l i e n s y m b o l i q u e ) ;
symlink retourne 0 en cas de succès, −1 en cas d’échec.
symlink entraı̂ne la création d’un lien vers un nouveau fichier
spécial (de type lien symbolique), le contenu de ce nouveau fichier
est la chaı̂ne de caractères passée dans le premier argument de
symlink.
Lien symbolique
Lien symbolique
symlink ( ”/ u s r / bin ” , ” t o b i n ” ) ;
s y m l i n k ( ”#∗+$ l 2 3 ” , ” . . / v e r s r i e n ” ) ;
s y m l i n k ( ” . . / xx ” , ” t o x x ” ) ;
s ym l i n k ( ”/ u s r / b i n ” , ” t o b i n ” ) ;
s y m l i n k ( ”#∗+$ l 2 3 ” , ” . . / v e r s r i e n ” ) ;
s y m l i n k ( ” . . / xx ” , ” t o x x ” ) ;
Création des liens symboliques to_bin et to_xx dans le répertoire
courant.
Et la création d’un lien symbolique vers_rien dans le répertoire
père.
Création des liens symboliques to_bin et to_xx dans le répertoire
courant. Et la création d’un lien symbolique vers_rien dans le
répertoire père.
.
..
xx
zz
vers_rien
.
..
xx
zz
.
..
a
b
c
répertoire
courant
répertoire
courant
.
..
a
b
c
to_bin
to_xx
"#*+$l23"
"/usr/bin"
"../xx"
Comparer avec les liens durs (link)
1
2
3
l i n k ( ”/ u s r / bin ” , ” t o b i n ” ) ;
l i n k ( ”#∗+$ l 2 3 ” , ” . . / v e r s r i e n ” ) ;
l i n k ( ” . . / xx ” , ” t o x x ” ) ;
(1) échoue – impossible de faire un lien dur vers un répertoire
(sauf pour l’administrateur de système),
(2) échoue - impossible de faire un lien dur vers un rien,
(3) création de lien dur (mais pas de création de fichier).
Suivre ou non le lien symbolique
Si on applique
i n t s t a t ( const char ∗ path , s t r u c t s t a t ∗ b u f ) ;
i n t f s t a t ( i n t fd , st r uct s t a t ∗ buf ) ;
i n t l s t a t ( const char ∗ path , s t r u c t s t a t ∗ b u f ) ;
à un lien symbolique
(1) stat affiche l’information sur le fichier pointé par le lien
symbolique et non pas sur le lien lui même,
(2) lstat affiche les informations sur le lien symbolique,
.
..
xx
zz
vers_rien
répertoire
courant
.
..
a
b
c
to_xx
(3) fstat – agit comme stat et affiche les informations sur le
fichier pointé par un lien symbolique.
On peut avoir une chaı̂ne de liens symboliques : un lien vers un
lien vers un lien etc. stat et fstat affiche les informations sur le
fichier à la fin de la chaı̂ne (à condition que la chaı̂ne de termine
pas par un lien symbolique).
Suivre ou non le lien symbolique
fonction
access
chdir
chmod
chown
creat
exec
lchown
link
lstat
open
opendir
pathconf
readlink
remove
rename
stat
truncate
unlink
ne suit pas le lien symbolique
Lecture de contenu de lien symbolique
suit le lien symbolique
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
s s i z e t r e a d l i n k ( const char ∗ chemin , char ∗ buf ,
size t bufsize );
lit le contenu d’un lien symbolique et le place dans le tampon buf.
La fonction retourne le nombre d’octets placés dans buf (ou −1 en
cas d’échec). La fonction n’ajoute pas de caractère ’\0’ à la fin
donc ce n’est pas une chaı̂ne de caractères qu’on obtient dans buf.
Pour obtenir le contenu comme une chaı̂ne la lecture doit
s’effectuer comme suit :
char b u f [ 1 0 2 4 ] ;
s s i z e t len ;
...
i f ( ( l e n = r e a d l i n k ( ”/ modul es / p a s s 1 ” , buf ,
s i z e o f ( b u f ) −1)) != −1)
b u f [ l e n ] = ’ \0 ’ ;