Dynamic memory (advanced 4)

realloc

malloc And calloc It's just calloc While opening up space , The number in space will also be assigned 0
Let's focus on realloc

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

ptr Is the memory address to be adjusted
size New size after adjustment
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 .
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

free The understanding of the

1,free（p） Just make the system recycle the space , Not destroying space , The space still exists .
2,free(NULL) There is no problem , because NULL There is no point to effective space
3,free It can only be used in dynamic space , The space on the stack area cannot be released
4, A space cannot be released many times , Suppose you release it once and the system uses it again , When you release again , It will destroy other effective spaces
5,free Be sure to set the pointer to NULL

Flexible array

Mainly when you need to use dynamically growing arrays in the structure

struct A
{
    
	int a;
	int arr[0];
	// perhaps int arr[];

};

Flexible arrays can be equivalent to dynamically growing arrays, but they are somewhat different when used

The characteristics of flexible arrays

A flexible array member in a structure 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 be larger than the size of the structure , To fit the expected size of the flexible array

In fact, from a functional point of view , It's not impossible for us to develop arrays dynamically alone
You can do that

A* p = (A*)malloc(sizeof(struct A) );
	p->a = (int*)malloc(sizeof(int) * 100);

This is also opening up for arrays 100*4 Bytes of space , But if you do this, it will be more troublesome in the subsequent memory release , The latter frees up more space than the former , When users are using our functions , I don't know that I made a secondary memory allocation , Users may only free memory once , Then it will cause memory leak , So we allocate the memory of the structure and its member memory at one time , And return a pointer , Users only need to do it once free That's all right. .
meanwhile Continuous memory helps to improve access speed , It also helps reduce memory fragmentation .
（ Because the allocated space is discontinuous , The array occupies continuous space ）