当前位置： 首页 > wzjs >正文

襄阳万家灯火网站建设重庆seo推广服务

wzjs 2025/8/16 22:31:40
襄阳万家灯火网站建设,重庆seo推广服务,南庄建网站,八年级信息所用软件做网站目录 一、 为什么存在动态内存分配 二、动态内存函数的介绍 1.malloc （void* malloc (size_t size);） ①malloc 函数介绍： ②malloc函数的使用： ③注意事项：malloc函数是需要进行内存释放的，虽然在程…

目录

一、 为什么存在动态内存分配

二、动态内存函数的介绍

1.malloc （void* malloc (size_t size);）

①malloc 函数介绍：

②malloc函数的使用：

③注意事项：malloc函数是需要进行内存释放的，虽然在程序结束后内存会自动释放，但是如果程序一直没有结束那么需要自己先释放

2.free函数（void free (void* ptr);）

①free函数介绍：

②free函数的使用：

③注意事项：如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。如果参数 ptr 是NULL指针，则函数什么事都不做。

3. calloc函数（void* calloc (size_t num, size_t size);//开辟num个大小为size 的空间）

①calloc函数介绍（void* realloc (void* ptr, size_t size);）：

②calloc函数的使用：

③注意事项：

（一）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。realloc在调整内存空间的是存在两种情况：

三、常见的动态内存错误

1.解引用空指针

2 对动态开辟空间的越界访问

3 对非动态开辟内存使用free释放

4 使用free释放一块动态开辟内存的一部分

5 对同一块动态内存多次释放

6 动态开辟内存忘记释放（内存泄漏）

四、几个经典的动态内存分配的笔试题

五、C/C++程序的内存开辟

六、柔性数组

 1.柔性数组的特点：

2 柔性数组的使用

3 柔性数组的优势

一、 为什么存在动态内存分配

int val = 20;//在栈空间上开辟固定的四个字节
char arr[10] = {0};//在栈空间上开辟固定10个字节的连续空间
但是上述的开辟空间的方式有两个特点：
1. 空间开辟大小是固定的。
2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

二、动态内存函数的介绍

这些函数都是在堆区存放的,使用时需要stdlib.h

1.malloc （void* malloc (size_t size);）

①malloc 函数介绍：

  • 这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。如果开辟成功，则返回一个指向开辟好空间的指针。
  • 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
  • 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
  • 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

②malloc函数的使用：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{//申请40个字节用来存放10个整型，需强制类型转换因为malloc返回的是void*int* p = (int*)malloc(40);//需要判断是否申请成功if (p == NULL){printf("%s\n", strerror(errno));}//存放1~10for (int i = 0; i < 10; i++){*(p + i) = i + 1;printf("%d ", *(p + i));}
}

③注意事项：malloc函数是需要进行内存释放的，虽然在程序结束后内存会自动释放，但是如果程序一直没有结束那么需要自己先释放

2.free函数（void free (void* ptr);）

①free函数介绍：

free函数用来释放动态开辟的内存。
联想退房：把酒店的房间使用权还给酒店，房间还在那。但是和退房还是有区别，free是你把房卡没有还给酒店，你还可以通过房卡再次进入酒店，但是这个行为是非法的，而且你在房间放的东西也有可能不见了

②free函数的使用：

#define _CRT_SECURE_NO_WARNINGS 1
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
int main()
{//申请40个字节用来存放10个整型，需强制类型转换因为malloc返回的是void*int* p = (int*)malloc(40);//需要判断是否申请成功if (p == NULL){printf("%s\n", strerror(errno));retrurn 1；}//存放1~10for (int i = 0; i < 10; i++){*(p + i) = i + 1;printf("%d ", *(p + i));}free(p);p = NULL;//在释放p地址对应的后面的空间后，p地址空间还没有释放，为了防止p被非法访问，需要将p置为空
}

③注意事项：如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。如果参数 ptr 是NULL指针，则函数什么事都不做。

3. calloc函数（void* calloc (size_t num, size_t size);//开辟num个大小为size 的空间）

①calloc函数介绍（void* realloc (void* ptr, size_t size);）：

realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。
ptr 是要调整的内存地址，size 调整之后新大小，返回值为调整之后的内存起始位置。

②calloc函数的使用：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{int* p = (int*)calloc(10, sizeof(int));if (NULL == p){perror("calloc");return 1;}for (int i = 0; i < 10; i++){*(p + i) = i;printf("%d " ,*(p + i));}free(p);p = NULL;return 0;
}

malloc申请到空间，没有初始化，直接返回起始地址

callloc申请好后，，会把空间初始化为0，然后返回起始地址

③注意事项：

（一）这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间可以扩容，直接在后面续上新的空间返回旧的起始地址
情况2：原有空间之后没有足够大的空间，扩展的方法是：在堆空间上另找一个合适大小的连续空间，把旧的空间的数据拷贝到新空间的前面的位置，并且把旧的空间释放掉，同时返回的是一个新的内存地址。
由于上述的两种情况，realloc函数的使用就要注意一些。

首先看下面代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{int* p = (int*)malloc(10, sizeof(int));if (NULL == p){perror("calloc");return 1;}for (int i = 0; i < 10; i++){*(p + i) = i;printf("%d " ,*(p + i));}//假如空间不够了，需要增加五个整型的空间int* ptr = (int*)realloc(p, 10 * sizeof(int));if (ptr != NULL){p = ptr;}free(p);p = NULL;return 0;
}
所以为什么不能写成* p = ( int*)realloc(p, 10 * sizeof( int));?
realloc在扩容的时候万一失败呢？-->直接返回NULL，如果用旧的指针维护它，这样会把扩容前的数据丢失
运行结果如下：
int *p=(int *)realloc(NULL,40); 功能和malloc是一样的
也可以根据自己输入的值来开辟大小
scanf count
int *p=(int *)malloc(count*sizeof(int));
malloc、calloc、realloc、free、在内存中申请空间是通过操作系统提供的接口调用的（系统调用）

三、常见的动态内存错误

1.解引用空指针

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
int main()
{int* p = (int*)malloc(100);for (int i = 0; i < 20; i++){*(p + i) = 0;}free(p);p = NULL;return 0;
}
这种操作是非常危险的，万一p指针开辟失败了为空，那么解引用就非法
malloc返回值一定要判断
修改后代码如下： 
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{int* p = (int*)malloc(100);//malloc 返回值一定要判断if (p == NULL){printf("%s", strerror(errno));}for (int i = 0; i < 20; i++){*(p + i) = 0;}free(p);p = NULL;return 0;
}

2 对动态开辟空间的越界访问

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{int* p = (int*)malloc(100);//malloc 返回值一定要判断if (p == NULL){printf("%s", strerror(errno));return 1;}for (int i = 0; i < 100; i++){*(p + i) = 0;}free(p);p = NULL;return 0;
}

写的100个字节结果要访问100*sizeof(int)(400)个字节的空间

3 对非动态开辟内存使用free释放

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include<errno.h>
int main()
{int a = 10;//栈区int* p = &a;free(p);p = NULL;return 0;
}

4 使用free释放一块动态开辟内存的一部分

void test()
{
int *p = (int *)malloc(100); p++;
free(p);
}

此时的p不再指向动态内存的起始位置

5 对同一块动态内存多次释放

void test()
{
int *p = (int *)malloc(100); free(p);
free(p);//重复释放
}

6 动态开辟内存忘记释放（内存泄漏）

void test()
{
int *p = (int *)malloc(100); if(NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while(1);
}

四、几个经典的动态内存分配的笔试题

下面代码运行后会有什么样的结果？

（一）

#define _CRT_SECURE_NO_WARNINGS 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;
}

答：什么都不会打印

①形参只是实参的一份零时拷贝，改变p并不会改变str。
②存在内存泄漏的问题，函数在调用完后会销毁，malloc函数还来得及释放
改错： 
#define _CRT_SECURE_NO_WARNINGS 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);free(str);str = NULL;
}
int main()
{test();return 0;
}

（二）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(void)
{char p[] = "hello world";return p;
}
void test()
{char* str = NULL;str = GetMemory();printf(str);
}
int main()
{test();return 0;
}

