Discussion :

[sympho]

Bonjour,

peut-on ouvrir le même fichier plusieurs fois en C en lecture (et éventuellement en écriture), positionner les descripteurs à des "offset" différents et faire des opérations de lecture (éventuellement écriture) ?

[fearyourself]

Pour la lecture, ca ne pose pas de probleme, mais pour l'ecriture il y a un probleme de cohesion... C'est generalement deconseille...

Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include <stdio.h>
 
int main()
{
        FILE *f1,*f2;
 
        f1 = fopen("test", "w");
        fprintf(f1,"Hello how are you?");
 
        f2 = fopen("test","w");
        fprintf(f2,"Fine and you?");
 
        fclose(f1);
        fclose(f2);
 
        return 1;
}

Montre le probleme, dans test il y a "Fine and you? you?"...

Jc

[sympho]

Merci fearyourself,

Si je connais d'avance la taille de mon fichier et que je prends le soin de toujours positionner mes descripteurs convenablement est-ce que j'ai la garantie d'avoir un résultat cohérent à tous les coups ?

par exemple : je veux écrire la chaîne "abc" dans le fichier test.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
 
int main() {
  int fd, fda, fdb, fdc;
 
  if ((fd = open("test", O_CREAT | O_WRONLY, 00644)) < 0) {
    perror("open ");
    exit(1);
  }
  if (write(fd, "\0\0\0", 3) <= 0) {
    perror("write ");
    exit(1);
  }
 
  fdb = open("test", O_WRONLY);                   // B open
  close(fd);
  fdc = open("test", O_WRONLY);                                    // C open
  lseek(fdb, 1, SEEK_SET);                        // B lseek
  fda = open("test", O_WRONLY);   // A open
  lseek(fdc, 2, SEEK_SET);                                         // C lseek
  write(fdc, "c", 1);                                              // C write
  close(fdc);                                                      // C close
  write(fdb, "b", 1);                             // B write
  write(fda, "a", 1);             // A write
  close(fdb);                                     // B close
  close(fda);                     // A close
 
  exit(0);
}

Est ce que le code précédent produira le résultat escompté à tous les coups ? Indépendamment de la quantité de données écrite à chaque posittion.

NOTE : dans mon exemple j'ai volontairement imbriqué quelque peu les opérations sur les descripteurs. Cependant, le résultat est celui que j'attendais. Je ne positionne pas fda par ce que le caractère 'a' est le premier dans le fichier.

[Médinoc]

fearyourself: essaie avec un fflush(f1) avant d'écrire dans f2...

[gangsoleil]

Bonjour,

Si je connais d'avance la taille de mon fichier et que je prends le soin de toujours positionner mes descripteurs convenablement est-ce que j'ai la garantie d'avoir un résultat cohérent à tous les coups ?

par exemple : je veux écrire la chaîne "abc" dans le fichier test.

D'abord, pourquoi ne pas utiliser les fonctions standards ? Elles ne te plaisent pas ?

Ensuite, pour ce qui est d'écrire un unique caractère, tu ne risques pas trop de te créer des problèmes.

En revanche, dès que tu vas écrire un peu plus, tu riques vite de te retrouver avec des phrases qui vont écraser les précédentes ou les suivantes, et donc de gros problèmes de cohérence.

Enfin, je ne vois pas l'intéret d'avoir plusieurs descripteurs : un suel descripteur est nécessaire, et tu te déplaces dans ton fichier lorsque tu en as besoin (en sauvegardant la place à laquelle tu viens d'écrire si jamais tu en as besoin).

[fearyourself]

fearyourself: essaie avec un fflush(f1) avant d'écrire dans f2...

Je suis d'accord, mon code n'était qu'un exemple...

D'abord, pourquoi ne pas utiliser les fonctions standards ? Elles ne te plaisent pas ?

Ensuite, pour ce qui est d'écrire un unique caractère, tu ne risques pas trop de te créer des problèmes.

En revanche, dès que tu vas écrire un peu plus, tu riques vite de te retrouver avec des phrases qui vont écraser les précédentes ou les suivantes, et donc de gros problèmes de cohérence.

Enfin, je ne vois pas l'intéret d'avoir plusieurs descripteurs : un suel descripteur est nécessaire, et tu te déplaces dans ton fichier lorsque tu en as besoin (en sauvegardant la place à laquelle tu viens d'écrire si jamais tu en as besoin).

Entièrement d'accord, par contre, j'aurais une tendance à proposer une solution qui utilise un tampon à la place et tu l'écris une fois dans le fichier à la fin quand t'as terminer...

[sympho]

Bonjour,
en fait mon code fonctionnne correctement (jusqu'ici), même avec des longues chaînes. Je voulais juste être sur que je n'aurais pas des "surprises". Si quelqu'un aurait un exp. qui ne fonctionne pas je suis prenneur (note: celui de fearyourself ne repositionne pas les descripteurs).
Quand aux fonctions utilisées, je crois que open est aussi "standard" que fopen non ? Après c'est une histoire de choix

pour ce qui est du tampon j'y ai pensé, mais vu que la quantité de données à écrire peut être importante ce ne serait pas efficace d'attendre de les avoir toutes avant d'écrire.

pourquoi plusieurs descripteurs ? Les lectures/écritures pourront se faire en parallèle (fork, pthread) oui je sais c'est affreux ...

c'est noté pour fopen et open

[Emmanuel Delahaye]

Quand au choix des fonctions, je crois que open est aussi "standard" que fopen non ?

Non. fopen() fait partie de la définition du langage C. open() n'en fait pas partie. Elle appartient éventuellement à POSIX qui est une norme système et non langage.

Sauf avis contraire, il n'y a aucune raison d'utiliser open() quand on programme en C.

[fearyourself]

pour ce qui est du tampon j'y ai pensé, mais vu que la quantité de données à écrire peut être importante ce ne serait pas efficace d'attendre de les avoir toutes avant d'écrire.

Dépendant de la quantité de données qui sont continuellement accédées ou si c'est plutôt juste "de temps en temps", les accès disques seront plus long que juste accédé la RAM. Par contre, tu peux très bien faire un système de gestion de tampon qui met une partie dans des fichiers temporaires en attendant d'avoir la version finale...

Les lectures/écritures pourront se faire en parallèle (fork, pthread) oui je sais c'est affreux ...

Si tu as un problème qui comporte des pthreads et des forks, tu vas avoir un problème de cohérence et de synchro assez lourd à mettre en oeuvre (que t'utilises des fichiers ou de la mémoire partagée...) Déjà qu'avec un processus, plusieurs descripteurs d'écriture est une mauvaise chose mais alors avec un programme multi-processus...