釋放未知大小的malloc

Question

我正在嘗試釋放使用數量不固定的數組生成的malloc。

char ** get_moves(){
    // some code
    char **moves = malloc(sizeof(char *) * k); // 'k', could ranges between 1~9
        if (!moves){
            return NULL;
        }
        for(int i = 0; i < k; i++){
            moves[i] = malloc(82);
            if (!moves[i]) {
                free (moves);
                return NULL;
            }
    // more code

    return moves;
}

int main(){

    //some code
    char **res = get_moves(some_input);
    //more code
    for (int i = 0; i < (sizeof(res)/sizeof(res[0)); i ++){
        free(res[i]);
    }
    free(res);

}

在get_move的輸入之一中，res應該有2個數組，但是sizeof（res）/ sizeof（res [0）僅給我1。

如何正確處理此問題？

Answer 1

 sizeof(res)

返回sizeof(double-pointer);

因此，如果您打算獲取存儲的指針數量，那么您可能無法通過執行操作來獲取此數量。

你需要做類似的事情

for(i=0;i<k;i++) /* As I see you are allocating k no of pointer Keep track of it*/
    free(res[i]);

free(res);

Answer 2

唯一的方法是跟蹤數組的元素計數，如果您不想在傳遞數組時將其傳遞給每個函數，則可以將兩個信息組合到一個結構中，如下所示

#include <stdlib.h>

struct ArrayOfStrings
{
    int    count;
    char **data;
};

struct ArrayOfStrings get_moves()
{
    struct ArrayOfStrings result;
    char **moves;

    // some code

    result.count = 0;
    result.data  = malloc(sizeof(char *) * k); // 'k', could ranges between 1~9
    if (result.data == NULL)
        return result;
    result.count = k;

    moves = result.data;    
    for (int i = 0; i < k; i++)
    {
        moves[i] = malloc(82);
        if (moves[i] == NULL) 
        {
            /* also free succesfully allocated ones */
            for (int j = i - 1 ; j >= 0 ; --j)
                free(moves[j]);
            free(moves);
        }
        result.count = 0;
        result.data  = NULL;
        return result;
    }
    // more code

    return result;
}

int main(){

    //some code
    struct ArrayOfStrings res = get_moves(some_input);
    //more code
    for (int i = 0; i < res.count ; i ++)
        free(res.data[i]);
    free(res.data);
    return 0; // you should return from main.
}

sizeof不是針對對象內容的長度，而是針對數據類型的大小，它是在編譯時計算的。

所以你的情況

sizeof(res) / sizeof(res[0]) == sizeof(char **) / sizeof(char *) == 1

因為sizeof(char **) == sizeof(char *)所以它只是指針的大小。

Answer 3

res實際上不是char類型的數組的數組 。 相反，它是一個指向char類型的指針 。 sizeof(res)將為您提供char**的大小。 您需要跟蹤分配數量。

Answer 4

由於要分配的最大數組數很小（9），因此可以通過分配最大數來簡化代碼。 用NULL填充未使用的元素：

#define MAX_K 9
char **moves = malloc(sizeof(char *) * MAX_K); 

for(int i = 0; i < k; i++){
    ...
}
for(int i = k; i < MAX_K; i++){
    moves[i] = NULL;
}

要取消分配，只需忽略NULL指針：

for (int i = 0; i < MAX_K; i ++){
    if (res[i])
        free(res[i]);
}
free(res);