做外贸到什么网站上发布比较好,重庆网站建设重庆网站建设公司网站建设,专业网页制作报价,软件开发工具case目录 前言
一、为什么要有动态内存分配
二、 malloc和free
2.1 malloc
2.2 free
三、calloc和realloc
3.1 calloc
3.2 realloc
四. 常见的动态内存的错误
4.1 对NULL指针的解引用操作
4.2 对动态开辟空间的越界访问
4.3 对非动态开辟内存使用free释放
4.4 使…目录 前言
一、为什么要有动态内存分配
二、 malloc和free
2.1 malloc
2.2 free
三、calloc和realloc
3.1 calloc
3.2 realloc
四. 常见的动态内存的错误
4.1 对NULL指针的解引用操作
4.2 对动态开辟空间的越界访问
4.3 对非动态开辟内存使用free释放
4.4 使用free释放一块动态开辟内存的⼀部分
4.5 对同一块动态内存多次释放
4.6 动态开辟内存忘记释放内存泄漏
五. 动态内存经典笔试题分析
5.1 题目1
5.2 题目2
5.3 题目3
5.4 题目4
六. 柔性数组
6.1 柔性数组的特点
6.2 柔性数组的使用
6.3 柔性数组的优势 前言
动态内存管理是C语言中用于在程序运行时分配和释放内存的一种机制
它允许程序根据需要动态地请求和释放内存空间而不是在编译时就固定下来。这种灵活性使得程序能够更好地适应不同的运行条件和需求。具体来说动态内存管理涉及以下几个方面
内存分配C语言提供了几种动态内存分配函数如malloc()、calloc()、realloc()等。这些函数可以在堆区为程序分配所需的内存空间。例如malloc()函数接受一个参数即需要分配的内存大小以字节为单位并返回一个指向分配内存的指针。内存释放当不再需要已分配的内存时应使用free()函数将其释放以避免内存泄漏。数组的动态内存分配对于数组特别是多维数组动态内存分配可以提供更大的灵活性。例如可以根据用户输入或程序运行状态来决定数组的大小。作用域与生命周期动态分配的内存的生命周期由程序员控制不同于自动变量的生命周期受作用域限制。这意味着程序员必须谨慎管理这些内存区域以避免悬垂指针和内存泄漏等问题。指针与地址运算动态内存管理经常涉及到指针的使用以及对地址的直接操作。这要求程序员对指针的概念有深入的理解。
总的来说动态内存管理是C语言编程中的一个重要组成部分它为程序设计提供了更多的灵活性和控制能力。然而这也要求程序员具备良好的内存管理习惯以确保程序的稳定性和效率。 一、为什么要有动态内存分配
我们已经掌握的内存开辟⽅式有
int val 20;//在栈空间上开辟四个字节
char arr[10] {0};//在栈空间上开辟10个字节的连续空间
但是上述的开辟空间的⽅式有两个特点
空间开辟大小是固定的。 数组在申明的时候必须指定数组的⻓度数组空间⼀旦确定了大小不能调整
但是对于空间的需求不仅仅是上述的情况。有时候我们需要的空间大小在程序运⾏的时候才能知 道那数组的编译时开辟空间的⽅式就不能满足了。 C语⾔引入了动态内存开辟让程序员⾃⼰可以申请和释放空间就⽐较灵活了。
二、 malloc和free
2.1 malloc
C语⾔提供了⼀个动态内存开辟的函数
void* malloc (size_t size);
这个函数向内存申请⼀块连续可用的空间并返回指向这块空间的指针。
如果开辟成功则返回⼀个指向开辟好空间的指针。 如果开辟失败则返回⼀个 NULL 指针因此malloc的返回值⼀定要做检查。返回值的类型是 void* 所以malloc函数并不知道开辟空间的类型具体在使⽤的时候使⽤者自己来决定。如果参数 size 为0malloc的⾏为是标准是未定义的取决于编译器。
malloc向内存申请的空间在堆区 2.2 free C语⾔提供了另外⼀个函数free专门是用来做动态内存的释放和回收的函数原型如下
void free (void* ptr);
free函数用来释放动态开辟的内存。
如果参数 ptr 指向的空间不是动态开辟的那free函数的⾏为是未定义的。 如果参数 ptr 是NULL指针则函数什么事都不做。
malloc和free都声明在 stdlib.h 头⽂件中。
举个列子 #include stdio.h
#include stdlib.h
int main()
{int num 0;scanf(%d, num);//int arr[num] { 0 }; //很显然这一行代码是行不通的数组后面的框不能是变量int* ptr NULL;ptr (int*)malloc(num * sizeof(int));//在开辟完动态内存后必须要进行判断if (ptr ! NULL){for (int i 0; i num; i){*(ptr i) i 1;printf(%d , *(ptr i));}}free(ptr); //释放的必须是ptr指向的动态内存ptr NULL; //将其设置为空指针目的是防止它成为野指针因为在释放内存后这个指针指向的内存为空return 0;
} 三、calloc和realloc
3.1 calloc
C语⾔还提供了⼀个函数叫 calloc calloc 函数也⽤来动态内存分配。原型如下
void* calloc (size_t num, size_t size); 函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间并且把空间的每个字节初始化为0。与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全 0
举个例子
#include stdio.h
#include stdlib.h
int main()
{int* p (int*)calloc(10, sizeof(int));if (p ! NULL){for (int i 0; i 10; i){printf(%d , *(p i));}}free(p);p NULL;return 0;
} 所以如果我们对申请的内存空间的内容要求初始化那么可以很⽅便的使⽤calloc函数来完成任务。
3.2 realloc realloc函数的出现让动态内存管理更加灵活。有时会我们发现过去申请的空间太小了有时候我们⼜会觉得申请的空间过大了那为了合理的使用内存我们⼀定会对内存的⼤小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。 函数原型如下
void* realloc (void* ptr, size_t size);
ptr 是要调整的内存地址size 调整之后新大小返回值为调整之后的内存起始位置。这个函数调整原内存空间大小的基础上还会将原来内存中的数据移动到 新 的空间。realloc在调整内存空间的是存在两种情况 ◦ 情况1原有空间之后有足够大的空间 ◦ 情况2原有空间之后没有足够大的空间 情况1
当是情况1的时候要扩展内存就直接原有内存之后直接追加空间原来空间的数据不发生变化同时返回就地址的其实地址。
情况2 当时情况2的时候原有空间之后没有⾜够多的空间时扩展的⽅法是在堆空间上另找⼀个合适大小的连续空间来使用将原来空间的数据拷贝到新的空间同时释放旧的空间返回新空间的其实地址。
由于上述的两种情况realloc函数的使⽤就要注意⼀些。
#include stdio.h
#include stdlib.h
int main()
{int* ptr (int*)malloc(100);if (ptr ! NULL){//业务处理}else{return 1;}//此时发现空间不够用需要扩展容量//代码1 -- 直接将realloc的返回值放到ptr中/*ptr (int*)realloc(ptr, 1000)*/; //这样可以吗// 其实时不可以的因为如果要扩展的空间过大内存中没有那么大的连续的内存空间则开辟失败返回空指针此时ptr为空指针// 其中的内容也就找不到了//代码1 - 先将realooc函数的返回值放到p中当不为NULL时则放在ptr中int* p (int*)realloc(ptr, 1000);if (p ! NULL){ptr p;}free(ptr);ptr NULL;return 0;
}
四. 常见的动态内存的错误
4.1 对NULL指针的解引用操作
void test(){int *p (int *)malloc(INT_MAX/4);*p 20;//如果p的值是NULL就会有问题free(p);} 4.2 对动态开辟空间的越界访问
void test(){int i 0;int *p (int *)malloc(10*sizeof(int));if(NULL p){exit(EXIT_FAILURE);}for(i0; i10; i){*(pi) i;//当i是10的时候越界访问}free(p);} 4.3 对非动态开辟内存使用free释放
void test(){int a 10;int *p a;free(p);//ok?} 4.4 使用free释放一块动态开辟内存的⼀部分
void test(){int *p (int *)malloc(100);p;free(p);//p不再指向动态内存的起始位置}
4.5 对同一块动态内存多次释放
void test(){int *p (int *)malloc(100);free(p);free(p);//重复释放}
4.6 动态开辟内存忘记释放内存泄漏
void test(){int *p (int *)malloc(100);if(NULL ! p){*p 20;}}
int main(){test();while(1);}
忘记释放不再使用的动态开辟的空间会造成内存泄漏。
切记动态开辟的空间⼀定要释放并且正确释放。
五. 动态内存经典笔试题分析
5.1 题目1
#include stdlib.h
#include string.h
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;
}
以上代码有哪些问题 5.2 题目2
char *GetMemory(void)
{char p[] hello world;return p;
}
void Test(void)
{char *str NULL;str GetMemory();printf(str);
}
以上代码有哪些问题 5.3 题目3
#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;
} 5.4 题目4 #include stdlib.h
#include string.h
#include stdio.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;
}
六. 柔性数组
也许你从来没有听说过柔性数组flexible array这个概念但是它确实是存在的。
C99 中结构中的最后⼀个元素允许是未知大小的数组这就叫做『柔性数组』成员。
例如
struct st_type
{int i; int a[0];//柔性数组成员
}; 有些编译器会报错⽆法编译可以改成
struct st_type
{int i;int a[];//柔性数组成员
};
6.1 柔性数组的特点
结构中的柔性数组成员前⾯必须至少⼀个其他成员。 sizeof 返回的这种结构大小不包括柔性数组的内存。包含柔性数组成员的结构用malloc ()函数进行内存的动态分配并且分配的内存应该大于结构的大小以适应柔性数组的预期大小。
struct st_type
{int i;int a[0];//柔性数组成员
};
int main()
{printf(%d\n, sizeof(struct st_type));//输出的是4return 0;
}
6.2 柔性数组的使用 图解1 // 柔性数组的使用
struct S
{int age;int arr[]; //柔性数组成员
};
int main()
{//为这个结构体开辟动态内存空间struct S* p (struct S*)malloc(sizeof(struct S) 5 * sizeof(int));if (p NULL){perror(malloc());return 1;}p-age 20;printf(%d , p-age);for (int i 0; i 5; i){p-arr[i] i 1;printf(%d , p-arr[i]);}free(p);p NULL;return 0;
} 图解2 6.3 柔性数组的优势
使用指针也可以设计为下⾯的结构也能完成同样的效果。但就不再是柔性数组了
struct S
{int age;int* p; //柔性数组成员
};int main()
{struct S* ps (struct S*)malloc(sizeof(struct S));if (ps NULL){perror(malloc);return 1;}ps-age 20;printf(%d , ps-age);ps-p (int*)malloc(5 * sizeof(int*));for (int i 0; i 5; i){*(ps-p i) i 1;printf(%d , *(ps-p i));}//释放空间free(ps-p);ps-p NULL;free(ps);ps NULL;return 0;
} 上述 代码1 和 代码2 可以完成同样的功能但是方法1 的实现有两个好处
第⼀个好处是方便内存释放
如果我们的代码是在⼀个给别⼈用的函数中你在里面做了⼆次内存分配并把整个结构体返回给用户。用户调用free可以释放结构体但是用户并不知道这个结构体内的成员也需要free所以你不能 指望用户来发现这个事。所以如果我们把结构体的内存以及其成员要的内存⼀次性分配好了并返 回给用户⼀个结构体指针用户做⼀次free就可以把所有的内存也给释放掉。 第⼆个好处是这样有利于访问速度 连续的内存有益于提⾼访问速度也有益于减少内存碎⽚。
