Malloc массив из массива структур

Question

Цель

Динамически создать массив массив элементов strucs (определено ниже)

typedef struct { 
    void* data; 
    } Element; 

Вопрос

Я знаю, как malloc массив элементов Element strucs

Element* arrayOfElements = malloc(4 * sizeof(Element)); 

Но тогда как я могу использовать Malloc из вышеперечисленного? (Массив arrayOfElements)

Вопрос 2

Допустит, массив arrayOfElements называется arrayOfArrayStruc, как бы я продолжу, чтобы установить значение внутри него

Для примера я хочу, чтобы скопировать 65 в arrayOfElements [2], который находится внутри arrayOfArrayStruc 1, как бы я об этом узнал?

Я знаю, как это сделать, если я хочу, чтобы скопировать 65 прямо на arrayOfElements [2]

arrayOfElements[2].data = malloc(sizeof(int)); 
ptr = arrayOfElements[2].data; 
*ptr = 65; 

, но им не уверен, как это сделать, если arrayOfElements [2] находится внутри arrayOfArrayStruc 1.

EDIT

Чтобы сделать это более ясно моя цель я сделал картину

Таким образом, в зеленый элемент структуры, определенный

typedef struct { 
    void* data; 
    } Element; 

Тогда в красном (который имел 4 зеленых ящика) представляет собой массив структур элемента, который я malloc'd использует

Element* arrayOfElements = malloc(4 * sizeof(Element)); 

Что им ищет сделать, это сохранить выше ^^ в массиве или сделать массив указателей (который является синяя коробка с красной коробки в ней)

Таким образом, в картине «Массив Элемент "содержит 4 элементаных структуры, затем я хочу создать массив для хранения 4" Array Of Element "(или массив из 4 указателей, указывающих на каждый« массив элементов »)

Answer 1

Если вы хотите массив элемент *, то вы могли бы сделать что-то подобное где n это число указателей

Element** arrayOfStructs = malloc(n* sizeof(Element*)); 

так при п = 4; вы получите массив из 4 указателей

arrayOfStructs

+---+ 
| | -> 
+---+ 
| | -> 
+---+ 
| | -> 
+---+ 
| | -> 
+---+ 

В настоящее время выделяют для каждой записи в arrayOfStructs так, если m это число элементов

for (int i = 0; i < n; ++i) 
{ 
    arrayOfStructs[i] = malloc(m * sizeof(Element)); 
} 

Поскольку каждый элемент имеет указатель данных , вам необходимо выделить то, что указывает на это также

for (int i = 0; i < n; ++i) 
{ 
    arrayOfStructs[i] = malloc(m * sizeof(Element)); 
    for (int j = 0; j < m; ++j) 
    { 
    arrayOfStructs[i][j].data = malloc(sizeof(int)); 
    } 
} 

После этого у вас будет следующее в памяти

Скажем, m = 3;

arrayOfStructs

+---+ +---+---+----+ 
| | -> | | | | array of Elements 
+---+ +---+---+----+ +---+---+----+ 
| | -------------------> | | | | 
+---+ +---+---+----+ +---+---+----+ 
| | -> | | | | 
+---+ +---+---+----+ +---+---+----+ 
| | -------------------> | | | | 
+---+      +---+---+----+ 

каждый элемент в «массив элементов» 1..3 (или, скорее, 0..2) указывают на другой «данные» (ниже на массив элементов поворачивается вокруг 90 градусов поэтому я могу с легкостью нарисовать коробки)

+---+ +---+ 
| | -> | | integer 
+---+ +---+ +---+ 
| | ---------> | | 
+---+   +---+  +---+ 
| | -------------------> | | 
+---+      +---+ 

Answer 2

arrayOfElementsarrayOfElements - переменная. У вас не может быть массива имен.

У вас может быть массив переменных указателя. Вы можете написать код для этого, это то же самое, что и код для массива int, но используйте тип указателя вместо int. Затем вам нужно будет инициализировать каждую из этих переменных указателя в массиве так же, как и сейчас.

Однако, как сообщалось, вопрос задан как «массив массивов», а не «массив указателей». «Массив массивов» представляет собой массив, в котором тип элемента представляет собой массив (а не указатель).

Ниже представлен массив без динамических распределений: int x[4][5];. Это массив из 4 элементов, каждый из которых представляет собой массив из 5 целых чисел.

Чтобы динамически выделить один из них, это тот же код, что и динамическое распределение любого массива из 4 элементов. Мы просто используем int[5] как тип элемента, а не int или что-то еще.

Тип указателя на первый элемент: «указатель на int[5]». В синтаксисе Си это написано int (*)[5] - не int *[5], который представляет собой массив указателей.

Один из способов, чтобы написать код будет:

int (*px)[5] = malloc(4 * sizeof(int[5])); 

надеюсь, вы можете увидеть сходство между этим и malloc в вашем вопросе. Мы только что заменили Element на int[5]. (Итак, теперь ваша работа состоит в том, чтобы использовать Element[5] вместо int[5]. Или независимо от размера вместо 5).

Чтобы избежать повторения (и поэтому во избежание возможных ошибок), то можно использовать общий идиома:

int (*px)[5] = malloc(4 * sizeof *px); 

, который составляет 4 элементов, каждый из нужного размера для того, что указатель указывает на.