Can you write to a byte array using a FILE*

Question

C# has a neat feature of being able to write to a memory stream using the MemoryStream object.

I'm looking for similar functionality from C using a FILE* pointer.

I want to be able to sprintf() but with the added functionality of having C remember "where I was" in the buffer I'm writing to.

Answer 1

Why not use mmap? You can map a file to memory and use a FILE* pointer.

Update: It does not work. Sorry.

Answer 2

MemoryStream is not a feature of C#, the language. It's simply a class in the BCL. You could write it yourself in C#.

And so it is in C - you'd write some functions that work similarly in use to fopen, fprintf, fwrite, fclose, etc., but give them names like mopen, mwrite, etc. (presumably) and write them so they operate on a memory buffer.

Answer 3

If you are using the GNU C Library, you can use fmemopen(). There may be other non-portable extensions for other environments, but there's no portable way using FILE*s.

You could also, however, wrap snprintf, if you don't insist on actually using FILE*s. For example, glib (note: not the same as the GNU C Library, and portable) has a g_string_append_printf that does what you want.

Answer 4

There's also an ugly hack which works with plain ISO-C: You can use fopen() to open a null file (/dev/null on *nix, NUL on Windows) and set the array as the file's buffer via

setvbuf(file, buffer, _IOFBF, buffer_size)

This should work fine as long as fflush() isn't called anywhere in the code. Also, the programmer has to explicitly take care of the string delimiter.

I don't really see a need to do this, though: As snprintf() returns the number of characters written, it's trivial to keep track of a buffer's position.

One can even write a function to automagically resize the buffer on overflow: bufprintf.c

The function's prototype is

int bufprintf(char **buffer, size_t *size, size_t *offset,
    const char *format, ...);

An example program could look like this:

#include <stdio.h>

extern int bufprintf(char **buffer, size_t *size, size_t *offset,
    const char *format, ...);

int main(void)
{
    size_t size = 0; // must be set!
    size_t offset;
    char * buffer;

    for(int i = 0; i < 100; ++i)
        bufprintf(&buffer, &size, &offset, "we rock %i\n", i);

    puts(buffer);
    printf("size:\t%u\noffset:\t%u\n", (unsigned)size, (unsigned)offset);
}

Answer 5

How about just manually managing your pointers. I don't have a compiler in front me but hopefully the code below gets the idea across:

char huge_buffer[REALLY_BIG_SIZE];
char *write_pos = huge_buffer;

//...

void fprintf_to_mem(char **mem_ptr, const char *fmt, ...)
{
  va_list args;
  int num_written;

  va_start(args, mem_ptr);
  num_written = vsprintf(*write_pos, fmt, args);
  *write_pos += num_written;

  va_end(args);
}

//...

fprintf_to_mem(&write_pos, "Testing %d %d %d", 1, 2, 3);
fprintf_to_mem(&write_pos, "Hello world!\r\n");

I would expect that to output "Testing 1 2 3Hello world!\r\n" to huge_buffer.

Answer 6

sprintf returns the number of characters that were printed into the string. You can use that value to increment the pointer of your buffer.

buffer += sprintf(buffer, "%d", i);

Make sure that you keep around a copy of the original pointer, as that is what you will be using when passing the buffer somewhere else.