动态内存分配和柔性数组
为什么进行动态内存开辟：
我们目前已经知道的动态内存开辟的方式有：
int val = 20;//在栈空间上开辟四个字节
char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间
但是上述开辟的内存空间大小是固定的，在数组的申请空间的时候需要指定大小，对于空间的需求，我们往往需要的空间只有在程序运行的时候才知道大小，所以我们要学习动态内存开辟空间
1、malloc
void* malloc(size_t size);
malloc函数是向内存申请一块连续可用的空间，并返回这块空间的指针
1、开辟成功，返回指向开辟好空间的指针
2、开辟失败，返回NULL，malloc的返回值要做检查
3、malloc在开辟空间的时候，开辟的空间类型由使用者决定
4、malloc的size为0，是未定义，取决于编译器
void free(void *ptr);
free函数用来释放动态开辟的内存
1、若是ptr指向的空间不是动态开辟的，那么free函数的行为是未定义的
2、若是ptr为NULL，则函数什么事都不做。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
malloc函数是向内存申请一块连续可用的空间，并返回这块空间的指针
1、开辟成功，返回指向开辟好空间的指针
2、开辟失败，返回NULL，malloc的返回值要做检查
3、malloc在开辟空间的时候，开辟的空间类型由使用者决定
4、malloc的size为0，是未定义，取决于编译器
*/
/*
free函数用来释放动态开辟的内存
1、若是ptr指向的空间不是动态开辟的，那么free函数的行为是未定义的
2、若是ptr为NULL，则函数什么事都不做。
*/
int main()
{
int num = 0;
scanf("%d", &num);
int arr;
int *ptr = NULL;
ptr = (int *)malloc(num*sizeof(int));
if (ptr)
{
for (int i = 0; i < num; i++)
{
*(ptr + i) = 0;
}
}
free(ptr);
ptr = NULL;
system("pause");
return 0;
}
2、calloc
void* calloc(size_t num, size_t size);
calloc
1、为num个大小为size的元素开辟一块空间，并把空间每个字节初始化为0
2、calloc在返回地址之前会把申请的空间的每个字节置零
#include <stdio.h>
#include <stdlib.h>
/*
calloc
1、为num个大小为size的元素开辟一块空间，并把空间每个字节初始化为0
2、calloc在返回地址之前会把申请的空间的每个字节置零
*/
int main()
{
int *p = calloc(10, sizeof(int));
if (p)
{
for (int i = 0; i < 10; i++)
{
*(p + i) = 0;
}
}
free(p);
p = NULL;
system("pause");
return 0;
}
3、realloc
void* realloc(void *ptr, size_t size);
realloc
可对动态开辟内存的大小进行调整
1、ptr是要调整的内存地址
2、size调整之后的大小
3、返回值为调整之后的内存起始地址
4、这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
realloc在调整内存空间的时候存在两种情况：
情况1：原有空间之后又足够大的空间
要扩展内存就直接在原有内存之后直接追加空间，原来空间的数据不发生变化
情况2：原有空间之后没有足够大的空间
在堆空间上另找一个合适大小的连续空间来使用，这样的函数返回的是一个新的内存地址 。
#include <stdio.h>
#include <stdlib.h>
/*
realloc
可对动态开辟内存的大小进行调整
1、ptr是要调整的内存地址
2、size调整之后的大小
3、返回值为调整之后的内存起始地址
4、这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间
*/
int main()
{
int *ptr = malloc(100);
if (ptr)
{
}
else
{
exit(EXIT_FAILURE);
}
//扩展容量
ptr = realloc(ptr, 1000);
int *p = NULL;
p = realloc(ptr, 1000);
if (p)
{
ptr = p;
}
free(ptr);
ptr = NULL;
system("pause");
return 0;
}
4、动态内存分配常见错误
常见错误主要有以下几种：
1、对NULL指针的解引用操作
2、对动态开辟空间的越界访问
3、对非动态内存使用free函数
4、使用free释放一块动态开辟的一部分
5、对同一块开辟内存的多次释放
6、动态内存开辟忘记释放（内存泄漏）
1、对NULL指针的解引用操作
#include <stdio.h>
#include <stdlib.h>
//对NULL指针的解引用操作
void test1()
{
int *p = (int *)malloc(INT_MAX / 4);
*p = 20;
free(p);
p = NULL;
}
int main()
{
test1();
system("pause");
return 0;
}
2、对动态开辟空间的越界访问
#include <stdio.h>
#include <stdlib.h>
//对动态开辟空间的越界访问
void test2()
{
int *p = (int *)malloc(10 * sizeof(int));
if (p == NULL)
{
exit(EXIT_FAILURE);
}
for (int i = 0; i <= 10; i++)//发生越界错误
{
*(p + i) = i;
}
free(p);
p = NULL;
}
int main()
{
test2();
system("pause");
return 0;
}
3、对非动态内存使用free函数
#include <stdio.h>
#include <stdlib.h>
//对非动态开辟内存使用free释放
void test3()
{
int a = 10;
int *p = &a;
free(p);
}
int main()
{
test3();
system("pause");
return 0;
}
4、使用free释放一块动态开辟的一部分
#include <stdio.h>
#include <stdlib.h>
//使用free释放一块动态开辟内存的一部分
void test()
{
int *p = (int *)malloc(100);
p++;
free(p);
}
int main4()
{
test4();
system("pause");
return 0;
}
5、对同一块开辟内存的多次释放
#include <stdio.h>
#include <stdlib.h>
//对同一块内存多次释放
void test5()
{
int *p = (int *)malloc(100);
free(p);
free(p);
}
int main()
{
test5();
system("pause");
return 0;
}
6、动态内存开辟忘记释放（内存泄漏）
#include <stdint.h>
#include <stdlib.h>
//动态内存开辟的忘记释放(会造成内存泄漏)
void test6()
{
int *p = (int *)malloc(100);
if (p)
{
*p = 20;
}
}
int main()
{
test6();
system("pause");
return 0;
}
5、柔性数组
概念：在C99中，结构体中最后一个元素是未知大小的数据，这就叫柔性数组成员
typedef struct st_type
{
int i;
int a[0];
}type_a;//柔性数组成员
柔性数组特点：
1、结构体中的柔性数组成员面前至少一个其他成员
2、sizeof返回的这种结构大小不包括柔性数组的内存
3、包含柔性数组成员的结果用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小
柔性数组的使用：
#include <stdio.h>
#include <stdlib.h>
/*
柔性数组特点：
1、结构体中的柔性数组成员面前至少一个其他成员
2、sizeof返回的这种结构大小不包括柔性数组的内存
3、包含柔性数组成员的结果用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构体的大小，以适应柔性数组的预期大小
*/
typedef struct st_type1
{
int i;
int a[0];//柔性数组成员
}type_a1;
typedef struct st_type2
{
int i;
int a[];//柔性数组成员
}type_a2;
int main()
{
printf("%d\n", sizeof(type_a1));//4
printf("%d\n", sizeof(type_a2));//4
system("pause");
return 0;
}
6、柔性数组优势
//代码1
#include <stdio.h>
#include <stdlib.h>
typedef struct st_type3
{
int i;
int a[];//柔性数组成员
}type_a3;
int main()
{
int i = 0;
type_a3 *p = (type_a3 *)malloc(sizeof(type_a3)+100 * sizeof(int));
p->i = 100;
for (int i = 0; i < 100; i++)
{
p->a[i] = i;
printf("%d ", p->a[i]);
}
free(p);
p = NULL;
system("pause");
return 0;
}
//代码2
#include <stdio.h>
#include <stdlib.h>
typedef struct st_type4
{
int i;
int *p_a;
}type_a4;
int main()
{
type_a4 *p = malloc(sizeof(type_a4));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));
for (int i = 0; i < 100; i++)
{
p->p_a[i] = i;
printf("%d ", p->p_a[i]);
}
free(p->p_a);
p->p_a = NULL;
free(p);
p = NULL;
system("pause");
return 0;
}
代码1有以下好处：
1、方便内存释放
2、有利于提高访问速度，减少内存碎片
7、C/C++内存开辟方式
1、栈区（stack）：在执行函数时，函数内部的局部变量的存储单元都可以在栈上创建，函数执行函数结束时，这些存储单元自动被释放，栈内存分配运算内置于处理器的指令中，效率很高，但是分配的内存容量有限，栈区主要存放运行函而分配的局部变量、函数参数、返回数据、返回地址等。
2、堆区（heap）：一般由程序员分配释放，若程序员不释放，可能由OS回收，分配方式类似于链表。
3、数据段（静态区）（static）：存放全局变量，静态数据，程序结束后由系统释放。
4、代码段：存放函数体（类成员函数和全局函数）的二进制代码。
8、练习
1.c
#include <stdio.h>
#include <stdlib.h>
void GetMemory7(char *p)
{
p = (char *)malloc(10);
}
void Test7(void)
{
char *str = NULL;
GetMemory7(str);
strcpy(str, "Hello,World!");
puts(str);
}
int main()
{
Test7();
system("pause");
return 0;
}
2.c
#include <stdio.h>
#include <stdlib.h>
char* GetMemory8(void)
{
char p[] = "Hello,World!";
return p;
}
void Test8(void)
{
char *str = NULL;
str = GetMemory8();
puts(str);
}
int main()
{
Test8();
system("pause");
return 0;
}
3.c
#include <stdio.h>
#include <stdlib.h>
void GetMemory9(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test9(void)
{
char *str = NULL;
GetMemory9(&str, 100);
strcpy(str, "Hello,World!");
puts(str);
}
int main()
{
Test9();
system("pause");
return 0;
}
4.c
#include <stdio.h>
#include <stdlib.h>
void Test10(void)
{
char *str = (char *)malloc(100);
strcpy(str, "Hello,World!");
free(str);
//str = NULL;
if (str)
{
strcpy(str, "123,456!");
puts(str);
}
}
int main()
{
Test10();
system("pause");
return 0;
}
