Malloc() C 中的双重嵌套结构

Question

The goal is to have structs of type unit filling that array in struct line, and struct line filling the array in struct fullData so it essentially turns into a 2d array like so:

|------|-----|-----|
|   a  |  b  |  c  |
|------|-----|-----|
|   b  |     |     | 
|------|-----|-----|
|   a  |  b  |     |
|------|-----|-----|

each square is a unit
each row is a line
i guess fullData is just the square around the outside that accomplishes nothing

In my code, I am double nesting a struct, but don't know how to malloc a struct with an array of a struct inside of it, with an array of a struct inside of that one:

/*Unit struct is where the unit tokens go directly to, they see if the
 struct is a not, and also hold the variable of the struct */
typedef struct unit
{
    bool isNot;
    char letter;
} unit;

/* The Line Struct has an array of structs, the unit struct will go in here */
typedef struct line
{
    struct* clause;
} line;

/*fullData struct has an array of stucts too, the line structs will go in here */
typedef struct fullData
{
     struct* table;
} fullData;

This is the way that I am mallocing them now, but it seems wrong:

struct fullData Block;
struct Line lines;
Block.table = malloc(max_number_of_lines * sizeof(struct lines));
lines.clause = malloc(number_of_unit * sizeof (struct unit));

Answer 1

Firstly, it's not nested struct, it's the pointer to struct.

typedef struct unit
{
    bool isNot;
    char letter;
} unit;

/* The Line Struct has an array of structs, the unit struct will go in here */
typedef struct line
{
    struct* clause;
} line;

typedef struct fullData
{
     struct* table;
} fullData;

You use typedef for unit end line but you did not use them to declare the parameter in other struct. You should change struct * to line or unit . Do not use the same name unit , line fullData like that, you should use the difference names, for example:

typedef struct __unit
{
    bool isNot;
    char letter;
} unit;

/* The Line Struct has an array of structs, the unit struct will go in here */
typedef struct __line
{
    unit* clause;
} line;

typedef struct __fullData
{
     line* table;
} fullData;

And

struct fullData Block;
struct Line lines; // even "Line" here is not exact 

should change to:

fullData Block;
line lines;

Why do you think you malloc is failed? It depends on how you use the variables in your code.

struct Line lines;

Here, i do not understand. You declared the variable lineS , it means many lines, so why do not you use array or pointer?

Answer 2

Your "line" struct and all the struct pointers just seems like extra bloat and you allocate the data fragmented, at multiple locations, leading to slower code. Consider rewriting this whole thing into this:

typedef struct 
{
    bool isNot;
    char letter;
} unit_t;

typedef struct
{
  unit_t unit[3][3];
} full_data_t;


full_data_t* full_data;
full_data = malloc(sizeof *full_data);
...
free(full_data);

If you need the dimensions to be variable at run-time, then C turns a bit shaky. One option is to use a flexible array member:

typedef struct 
{
    bool isNot;
    char letter;
} unit_t;

typedef struct
{
  size_t x;
  size_t y;
  unit_t unit[];
} full_data_t;

full_data_t* full_data;
full_data = malloc(sizeof *full_data + sizeof(unit_t[x][y]));

Unfortunately this only declares a "mangled" 2D array, since unit is actually a 1D array (flex array members must be 1D arrays). You can access it as a 2D array through an array pointer, well-defined without breaking any aliasing rules, but the syntax turns a bit evil:

unit_t (*unit_ptr)[y] = &full_data->unit;
...
unit_ptr[i][j]->letter = 'X';

Full example:

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

typedef struct 
{
    bool isNot;
    char letter;
} unit_t;

typedef struct
{
  size_t x;
  size_t y;
  unit_t unit[];
} full_data_t;

int main(void)
{
  size_t x = 3;
  size_t y = 4;

  full_data_t* full_data;
  full_data = malloc(sizeof *full_data + sizeof(unit_t[x][y]));

  unit_t (*unit_ptr)[y] = &full_data->unit;

  for(size_t i=0; i<x; i++)
  {
    for(size_t j=0; j<y; j++)
    {
      unit_ptr[i][j].letter = 'A'+i*y+j; // whatever makes sense to use here
      printf("%c ", unit_ptr[i][j].letter);
    }
    printf("\n");
  }

  free(full_data);
  return 0;
}

Another option is to go with the "mangled" syntax and access full_data->unit directly even though it's a 1D array, with full_data->unit[i*y+j] . Less readable in my opinion, but mostly a matter of style.