我應該在函數內部分配內存還是函數被稱爲

Question

我們假設我將一個指向數組或結構的指針傳遞給函數。

像

myfun1(struct node *head, int* arr, int N){ 
    head = malloc(sizeof head); 
    arr = malloc(N* sizeof arr); 
    ...... 
} 
myfun2(struct node *head, int* arr){ 
... 
} 

，我來自另一個功能

void CallingFunction(void){ 
    struct node* head1 = NULL; 
    int *arr1; 

    struct node* head2 = NULL; 
    int *arr2; 

    int N = 10; 

    head2 = malloc(sizeof head); 
    arr2 = malloc(N* sizeof arr); 

    myfunc1(head1, arr1, N); 
    myfunc2(head2, arr2); 
} 

其中調用函數的方法是更好的調用這些功能。 myfun1或myfun2？

我應該從CallingFunction還是內部函數分配內存給結構和數組？

編輯：

正如指出的那樣，程序有一些錯誤，讓我們說我糾正這兩個錯誤。

head = malloc(sizeof *head); 
    myfunc2(head2, arr2, N); 

現在，會是什麼答案。我應該在callingFunction（）還是myfun（）中分配內存。

Answer 1

第一個是內存泄漏（除了錯誤的sizeof head和sizeof arr）。您必須通過struct node **來設置功能參數。

第二個更好（除了沒有得到arr的大小）：它不隱藏內存分配，並導致malloc/free在調用函數內正確配對。

Answer 2

head = malloc(sizeof head); 

是錯誤的，你想用一個物體的大小預留空間，而不是一個指針的大小到這個對象，更改爲：

head = malloc(sizeof *head); 

其中調用的方法功能更好。 myfun1或myfun2？

如果不知道有多少元素myfun2不起作用，則無法預留陣列空間。

Answer 3

arr2 = malloc(N* sizeof arr); 

我建議使用而不是做的malloc參數內的乘法釋放calloc：

實施例：

arr2 = calloc(N, sizeof(*arr)); 

通常myfunc2所優選除非函數是一個包裝分配的東西，在其中情況下存在另一個釋放內存的函數。

Answer 4

兩種方法都是正確的，選擇最佳選項取決於分配塊的生命週期;配對內存分配和釋放操作非常重要。如果該內存只用於myfun1()/myfun2()上下文中，我會建議在那裏分配和釋放它。但是，如果它會持續存在並被用於程序的其他部分，那麼最好在存儲器分配和釋放的地方非常明顯，而不是其他操作的副作用。

此外，我會建議始終使用sizeof(struct node)和sizeof(int)而不是sizeof(*head)和sizeof(*arr)。它更清晰，並防止其他人在您的原始代碼中指出的那種錯誤。

在myfun1()背景下，sizeof(head)給你一個指針的大小，以一個struct而sizeof(*head)給你結構本身的大小，這是你在這種情況下，想要的東西。

同樣，sizeof(arr)給你一個指針的大小爲int和sizeof(*arr)給你的單個int大小。

在數組中使用sizeof操作數還有另外一個警告：它的行爲取決於聲明數組的上下文以及它是分配在堆棧上還是堆中。

這是一個小程序，可以說明這一點。在聲明數組的相同上下文中使用時，請特別注意sizeof(stackArray)。

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

#define N 10 

void aux(int *stackArray, int *heapArray) { 
    printf("\nIn a different context:\n"); 
    printf("sizeof(*stackArray) == sizeof(int): %zu\n", sizeof(*stackArray)); 
    printf("sizeof(*heapArray) == sizeof(int): %zu\n", sizeof(*heapArray)); 
    printf("sizeof(stackArray) == sizeof(int *): %zu\n", sizeof(stackArray)); 
    printf("sizeof(heapArray) == sizeof(int *): %zu\n", sizeof(heapArray)); 
} 

int main() { 
    int stackArray[N]; 
    int *heapArray = malloc(N * sizeof(int)); 

    printf("In the context in which they were declared/allocated:\n"); 
    printf("sizeof(*stackArray) == sizeof(int): %zu\n", sizeof(*stackArray)); 
    printf("sizeof(*heapArray) == sizeof(int): %zu\n", sizeof(*heapArray)); 
    printf("sizeof(stackArray) == N * sizeof(int): %zu\n", sizeof(stackArray)); 
    printf("sizeof(heapArray) == sizeof(int *): %zu\n", sizeof(heapArray)); 

    aux(stackArray, heapArray); 

    free(heapArray); 

    return 0; 
} 

在我的機器該程序的輸出是：

在其中它們被宣佈/分配的上下文：
的sizeof（* stackArray）==的sizeof（int）的：4
的sizeof（* heapArray）==的sizeof（int）的：4
的sizeof（stackArray）== N *的sizeof（int）的：40
的sizeof（heapArray）==的sizeof（INT *）：8

在不同的上下文：
的sizeof（* stackArray）==的sizeof（int）的：4
的sizeof（* heapArray）==的sizeof（int）的：4
的sizeof（stackArray）==的sizeof（INT * ）：8
的sizeof（heapArray）==的sizeof（INT *）：8

總之，如果你總是使用sizeof()你想要的，而不是變量名的類型，你不必擔心這些東西。