Advanced C language (XIII) - Example Analysis of dynamic memory management

Preface

This section mainly analyzes several examples , In order to slightly deepen the understanding of dynamic memory management .

---

1.

#include <stdio.h>
#include <stdlib.h>

void GetMemory(char* p){
    
	p = (char*)malloc(100);
}

void Test(void){
    
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
}

int main() {
    
	Test();
	return 0;
}

Result analysis

main() Function call Test() function , after Test() Function call GetMemory() function .

Character pointer str Passed in the function GetMemory(),GetMemory() Function parameters are also character pointers , So character pointer str In fact, it is a value passing call , The message is str Value . It is equivalent to creating a pointer with characters in the stack area of memory p Received character pointer str Value NULL.

stay GetMemoey Internal function , The pointer p Yes malloc() Function development 100 The starting position of a space of bytes .p The starting address of the memory space is stored in . after GetMemory End of function call , And no value is returned , The pointer p Because it is in GetMemory() Internal function , It's a local variable , therefore p The memory block in which it is located is destroyed as the function call ends . here p The space pointed to has not been released free(), And because of the function GetMemory() The call has ended without any pointer to this open space , It belongs to memory leakage .

go back to Test() Continue to execute the program inside the function , At this time, due to the pointer p Is a pointer str A temporary copy of , The pointer p Nothing happens that affects the pointer str Value , So character pointer str The value of the or NULL. Next function strcpy() Perform the operation ： Put the string "hello world" Copy to pointer str The space it points to . however str The value of is NULL, The pointer str Is a null pointer , There is no clear direction to , Copying will cause errors that cause the program to stop .

Correct or improve

#include <stdio.h>
#include <stdlib.h>
// Return the starting address of the dynamically opened space 
char* GetMemory(){
    
	char* p = (char*)malloc(100);
	return p;
}

void Test(void){
    
	char* str = NULL;
	str = GetMemory();
	strcpy(str, "hello world");
	printf(str);
	free(str);
	str = NULL;
}

int main() {
    
	Test();
	return 0;
}

Running results ：

---

2.

#include <stdio.h>
#include <stdlib.h>

char* GetMemory(void) {
    
    char p[] = "hello world";
    return p;
}
void Test(void) {
    
    char* str = NULL;
    str = GetMemory();
    printf(str);
}
int main() {
    
    Test();

	return 0;
}

Running results ：

Result analysis

main() Function call Test() function , after Test() Function call GetMemory() function .

stay GetMemory() Internal function ,p Is the name of the local character array , This array stores a string "hello world",GetMemory() Function returns the local character array name , That is, the address of the first element of the array .

stay GetMemory After the function ends the call, all its internal data is destroyed , Include local character arrays , Its memory area is reclaimed by the operating system ,Test() Character pointer in function str Accept the address of the memory area that has been reclaimed , so str It's a wild pointer , Points to the memory area that has been recycled that does not belong to this program . At this time, we don't know what is stored in this memory area , Of course, the output content is unknown .

Improve or correct

When defining a function, you can return the value of a local variable , This value can be received by external variables ; Do not return the address of a local variable , It doesn't make sense . It will also cause the pointer that accepts this address to become a wild pointer .

#include <stdio.h>

int* test() {
    
    int a = 20;
    return &a;
}
int main() {
    
    int* p = test();
    //printf("%d\n", 10);
    printf("%d\n", *p);

    return 0;
}

Running results ：

#include <stdio.h>

int* test() {
    
    int a = 20;
    return &a;
}
int main() {
    
    int* p = test();
    printf("%d\n", 10);
    printf("%d\n", *p);

    return 0;
}

Running results :

Each call to a function will open up a function stack frame , After the function call is completed and returned, the stack frame is recycled by the operating system . After recycling , It is unknown whether the value stored in the reclaimed space is still the original value , If you open up a new function stack frame , Then it will cover the original recycled （ old ） Function stack frame .

---

3.

#include <stdio.h>
#include <stdlib.h>

void GetMemory(char** p, int num){
    
	*p = (char*)malloc(num);
}

void Test(void){
    
	char* str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}
int main() {
    
	Test();
	return 0;
}

Running results ：

Result analysis

main() Function call Test() function , after Test() Function call GetMemory() function .

Test() Character pointer in function str Address and integer 100 Into GetMemory() function .GetMemory() Second level pointers are used for function parameters p And integers num Received correctly . After the GetMemory() Internal function , The secondary pointer p Dereference once found Test() First level pointer in function str, It's equivalent to a first level pointer str receive malloc() The starting address of the allocated memory space . after GetMemory() The function call ends and returns to Test() function .

The pointer str What is stored in is the starting address of the dynamically opened memory .strcpy() Function to string "hello" Copy to pointer str The space it points to .printf() Function print pointer str The string pointed to . after Text() The function call ends and returns to main(). after main() Function execution ends and returns 0, Program end .

4.

#include <stdio.h>
#include <string.h>

void Test(void){
    
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
    //free After that, I didn't put the pointer str Set to null pointer ,str It's a wild pointer .
    // Using wild pointers directly will cause problems .
	free(str);
    
	if (str != NULL){
    
		strcpy(str, "world");
		printf(str);
	}
}

int main() {
    
	Test();

	return 0;
}

Result analysis

main() Function call Text() function .

Test() Internal function , The pointer str Yes malloc() The starting address of the allocated memory space . But there will be malloc() Failure to allocate memory , here str Deposit is NULL. There should be right str Whether it is NULL The inspection of .

strcpy() Function to string "hello" Copy to pointer str The memory space pointed to , after free() Function releases the pointer str The dynamically allocated memory space pointed to . Notice the following pointer str It's not set to NULL, The pointer str It also points to the starting address of the memory area that has been released . Now the pointer str It's a wild pointer . It's dangerous .

if Judge str Whether it is a null pointer , We have until str It's not a null pointer , Points to the address of memory that does not belong to this program . If the judgment is true, perform the following operations ：strcpy() The function will put the string "world" Copy to pointer str The space it points to , This operation is an illegal access to memory , Although the program can also output strings to the console , But this program also has problems .

Improve or correct

#include <stdio.h>
#include <string.h>

void Test(void){
    
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
    //
	free(str);
    str = NULL;
    
	if (str != NULL){
    
		strcpy(str, "world");
		printf(str);
	}
}

int main() {
    
	Test();

	return 0;
}

---

Conclusion

There may be obvious errors in the code related to dynamic memory management , This is certainly easy to correct . For example, receiving malloc()、calloc()、realloc() Check the validity of the pointer to the starting address of the space 、 Release the dynamically opened memory space pointed to by the pointer and set the pointer to NULL etc. . There are also loopholes in writing logic that don't look good , We need to think and look for .

---

END