站在大佬的肩膀上了解动态内存分配与内存泄漏

已于 2022-09-21 20:00:47 修改
阅读量691 收藏
点赞数
文章标签： c++ c语言
于 2022-08-11 20:49:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45099376/article/details/126287894
版权

目录

1. Linux程序内存结构&内存分配

1.1 栈简介

1.2 堆简介

2. 动态内存分配

2.1 malloc函数  申请动态开辟内存空间

2.2 free函数  释放动态开辟内存空间

2.3 常见的动态内存错误

3. 什么是内存泄漏？

练习一下

3.1 第一题：下列代码存在什么问题？请指出问题并做出相应的修改。

3.2 第二题：下列代码存在什么问题？

3.3 第三题：下列代码存在什么问题？请指出问题并做出相应的修改。

3.4 第四题：下列代码存在什么问题？请指出问题并做出相应的修改。

1. Linux程序内存结构&内存分配

对于一个32位的linux操作系统，他的进程内存分布如下图：

​

内存四区：代码区    全局区    栈区    堆区

1.1 栈简介

栈由编译器自动分配释放 ，用于存放函数的参数值、局部变量等，其操作方式类似于数据结构中的栈。

int main()
{
    int a;
    char b;
    long c;
}
  • 其中函数中定义的局部变量按照先后定义的顺序依次压入栈中，也就是说相邻变量的地址之间不会存在其它变量。
  • 栈的内存地址由高到低向下增长，所以后定义的变量地址低于先定义的变量，比如上面代码中变量 b 的地址小于变量 a 的地址，c 地址小于 b 的地址。
  • 栈中存储的数据的生命周期随着函数的执行完成而结束。
     

1.2 堆简介

堆由开发人员分配和释放， 若开发人员不释放，程序结束时由操作系统回收，分配方式类似于链表。C用malloc (申请)、free (释放)，C++用new (申请)、delete (释放)。参考如下代码：

int main() {
	// C 中用 malloc() 函数申请
	char* p1 = (char *)malloc(10);
	cout << (int*)p1 << endl;		//输出：00000000003BA0C0
	
	// 用 free() 函数释放
	free(p1);
   
	// C++ 中用 new 运算符申请
	char* p2 = new char[10];
	cout << (int*)p2 << endl;		//输出：00000000003BA0C0
	
	// 用 delete 运算符释放
	delete[] p2;
}
  • 其中 p1 所指的 10 字节的内存空间与 p2 所指的 10 字节内存空间都是存在于堆。
  • 堆的内存地址生长方向与栈相反，由低到高向上增长，但需要注意的是，后申请的内存空间并不一定在先申请的内存空间的后面，即 p2 指向的地址并不一定大于 p1 所指向的内存地址，原因是先申请的内存空间一旦被释放，后申请的内存空间则会利用先前被释放的内存，从而导致先后分配的内存空间在地址上不存在先后关系。
  • 堆中存储的数据若未释放，则其生命周期等同于程序的生命周期。
     

2. 动态内存分配

所谓动态内存分配(Dynamic Memory Allocation) 就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。

动态内存开辟是在堆上

为什么会有动态内存开辟呢?     因为有时没办法提前知道所需要多大的存储空间，只有在程序运行的时候才知道，这时在数组编译时开辟空间的方法就无法实现。

2.1 malloc函数  申请动态开辟内存空间

void* malloc (size_t size);             //头文件stdlib.h

  1. 如果开辟成功，则返回一个指向开辟好空间的指针；
  2. 如果开辟失败，则返回一个 NULL 指针；
  3. 返回值的类型为 void* ，malloc 函数并不知道开辟空间的类型，由使用者自己决定；
  4. 如果 size 为 0（开辟0个字节），malloc 的行为是标准未定义的，结果将取决于编译器。
     

2.2 free函数  释放动态开辟内存空间

void free (void*  ptr);             //头文件stdlib.h

  1. 如果参数 ptr 指向的空间不是动态开辟的，那么 free 函数的行为是未定义的；
  2. 如果参数 ptr 是 NULL 指针，那么 free 将不会执行任何动作；
  3. 一定要记得使用 free 函数释放所开辟的内存空间；
  4. 使用指针指向动态开辟的内存，使用完并 free 之后一定要记得将其置为空指针。
//动态内存开辟10个整型空间

#include <stdio.h>
#include <stdlib.h>
 
