Deep analysis - dynamic memory management

List of articles

Depth analysis ： data
Depth analysis ： recursive
Depth analysis ： Structure
Depth analysis ： Dynamic memory management

---

---

Preface

The need for space , Sometimes the amount of space we need is known when the program is running , The way to open up space when compiling arrays is not enough . At this time, it is necessary to run the program , Open up memory in the heap area as required .

---

One 、 Example questions ： The capacity of the address book

1. Address book requirements

The address book needs a way to open up corresponding space according to the amount of information stored

The way we usually use is to open up a fixed size array , This leads to poor flexibility in address book storage . If the space is too small , Can't put so much information . If you open up a lot of space , There is also a waste of space . Therefore, we need a new way to change the size of the development space according to the storage requirements .

Two 、 Dynamic memory functions

1. malloc

void *malloc (size_t size);

malloc： Functions that can be opened up dynamically for any type

This function applies to memory for a contiguous block of free space , And return the pointer to this space .

• 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 user will decide when using it .
• If parameters size by 0,malloc The standard is undefined , Depends on the compiler .

2. calloc

void *calloc (size_t num, size_t size);

calloc： Functions that can be opened up dynamically for any type , And initialize each byte of the space to 0

This function applies to memory for a contiguous block of free space , And return the pointer to this space , And initialize each byte of the space to 0.

• 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 calloc Function doesn't know the type of open space , The user will decide when using it .
• If parameters size by 0,calloc The standard is undefined , Depends on the compiler .
• The function is for num Size is size The elements of open up a space , And initialize each byte of the space to 0.
• And functions malloc The only difference is calloc Initializes each byte of the requested space to full before returning the address 0.

3. realloc

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

realloc： Function can adjust the size of dynamic development memory

• realloc Functions make dynamic memory management more flexible .
• Sometimes we find that the application space is too small in the past , Sometimes we think the application space is too large , In order to make rational use of memory , We often make flexible adjustments to the size of memory . that realloc Function can be used to adjust the dynamic memory size .
• ptr Is the memory address to be adjusted .
• size Is the adjusted new size .
• The return value is the starting memory position after adjustment .
• This function adjusts the size of the original memory space , It will also move the data in the original memory to a new space .

realloc There are two ways to adjust memory space ：

1. There is enough space behind the original space ： To expand memory, add space directly after the original memory , The original spatial data does not change .
   

2. When there is not enough space after the original space , The way to expand is ： Find a suitable size of continuous space on the heap space Use . This function returns a new memory address .

4. free

void free (void* ptr);

free： Function is used to release memory opened dynamically

• If parameters ptr The pointed space is not opened dynamically , that free The behavior of a function is undefined .
• If parameters ptr yes NULL The pointer , Then the function does nothing .

3、 ... and 、 Common dynamic memory errors

1. Yes NULL Dereference operation of pointer

void test() {
    
	int *p = (int *)malloc(INT_MAX/4);
	*p = 20;   // If p The value of is NULL, There will be problems 
	free(p);
}

2. Cross border access to dynamic open space

void test() {
    
	int i = 0;
	int *p = (int *)malloc(10 * sizeof(int));
	if(NULL == p) {
     
		exit(EXIT_FAILURE); 
	}
	for(i=0; i<=10; i++) {
    
		*(p+i) = i;// When i yes 10 Cross border visits when 
	} 
	free(p);
}

3. Use of non dynamic memory free Release

void test() {
    
	int a = 10;
	int *p = &a;
	free(p);     // Free up non dynamic space 
}

4. Use free Release a piece of dynamic memory

void test() {
    
	int *p = (int *)malloc(100);
	p++; 
	free(p);    //p No longer points to the start of dynamic memory 
}

5. Multiple releases of the same dynamic memory

void test() {
    
	int *p = (int *)malloc(100);
	free(p); 
	free(p);// Repeat release 
}

6. Dynamic memory forget to release （ Memory leak ）

void test() {
    
	int *p = (int *)malloc(100); 
	if(NULL != p) {
     
		*p = 20; 
	}
}

int main() {
    
	test();
}

---

summary

Dynamically allocated memory consists of malloc Equal correlation function assignment , This function returns a pointer to a memory block with a specified number of bytes . This memory is free After the function is released, it can be reused ,free The function takes the address of the memory block as the parameter . Dynamic memory management makes our program more flexible , It provides more possibilities for our program .