Устранение утечек памяти при прохождении указателей на функции

Question

Im читает, как избежать утечек памяти, и, насколько мне известно, происходит утечка памяти, если вы все равно потеряете ссылку на выделенную память (поэтому вы не можете ее освободить), но этот пример из Википедии смущает мне

#include <stdlib.h> 

void function_which_allocates(void) { 
    /* allocate an array of 45 floats */ 
    float *a = malloc(sizeof(float) * 45); 

    /* additional code making use of 'a' */ 

    /* return to main, having forgotten to free the memory we malloc'd */ 
} 

int main(void) { 
    function_which_allocates(); 

    /* the pointer 'a' no longer exists, and therefore cannot be freed, 
    but the memory is still allocated. a leak has occurred. */ 
} 

Мой код ниже, чем Im делает это создает массив структур, называемых arrayOfStrucs, которые держат структуры, называемые CreatedStruct, то LinkedList баллов каждому экземпляру arrayOfStrucs.

Будет ли я получать утечки памяти, поскольку я не имею свободной памяти, которую я выделил в той же функции, т.е. CreateLinkedList (я выделяю arrayOfStructs, но не освобождаю его, поскольку мне все еще нужно, чтобы он указывался связанным списком). Мне не создавать никаких сирот указатели, как им всегда могут ссылаться на них в любое время

struct LinkedList *temp = head; 
    CreatedStruct* StructPtr = &temp->arrayOfStruct[1]; 
    int* intPtr = StructPrt->data; 
    printf("int data = %d\n", *intPtr); 

с кодом выше я могу напечатать значение arrayOfStruct (так что единственный член данных в CreatedStruct который Int * данные), так доцент, что означает, что она обыкновение течь ? Возникает ли в вики-примере утечка, потому что function_which_allocates(); вратаря возвращает ссылку на выделенную память, или это потому, что выделение и освобождение памяти было в разных функциях (разных областях)

int main(void) 
{ 
    struct LinkedList *head =NULL; 
    head = CreateLinkedList(head) 
    printLinkedList(head) 
    //Can this be done if I follow the correct way of freeing a linked list? 
    FreeLinkedList(head) 
} 

LinkedList* CreateLinkedList(LinkedList* head) 
{ 
    CreatedStruct* arrayOfStrucs; 
    //Allocated but will be freed in a separate function  
    arrayOfStructs= malloc(1 * sizeof(CreatedStruct)); 
    FillArrayOfStructs(arrayOfStructs); 
    head = FillLinkedList(head, arrayOfStrucs); 
    return(head) 
} 


FillArrayOfStructs(CreatedStruct* arrayOfStructs) 
{ 
    arrayOfElements[1].data = malloc(sizeof(int)); 
    ptr = arrayOfElements[1].data; 
    *ptr = 65;  
} 


LinkedList* FillLinkedList(LinkedList* head, CreatedStruct* arrayOfStructs) 
{ 
    LinkedList* insertNode = malloc(sizeof(LinkedList)); 
    insertNode->arrayOfStruct = (void*)arrayOfStructs; 
    insertNode->next = head; 
    return insertNode;   
} 

Резюме

Может утечка памяти быть вызван не выделяя и затем освобождает память в той же области действия (т.е. выделяется в основном, основная часть затем передает указатель на отдельную функцию освобождения)

Answer 1

Каждый блок памяти, полученный через malloc, и друзей, которые не освобождаются с помощью функции free ион будет возникать при утечке памяти, и это не зависит от областей.

Другими словами, вы можете выделить блок памяти в некоторой функции и освободить ее позже в совершенно другой функции; на самом деле так как malloc и free используются большую часть времени.

Пример (только для целей иллюстрации, не обязательно хорошая практика программирования)

char *Foo() 
{ 
    ... 
    return malloc(...); 
} 

void Bar() 
{ 
    char *p = Foo(); 
    ... 
    free(p); // freeing the pointer that has been allocated in Foo 
} 

Пример вики вызывает утечку, потому что когда функция была выполнена, указатель не существует больше, потому что это локальная переменная , которая существует только во время выполнения функции.

Но сам блок памяти, который был выделен и который был указан a, по-прежнему выделен, и теперь его больше нет, потому что единственный указатель (a), который указал на него, исчез.

Answer 2

Получу ли я утечку памяти ...

Нет, вы не можете получить утечки памяти, если ваш код не компилируется.