[C language note sharing] - dynamic memory management malloc, free, calloc, realloc, flexible array

1. Why is there dynamic memory allocation

int val = 20;// Open up on the stack space 4 Bytes 
char arr[10]={
    0};// Open up on the stack space 10 Bytes of contiguous space 

• The way the above code opens up space has two characteristics ：

1. The size of the space is fixed .
2. When an array is declared , You must specify the length of the array , The memory it needs is allocated at compile time .

• The need for space , Not only the above situation , Sometimes the required space size can only be known when the program is running , The way arrays open up space at compile time is not enough .

2. Dynamic memory function introduction

notes ： All dynamically developed spaces are developed in the stack area ！

2.1 malloc and free

• malloc and free It's all stated that stdlib.h Header file .

2.1.1 malloc Use

malloc( Function link )

void* malloc (size_t size);

• If the development is successful , Then return a pointer to open a good space .
• If the development fails , Returns a NULL The pointer , therefore malloc The return value of must be checked ！
• The type of return value is void*, therefore malloc Function doesn't know the type of open space , The specific time of use is determined by the user himself .
• If parameters size by 0,malloc The standard of behavior is undefined , Depends on the compiler .( open up 0 Byte space doesn't mean it's wrong )
• Frequent use malloc Opening up space will lead to memory fragmentation

• [ ] effect : Apply for a piece of memory Continuously available space , And return the... Pointing to this space The pointer .

• Example ：

2.1.2 free Use

free( Function link )

void free (void* ptr);

• If parameters ptr The pointed space is not opened dynamically , that free The behavior of a function is undefined .( It does not mean that only dynamically opened memory can be released )

• If parameters ptr yes NULL The pointer , Then the function does nothing

• For the same space , Several times free Release , There's no mistake , But it is recommended not to release multiple times

• effect ： Used to free up dynamically opened memory .

  • Example ：

2.2 calloc

calloc( Function link )

void* calloc (size_t num, size_t size);

• calloc It is also used for dynamic memory allocation .
• And functions malloc The only difference is calloc Each byte of the requested space will be returned before the address is returned Initialize to full 0.

• [ ] effect : by num Size is size The elements of open up a space , And initialize each byte of the space to 0.

• Example ：

2.3 realloc

realloc( Function link )

void* realloc (void* ptr, size_t size);

• realloc Functions make dynamic memory management more flexible .
• realloc Function can be used to adjust the size of dynamic development memory ( Expand memory , Reduce memory )
• ptr Is the memory address to be adjusted .
• size Adjusted new size
• The return value is the starting memory position after adjustment .
• This function adjusts the size of the original memory space , The original data in memory will also be moved to new Space .
• In the use of realloc When adding memory , Do not use the original Pointer variable receiving （ptr）, Need to create New pointer variable receive , prevent realloc Failed to apply for space , Lead to The original pointer (ptr) by Null pointer
• realloc There are two ways to adjust memory space ：
  situation 1. There is enough space behind the original space
  situation 2. There is not enough space after the original space

situation 1： When it's the case 1 When , To expand memory, add space directly after the original memory , The original spatial data does not change .
situation 2： When there is not enough space after the original space ,
The way to expand is ： In the heap space to find another suitable size of continuous space to use . In this way, the function returns a new memory address .

• Example ：
  

Capacity expansion , Address Probably change , Compare the following three screenshots
Here are situation 2：
When there is not enough space after the original space ,
In the heap space to find another suitable size of continuous space to use . In this way, the function returns a new memory address .

3. Common dynamic memory errors

3.1 Yes NULL Dereference operation of pointer

3.2 Cross border access to dynamic open space

3.3 Use of non dynamic memory free Release

3.4 Use free Release a piece of dynamically opened memory Part of the

To release the dynamically opened space, you must release it from the starting address , It is impossible to release only part of the memory ！

3.5 For the same dynamic memory Multiple releases

3.6 Dynamic memory Forget to release ( Memory leak )

Forgetting to free the dynamically opened space that is no longer used will cause a memory leak .
Bear in mind ： The space opened up dynamically must be released , And release it properly

4. Classic written test questions

• Example ：

printf(str); == printf("abcd");
Is equivalent to str The first address was given to printf

char* p ="abcd";//p It's just a The address of 
printf(p);

• 1. Correct modification ： Address transmission

• 2. Correct modification ： Function return value
  

5. C/C++ Program memory development

C/C++ Several areas of program memory allocation ：

1. The stack area (stack)： When executing a function , The memory units of local variables in the function can be created on the stack , At the end of the function execution, these storage units Automatically released . Stack memory allocation operations are built into the processor's instruction set , It's very efficient , But the allocated memory capacity is limited . The stack area is mainly used to store the... Allocated by running the function local variable 、 Function parameter 、 Return the data 、 The return address etc. .
2. Heap area (heap)： Release is usually assigned by the programmer , If programmers don't release , At the end of the program, the OS Recycling . The distribution method is similar to Linked list . Deposit malloc、realloc、calloc Open up space and free.
3. Data segment ( Static zone static)： Deposit Global variables 、 Static data . Released by the system at the end of the program .
4. Code block ： Deposit The body of the function ( Class member functions and global functions ) The binary code of

6. Flexible array

Maybe you've never heard of flexible arrays （flexible array） The concept , But it does exist .
C99 in , The last element in the structure is allowed to be an array of unknown size , This is called 『 Flexible array 』 member .

for example ：

• Some compilers will report errors and cannot compile , You can change to ：

6.1 The characteristics of flexible arrays

• The flexible array member of structure red must be preceded by at least one other member .
• sizeof The size of the structure returned does not include the memory of the flexible array .
• Structures that contain flexible array members use malloc() Function to dynamically allocate memory , And the allocated memory should Larger than the size of the structure , To fit the expected size of the flexible array

for example ：

6.2 The use of flexible arrays

Flexible array scheme ： once free、malloc

So flexible array members a, It's equivalent to getting 100 A continuous space of two shaping elements . If you feel malloc The space opened up is small , You can use realloc Resize .

6.3 The advantages of flexible arrays

No Flexible array scheme ：2 Time free、malloc, secondly malloc The more you use , Memory fragments The more possibilities

1. The first advantage is ： Convenient memory release

If our code is really a function for others , You do a secondary memory allocation in it , And return the whole structure to the user . The user calls free You can release the structure , But the user doesn't know that this structure member may free, So you can't expect users to find out . therefore , If we allocate the memory of the structure and its members at one time , And return a structure pointer to the user , Users once free You can also free up all the memory .

2. The second advantage is ： This is good for access speed .

Continuous memory is good for improving access speed , It also helps reduce memory fragmentation .( Actually , Personally, I don't think it's much higher , Anyway, if you can't run, you need to add offset to address )

Extended reading （ Hyperlinks ）
C Arrays and pointers in language structures