int main(void) 
{
    // 假设开辟10个整型空间
    int arr[10]; // 在栈区上开辟
 
    // 动态内存开辟
    int* p = (int*)malloc(10*sizeof(int)); // 开辟10个大小为int的空间
 
    // 使用这些空间的时候
    if (p == NULL) {
        perror("main"); // main: 错误信息
        return 0;
    }
    
    // 使用
    int i = 0;
    for (i = 0; i < 10; i++) {
        *(p + i) = i;
    }
    for (i = 0; i < 10; i++) {
        printf("%d ", p[i]);
    }
 
    // 回收空间
    free(p);
    p = NULL; // 需要手动置为空指针
 
    return 0;
}

Q：为什么 free 之后，需要把 p 置成空指针？ p=NULL

A：因为 free 之后那块开辟的内存空间已经不在了，它的功能只是把开辟的空间回收掉，但是 p 仍然还指向那块内存空间的起始位置，所以我们需要使用 p = NULL 把他置成空指针。

Q：为什么 malloc 前面要进行强制类型转换呢？  int* p = (int*)malloc(10*sizeof(int));

A：为了和 int* p 类型相呼应，所以要进行强制类型转换。你可以试着把强转删掉，其实也不会有什么问题。但是因为有些编译器要求强转，所以最好进行一下强转，避免不必要的麻烦。

除了malloc之外，还有calloc、realloc，原作者：柠檬叶子C的博文中有详细介绍，指路http://t.csdn.cn/CoMvW

2.3 常见的动态内存错误

  1. 对空指针进行解引用操作————需要对函数的返回值做判空处理；
  2. 对动态开辟空间的越界访问————即只申请了10个整型空间，但是却要求访问40个；
  3. 对非动态开辟的内存使用free释放————在栈上开辟的空间无需手动释放；
  4. 使用free释放一块动态开辟内存的一部分————必须从头开始释放；
  5. 对同一块动态内存多次释放————第一次free后直接 p = NULL；
  6. 动态开辟内存忘记释放导致内存泄漏。

3. 什么是内存泄漏？

在编写应用程序的时候，程序分配了一块内存，但已经不再持有引用这块内存的对象（通常是指针），虽然这些内存被分配出去，但是无法收回，将无法被其他的进程所使用，我们说这块内存泄漏了，被泄漏的内存将在整个程序声明周期内都不可使用。

主要原因：申请内存后未及时释放。

练习一下

选取 柠檬叶子C 大佬的一些题目进行巩固，呜呜讲的太好了

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;
}

解析：

代码修改：

① 返回 p ，让 str 接收：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
// ↓ 修改返回类型为char*
char* GetMemory(char *p) {
    p = (char*)malloc(100);
    return p; // 将p带回来
}
 
void Test() {
    char *str = NULL;
    str = GetMemory(str); // 用str接收，此时str指向刚才开辟的空间
    strcpy(str, "hello world"); // 此时copy就没有问题了
    printf(str);
    // 用完之后记得free，就可以解决内存泄露问题
    free(str);
    str = NULL; // 还要将str置为空指针
}
 
int main() {
    Test();
 
    return 0;
}

② 将值传递改为址传递：


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
//              ↓ 用char**接收
void GetMemory(char** p) {
    *p = (char*)malloc(100);
}
 
void Test() {
    char *str = NULL;
    GetMemory(&str); // 址传递，就可以得到地址
    strcpy(str, "hello world");
    printf(str);
    // 记得free，就可以解决内存泄露问题
    free(str);
    str = NULL; // 还要将str置为空指针
}
 
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 数组的空间就还给了操作系统，返回的地址是没有实际意义的，如果通过返回的地址去访问内存，就会导致非法访问内存问题。

解析：

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;
}

答案：没有 free，导致内存泄漏。

解析：

 修改：


#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.4 第四题：下列代码存在什么问题？请指出问题并做出相应的修改。

#include <stdio.h>
#include <stdlib.h>
#include <string.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;
}

答案：free 之后没有将 str 置为空指针，导致 if 为真，对已经释放掉的内存进行了访问，引发非法访问的问题。

解析：

修改：

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

参考文章：

1.【操作系统】Linux程序内存结构&内存分配   作者：netlogs  链接：http://t.csdn.cn/uawUX

2.  一文读懂堆与栈的区别   作者：恋喵大鲤鱼     链接：http://t.csdn.cn/bhfa4

3. 【维生素C语言】第十三章 - 动态内存管理    作者：柠檬叶子C    链接：http://t.csdn.cn/CoMvW

