如何使用 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

有一个POSIX的方式来使用内存作为FILE描述： fmemopen或open_memstream ，根据语义你想要的： fmemopen和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 可以从缓冲区创建 FILE，这对您有意义吗？

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()