当前位置：网站首页>[C language] dynamic memory allocation

But actually , The need for space , Sometimes , We don't know how much memory space to allocate , Sometimes you need to know when the program is running , For example, use an array to store the age of students in the class , We don't know how many students , I don't know how much space is needed , And the compiler does not support variable length arrays , Constant expression expected . Now , Using arrays to allocate fixed space is not suitable .

To better allocate memory space , At this time, we need our dynamic memory allocation .

When it comes to memory , We know that memory is divided into 3 Regions , The stack area , Heap area , Static zone .

The stack area —— local variable , Function parameter

Heap area —— Dynamic memory allocation

Static zone —— Global variables , Static variables （ Such as static int a = 10）

The introduction of dynamic memory function

malloc

void *malloc( size_t size ); A function opens up a continuous space to the heap , Return the starting address of the space .

● It's a success , Return a pointer to the opened space
● Failed to open up , return NULL The pointer , So check whether the development is successful
● The type returned is void*, therefore malloc I don't know the type of development , Their own decisions
● If size by 0,malloc The standard of behavior is undefined , Depends on the compiler
● Remember to reference the header file #include <stdlib.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main()
{
    int* p = (int*)malloc(10 * sizeof(int));
    if (p == NULL)
    {
        // One way to print the cause of the error 
        printf("%s\n", strerror(errno));
    }
    else
    {
        // Normal use 
        int i = 0;
        for (i = 0; i < 10; i++)
        {
            *(p + i) = i;
        }
        for (i = 0; i < 10; i++)
        {
            printf("%d ", *(p+i));
        }
    }
    // Release 
    free(p);
    p = NULL;
    return 0;
}

free

void free( void *memblock );

c Language provides a function free, Specially used for dynamic memory recovery and release

The header file is #include <stdlib.h>

Pay attention to some points. ：

Memory for dynamic development , If not , that free Function behavior is undefined
If the pointer is NULL The pointer , Then the function does nothing
By free It's better to manually set the pointer after to NULL, Avoid wild pointer , Cause mistakes

free(p);
p=NULL;

calloc

void *calloc( size_t num, size_t size );

calloc It is also used to dynamically open up space . The header file is also #include <stdlib.h>

And malloc The difference between ：

● Different parameters

● And malloc The only difference is calloc Each byte of the requested space is initialized to... Before returning the address 0.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main()
{
    //malloc(10*sizeof(int));
    int*p = (int*)calloc(10, sizeof(int));
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
    }
    else
    {
        int i = 0;
        for (i = 0; i < 10; i++)
        {
            printf("%d ", *(p + i));
        }
    }
    free(p);
    p = NULL;
    return 0;
}

debugged , You can see that the memory is initialized to 0 了

According to the actual situation , If initialization is required, use calloc

realloc

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

Header files are also references #include <stdlib.h>

ptr Is the memory address to be adjusted
size New size after adjustment , Instead of increasing the size
The return value is the starting memory position after adjustment

realloc Functions make dynamic memory management more flexible

Sometimes we find that the application space is too small , Sometimes I feel that the application is too big , In order to allocate memory reasonably , We can flexibly adjust the size of memory ,realloc You can adjust the size of dynamic memory

matters needing attention

realloc There are two situations in adjusting memory
situation 1： There is enough space behind the original space
● If p There is enough memory to append after the space pointed to , Then... Is added directly , After the return p
situation 2： There is not enough space after the original space
● If p There is not enough memory space to append after the space pointed to , be realloc The function will find a new memory area again
Open up a space to meet the needs , And copy back the data in the original memory , Free up old memory space , Finally, return the newly opened memory space address
● You have to use a new variable to receive realloc The return value of

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main()
{
    int* p = (int*)malloc(20);
    if (p == NULL)
    {
        printf("%s\n", strerror(errno));
    }
    else
    {
        int i = 0;
        for (i = 0; i < 5; i++)
        {
            *(p + i) = i;
        }
    }
    // In the use of malloc Opened up 20 Space 
    // Suppose here 20 One byte is not enough for our use 
    // I hope we can have 40 Bytes of space 
    // You can use realloc To adjust the dynamically opened memory 
    int* ptr = realloc(p, 40);
    if (ptr != NULL)
    {
        p = ptr; 
        int i = 0;
        for (i = 5; i < 10; i++)
        {
            *(p + i) = i;
        }
        for (i = 0; i < 10; i++)
        {
            printf("%d ", *(p+ i));
        }
    }
    free(p);
    p = NULL;
    return 0;
}

Common mistakes

Yes NULL Dereference operation of pointer

int main()
{
    int* p = (int*)malloc(INT_MAX/4);
    *p = 20;// If p Is a null pointer , There will be problems ;
    free(p);
    return 0;
}

A cross-border visit

int* p = (int*)malloc(40);
    if (p == NULL)
    {
        return 0;
    }
    int i = 0;
    // Transboundary 
    for (i = 0; i <= 10; i++)
    {
        *(p + i) = i;
    }
    free(p);
    p = NULL;

Should be i<10

For non dynamic memory free

 int a = 10;
    int* p = &a;
    free(p);
    p = NULL;

Use free Release a part of dynamic memory

int* p = (int*)malloc(40);
    if (p == NULL)
    {
        return 0;
    }
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        *p++ = i;
    }
    free(p);
    return 0;

p Not at the starting point of dynamic memory development , We should redefine a pointer to remember the starting address

Multiple releases of the same dynamic memory

int* p = (int*)malloc(40);
    if (p == NULL)
    {
        return 0;
    }
    free(p);
    free(p);

Forget to release dynamic memory （ Memory leak ）

Forget to free dynamically opened memory , Will cause memory leaks

 while (1)
    {
        malloc(1);
        Sleep(1000);
    }

Apply for memory without returning it , The memory of a computer is limited , Memory will run out

Conclusion

All right. , This time about c The knowledge of language dynamic memory is over , A great bai .

原网站

版权声明
本文为[Ordinary people 1]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/03/202203011100270313.html