Question

我正在阅读如何避免内存泄漏和我的理解，如果你无论如何丢失引用已分配的内存（因此你无法释放它）就会发生内存泄漏但是这个来自维基百科的例子让我感到困惑

 #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. */
}

我的代码如下，我正在做的是创建一个名为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 *数据）所以剂量意味着它不会泄漏？ Wiki示例是否会导致泄漏，因为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;         
}

摘要

内存泄漏是由于在同一功能范围内没有分配然后释放内存引起的（即在main中分配，然后main将指针传递给单独的释放函数）

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
}

Wiki示例导致泄漏，因为一旦执行了该函数，a指针就不再存在，因为它只是一个局部变量，它只存在于执行时。功能

但是已经分配了a指向的内存块本身仍然被分配，现在没有更多的方法来释放它，因为指向它的唯一指针（a）走了。

Answer 2

我是否会泄漏内存......

没有。如果您的代码没有编译，则无法获得内存泄漏。

传递指向函数的指针时避免内存泄漏

2 个答案: