FILE* sans fichier ?

Version imprimable

07/04/2008, 18h11
k1000

FILE* sans fichier ?
Bonjour,
J'ai une fonction dans une bibliothèque qui prend comme paramètre un FILE* por une lecture.
Je voudrais pouvoir modifier la valeur qui va être lue depuis l'intérieur du programme.

Le déroulement est le suivant :
- Je crée un FILE* appelé buf (je ne sais pas avec quelle manipulation de pointeurs ces savants fous font ça)
- Je remplis buf avec une valeur
- Je lance ma fonction en thread
- Je remplis de temps en temps buf
- J'attends la fin de la fonction après lui avoir donné l'ordre de s'arrêter (par l'intermédiaire de buf)
S'il vous plaît, est-ce que quelqu'un pourrait m'aider (à résoudre mon problème ou à me faire comprendre) ?
Merci.
07/04/2008, 20h54
ram-0000

Même après plusieurs relectures attentives, je ne comprends toujours pas ce que tu veux faire.
07/04/2008, 21h38
Emmanuel Delahaye

Citation:

Envoyé par k1000

S'il vous plaît, est-ce que quelqu'un pourrait m'aider (à résoudre mon problème ou à me faire comprendre) ?

Il est illusoire de vouloir trouver une solution a un problème qui n'a pas été défini.

Commence donc par définir exactement ce que tu veux faire. Je ne veux pas entendre parler de C dans cette définition.
07/04/2008, 22h17
Sve@r
Citation:
Envoyé par k1000

Bonjour,
J'ai une fonction dans une bibliothèque qui prend comme paramètre un FILE* por une lecture.
Je voudrais pouvoir modifier la valeur qui va être lue depuis l'intérieur du programme.

Le déroulement est le suivant :

Je crée un FILE* appelé buf (je ne sais pas avec quelle manipulation de pointeurs ces savants fous font ça)
Je remplis buf avec une valeur
Je lance ma fonction en thread
Je remplis de temps en temps buf
J'attends la fin de la fonction après lui avoir donné l'ordre de s'arrêter (par l'intermédiaire de buf)

