文章目录
- 1.动态内存函数
- 1.1free
- 1.2malloc
- 1.3calloc
- 1.4realloc
- 2.动态内存错误
- 2.1解引用空指针--非法访问内存
- 2.2越界访问动态空间
- 2.3free释放非动态空间
- 2.4free释放部分动态空间
- 2.5free多次释放动态空间
- 2.6未释放动态内存
- 3.动态内存题目
- 3.1形参不影响实参
- 3.2地址返回，空间已无
- 3.3忘记释放动态内存
- 3.4free后未置空
- 4.C/C++程序内存开辟
- 1．栈区（stack）
- 2．堆区（heap）
- 3．数据段（data segment）
- 4．代码段（code segment）
- 5.图解
- 5.柔性数组
- 5.1介绍
- 5.2使用
- 5.3优点
- 5.3.1使用柔性数组
- 5.3.2使用指针
- 5.3.3代码分析
1.动态内存函数
1.1free
#include<stdlib.h>
void free(void* ptr);
释放动态开辟的内存空间
ptr 指向空间不是动态开辟的， free 函数行为未定义。
ptr 是 NULL ， free 不会执行任何动作。
一定要使用 free 函数释放所开辟的内存空间。
free 之后要将其置为空指针。
1.2malloc
#include<stdlib.h>
void* malloc(size_t size);
int* p = (int*)malloc(10*sizeof(int));
C语言动态内存开辟函数
向内存申请一块连续可用空间
返回指向这块空间的指针
① 开辟成功，返回一个指向开辟空间的指针。
② 开辟失败，返回一NULL 指针。
③ 返回值类型 void* ，使用者决定开辟空间类型
④ size == 0的行为标准未定义，结果取决于编译器。
1.3calloc
#include<stdio.h>
void* calloc(size_t num,size_t size);
为num 个， size大小的元素开辟空间
把每个字节初始化 0
返回一个指向此内存的指针。
1.4realloc
#include<stdio.h>
void* realloc(void* ptr,size_t size);
函数讲解：
重新调整 malloc 或 calloc 分配内存块的大小
对动态开辟的内存进行大小调整
ptr 指向要调整的内存地址
size 为调整之后的大小
返回调整之后内存起始位置，失败返回空指针
调整原内存空间大小
将原来内存中数据移动到新空间
调整内存空间时三种情况：
情况1：原空间后有足够空间：直接追加
情况2：原空间后无足够空间，在堆空间上找一块大小合适的连续空间存放
情况3：找不到合适空间：返回空指针
2.动态内存错误
2.1解引用空指针–非法访问内存
错误示例：
int main()
{
int* p = (int*)malloc(9999999999);
for (int = 0; i < 10; i++)
*(p + i) = i;
return 0;
}
解决办法：
int main()
{
int* p = (int*)malloc(9999999999);
if (p == NULL)
{
perror("malloc");
return 1;
}
for (int = 0; i < 10; i++)
*(p + i) = i;
return 0;
}
2.2越界访问动态空间
错误示例：
int main()
{
int* p = (int*)malloc(10*sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;
}
int i = 0;
for (int i = 0; i < 40; i++)
*(p + i) = i;
free(p);
p = NULL;
return 0;
}
解决办法：
使用空间时，注意所开辟空间大小。
2.3free释放非动态空间
错误示例：
int main()
{
int arr[10] = {0};
int* p = arr;
free(p);
p = NULL;
return 0;
代码卡死
}
解决办法：
分清所用空间是否为动态开辟空间
2.4free释放部分动态空间
错误示例：
int main()
{
int* p = malloc(10*sizeof(int));
if (p == NULL)
return 1;
for (int i = 0; i < 5; i++)
*p++ = i;
free(p);
p = NULL;
程序崩溃，原内存起始位置遗忘，存在内存泄漏风险
return 0;
}
解决办法：
定义临时指针变量tmp记录起始位置。
2.5free多次释放动态空间
错误示例：
int main()
{
int* p = malloc(10*sizeof(int));
if (p == NULL)
return 1;
for (int i = 0; i < 10; i++)
p[i] = i;
free(p);
free(p);
代码卡死
return 0;
}
解决办法：
free(p);
p = NULL;
free(p); // p为空，free无操作
2.6未释放动态内存
错误示例：
void test()
{
int* p = (int*)malloc(100);
if (p == NULL)
return;
}
int main()
{
test();
free(p);
// test()函数调用结束后，p被销毁，所申请的100个字节内存块地址被遗忘。
p = NULL;
}
提醒：
1.内存泄漏（Memory Leak）： 程序中已动态分配的堆内存由于某种原因，程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。
2.动态开辟的内存空间回收方式：
主动释放（free）
程序结束
3.动态内存题目
3.1形参不影响实参
错误示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char *p)
{
p = (char*)malloc(100);
}
void Test()
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
Test();
return 0;
}
str 传给 GetMemory 函数时为值传递，GetMemory 函数的形参 p 是 str 的一份临时拷贝。GetMemory 函数内部动态开辟的内存空间地址存放在 p 中，不影响 str。当 GetMemory 函数返回后
1.str 仍是 NULL，导致 strcpy 拷贝失败。
2.形参 p 销毁，没有及时使用 free 释放，导致动态开辟的100个字节存在内存泄露问题
程序卡死。
解决办法：
1：str传参，str接收p
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* GetMemory(char *p)
{
p = (char*)malloc(100);
return p;
}
void Test()
{
char *str = NULL;
str = GetMemory(str);
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
2：值传递改为址传递
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test()
{
char *str = NULL;
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
3.2地址返回，空间已无
#include <stdio.h>
#include <stdlib.h>
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
}
GetMemory 函数内部数组p在栈区上创建，函数调用结束， 数组p的空间还给操作系统。返回的地址没有实际意义，若通过返回的地址访问内存，导致非法访问内存问题。
3.3忘记释放动态内存
错误示例：
#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()
{
Test();
return 0;
}
解决办法：
#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(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
3.4free后未置空
错误示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
//if为真，非法访问已释放内存
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0;
}
解决办法：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
str = NULL;
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0;
}
4.C/C++程序内存开辟
1．栈区（stack）
执行函数时，函数内部局部变量的存储单元在栈上创建。函数执行结束后这些存储单元自动释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配内存容量是有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2．堆区（heap）
一般由程序员自主分配释放，若程序员不主动不释放，程序结束时可能由操作系统回收。分配方式类似于链表。
3．数据段（data segment）
静态存储区，存放全局变量和静态数据，程序结束后由系统释放。
4．代码段（code segment）
存放函数体（类成员函数和全局函数）的二进制代码。
5.图解
图片来自于比特科技C语言进阶课件
5.柔性数组
5.1介绍
柔性数组（Flexible Array），又称可变长数组。一般数组长度在编译时确定，而柔性数组长度在运行时确定。在定义结构体时创建一个空数组（例如：arr [ 0 ] ），该数组的大小可程序运行过程中按照需求变动。
struct S {
int n; 至少一个其他成员
int arr[]; 柔性数组成员
int arr[0]; 柔性数组成员
};
int main()
{ 此结构大小不包含柔性数组成员
struct S s = {0};
printf("%d\n", sizeof(s));//4
此结构用 malloc 函数分配的内存应大于结构大小，以适应柔性数组预期大小
struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(int));
return 0;
}
5.2使用
#include <stdio.h>
#include <stdlib.h>
struct S
{
int n;
int arr[0];
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
ps->n = 10;
for (int i = 0; i < 10; i++)
ps->arr[i];
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20*sizeof(int));
if (ptr != NULL)
ps = ptr;
free(ps);
ps = NULL;
return 0;
}
5.3优点
5.3.1使用柔性数组
#include <stdio.h>
#include <stdlib.h>
struct S
{
int n;
int arr[0];
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10*sizeof(int));
ps->n = 10;
for (int i = 0; i < 10; i++)
ps->arr[i];
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20*sizeof(int));
if (ptr != NULL)
ps = ptr;
free(ps);
ps = NULL;
return 0;
}
5.3.2使用指针
#include <stdio.h>
#include <stdlib.h>
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
return 1;
ps->n = 10;
ps->arr = (int*)malloc(10 * sizeof(int));
if (ps->arr == NULL)
return 1;
for (int i = 0; i < 10; i++)
ps->arr[i] = i;
int* ptr = (struct S*)realloc(ps->arr, 20 * sizeof(int));
if (ptr != NULL)
ps->arr = ptr;
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL;
return 0;
}
5.3.3代码分析
使用柔性数组的优势：
1.利于内存释放
2使用指针完成，两次 malloc ，两次 free ，更易出错。若整个结构体返回用户，用户调用 free 释放结构体，但用户不知道结构体内成员也需要 free。把内存一次性分配好，返回用户一个结构体指针，用户只需使用一次 free 就可以把所有内存释放，间接减少内存泄露可能性。
2.利于访问速度，减少内存碎片
连续内存益于提高访问速度，减少内存碎片。
malloc 次数越多，产生的内存碎片越多，这些内存碎片再被利用的可能性很低。内存碎片越多，内存的利用率越低。频繁的开辟空间效率变低，碎片增加。
