How to write to a memory buffer with a FILE*?

Question

Is there any way to create a memory buffer as a FILE*. In TiXml it can print the xml to a FILE* but i cant seem to make it print to a memory buffer.

Answer 1

There is a POSIX way to use memory as a FILE descriptor: fmemopen or open_memstream, depending on the semantics you want: Difference between fmemopen and open_memstream

Answer 2

I guess the proper answer is that by Kevin. But here is a hack to do it with FILE *. Note that if the buffer size (here 100000) is too small then you lose data, as it is written out when the buffer is flushed. Also, if the program calls fflush() you lose the data.

#include <stdio.h>
#include <stdlib.h>

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]);
    }
}

Answer 3

fmemopen can create FILE from buffer, does it make any sense to you?

Answer 4

I wrote a simple example how i would create an in-memory FILE:

#include <unistd.h> 
#include <stdio.h> 

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

Answer 5

C++ basic_streambuf inheritance

In C++, you should avoid FILE* if you can.

Using only the C++ stdlib, it is possible to make a single interface that transparently uses file or memory IO.

This uses techniques mentioned at: Setting the internal buffer used by a standard stream (pubsetbuf)

#include <cassert>
#include <cstring>
#include <fstream>
#include <iostream>
#include <ostream>
#include <sstream>

/* This can write either to files or memory. */
void write(std::ostream& os) {
    os << "abc";
}    

template <typename char_type>
struct ostreambuf : public std::basic_streambuf<char_type, std::char_traits<char_type> > {
    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<char> 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);
    }
}

Unfortunately, it does not seem possible to interchange FILE* and fstream: Getting a FILE* from a std::fstream

Answer 6

You could use the CStr method of TiXMLPrinter which the documentation states:

The TiXmlPrinter is useful when you need to:

1. Print to memory (especially in non-STL mode)
2. Control formatting (line endings, etc.)

Answer 7

https://github.com/Snaipe/fmem is a wrapper for different platform/version specific implementations of memory streams

It tries in sequence the following implementations:

• open_memstream.
• fopencookie, with growing dynamic buffer.
• funopen, with growing dynamic buffer.
• WinAPI temporary memory-backed file.

When no other mean is available, fmem falls back to tmpfile()