\

Currently we know how we use memory \

1. Create a variable

int a=0;
Copy the code

Global variables – Open up memory in static areas

Local variable – Opens up memory in the stack area

2. Create an array

An array is a contiguous memory space

int arr[10] =0;
Copy the code

Create global array – free up memory in static area

Create local arrays – create memory in the stack area

3. Parameters and arguments of a function

There are also some other data that occupy the memory space. The specific memory usage is as follows:

\

\

C language also provides another function free, specifically for dynamic memory release and reclamation, function prototype is as follows.

Specific requirements of the function:

When dynamically requested space is no longer used, it should be returned to the operating system.

So we need to release the space malloc requested

free(p);
p=NULL;
Copy the code

\

Since P is released, the space pointed to by P is meaningless, but the content of that space is still there, so P still has the ability to find this space. In order to avoid the wrong use of this space, we set P =NULL and assign it as a NULL pointer, so that the P pointer is truly disconnected from this space.

\

\

C language also provides a function called calloc, calloc function is also used for dynamic memory. The prototype is as follows:

The open () function opens a contiguous space in memory and initializes each byte in the space to 0

Function argument First argument: number of elements second argument: size in bytes for each element

Function return type: void * null pointer type

Specific requirements of the function:

\

Function Reallocate memory space to adjust the size of the dynamic memory space

Function arguments: The first argument is the address of the previously opened memory block, and the second argument is the size of the adjusted space in bytes.

Function return type: void * null pointer type

Function specific functions:

Matters needing attention:

Realloc functions have two situations when adjusting the memory space:

Case one: there is not enough space after the original space

We want to be in the original memory location change memory size, but the back of the original memory block is not enough space, we extend the method is: on the heap space find another suitable size of contiguous space to use, and the original data in memory copy to come over, this function returns a new memory address. Note that in the process of finding a new space, the original memory is released, and we do not need to worry about memory leaks.

\

Case two: there is enough space after the original space

When we want to adjust the original memory space, to expand the memory directly after the original memory directly add space, the original space data does not change. The last return is the original address.

\

\

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

int main(a)
{
	int *p = (int *)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		printf("Failed to open memory \n");
	}
	else
	{
		int i = 0;
		for (i = 0; i<20; i++)
		{
			p[i] = i;
		}
		for (i = 0; i<20; i++)
		{
			printf("%d ", p[i]); }}return 0;
}
Copy the code

We created 10 ints in the heap, but we started at the beginning of the memory and accessed 20 ints beyond the size of the heap. This is an out-of-bounds access, and the system will report an error.

\

#include <stdio.h>
#include <stdlib.h>
int main(a)
{
	int *p = (int *)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		printf("Failed to open memory \n");
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p++;
	}
	free(p);
	p = NULL;
	return 0;
}
Copy the code

Here we should note:

The pointer to this memory keeps changing as we give p++

When we finally free (p), p does not point to the initial location of memory, so the space we created cannot be fully freed, resulting in memory leakage.

\

#include <stdio.h>

int main(a)
{
	int *p = (int *)malloc(100);
	if (NULL! = p) { *p =20;
	}
	while (1);
	return 0;
}
Copy the code

Note: Forgetting to free up dynamically opened space that is no longer in use can cause memory leaks.

Remember: dynamic space must be released, and the correct release.

\

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

void GetMemory(char *p)
{
	p = (char *)malloc(100);
}
void Test(void)
{
	char *str = NULL;
	GetMemmory(str);
	strcpy(str, "helloworld");
	printf(str);
}
int main(a)
{
	Test();
	return 0;
}
Copy the code

What is the result of the Test function?

The problem with this code:

The result is that the STR returned by GetMemory is still NULL, putting “Hello world” into the space pointed to by the NULL pointer, and the program inevitably crashes.

How to fix the code:

#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);
	free(str);
	str = NULL;
}
int main(a)
{
	Test();
	return 0;
}
Copy the code

Display effect:

\

#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(a)
{
   Test();
   return 0;
}
Copy the code

What is the result of the Test function?

Problem with code:

Memory leaks due to forgetting to free dynamically allocated memory

Correct code:

#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);
   free(p);
   p=NULL;
}
int main(a)
{
   Test();
   return 0;
}
Copy the code

\

In fact, ordinary local variables are allocated space in the stack area, which is characterized by variables created there being destroyed out of scope.

However, static variables are stored in the data segment (the static section), which is characterized by variables created on it that are not destroyed until the end of the program, so the life cycle is longer.

\

Such as:

/ / code 1

typedef struct st_type
{
 int i;
 int a[0];// A flexible array member
}type_a;
printf("%d\n".sizeof(type_a);  // The output is 4
Copy the code

\

The type_A structure described above can also be designed as:

/ / code 2
typedef struct st_type
{
   int i;
   int *p_a; 
}type_a;
   type_a *p = malloc(sizeof(type_a));
   p->i = 100;
   p->p_a = (int *)malloc(p->i*sizeof(int));
// Business processing
  for(i=0; i<100; i++)
   {
     p->p_a[i] = i; 
   }
// Free up space
  free(p->p_a);
  p->p_a = NULL;
  free(p);
  p = NULL;
Copy the code

\

Code 1 and code 2 above can do the same thing, but the implementation of method 1 has two benefits: the first benefit is to facilitate memory freeing

If our code is in a function for someone else to use, you do a secondary memory allocation in it and return the entire structure to the user. The user calls free to free the structure, but the user doesn’t know that members of the structure also need free, so you can’t expect the user to find out. So, if we allocate the structure’s memory and its members’ memory all at once, and return the user a pointer to the structure, the user can do a free to free all of the memory.

\

The second benefit is that it facilitates access speed.

Continuous memory is good for improving access speed and reducing memory fragmentation. (Actually, I personally don’t think it’s that high, you can’t run away from it anyway and you have to use offset addition to address it.

\

Well, this is the end of dynamic memory management, I hope you can practice more…

Thank you ！！！！

\