You are trying to allocate a array with the size of the pointer to the date struct instead of the actual size of the date struct.

Change date* to date:

array = malloc(size*sizeof(date));

Furthermore you don't need to allocate the day and year variables, because the malloc allocates them for you.

for (i=0; i<size; i++)
{
     array[i].month = calloc(MAX_MONTH_STR,sizeof(char));
     array[i].day = 0;
     array[i].year = 0;
}

The simplest way to allocate and initialize the array is this:

struct student *allocate(void) {
    /* Allocate and initialize memory for ten students */
    return calloc(10, sizeof(struct student));
}

Notes:

• calloc(), unlike malloc() initializes the memory block to all bits zero. Hence the fields id and score of all elements in the array are initialized to 0.
• It would be a good idea to pass the number of students as an argument to the function allocate().
• It is considered good style to free() allocated memory when you no longer need it. Your instructor did not hint that you should call free(stud); before returning from main(): while not strictly necessary (all memory allocated by the program is reclaimed by the system when the program exits), it is a good habit to take and makes it easier to locate memory leaks in larger programs.

Change

unsigned char getStructs(My_struct *structs) {
    ...
}
getStructs(structs);

To

unsigned char getStructs(My_struct **p_structs) {
    // C function can't be pass by reference, so convert to a reference here
    auto& struct = *p_structs;  
    ...
}
...
getStructs(&structs);

Your problem is that your struct = ... line is not modifying the value of structs in getStructFromWrapper.

You already allocated memory. You did this by so called static allocation (or more specific automatic memory allocation).

If you want to allocate the memory dynamically you would have to use:

user *database = malloc(sizeof(user) * 50); 
user *banlist = malloc(sizeof(user) * 100);
admin *list = malloc(sizeof(admin) * 10);

And don't forget to free the space up, when you don't need those variables anymore.

free(database);
free(banlist);
free(list);

For more information see also: Difference between static memory allocation and dynamic memory allocation

I would do it a bit different way. Only one malloc and free needed.

typedef struct {
    size_t   pc;
    int   ram[];
} vm_t;

vm_t* init(size_t ram_size)
{
   vm_t *vm = malloc(sizeof(*vm) + ram_size * sizeof(vm -> ram[0]));
   if(vm)
    vm -> pc = 0;
  
   return vm; 
}

Some remarks: use size_t for sizes, always checks the result of malloc. Use objects not types in the sizeof. When you change the type memory allocation will not have to be changed.

I do not know why RAM has int type but it does not matter in this question.

EDIT. How to access. Example how to read the ram

int read_RAM(vm_t *vm, size_t address)
{
    return vm -> ram[address];
}

int read_RAM1(vm_t *vm, size_t address)
{
    return *(vm -> ram + address);
}

There is no struct S, only S which is a typedef of anonymous structure.

Define struct S too:

typedef struct S {
  char id;
  struct S *children[SIZE];
}S;

Or:

typedef struct S S;
struct S {
  char id;
  S *children[SIZE];
};

And do avoid casting return of malloc in C:

arr[0].children[0] = malloc(sizeof(S));

The second example is correct.

You want to create a 1 dimensional array of Rules. So you allocate space for alloc_size*sizeof(Rules) bytes. Because your function is (presumably) getting passed the address of a pointer (i.e. a Rules **), you want to assign the allocated memory to the dereferenced pointer, i.e. *rules_array. Then when the function returns, you have access to that memory.

The only thing that needs to change is to get rid of the cast. Casting the return value of malloc can mask other errors in your code. See Do I cast the result of malloc? for more details.

Your assumption about the first example is correct. That's part 1 of creating a 2 dimensional array, or more precisely an array of pointers, each of which will point to an array. In that case, you would either need to return rules_array and assign that to a Rules **, or pass the address of a Rules ** so that rules_array is a Rules *** and dereference it before assigning to it.

Your allocation appears to be correct (aside from the standard advice that is normally given to not cast the return of malloc). You can free it via free(A_array[current_element].B_array[i]);.

Allocating works the same for all types. If you need to allocate an array of line structs, you do that with:

struct line* array = malloc(number_of_elements * sizeof(struct line));

In your code, you were allocating an array that had the appropriate size for line pointers, not for line structs. Also note that there is no reason to cast the return value of malloc().

Note that's it's better style to use:

sizeof(*array)

instead of:

sizeof(struct line)

The reason for this is that the allocation will still work as intended in case you change the type of array. In this case this is unlikely, but it's just a general thing worth getting used to.

Also note that it's possible to avoid having to repeat the word struct over and over again, by typedefing the struct:

typedef struct line
{
    char* addr;
    char* inst;
} line;

You can then just do:

line* array = malloc(number_of_elements * sizeof(*array));

Of course don't forget to also allocate memory for array.addr and array.inst.

To allocate space for an array of nWords elements, use

wordArray = malloc(nWords * sizeof(*WordInfo));