S'il vous plaît, est-ce que quelqu'un pourrait m'aider (à résoudre mon problème ou à me faire comprendre) ?
Merci.
Ce qui se conçoit bien s'énonce clairement
Et les mots pour le dire arrivent aisément
(Boileau)
10/04/2008, 20h49
k1000
Je voudrais simplement savoir :
- comment on peut créer le FILE* (buf de son petit nom),
- comment mettre une valeur dedans qui puisse être lue par la fonction en thread, avec les fonctions standard.
(Je me disais bien que j'étais pas clair)
Merci.
10/04/2008, 21h15
Emmanuel Delahaye

Citation:

Envoyé par k1000

comment on peut créer le FILE*

fopen().

Citation:

comment mettre une valeur dedans qui puisse être lue par la fonction en thread, avec les fonctions standard.

écrire : fputc(), fwrite(), fputs(), fprintf()
lire : fgetc(), fread(), fgets(), fscanf()

Que veux-tu faire exactement ?
Quel est le code source C avec lequel tu as un problème ?

C'est quoi cette histoire de thread . Tu veux écrire et lire dans le même fichier avec 2 threads différents ? C'est plutôt casse-g. comme manip... Tu y tiens vraiment ? Ça sent l'erreur de conception...
10/04/2008, 22h04
Sve@r

Citation:

Envoyé par k1000

comment mettre une valeur dedans qui puisse être lue par la fonction en thread, avec les fonctions standard.

Emmanuel t'a répondu. J'ajouterai juste que t'as le droit de le faire mais faut que tu gères toi-même les accès concurrents

Citation:

Envoyé par k1000

(Je me disais bien que j'étais pas clair)

Nous aussi...:bug:

Désolé pour le silence radio mais je n'étais pas très disponible.

J'ai finallement trouvé une solution à ma question sur la glibc :

Code:

FILE* fmemopen(void*, size_t, const char*);

mais : je ne l'ai pas sur mingw, est-ce que quelqu'un peut m'indiquer où la trouver (utilisable sur mingw bien sur), merci beaucoup.

Code:

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
35
36
/* j'utilise du C++ */
#include <stdio.h>
#include <boost/thread.hpp>
 
extern void fonction(FILE*);
 
/* normalement déclarée dans stdio.h mais absente*/
extern FILE* fmemopen(void*, size_t, const char*);
 
int main(int argc, char** argv)
{
    char* buf = malloc(512);
    FILE* iobuf = fmemopen(buf, 512, "w");
    FILE* iobuf2= fmemopen(buf, 512, "r");
    int index = 0;
 
    /* lancement du thread (C++) */
    boost::thread t (boost::bind(&fonction, iobuf2));
 
    for(index = 1; index < argc; ++index)
    {
        fprintf(iobuf, "%s", argv[index]);
        fflush(iobuf);
    }
 
    /* signal d'arret */
    fprintf(iobuf, "stop !!!");
 
    /* attente de la fin du thread (C++) */
    t.join();
 
    fclose(iobuf);
    fclose(iobuf2);
 
    return EXIT_SUCCESS;
}

15/04/2008, 13h07
Emmanuel Delahaye
Citation:
Envoyé par k1000

Code:

1 2 3 /* j'utilise du C++ */ #include <stdio.h> #include <boost/thread.hpp>
Alors tu t'es trompé de forum. Je déplace ?

Nota : glibc est disponible pour MinGW...

http://devpaks.org/details.php?devpak=39
16/04/2008, 15h13
k1000

Citation:

Envoyé par Emmanuel Delahaye

Alors tu t'es trompé de forum. Je déplace ?

Non, j'utilise du C++ pour les threads, mais la glib C pour les FILE* :).

Citation:

Envoyé par Emmanuel Delahaye

Nota : glibc est disponible pour MinGW...

http://devpaks.org/details.php?devpak=39

Tu t'es trompé : c'est un lien vers la glib de GTK, ça m'avance pas vraiment :(.
16/04/2008, 21h39
Emmanuel Delahaye

Citation:

Envoyé par k1000

Tu t'es trompé : c'est un lien vers la glib de GTK, ça m'avance pas vraiment :(.

glibc, ça fait partie de MinGW... C'est l'extension GNU (gcc) de la libc.
17/04/2008, 19h04
k1000

Citation:

Envoyé par Emmanuel Delahaye

glibc, ça fait partie de MinGW... C'est l'extension GNU (gcc) de la libc.

Oui, mais la lib de mingw ne contient pas toute (:cry:) la glibc, c'est ça le problème, je cherche à compléter avec fmemopen.

C'est bon, j'ai trouvé mon bonheur :yaisse2: avec la fonction :
setvbuf(FILE* f, char* buf, int mode, size_t size)
f : le FILE*
buf : un pointeur sur le buffer
mode : le mode d'ouverture parmi :
_IOFBF : complètement bufferisée
_IOLBF : bufferisée par ligne
_IONBF : pas bufferisée
size : la taille du buffer

Il y a aussi setbuf(FILE* f, char* buf) qui est équivalente à setvbuf(f, buf, _IOFBF, BUFSIZ /* défini à 512 dans stdio.h */)

Alors mon code est :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include <stdlib.h> #include <stdio.h> int main() { FILE* f = tmpfile(); char* buf = (char*)malloc(BUFSIZ); setbuf(f, buf); fprintf(f, "quelquechose"); fclose(f); printf("%s", buf); return 0; }
Et il y a encore un problème : il y a une sorte de texte parasite qui se met derrière (le même à chaque compilation).
J'ai bien essayé une mise à '\0' de tous les char de mon buffer, mais ça change rien. :bug:

Citation:
Envoyé par k1000
Alors mon code est :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include <stdlib.h> #include <stdio.h> int main() { FILE* f = tmpfile(); char* buf = (char*)malloc(BUFSIZ); setbuf(f, buf); fprintf(f, "quelquechose"); fclose(f); printf("%s", buf); return 0; }
Et il y a encore un problème : il y a une sorte de texte parasite qui se met derrière (le même à chaque compilation).
J'ai bien essayé une mise à '\0' de tous les char de mon buffer, mais ça change rien. :bug:
Je crois que tu fais un peu n'importe quoi... Le contenu du buffer ne sert que pendant l'exécution de la fonction fprintf(). Ce qu'il y a dedans après est indéterminé et n'a aucun sens.

Je n'a toujours pas compris ce que tu cherchais à faire. Est-ce que ce n'est sprintf() que tu cherches ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #include <stdio.h> int main(void) { char buf[64]; sprintf(buf, "quelquechose"); printf("%s\n", buf); return 0; }

Le parasite derrière c'est réglé : je me suis planté dans ma fonction de mise à '\0' du buffer.
En fait, je cherchais un équivalent à sscanf qui utilise un FILE* et fscanf.

C'est bon, avec tmpfile et tmpnam.

Code:

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 <stdlib.h>
#include <stdio.h>
 
int main()
{
    char* name = tmpnam(NULL);
    if(name == NULL) return EXIT_FAILURE;
 
    /* écriture */
    FILE* file = fopen(name, "wb");
    if(file == NULL) return EXIT_FAILURE;
    fprintf(file, "quelquechose");
    fclose(file);
 
 
    char* chr = (char*)malloc(512);
    if(chr == NULL) return EXIT_FAILURE;
 
    /* lecture */
    FILE* f2 = fopen(name, "rb");
    if(f2 == NULL) return EXIT_FAILURE;
    fscanf(f2, "%s", chr);
    fclose(f2);
 
    printf("%s", chr);
 
    /* suppression du fichier */
    remove(name);
 
    free(chr);
    free(name);
 
    return EXIT_SUCCESS;
}

Et c'est bon, tout marche :king:.