如何释放我需要的结构指针

Question

I am trying to avoid memory leaks in my code. I need to de-allocate pElement, line and pSecond, without losing the values inside pImage. Because I need to print those values inside my print function.

My add function contains struct GraphicElement *pElements;, struct GraphicElement *pSecond;, struct Point point;.

I allocate memory using malloc for each struct and then add the values and then I pass the final values into pImage. All my other functions work perfectly besides the fact that I always end up with 3 memory leaks. Because I didnt not free(pSecond);....free(pElement)...free(line);

If I try to free them before my function exits and after passing the values into pImage. My values all get erased.

How can I free those values inside my add function locally?

struct Point
{
    int x, y;
};

struct Line
{  
    Point start;
    Point end;
};

struct GraphicElement
{
    enum{ SIZE = 256 };
    unsigned int numLines; //number of lines
    Line* pLines; //plines points to start and end
    char name[SIZE];
};

typedef struct
{
    unsigned int numGraphicElements;
    GraphicElement* pElements; //the head points to pLines
}   VectorGraphic;

void InitVectorGraphic(VectorGraphic*); //initializes pImage->pElement
void AddGraphicElement(VectorGraphic*); //Used to add
void ReportVectorGraphic(VectorGraphic*); // prints pImage contents
void CleanUpVectorGraphic(VectorGraphic*); //deallocates memory

Answer 1

How can I free those values inside my add function locally?

It is not possible to explicitly free a memory allocated locally. Nor to locally free some memory. Once freed, a memory slot cannot be accessed and the data stored inside are lost.

In C, you have two option to allocate some memory: you can allocate it on the heap or on the stack. The memory slots reserved on the heap can be accessed globally and will remain until they are explicitly freed. The one reserved on the stack are only valid while you stay within the context they were created.

Let's say you execute the following code :

void func()
{
  int   x = 3;    // [2]
  int * p = & x;  // [3]
}

int main()
{
  func();         // [1]

  // [4]
  return 0;
}

The instruction [2] will allocate some memory on the stack. The second one ( [3] ) will do the same and will store the address of the of the first variable in the new memory slot. After the function returns ( [4] ), this memory is freed. Graphically, here is what happens :

       Context   STACK    Address
              +---------+      
              |         | 0xa1  
       main   |         | 0xa0            
              +---------+      

 [1]          +---------+ 
=====>        |         |          
       func   |         | 0xa2        
              +---------+
              |         | 0xa1
       main   |         | 0xa0
              +---------+

 [2]          +---------+
=====>        |         | 
       func   | 3       | 0xa2 <-- x 
              +---------+
              |         | 0xa1
       main   |         | 0xa0
              +---------+

 [3]          +---------+
=====>        | 0xa2    | 0xa3 <-- p
       func   | 3       | 0xa2 <-- x 
              +---------+
              |         | 0xa1
       main   |         | 0xa0
              +---------+

 [4]          +---------+
=====>        |         | 0xa1
       main   |         | 0xa0
              +---------+

So if i use malloc inside a function. Once I exist the function the allocated memory on the heap is freed automatically?

It's the opposite. If you use, a function like malloc , the memory slot will be allocated on the heap. So if we change the line [3] above to something like

int * p = malloc(sizeof(int));  // [3]

The memory allocated on the stack will be freed as you'll leave the function, but the memory allocated on the heap will remain allocated and will still be accessible, until you free it. Graphically :

                                                  HEAP     Address Free (y/n)
                                               +---------+ 
                                               |         | 0xb4  - Yes
                                               |         | 0xb3  - Yes
                                               +---------+
       Context   STACK    Address             
 [3]          +---------+                      +---------+ 
=====>        | 0xb4    | 0xa3 <-- p           |         | 0xb4  - No
       func   | 3       | 0xa2 <-- x           |         | 0xb3  - Yes
              +---------+                      +---------+
              |         | 0xa1
       main   |         | 0xa0
              +---------+

 [4]          +---------+                      +---------+ 
=====>        |         | 0xa1                 |         | 0xb4  - No !!! Leak !!!
       main   |         | 0xa0                 |         | 0xb3  - Yes
              +---------+                      +---------+

As you can see, after you leave the function, you have a memory leak as you don't have any pointer to the dynamically allocated memory. One way to avoid this is to return the pointer (so to pass the address of the new memory slot to the calling function) or to store it somewhere to free it later. It's also possible to allocate the memory before calling the function and to pass it to the function as a parameter. It really depends on your application.