Question

I am writing a light weight serialization function and need to include two variable sized arrays within this.

• How should I track the size of each?
• How should I define the struct?
• Am I going about this all wrong?

EDIT: the result must be a contiguous block of memory

Answer 1

Since the data should be continuous in memory it is necessary to malloc a chunk of memory of the right size and manage it’s contents more or less manually. You probably best create a struct that contains the “static” information and related management functions that do the memory management and give access to the “dynamic” members of the struct:

typedef struct _serial {
  size_t sz_a;
  size_t sz_b;
  char data[1]; // "dummy" array as pointer to space at end of the struct
} serial;

serial* malloc_serial(size_t a, size_t b) {
  serial *result;
  // malloc more memory than just sizeof(serial), so that there
  // is enough space "in" the data member for both of the variable arrays
  result = malloc(sizeof(serial) - 1 + a + b);
  if (result) {
    result->sz_a = a;
    result->sz_b = b;
  }
  return result;
}

// access the "arrays" in the struct:

char* access_a(serial *s) {
  return &s->data[0];
}

char* access_b(serial *s) {
  return &s->data[s->sz_a];
}

Then you could do things like this:

  serial *s = ...;
  memcpy(access_a(s), "hallo", 6);
  access_a(s)[1] = 'e';

Also note that you can’t just assign one serial to another one, you need to make sure that the sizes are compatible and copy the data manually.