4.  c/c++ 内存泄漏   作者：MagicDong   链接：https://www.jianshu.com/p/5770c067a552

5. 【维生素C语言】经典动态内存分配笔试题（题目+答案+详解）   作者：柠檬叶子C     链接：http://t.csdn.cn/aCWuC

TinyHorse！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【循环控制结构 习题练习 计算1*2*3+3*4*5+...+99*100*101的值——苏小红版C语言（第3版）】| C语言面试：如何在C语言中进行动态内存分配和释放？
追光者♂：记录、分享、总结、提升，现象级专栏《Python从入门到人工智能》作者，无惧黑暗，坚信曙光
03-05 2024
目录说明题目运行结果 说明 这是苏小红版C语言的课后习题（第六章）的第二题 的第2小问，即习题6.2（2），为循环控制结构。可供初学者食用，已经经过运行。题目过于简单，编程界大佬请忽略。 题目 编程计算 1*2*3 + 3*4*5 +...+ 99*100*101 的值 编写C语言代码如下： #include <stdio.h> int main(){ long i; long term,sum=0; for(i=1;i<100;i+=2){ term=i*(i+1)*(i
动态内存、智能指针（shared_ptr、unique_ptr、weak_ptr）、动态数组
Jormungand_V的博客
04-18 2623
文章目录三种对象的分类三种内存的区别动态内存shared_ptr类格式独有的操作make_shared函数shared_ptr的计数器使用了动态生存期的资源的类 三种对象的分类 三种对象： 全局对象在程序启动时分配，在程序结束时销毁。 局部自动对象，当我们进入其定义所在的程序块时被创建，在离开块时销毁。 局部static对象在第一次使用前分配，在程序结束时销毁。 三种内存的区别 静态存储区：主要存放static静态变量、全局变量、常量。这些数据内存在编译的时候就已经为他们分配好了内存，生命周期是整个
动态内存泄漏
wwj923000的博客
05-29 395
动态内存泄露分析时间：2017年9月29日 周五1、内存泄露通常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的、大小任意的（内存块的大小可以在程序运行期决定），使用完后必须显式释放的内存。创建对象时，用alloc、new、copy等方法从堆中分配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存块，否则，这块内存就不能被再次使用，我们就说这块内存泄漏了。如果程序...
常见动态内存错误---内存泄漏
lanzh_
10-03 2258
交流学习！
动态内存分配导致内存泄漏之处
weixin_30493401的博客
07-07 388
摘要：举了几个动态内存分配过程中，发生内存泄漏的例子 1. 分配了内存，却没有及时删除,导致泄漏 1: void doSomething() 2: { 3: int *pnValue = new int; 4: } 2. 为指针变量分配了一个内存，然后又让指针变量指向其他的值,导致泄漏 1: int nValue = 5;...
内存泄露
无与伦比BLOG
05-21 973
在编程时进行动态内存分配是非常必要的。它可以在程序运行的过程中帮助分配所需的内存，而不是在进程启动的时候就进行分配。然而，有效地管理这些内存同样也是非常重要的。在大型的、复杂的应用程序中，内存泄漏是常见的问题。当以前分配的一片内存不再需要使用或无法访问时，但是却并没有释放它，那么对于该进程来说，会因此导致总可用内存的减少，这时就出现了内存泄漏。尽管优秀的编程实践可以确保最少的泄漏，但是根据经验，当
动态内存分配、释放和内存泄露
骑猪看彩虹的博客
08-02 417
List item
深大操作系统实验三：crash 与地址转换，内存分配与回收，物理页帧的竞争
AKGWSB 's blog
05-10 5564
1. 利用 crash 展示和解说一个虚地址经过页表逐级转换的过程 2. 分配内存，释放内存形成孔洞，记录该进程的虚存空间变化，验证进程空间的内存分配算法 3. 测试出你的系统单个进程所能分配到的最大虚拟内存空间为多大 4. 每隔4KB间隔将相应地址进行读操作，然后重复上面操作，不过此时为读操作，再观察其变化 5. 展示两个进程的物理页帧竞争的动态变化过程 6. 验证快表
Android的内存分配、管理、OOM这一篇文章就够够的了！
weixin_39079048的博客
03-12 1195
Android的内存分配和管理为两个大板块： （Android手机系统和手机应用APP） 一、Android 手机系统的内存分配和管理 主要3点内容介绍 -Android 系统的低内存工作机制： -Android 应用内存的使用情况： -如何减少Android 应用内存的占用： 1、Android 系统的低内存工作机制： 首先给大家提出一个问题，为什么有的手机打开应用多了，在使用的时候回特别卡呢。...
C++动态内存管理
qq_61500888的博客
05-27 3143
带你一命通关C++内存管理 十分钟手撕C++底层原理
一种MFC误报动态库中内存泄露的处理方法
tumin999的专栏
03-29 1480
关于MFC误报动态库中的内存泄露，在这篇文章中有比较详细的解释：关于DLL工程中存在全局变量可能导致MFC内存泄露误报的原因分析及解决办法。认为这种原因是因为MFC的dll早于调用的dll卸载，在MFC的dll泄露时会打印出当前尚未释放的内存，认为这些内存泄露，但事实上当后来真正卸载调用动态库时是正确做了内存清理的。因此文章中认为这个问题是隐式的动态库卸载顺序造成的。解决办法是重新配置调用的dll
C/C++ new/delete []、内存泄漏、动态数组
weixin_30335575的博客
08-22 190
一、概念 　　new/delete是用于动态分配和撤销内存的运算符。new/delete是c++里才有的，c中是用malloc和free，c++虽然也可以用，但是不建议用。当我们使用关键字new在堆上动态创建一个对象时，它实际上做了三件事：获得一块内存空间、调用构造函数、返回正确的指针。当然，如果我们创建的是简单类型的变量，那么第二步会被省略。删除一个指针p（delete p）实际意思是删除了p...
动态内存泄漏的常见问题及两种改进方法
m0_57180439的博客
10-08 264
前言 今天遇见了一道有意思的内存泄露题目，特地分享给大家，相信屏幕前的你学习完一定有所收获，预祝读者学习愉快 一、例题 试问该段代码能打印什么，或者不能打印什么，说出理由 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #include<stdlib.h> void getmemory(char*p) { p = (char*)malloc(100); } void test(.
[c++]动态分配内存和内存泄漏
LumenWang
03-27 671
动态分配内存 1. new 和 delete 函数原型： void *operator new(size_t); //allocate an object void *operator delete(void *); //free an object 1.1 new和delete的运行机制（单个对象） 以类A为例： class A { public: A(int v) ...
动态内存分分配（malloc、free、calloc、realloc）
m0_60416282的博客
06-30 194
1. malloc 和free函数 2. calloc函数3. realloc函数，对内存的大小进行调整
C++ 内存管理中内存泄漏问题产生原因以及解决方法
最新发布
weixin_42492218的博客
05-06 1928
C++内存管理中内存泄露（memory leak）一般指的是程序在申请内存后，无法释放已经申请的内存空间，内存泄露的积累往往会导致内存溢出。
容易发生内存泄漏的八个场景，你都知道吗？
Java技术攻略的博客
02-28 594
这篇文章介绍内存泄漏与内存溢出的区别，并从生命周期变长、不关闭资源、改变哈希值、缓存等多方面举例内存泄漏的场景内存泄漏是指当对象不再使用，但是GC无法回收该对象内存溢出是指当大量对象内存泄漏，没有资源再给新对象分配静态集合、饿汉单例、不合理的设置变量作用域都会使对象生命周期变长，从而导致内存泄漏非静态内部对象有隐式指向外部对象的指针、使用集合不删除元素等都会隐式导致内存泄漏忘记关闭资源导致内存泄漏（try-with-resource自动关闭解决）
c指针作为参数传递以及指针的指针
aifuxun2845的博客
04-06 170
指针作为函数参数传递 函数参数传递的只能是数值，所以当指针作为函数参数传递时，传递的是指针的值，而不是地址。 #include "stdio.h" void pointer(int *p) { int a = 11; printf("\n\nEnter function"); printf("\nthe p is point to %p , addr is...
【C/C++】——修改指针的值
怡宝2号
02-18 1673
转载自:https://blog.csdn.net/qq_22525091/article/details/80116128 code #include<stdio.h> #include<stdlib.h> void GetMemory(char *p, int num) { p = (char *)malloc(sizeof(char) * num); } void Test(void) { char *str = NULL; GetMemo.
"业界大佬编写的内存数据库综述：主内存数据库系统
本文是由业界大佬编写的内存数据库综述，详细介绍了主内存数据库系统。主内存数据库系统是一种在计算机内存中存储和操作数据的数据库管理系统，相比传统的磁盘存储数据库系统具有更高的性能和吞吐量。本文由SAP的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值