manage similar structs, one with arrays, the other with pointers

I have some structs containing arrays

struct mystruct_withArrays {
  int foo;
  int bar[MaxN];
  int baz[MaxM];
}

and their equivalent with pointers

struct mystruct_withPointers {
   int foo;
   int *bar;
   int *baz;
}

and I want to avoid the double definition. This is I want to make something as a template

#define myStruct(M,N)
...

such that myStruct(MaxM,MaxN) produces the array struct and myStruct(,) produces the struct with pointers.

Moreover, of course I want to do the same technique for multiple structs and to have automatic mapping from arrays to pointers. A final use case could be as follow

#include "mystructs.h"

//globals, for huge space usage

struct myStructA(1000,10000) hugeA;

struct myStructB(1024*1024) * hugeB;

void main(){


struct myStructA(,) smallA;
struct myStructB() smallB;


mapStruct(hugeA,smallA) //this is a macro
mapStruct(hugeB,smallB) //this is a macro

doSomething(smallA);
doSomethingMore(smallA,smallB);
doSomethingDetailed(smallB.qux);
}

where mapStruct(hugeA, smallA) is the obvious mapping smallA.bar = hugeA.bar, etc. The expanded code would be:

struct myStructA(1000,10000) hugeA;
struct myStructB(1024*1024) hugeB;

struct mystructA_withArrays {
  int foo;
  int bar[1000];
  int baz[10000];
} hugeA;

struct mystructB_withArrays * {
  int qux[1048576];
  int quux[1048576];
} hugeB;


void main(){


struct mystructA_withPointers {
  int foo;
  int * bar;
  int * baz;
} smallA;

struct mystructB_withArrays {
  int * qux;
  int * quxx;
} smallB;

smallA.bar=hugeA.bar;
smallA.baz=hugeA.baz;
smallB.qux=hugeB.qux;
smallB.quxx=hugeB.quxx;

doSomething(smallA);
doSomethingMore(smallA,smallB);
doSomethingDetailed(smallB.qux);

}

As you can see, the general idea is that some variables are allocated outside of the stack, but still without using malloc, just declaring them as globals. Even in some use case they are external globals from a linked shared object.

EDIT: about memory performance, it is not easy to ascertain if malloc structs are better or worse than global struct. It depends also on the flag -mcmodel of the compiler

Solution 1:

The sensible KISS solution seems to be this:

struct mystruct {
   int foo;
   int *bar;
   int *baz;
};

struct mystruct array = 
{ 
  .bar = (int[ 1000]){0},
  .baz = (int[10000]){0},
};

struct mystruct pointers;

Now the interface of this struct is the same no matter how data was allocated and "array structs" are 100% compatible with "pointer structs". If declared at file scope, the allocation of the compound literals will end up in .bss, same deal as in your pseudo code.

Solution 2:

A possible solution to create several similar structures might be the use of an X macro. (Unlike the Wikipedia page, I pass the macro X as an argument instead of redefining the macro.)

I edited the code a bit to add the assignments of the arrays to the corresponding pointers. I used variadic macros to allow omitting the variable names in the argument list. This is to show the concept, there may be room for improvement.

Example file macro.c

#define LIST_OF_ARRAY_FIELDS_1(X, ...) \
    X(int, bar, MaxN, __VA_ARGS__) \
    X(int, baz, MaxM, __VA_ARGS__)

#define LIST_OF_ARRAY_FIELDS_2(X, ...) \
    X(char, bla1, MaxK, __VA_ARGS__) \
    X(char, bla2, MaxL, __VA_ARGS__)

#define CREATE_ARRAY_FIELD(type, name, size, ...) \
    type name[size];

#define CREATE_POINTER_FIELD(type, name, size, ...) \
    type *name;

struct mystruct_withArrays {
    int foo;
    LIST_OF_ARRAY_FIELDS_1(CREATE_ARRAY_FIELD)
}

struct mystruct_withPointers {
    int foo;
    LIST_OF_ARRAY_FIELDS_1(CREATE_POINTER_FIELD)
}

struct otherstruct_withArrays {
    int foo;
    LIST_OF_ARRAY_FIELDS_2(CREATE_ARRAY_FIELD)
}

struct otherstruct_withPointers {
    int foo;
    LIST_OF_ARRAY_FIELDS_2(CREATE_POINTER_FIELD)
}

mystruct_withArrays hugeA;
mystruct_withPointers smallA;

otherstruct_withArrays hugeB;
otherstruct_withPointers smallB;

#define ASSIGN_POINTERS(type, name, size, dest, src) \
    dest.name = src.name;

LIST_OF_ARRAY_FIELDS_1(ASSIGN_POINTERS, smallA, hugeA)

LIST_OF_ARRAY_FIELDS_2(ASSIGN_POINTERS, smallB, hugeB)

Result:

$ gcc -E macro.c
# 1 "macro.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "macro.c"
# 15 "macro.c"
struct mystruct_withArrays {
    int foo;
    int bar[MaxN]; int baz[MaxM];
}

struct mystruct_withPointers {
    int foo;
    int *bar; int *baz;
}

struct otherstruct_withArrays {
    int foo;
    char bla1[MaxK]; char bla2[MaxL];
}

struct otherstruct_withPointers {
    int foo;
    char *bla1; char *bla2;
}

mystruct_withArrays hugeA;
mystruct_withPointers smallA;

otherstruct_withArrays hugeB;
otherstruct_withPointers smallB;




smallA.bar = hugeA.bar; smallA.baz = hugeA.baz;

smallB.bla1 = hugeB.bla1; smallB.bla2 = hugeB.bla2;