¿Cómo escribir en un búfer de memoria con un ARCHIVO *?

¿Hay alguna forma de crear un búfer de memoria como un ARCHIVO *? En TiXml puede imprimir el xml a un ARCHIVO * pero no puedo hacer que se imprima en un búfer de memoria.

Existe una forma POSIX de utilizar la memoria como un descriptor FILE : fmemopen o open_memstream , dependiendo de la semántica que desee: Diferencia entre fmemopen y open_memstream

Creo que la respuesta correcta es la de Kevin. Pero aquí hay un truco para hacerlo con FILE *. Tenga en cuenta que si el tamaño del búfer (aquí 100000) es demasiado pequeño, perderá datos, ya que se escribe cuando se vacía el búfer. Además, si el progtwig llama a fflush () pierde los datos.

 #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 puede crear un ARCHIVO desde el búfer, ¿tiene sentido para usted?

Escribí un ejemplo simple de cómo crearía un ARCHIVO en memoria:

 #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(""); } 

Puede usar el método CStr de TiXMLPrinter que indica la documentación:

TiXmlPrinter es útil cuando necesita:

  1. Imprimir en la memoria (especialmente en modo no STL)
  2. Formato de control (terminaciones de línea, etc.)

C ++ basic_streambuf

En C ++, debe evitar FILE* si puede.

Al utilizar solo C ++ stdlib, es posible crear una única interfaz que utilice de forma transparente IO de archivos o memoria.

Esto usa las técnicas mencionadas en: Configuración del buffer interno utilizado por una secuencia estándar (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::stringstream 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); } } 

Desafortunadamente, no parece posible intercambiar FILE* y fstream : Obtener un FILE * desde un std :: fstream