[C语言]动态内存管理与柔性数组
动态内存管理与柔性数组：：
动态内存：
定义数组开辟内存的缺陷：
1.开辟空间的大小固定.
2.数组在定义的时候，必须指定数组的长度.
动态内存开辟的原因：
1.程序不知道要使用多少对象.例如：容器类
2.程序不知道所需对象的准确类型.
3.程序需要在多个对象间共享数据.例如：智能指针
动态内存函数的介绍
malloc
malloc 头文件为#include<stdlib.h>
如果开辟成功 则返回一个指向开辟好空间的指针
如果开辟失败 则返回一个NULL 因此malloc的返回值一定要做检查
返回值的类型是void* 所以malloc函数并不知道开辟空间的类型 具体在使用的时候 使用者自己决定
如果size为0 malloc的行为是标准未定义的 取决于编译器
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<stdio.h>
int main()
{
动态内存开辟
malloc申请的空间在堆区申请
int* p = (int*)malloc(40);
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
使用内存
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d\n", *(p + i));
}
没有free并不是说内存空间就不回收了 当程序退出的时候 系统会自动回收内存空间的
free(p);
p = NULL;
return 0;
}
int main()
{
发生内存泄漏
while (1)
{
malloc(1);
}
return 0;
}free
free函数
free函数用来释放动态开辟的内存
如果参数ptr指向的空间不是动态内存开辟的 那么free函数的行为是未定义的
如果参数ptr是NULL 则函数什么事都不做calloc
calloc函数的功能是为num个大小为size的元素开辟一块空间 并且把空间的每个字节初始化为0
与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<stdio.h>
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
free(p);
p = NULL;
return 0;
}
注：calloc = malloc + memset
realloc
ptr为要修改空间的起始位置
size 大小(以字节为单位)
realloc的增容
情况1:如果后续空间足够大会直接增容 返回值为旧的地址
情况2:后续空间不足 会在内存中申请一份足够大的空间 把原数据拷贝下来在后面继续增容 旧的数据则会被自动释放掉 返回值为新的地址
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<stdio.h>
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i + 1;
}
扩容
int* ptr = (int*)realloc(p, 80);
if (ptr != NULL)
{
p = ptr;
}
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
free(p);
p = NULL;
return 0;
}
realloc也可以实现malloc的功能
int main()
{
realloc(NULL, 40);等价于malloc(40)
return 0;
}
常见的动态内存错误
1.对空指针的解引用操作
#include<stdlib.h>
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return 1;
}
*p = 20;
free(p);
p = NULL;
return 0;
}2.对动态开辟空间的越界访问
#include<stdlib.h>
#include<errno.h>
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
printf("%s\n", strerror(errno));
return 1;
}
int i = 0;
for (i = 0; i <= 10; i++)
{
*(p + i) = i;
}
free(p);
p = NULL;
return 0;
}3.对非动态开辟空间的free释放
#include<stdlib.h>
int main()
{
int a = 10;
int* p = &a;
free(p);
p = NULL;
}4.使用free释放动态开辟内存的一部分
#include<stdlib.h>
int main()
{
int* p = (int*)malloc(40);
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
*p = i;
p++;
}
free(p);
p = NULL;
return 0;
}5.对同一块动态内存多次释放
#include<stdlib.h>
int main()
{
int* p = (int*)malloc(40);
free(p);
free(p);
return 0;
}6.动态内存忘记释放(内存泄漏)
代码1
void test()
{
int* p = (int*)malloc(100);
int flag = 0;
scanf("%d", &flag);
if (flag == 5)
return;
free(p);
p = NULL;
}
int main()
{
test();
return 0;
}
代码2
int* test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return p;
}
return p;
}
int main()
{
int* ret = test();
忘记释放
return 0;
}动态内存相关笔试题
笔试题1
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
请问Test()函数的执行结果并优化上述代码
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
Test();
return 0;
}
程序的运行结果为：str是空指针 解引用时程序会崩溃 同时动态内存开辟处会存在内存泄漏
优化1:
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(&str);
str存放的是动态开辟的100byte的地址
strcpy(str, "hello world");
printf(str);
释放
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
程序的运行结果为：打印hello world
优化2:
char* GetMemory(char* p)
{
p = (char*)malloc(100);
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory(str);
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
优化3:
char* GetMemory()
{
char* p = (char*)malloc(100);
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}两道Nice公司经典笔试题
阅读下面两段程序 指出程序的问题所在
int* f1(void)
{
int x = 10;
return(&x);
}
程序返回的结果为野指针
int* f2(void)
{
int* ptr;
*ptr = 10;
return ptr;
}
程序返回的结果为野指针笔试题2
请问Test()函数的执行结果
#include<stdio.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;
}
程序的运行结果为：p为局部数组 str接收的是野指针 不能打印hello world笔试题3
请问Test()函数的执行结果并优化代码
#include<stdlib.h>
#include<string.h>
#include<stdio.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;
}
程序的运行结果为：正常打印hello world但内存泄漏
优化
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;
}笔试题4
请问Test()函数的执行结果并优化代码
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
void Test(void)
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0;
}
程序的运行结果为：str是野指针 程序会报错C/C++程序的内存开辟
C/C++ 程序内存分配的几个区域：
1. 栈区（ stack ）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结
束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是
分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返
回地址等。
2. 堆区（ heap ）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由 OS 回收 。分
配方式类似于链表。
3. 数据段（静态区）（ static ）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
柔性数组：
柔性数组的定义：
结构体中最后一个元素允许是未知大小的数组，这就是柔性数组成员，柔性数组就是结构体中的一
个成员变量.
typedef struct st_type
{
int i;
int a[0];柔性数组成员
}type_a;
typedef struct st_type
{
int i;
int a[];柔性数组成员
}type_a;柔性数组的特点
1.结构中的柔性数组成员前面必须至少一个其他成员.
2.sizeof返回的这种结构大小不包括柔性数组的内存.
3.包含柔性数组成员的结构用malloc函数进行内存的动态分配，并且分配的内存应该大于结构的大
小，以适应柔性数组的预期大小.
柔性数组的使用
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
struct S
{
int n;
int arr[];
};
int main()
{
struct S s;柔性数组不能这么创建变量 s只占4byte 没有包括柔性数组成员的大小
正确写法
struct S* ps = (struct S*)malloc(sizeof(struct S) + 40);
if (ps = NULL)
{
return 1;
}
ps->n = 100;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 80);
if (ptr != NULL)
{
ps = ptr;
}
free(ps);
ps = NULL;
return 0;
}
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
{
return 1;
}
ps->n = 100;
ps->arr = (int*)malloc(40);
if (ps->arr = NULL)
{
return 1;
}
使用
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", ps->arr[i]);
}
扩容
int* ptr = (int*)realloc(ps->arr,80 );
if (ptr == NULL)
{
return 1;
}
释放
free(ps->arr);
free(ps);
ps = NULL;
return 0;
}柔性数组的优势
第一个好处是： 方便内存释放.
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给
用户。用户调用 free 可以释放结构体，但是用户并不知道这个结构体内的成员也需要 free ，所以你
不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好
了，并返回给用户一个结构体指针，用户做一次 free 就可以把所有的内存也给释放掉。
第二个好处是： 这样有利于访问速度 .
连续的内存有益于提高访问速度，也有益于减少内存碎片，防止内存泄漏。
C语言编程训练：
1.BC65-箭形图案
#include <stdio.h>
int main()
{
int n = 0;
while (scanf("%d", &n) == 1)
{
上n行
int i = 0;
for (i = 0; i < n; i++)
{
打印空格
int j = 0;
for (j = 0; j < n - i; j++)
printf(" ");
打印*
for (j = 0; j <= i; j++)
{
printf("*");
}
printf("\n");
}
下n+1行
for (i = 0; i < n + 1; i++)
{
打印空格
int j = 0;
for (j = 0; j < i; j++)
printf(" ");
打印*
for (j = 0; j < n + 1 - i; j++)
{
printf("*");
}
printf("\n");
}
}
return 0;
}2.BC69—空心正方形图案
int main()
{
int n = 0;
while (scanf("%d", &n) == 1)
{
int i = 0;
int j = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
if (i == 0 || i == n - 1 || j == 0 || j == n - 1)
printf("* ");
else
printf(" ");
}
printf("\n");
}
}
return 0;
}3.BC76-公务员面试
#include <stdio.h>
int main()
{
int score = 0;
int n = 0;
int max = 0;
int min = 100;
int sum = 0;
while (scanf("%d", &score) == 1)
{
n++;
if (score > max)
max = score;
if (score < min)
min = score;
sum += score;
if (n == 7)
{
printf("%.2lf\n", (sum - max - min) / 5.0);
n = 0;
max = 0;
min = 100;
sum = 0;
}
}
return 0;
}4.找单身狗
一个数组中只有两个数字是出现一次，其他所有数字都出现了两次.
编写一个函数找出这两个只出现一次的数字.
思路:先分组再异或
分组:
1.所有数字异或
2.找出异或的结果中哪一位为1 - n
以第n位为1分一组 第n位为0分一组
void find_singal_dog(int arr[], int sz, int* pd1, int* pd2)
{
int i = 0;
int ret = 0;
for (i = 0; i < sz; i++)
{
ret ^= arr[i];
}
计算二进制中最右边的第几位是1
int pos = 0;
for (pos = 0; pos < 32; pos++)
{
if (((ret >> pos) & 1) == 1)
{
break;
}
}
for (i = 0; i < sz; i++)
{
if ((arr[i] >> pos) & 1 == 1)
{
*pd1 ^= arr[i];
}
else
{
*pd2 ^= arr[i];
}
}
}
int main()
{
int arr[] = { 1,2,3,4,5,1,2,3,4,6 };
int sz = sizeof(arr) / sizeof(arr[0]);
int dog1 = 0;
int dog2 = 0;
find_singal_dog(arr, sz, dog1, dog2);
printf("%d %d\n", dog1, dog2);
return 0;
}本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2023-04-03，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
腾讯云开发者
