как объявить char * [20] [250]

Question

У меня есть char * [] [], и мне нужно его опорожнить и делать что-то новое время от времени, но я не знаю, как его повторно инициализировать и снова

я попытался

args = malloc(sizeof(char*[20][250])*20); 

и

args = malloc(sizeof(char***)*20); 

, но я до сих пор не могу reinitilize массив. Является ли массив действительно 20 X 250 с символом char * как элемент?

и как вы выполняете итерацию по массиву символов, который относится к типу * [20] [250]?

это для execv и будет использоваться как этот

for(int i =0 ;i< maxArgs;i++){ 
    execv(args[i][0],args[i]); 
    ERROR("failed to start"); 
} 

Answer 1

Если args объявлен как:

char* args[20][250]; 

Вы можете выделить память для каждого элемента этого массива с помощью:

for (int i = 0; i < 20; ++i) 
{ 
    for (int j = 0; j < 250; ++j) 
    { 
     args[i][j] = malloc(sizeof(*args[i][j])*(SIZE_OF_STRING+1)); 
    } 
} 

Если args объявлено как:

char*** args; 

Необходимо еще несколько malloc звонков.

Шаг 1

Выделение памяти для arg.

args = malloc(sizeof(*args)*20); 

Шаг 2

Выделение памяти для args[0] - args[19].

for (int i = 0; i < 20; ++i) 
{ 
    args[i] = malloc(sizeof(*args[i])*250); 
} 

Шаг 3

Выделение памяти для args[0][0] - args[19][249].

for (int i = 0; i < 20; ++i) 
{ 
    for (int j = 0; j < 250; ++j) 
    { 
     args[i][j] = malloc(sizeof(*args[i][j])*(SIZE_OF_STRING+1)); 
    } 
} 

комбинат им

args = malloc(sizeof(*args)*20); 
for (int i = 0; i < 20; ++i) 
{ 
    args[i] = malloc(sizeof(*args[i])*250); 
    for (int j = 0; j < 250; ++j) 
    { 
     args[i][j] = malloc(sizeof(*args[i][j])*(SIZE_OF_STRING+1)); 
    } 
} 

Answer 2

Просто чтобы быть ясно, когда вы желаете 2D массив типа char*[20][250], что вы просите в C-говорить 20-элементный массив char*[250] s, каждый из которых представляет собой 250-элементный массив из char * C-строк (каждый из которых представляет собой массив из char s).

Поскольку динамически выделенный 2D-массив не является областью памяти, а представляет собой массив указателей на другие массивы, вы не можете сделать это за один шаг. .Распределение, что будет делать то, что вы хотите, будет выглядеть следующим образом:

char ***args; 

args = malloc(sizeof(char**[20])); 
for (int i = 0; i < 20; ++i) { 
    args[i] = malloc(sizeof(char*[250])); 

    // optional, depending on your usage: 
    for (int j = 0; j < 20; ++j) 
     args[i][j] = ""; // This makes every `char *` element point to the same location in memory— the location of the compiled-in `""`/`(char *){ '\0' }`. 
} 

Чтобы освободить память, структура ваших звонков так же, как malloc -ную кода, но в обратном порядке: иерархическая

for (int i = 0; i < 20; ++i) 
    free(args[i]); 
free(args); 

_{Хорошо, поэтому технически можно выделить его как один большой блок, а затем подключить 20-элементный массив, чтобы указать на нужные смещения в blob. Это свершится, хотя и, как правило, не является необходимым - для большинства случаев использования прирост производительности был бы незначительным (и вам все равно потребуется malloc() отдельный массив указателей, которые адресуются в 2D-блок). Обычно вы видите только распределение 2D-blob, когда данные массово 2D - такие как данные изображения - и data[x][y] - синтаксис доступа исключен в пользу синтаксиса data[y * width + x], поскольку он не менее эффективен, чем то, что сделает компилятор, и не требует более одного malloc/free пара на каждый блок данных.}

Answer 3

Postfix операторы всегда выше приоритет, чем префикс, поэтому, когда вы говорите

char*[20][250] 

вы получите массив из 20 массивов 250 указателей на символы. Вы можете использовать скобки привязки более * плотно:

char (*)[20][250] 

обозначает указатель на массив из 20 массивов 250 символов. Так что если у вас есть

char (*args)[20][250]; 

вы можете использовать

args = malloc(sizeof(char [20][250])); 

Answer 4

Вы можете объявить ЬурейеЕ для 2d массива следующим образом:

typedef char *array2d_t[20][250]; 

Вы можете теперь malloc достаточно памяти для хранения одного экземпляр этого 2-го массива:

array2d_t *array3d = malloc(1 * sizeof(*array3d)); 

Поскольку указатели ведут себя как массивы вещей, на которые они указывают, у нас фактически есть 3d-массив, у первого измерения которого есть arity 1 (обратите внимание на 1 * в malloc), поэтому первый индекс может быть только 0. Мы можем его индексировать таким образом :

array3d[0][0][0] = "Hello"; 
    array3d[0][1][0] = "World"; 
    array3d[0][19][249] = "End of the world!"; 

Или, если вы предпочитаете, мы можем разыменования указателя в явном виде:

(*array3d)[0][0] = "Hello"; 
    (*array3d)[1][0] = "World"; 
    (*array3d)[19][249] = "End of the world!"; 

в качестве альтернативы, мы можем объявить ЬурейеЕ для 1d массива следующим образом:

typedef char *array1d_t[250]; 

теперь malloc достаточно памяти для хранения 20 экземпляров этого 1d массива:

array1d_t *array2d = malloc(20 * sizeof(*array2d)); 

Мы не можем в настоящее время индекс массива с:

array2d[0][0] = "Hello"; 
    array2d[1][0] = "World"; 
    array2d[19][249] = "End of the world!";