str为数组首元素的地址，但是在出函数后内容被销毁，再printf后就非法访问空间

这类问题被称为返回栈空间的地址问题

修改：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(void)
{static char p[] = "hello world";return p;
}
void test()
{char* str = NULL;str = GetMemory();printf(str);
}
int main()
{test();return 0;
}

（三）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(char **p,int num)
{*p = (char*)malloc(num);
}
void test()
{char* str = (char *)malloc(100);strcpy(str, "hello");free(str);if (str != NULL){strcpy(str, "world");printf(str);}
}
int main()
{test();return 0;
}

野指针非法访问，当cpy world的时候，那块空间已经释放了

修改：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* GetMemory(char **p,int num)
{*p = (char*)malloc(num);
}
void test()
{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;
}

五、C/C++程序的内存开辟

        

C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

六、柔性数组

C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

例如：

typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;

 1.柔性数组的特点：

①结构中的柔性数组成员前面必须至少一个其他成员（为了好分配空间）。
②sizeof 返回的这种结构大小不包括柔性数组的内存。
③包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
例如： 
//code1
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;printf("%d\n", sizeof(type_a));//输出的是4

2 柔性数组的使用

//code1
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;printf("%d\n", sizeof(type_a));//输出的是4
int i = 0;
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));//业务处理
p->i = 100;
for(i=0; i<100; i++)
{
p->a[i] = i;
}
free(p);

这样柔性数组成员a，相当于获得了100个整型元素的连续空间。

3 柔性数组的优势

上述的 type_a 结构也可以设计为：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct st_type
{int i;int* p_a;
}type_a;
int main()
{type_a* p = (type_a*)malloc(sizeof(type_a));p->i = 100;p->p_a = (int*)malloc(p->i * sizeof(int));//业务处理for (int i = 0; i < 100; i++){p->p_a[i] = i;}//增容type_a *ptr=(type_a*)realloc(p, sizeof(type_a) + 20 * sizeof(char));if (ptr != NULL){p = ptr;}else{return 1;}//释放空间free(p->p_a);p->p_a = NULL;free(p);p = NULL;return 0;
}
上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处：
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正
你跑不了要用做偏移量的加法来寻址）
http://www.dtcms.com/wzjs/303727.html

相关文章：

  • 福州网站设计大概多少钱系统优化助手
  • 湖南中小企业建站价格推推蛙seo
  • 乡政府网站建设实施方案谷歌seo外包
  • 网站制作属于什么科目自媒体平台注册入口官网
  • 珠海市网站建设开发公司海会网络做的网站怎么做优化
  • wordpress 更改 虚拟目录百度seo搜索营销新视角
  • html5网站是用什么软件做的广州抖音推广公司
  • 深圳怎么建设网站怎么理解搜索引擎优化
  • 图书馆网站开发的前期准备zac博客seo
  • 什么网站免费可以做app公司品牌宣传
  • 做网站 信息集成过程的顺序2023新闻大事件摘抄
  • appmakr手机版福州seo结算
  • asp装修网站源码营销策略有哪几种
  • 制作英文网站案例网络营销主要特点有哪些
  • 有什么网站可以做名片邢台市seo服务
  • 网站图片怎么做优化seo的基本工作内容
  • 支付网站建设费进什么科目网站收录怎么弄
  • 网站年报公示怎么做b2b免费发布信息网站
  • 江苏网站建设工作室百度商家平台客服电话
  • 东山县建设银行网站免费seo营销软件
  • 怎样用电脑ip做网站电商网站入口
  • wordpress固定地址404奉节县关键词seo排名优化
  • 做网站须要什么技术外贸业务推广
  • 网站备案 备注搜索引擎优化实验报告
  • 网站首页logo怎么修改关键词诊断优化全部关键词
  • 衢州网站建设招聘学编程的正规学校
  • 天津手机网站公司学电脑办公软件培训班
  • 河南网站建设软件网站的开发流程
  • 网站建设多少钱杭州百度云搜索引擎入口盘搜搜
  • wap 网站模板营销自动化工具