Comment écrire dans une mémoire tampon avec un FILE *?

Est-il possible de créer une mémoire tampon en tant que FILE *. Dans TiXml, il peut imprimer le xml dans un FICHIER *, mais je ne peux pas le faire imprimer dans une mémoire tampon.

Il existe un moyen POSIX d’utiliser la mémoire comme descripteur FILE : fmemopen ou open_memstream , en fonction de la sémantique souhaitée: Différence entre fmemopen et open_memstream

Je suppose que la bonne réponse est celle de Kevin. Mais voici un hack pour le faire avec FILE *. Notez que si la taille de la mémoire tampon (ici 100 000) est trop petite, vous perdez des données car elles sont écrites lorsque la mémoire tampon est vidée. De plus, si le programme appelle fflush (), vous perdez les données.

 #include  #include  int main(int argc, char **argv) { FILE *f = fopen("/dev/null", "w"); int i; int written = 0; char *buf = malloc(100000); setbuffer(f, buf, 100000); for (i = 0; i < 1000; i++) { written += fprintf(f, "Number %d\n", i); } for (i = 0; i < written; i++) { printf("%c", buf[i]); } } 

fmemopen peut créer un FILE à partir d’un tampon, est-ce que cela a un sens pour vous?

J’ai écrit un exemple simple pour créer un fichier en mémoire:

 #include  #include  int main(){ int p[2]; pipe(p); FILE *f = fdopen( p[1], "w" ); if( !fork() ){ fprintf( f, "working" ); return 0; } fclose(f); close(p[1]); char buff[100]; int len; while( (len=read(p[0], buff, 100))>0 ) printf(" from child: '%*s'", len, buff ); puts(""); } 

Vous pouvez utiliser la méthode CStr de TiXMLPrinter dont la documentation indique:

TiXmlPrinter est utile lorsque vous devez:

  1. Imprimer en mémoire (surtout en mode non-STL)
  2. Contrôle du formatage (fins de ligne, etc.)

Héritage C ++ basic_streambuf

En C ++, évitez FILE* si vous le pouvez.

En utilisant uniquement la bibliothèque stdlib C ++, il est possible de créer une interface unique qui utilise de manière transparente les E / S de fichier ou de mémoire.

Ceci utilise les techniques mentionnées à: Définition du tampon interne utilisé par un stream standard (pubsetbuf)

 #include  #include  #include  #include  #include  #include  /* This can write either to files or memory. */ void write(std::ostream& os) { os << "abc"; } template  struct ostreambuf : public std::basic_streambuf > { ostreambuf(char_type* buffer, std::streamsize bufferLength) { this->setp(buffer, buffer + bufferLength); } }; int main() { /* To memory, in our own externally supplied buffer. */ { char c[3]; ostreambuf buf(c, sizeof(c)); std::ostream s(&buf); write(s); assert(memcmp(c, "abc", sizeof(c)) == 0); } /* To memory, but in a hidden buffer. */ { std::ssortingngstream s; write(s); assert(s.str() == "abc"); } /* To file. */ { std::ofstream s("a.tmp"); write(s); s.close(); } /* I think this is implementation defined. * pusetbuf calls basic_filebuf::setbuf(). */ { char c[3]; std::ofstream s; s.rdbuf()->pubsetbuf(c, sizeof c); write(s); s.close(); //assert(memcmp(c, "abc", sizeof(c)) == 0); } } 

Malheureusement, il ne semble pas possible d’échanger FILE* et fstream : Obtenir un FILE * à partir d’un std :: fstream