In the c language, we focus on what exists in the memory: (There are other areas besides this)
stack area
local variables
Formal parameters of the function (parameters)
heap area
malloc/free
calloc
realloc
Dynamic memory allocation
static area
`` global variables
static variable (const)
The four main functions of dynamic memory management
#include <stdlib.h> //Dynamic memory header file
mallco and free
void* malloc(size_t size);
This function applies for a contiguous available space from memory and returns a pointer to this space.
void free (void* ptr);
If the space pointed to by the parameter ptr is not dynamically allocated, the behavior of the free function is undefined.
If the parameter ptr is a NULL pointer, the function does nothing.
int main() { int* ptr = (int*)malloc(40); //malloc applied for 40 bytes to the heap area and returned void* type. We cast to type int* int* p = ptr; //Make sure that the starting address of the requested space is not lost if (p == NULL) { perror("malloc"); //If the development fails, use perror to return the error reason return 1; } //memset(p, 0, 40); //Initialize the space of 40 bytes starting from p address int i = 0; for (i = 0; i < 10; i++) { *p = i; p++; }//Here is the space initialization of 40 bytes requested //If you don't need the space after using it, free up the space free free(ptr); //Release from the starting address of the requested space, so ptr is required ptr = NULL; //After release, ptr becomes a wild pointer and is set to NULL return 0; }
calloc
void* calloc(size_t num, size_t size);
Used to apply for memory and initialized to 0
int main() { int* p = (int*)calloc(10, sizeof(int)); if (p == NULL) { perror("calloc"); return 1; } int i = 0; for (i = 0; i < 10; i++) { printf("%d ", *(p + i)); } free(p); p = NULL; return 0; }
realloc
void* realloc (void* ptr, size_t size);
Adjust the size of the requested memory space
int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc"); return 1; } int i = 0; for (i = 0; i < 10; i++) { *(p+i) = i; } //When the space is not enough, I hope that 20 elements can be placed, and realloc is needed to expand the capacity int* ptr = (int*)realloc(p, 80);//The whole becomes 80 bytes. instead of appending 80 bytes //Here are two situations if (ptr != NULL) { p = ptr; } //The expansion is successful, start using it. //No longer use free(p); p = NULL; return 0; }
The above two situations:
1. If the subsequent space is sufficient for expansion, then continue to expand the space after the address of p
p[][][][][][][] (later expansion) [][][][][][][]
2. If the subsequent space is not enough to expand, then it will look for a sufficient space elsewhere in the memory, transfer the content of p to the new space and continue to expand, and will free the original space of p at the same time, so in order to prevent The capacity expansion failed (not enough space could be found) and the original space was released, perform int* ptr = realloc(p,80); to ensure success and then assign ptr to p
Common memory errors
1. Dereferencing a null pointer
Solution: Make a null pointer judgment on the return value of the malloc function
if (p == NULL)
{
perror("malloc"); //If the allocation fails, use perror to return the error reason
return 1;
}
2. Out-of-bounds access to dynamic memory opening space
3. Use free to release non-dynamically allocated memory
4. Use free to release part of a dynamically allocated memory
5. Release the same piece of dynamic memory multiple times
void test()
{
int *p = (int *)malloc(100);
free(p);
free(p);//repeated release
}
6. Dynamically open up memory and forget to release it (memory leak)
classic interview questions
void GetMemory(char* p) { p = (char*)malloc(100); } void main(void) { char* str = NULL; GetMemory(str); if (str == NULL) { perror("malloc"); } strcpy(str, "hello world"); printf(str); } run error, p is a formal parameter. after the end str Still a null pointer. Error type: dereference to null pointer, program crashes Modified to be correct: void GetMemory(char** p) { *p = (char*)malloc(100); } void main(void) { char* str = NULL; GetMemory(&str); if (str == NULL) { perror("malloc"); } strcpy(str, "hello world"); printf(str); }