C标准库 | 内存分配以及释放函数汇总

在日常C语言使用过程中，不可避免遇到从堆中申请空间给特定的数据结构（结构体指针）！

一、头文件

#include <stdlib.h>

文件所在路径：

$ ls /usr/include/stdlib.h

二、函数声明

/* Allocate SIZE bytes of memory.  */
extern void *malloc (size_t __size) __THROW __attribute_malloc__
     __attribute_alloc_size__ ((1)) __wur;
/* Allocate NMEMB elements of SIZE bytes each, all initialized to 0.  */
extern void *calloc (size_t __nmemb, size_t __size)
     __THROW __attribute_malloc__ __attribute_alloc_size__ ((1, 2)) __wur;

/* Re-allocate the previously allocated block
   in PTR, making the new block SIZE bytes long.  */
/* __attribute_malloc__ is not used, because if realloc returns
   the same pointer that was passed to it, aliasing needs to be allowed
   between objects pointed by the old and new pointers.  */
extern void *realloc (void *__ptr, size_t __size)
     __THROW __attribute_warn_unused_result__ __attribute_alloc_size__ ((2));

/* Free a block allocated by `malloc', `realloc' or `calloc'.  */
extern void free (void *__ptr) __THROW;

三、函数作用

形参的作用：

• __size：要被分配的元素大小（单位是字节）
• __nmemb：要被分配的元素个数
• __ptr：指向已分配内存块的指针

函数的作用：

函数	参数	返回值	作用
malloc	__size	void *	分配__size字节大小的内存块，并返回指向该内存块的指针
calloc	__nmemb, __size	void	分配__nmemb个__size字节大小的内存块，并返回指向该内存块的指针
realloc	__ptr, __size	long int	把__ptr内存块重新分配为__size字节大小，并返回指向新内存块的指针
free	__ptr	void	把__ptr内存块进行释放

注意点：

• malloc 和 calloc 函数之间的不同点是，malloc 函数不会设置内存块为零，而 calloc 函数会设置分配的内存块为零
• realloc 函数的__ptr参数内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果为空指针，则会分配一个新的内存块，且函数返回一个指向它的指针
• realloc 函数的__size参数为0，则相当与free函数，并返回空指针
• 没有分配的内存块不能使用free函数，会造成内存泄露

四、使用

• 源代码：

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

struct person {
        int age;
        int height;
        int weight;
};

int main(int argc, char *argv[])
{
        struct person *person;

        person = (struct person *)malloc(sizeof(struct person));
        person->age = 20;
        person->height = 175;
        person->weight = 130;
        printf("persons.age: %d\n", person->age);
        printf("persons.height: %d\n", person->height);
        printf("persons.weight: %d\n", person->weight);
        free(person);

        person = (struct person *)calloc(1, sizeof(struct person));
        person->age = 30;
        person->height = 180;
        person->weight = 150;
        printf("persons.age: %d\n", person->age);
        printf("persons.height: %d\n", person->height);
        printf("persons.weight: %d\n", person->weight);

        person = (struct person *)realloc(person, 2 * sizeof(struct person));
        person->age = 30;
        person->height = 180;
        person->weight = 150;
        printf("persons.age: %d\n", person->age);
        printf("persons.height: %d\n", person->height);
        printf("persons.weight: %d\n", person->weight);
        person++; // 指向第二项结构体
        person->age = 40;
        person->height = 185;
        person->weight = 160;
        printf("persons.age: %d\n", person->age);
        printf("persons.height: %d\n", person->height);
        person--; // 回到指向第一项结构体
        free(person); // 必须传入指向第一项结构体的指针，否则会内存泄漏

        return 0;
}

• 打印结果：