delete void* 造成内存泄漏

于 2023-12-06 13:13:00 发布
阅读量28 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingxingdi/article/details/134945294
版权

见这篇文章

同理，结构体也可能会有类似问题

void* 指向一个数组时，不加[]也可能会有类似问题

如何解决？手动调用析构函数或者说手动删除结构体或类里面的指针所指向的内容

dingxingdi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MFC中解决子线程中打开非模态对话框内存泄漏实例（VC++2008）
03-27
子线程中打开非模式对话框内存泄漏问题 这个问题困扰已久 网上没有完整的解决方案；现将实例源代码分享给大家 希望对您有帮助 （代码是VS2008下编写的） 问题原因： 对话框的默认关闭方式模式对话框关闭 而现在是以非模式对话框方式打开 所以关闭的时候要把模式对话框的处理屏蔽 解决方案如下： 重写对话框的PostNcDestroy OnClose OnDestroy 具体代码如下： void CMyDlg::PostNcDestroy { TODO: 在此添加专用代码和 或调用基类 delete this; CDialog::PostNcDestroy ; } void CMyDlg::OnClose { TODO: 在此添加消息处理程序代码和 或调用默认值 this >DestroyWindow ; CDialog::OnClose ; } void CMyDlg::OnDestroy { CDialog::OnDestroy ; PostQuitMessage 0 ; TODO: 在此处添加消息处理程序代码 } 另外默认的Ok Cancel按钮换成 void CMyDlg::OnBnClickedOk { TODO: 在此添加控件通知处理程序代码 OnOK ; this >DestroyWindow ; } void CMyDlg::OnBnClickedCancel { TODO: 在此添加控件通知处理程序代码 OnCancel ; this >DestroyWindow ; }">子线程中打开非模式对话框内存泄漏问题 这个问题困扰已久 网上没有完整的解决方案；现将实例源代码分享给大家 希望对您有帮助 （代码是VS2008下编写的） 问题原因： 对话框的默认关闭方式模式对话框关闭 而现在 [更多]
vld(Visual Leak Detector 内存泄露检测工具 源码)
12-16
初识Visual Leak Detector 　　灵活自由是C/C++语言的一大特色，而这也为C/C++程序员出了一个难题。当程序越来越复杂时，内存的管理也会变得越加复杂，稍有不慎就会出现内存问题。内存泄漏是最常见的内存问题之一。内存泄漏如果不是很严重，在短时间内对程序不会有太大的影响，这也使得内存泄漏问题有很强的隐蔽性，不容易被发现。然而不管内存泄漏多么轻微，当程序长时间运行时，其破坏力是惊人的，从性能下降到内存耗尽，甚至会影响到其他程序的正常运行。另外内存问题的一个共同特点是，内存问题本身并不会有很明显的现象，当有异常现象出现时已时过境迁，其现场已非出现问题时的现场了，这给调试内存问题带来了很大的难度。 　　Visual Leak Detector是一款用于Visual C++的免费的内存泄露检测工具。相比较其它的内存泄露检测工具，它在检测到内存泄漏的同时，还具有如下特点： 　　1、 可以得到内存泄漏点的调用堆栈，如果可以的话，还可以得到其所在文件及行号； 　　2、 可以得到泄露内存的完整数据； 　　3、 可以设置内存泄露报告的级别； 　　4、 它是一个已经打包的lib，使用时无须编译它的源代码。而对于使用者自己的代码，也只需要做很小的改动； 　　5、 他的源代码使用GNU许可发布，并有详尽的文档及注释。对于想深入了解堆内存管理的读者，是一个不错的选择。 　　可见，从使用角度来讲，Visual Leak Detector简单易用，对于使用者自己的代码，唯一的修改是#include Visual Leak Detector的头文件后正常运行自己的程序，就可以发现内存问题。从研究的角度来讲，如果深入Visual Leak Detector源代码，可以学习到堆内存分配与释放的原理、内存泄漏检测的原理及内存操作的常用技巧等。 　　本文首先将介绍Visual Leak Detector的使用方法与步骤，然后再和读者一起初步的研究Visual Leak Detector的源代码，去了解Visual Leak Detector的工作原理。 　　使用Visual Leak Detector(1.0) 　　下面让我们来介绍如何使用这个小巧的工具。 　　首先从网站上下载zip包，解压之后得到vld.h, vldapi.h, vld.lib, vldmt.lib, vldmtdll.lib, dbghelp.dll等文件。将.h文件拷贝到Visual C++的默认include目录下，将.lib文件拷贝到Visual C++的默认lib目录下，便安装完成了。因为版本问题，如果使用windows 2000或者以前的版本，需要将dbghelp.dll拷贝到你的程序的运行目录下，或其他可以引用到的目录。 　　接下来需要将其加入到自己的代码中。方法很简单，只要在包含入口函数的.cpp文件中包含vld.h就可以。如果这个cpp文件包含了stdafx.h，则将包含vld.h的语句放在stdafx.h的包含语句之后，否则放在最前面。如下是一个示例程序： 　　#include 　　void main() 　　{ 　　… 　　} 　　接下来让我们来演示如何使用Visual Leak Detector检测内存泄漏。下面是一个简单的程序，用new分配了一个int大小的堆内存，并没有释放。其申请的内存地址用printf输出到屏幕上。 　　#include 　　#include 　　#include 　　void f() 　　{ 　　int *p = new int(0x12345678); 　　printf("p=%08x, ", p); 　　} 　　void main() 　　{ 　　f(); 　　} 　　编译运行后，在标准输出窗口得到： 　　p=003a89c0 　　在Visual C++的Output窗口得到： 　　WARNING: Visual Leak Detector detected memory leaks! 　　---------- Block 57 at 0x003A89C0: 4 bytes ---------- --57号块0x003A89C0地址泄漏了4个字节 　　Call Stack: --下面是调用堆栈 　　d:\test\testvldconsole\testvldconsole\main.cpp (7): f --表示在main.cpp第7行的f()函数 　　d:\test\testvldconsole\testvldconsole\main.cpp (14): main –双击以引导至对应代码处 　　f:\rtm\vctools\crt_bld\self_x8
c++11智能指针
01-06
智能指针     智能指针是行为类似于指针的类对象。可以帮助管理动态内存分配。普通指针分配内存后都必须释放内存 new 之后需要使用 delete 否则内存泄漏。智能指针类对象封装了自动释放内存的功能 从而避免内存泄漏 例如 void remodel(std::string & str) { std::string * ps = new std::string(str); //str = ps; return; //内存泄漏 } void remodel1(std::string & str1) { std::shared_ptr ps(new std::string(str1))
C++智能指针原理.pdf
02-27
C++智能指针原理 C++智能指针 1. 智能指针原理 采⽤C++ Primer Plus中作者引出智能指针的⽅式进⾏说明，感觉超好。 ⾸先看2个函数： //函数1 void remodel(std::string & str) { std::string * ps = new std::string(str); ... str = ps; return; } //函数2 void remodel(std::string &str) { std::string * ps = new std::string(str); ... if (weird_thing()) throw exception(); str = *ps; delete ps; return; } 上⾯，函数1每次调⽤都在堆中申请内存，但从未收回，铁定内存泄漏；函数2虽然使⽤了异常，但是代码中出现异常时，delete将不执 ⾏，因此也仍会导致内存泄漏。 分析⼀下问题在哪？ 其实不论上⾯remodel()函数是正常终⽌还是异常终⽌的，函数中的指针变量ps⾃⼰占据的内存都将从栈内存中删除，⽽ps指向的新申请到 的堆内存却没有被释放，导致了内存泄漏。所以啊，我们就在想当指针ps⾃⼰占据的内存被释放的时候，它指向的内存也被释放该多好啊。 但问题是ps现在是⼀个常规指针，它⽆法做到这⼀点。那C++中我们想的这件事情谁能帮我们做到呢？那就是类对象的析构函数，当ps是 ⼀个类对象的时候，在ps过期时，它的析构函数释放掉它所指的内存不就完成我们上⾯想要的事情了嘛！这正是C++智能指针的原理！！ 这个原理就是：⽤具有析构函数的类对象充当指针，当该指针过期时，它的析构函数释放掉它所指的堆内存。 2. C++中4种智能指针模版类的区别 C++中4种智能指针模版类：auto_ptr，unique_ptr，shared_ptr，weak_ptr。 这4种智能指针也全都是基于上⾯的原理实现的。当使⽤这些指针时，是不需要我们⼿动使⽤delete去释放指针所指内存的。 简单的使⽤实例：记得包含头⽂件memory #include <memory> void remodel(std::string &str) { std::string * ps = new std::string(str); str = *ps; return; } 接下来思考⼀个问题，如果你基于上⾯智能指针的思想实现了⼀个智能指针模版类mysmart_ptr。假设使⽤它进⾏内存管理，看下⾯的赋 值语句： mysmart_ptr<string> ps (new string("I reigned lonely as a cloud.")); mysmart_ptr<string> vocation; vocation = ps; 上⾯ps和vocation将指向同⼀个string对象，这样的话，当程序结束时可能会出现删除同⼀个对象两次的现象——⼀次是ps过期时，另⼀ 次是vocation过期的时候，如果想避免这样的问题的话，我们需要想⼀下怎么解决？其实这样的⽅法有多种： 1. 定义赋值运算符，使之执⾏深拷贝。这样两个指针将指向不同的对象，其中的⼀个对象是另⼀个对象的副本。 2. 建⽴所有权(ownership)概念，对于特定的对象，只能有⼀个智能指针可拥有它，这样只有拥有对象的智能指针的构造函数会删除该 对象。然后，让赋值操作转让所有权。这就是⽤于auto_ptr和unique_ptr的策略，但unique_ptr的策略更严格。 3. 创建智能指针更⾼的指针，跟踪引⽤特定对象的智能指针数。这称为引⽤计数(reference counting)。例如，赋值时，计数将加1， ⽽指针过期时，计数将减1。仅当最后⼀个指针过期时，才调⽤delete。这是shared_ptr采⽤的策略。 当然，同样的策略也适⽤于复制构造函数。每种⽅法都有其⽤途。 auto_ptr和unique_ptr： 上⾯也提到了，⽆论是auto_ptr还是unique_ptr，都是基于所有权的概念去解决可能出现的删除⼀个对象两次的问题的。这种情况下会有 什么问题呢？先看auto_ptr，看⼀个⼩例⼦： auto_ptr<string> films[2] = { auto_ptr<string> (new string("Fowl Balls")), auto_ptr<string> (new string("Duck Walks")) }; auto_ptr<string> pwin; pwin = films[0];//注：films[0]对内存失去了所有权 cout << films[0] << endl;//注：会出现错误，因为film[0]指向的内存此时已经
C++程序内存泄露检测工具
01-20
功能： 　　用于检?c++程序的内存泄露。 　　原理： 　　事实上非常easy，是通过函数的重载机制，捕获应用程序的new， new[] ， delete ， delete[]， malloc，calloc，free等内存操作函数。 　　特点: 　　因为在检?的过程中，须要记录用户程序内存分配信息，所以工具本身必须进行内存动态分配。为了提高内存分配效率，程序实现了两个链表。 　　1、空暇链表，事实上是一个简单的内存池 //定义一个结构，保存内存分配信息 typedef struct _tagMemoryInfo {     void* addr;          //保存
delete void* 释放内存问题（C++）
zhangpiu的专栏
12-30 7960
有时候我们可能遇到将一个指向一块堆内存的类型指针转为 void* 类型的情况，这时候如果直接 delete void* 会出现什么情况呢？我们先用一段代码说明问题： class mycalss { public: mycalss() : data(new int[100]){} ~mycalss() { delete[] data; } private: int *data; }
C++随笔 delete void *
xiaokepc_921112的专栏
01-30 400
用了这么久的C++，才发现C++是目前所有的编成语言中最为复杂的一种，C++之路,   艰难.....        delete void *        这一操作对于一些简单的系统内建类型不会有问题，但如果void*所指向的对象在析构函数里要释放，进行此造作会丢失内存，因为它不执行析构函数，例如：               class CEntity { public:
C++：delete void*问题
weixin_53762042的博客
07-28 670
#define _CRT_SECURE_NO_WARNINGS 2 #include 3 #include <string.h> 4 #include 5 using namespace std; 6 class Person 7 { 8 public: 9 Person(int age,char *str) 10 { 11 cout << “有参构造” << endl; 12 mAge = age; 13 name = (char *)malloc(strlen(s
[C++]void* 类型指针能否使用 delete 释放空间
的专栏
02-23 2147
void* 类型指针能否使用 delete 释放空间? 答案是取决于指向的对象: // 只包含基本类型 typedef struct A { char name[32]; int age; double score; } A; // 包含指针和对象 typedef struct B { char *name; int age; double score; std::string addr; } B; // 与 B 一样包含对象 typedef struct C { char name[3
c++ delete void*
guoliangyujunfei的专栏
11-15 1696
附注：在C语言中，void*型的指针与其它类型的指针直接互相赋值，不用强制转换；在C++中，从其它类型的指针到void*的赋值不用强制转换，但从void *到其它类型的指针的赋值需要强制转换。 正文： 前一段时间看代码：  RESULT SWF_Storage_FreeFile(void *pBuffer) { if (pBuffer) delete[] pBuffer; re
警惕“delete void*”
不是码农
11-22 7553
对一个void*类型指针进行delete操作会出错，除非指针所指的内容是简单类型内容，因为这个操作只会释放内存，而不会执行析构函数 下面是一个代码示例： //:BadVoidPointerDeletion.cpp #include using namespace std; class Object { void* data; // Some storage const int si
void*指针及delete释放void*内存(转)
u011595231的专栏
11-25 6938
转自： http://blog.163.com/xuelinxu@126/blog/static/7117728220088102340679/ 在面向对象语言中，明白什么叫“对象”非常重要，其实最根本最贴切的含义应该是：“对象就是一块命了名的存储空间”。当我们定义 （define）一个对象的时候，系统会在栈中给我们的应用程序分配一块内存，用于存储对象的信息。但是当我们用new操作
delete void *指针的问题
最新发布
sunfanup的博客
08-15 308
在您的代码中，data 被声明为 void* 类型。来释放内存时，编译器无法确定 data 指向的数组的元素类型。来释放内存时，编译器能够确定 data 指向的数组的元素类型，并正确地释放内存。在 C++ 中，当您使用 new[] 运算符动态分配一个数组时，您必须使用数组形式的 delete[] 运算符来释放该数组所占用的内存。然而，为了正确地使用 delete[] 运算符，您必须提供一个指向数组元素类型的指针。在这一行中，您试图使用数组形式的 delete 运算符来释放 data 指向的内存。
delete void pointer
weixin_30421809的博客
10-17 185
delete void pointer是否会有内存泄漏？ 看下面一个简单例子 class Test{ public: Test(){ printf ("constructor\n"); } ~Test(){ printf("destructor"); } }; int main(int argc, char *argv[]) { Test *p ...
如何在delete一个void *对象后有效执行析构函数
zgjxhgh
07-16 867
正常情况下： classT *pA = new classT(); delete pA; 很容易实现完成。 如下代码就会有些需要注意的地方： classT *pA= new classT(); void *pHandle = pA; delete pHandle;  //这里就不能有效的执行析构函数，可能会造成内存泄漏。 怎么办呢？ 其实和很简单，如下就可以。 delete (
delete一个void*可能会造成泄漏内存
桑海的专栏
01-02 5630
一个论坛上看到k2eats对着个问题的回答，受益匪浅; delete void*在删除内建类型是没有问题的．系统在malloc()的时候已经在分配的内存块记录了分配内存的大小，所以不存在不知道不知道释放多少内存的说法 本身不会泄露内存，因为： 在堆中分配内存的时候，空闲内存是按照链表连接起来的，释放内存则将内存块链到空闲链上面去， 关键是分配的时候不只是分配你所需求的内存大
delete 类对象指针的注意事项]
weixin_30556959的博客
10-22 1421
http://blog.csdn.net/infoworld/article/details/45560219 场景:1. C++类有构造和析构函数,析构函数是在类对象被delete时(或局部变量自动销毁时)调用来释放资源。2. C++类对象指针很多情况下需要赋值给void*通用指针来达到传输对象的目的,但是往往这种void*指针就是造成内存泄漏或程序错误的根源，这就是为什么C++存在泛型的目的...
c++万能但释放内存时痛苦的void *指针及替代方案
zmlovelx(帅得不敢出门 程序员群31843264)
11-11 2094
void *在c/c++中可以说是万金油的存在，无论什么类型的数据都可以塞给它，但是释放的时候，却需要知道具体的类型，才能调用delete去释放，直接delete void *的指针是未定义的有可能会导致内存泄露。 如果编译器支持c++17, 可用std::any来代替void *， 如果编译器只支持c++ 11可以用shared_ptr来替代。下面以shared_ptr来做为例子 释放void *要知道原来申请的对象是什么类型，伪代码如下： void *p = new xx; if p is A:
请参考我给出的代码框架，实现对EMPLOYEE结构体为数据的双向链表的排序算法，要求按照按employeeId升序排列 typedef struct linkNode { void* data; //使用空指针使得NODE适配多种数据结构 struct linkNode* preNode; struct linkNode* nextNode; }LINKED_NODE; /*Define the struct of double linked list.*/ typedef struct { LINKED_NODE* head; LINKED_NODE* tail; size_t size; }DOUBLE_LINK_LIST; typedef struct { int employeeId; char name[20]; char ipAddress[30]; char seatNumber[20]; char group[10]; } EMPLOYEE; DOUBLE_LINK_LIST* createDoubleLinkedList() { DOUBLE_LINK_LIST* newList = (DOUBLE_LINK_LIST*)malloc(sizeof(DOUBLE_LINK_LIST)); newList->head = NULL; newList->tail = NULL; newList->size = 0; return newList; } void destroyDoubleLinkedList(DOUBLE_LINK_LIST* list) {} /*Add a new node before the head.*/ void insertHead(DOUBLE_LINK_LIST* list, void* data) // void执政适配其他data类型？ {} /*Add a new node after tail.*/ void insertTail(DOUBLE_LINK_LIST* list, void* data) // 如何适配其他data类型？ {} /*Insert a new node.*/ void insertNode(DOUBLE_LINK_LIST* list, void* data,int index) // 如何适配其他data类型？ {} void deleteHead(DOUBLE_LINK_LIST* list) {} void deleteTail(DOUBLE_LINK_LIST* list) {} void deleteNode(DOUBLE_LINK_LIST* list, int index) {} LINKED_NODE* getNode(DOUBLE_LINK_LIST* list, int index) {} /* 遍历链表，对每个节点执行指定操作*/ void traverseList(DOUBLE_LINK_LIST* list, void (*callback)(void*)) { LINKED_NODE* currentNode = list->head; while (currentNode != NULL) { callback(currentNode->data); currentNode = currentNode->nextNode; } } void printEmployee(void* data) {}
07-25
你可以使用以下代码来实现对EMPLOYEE结构体为数据的双向链表的排序算法，按照按employeeId升序...请注意，在代码中使用了动态内存分配（`malloc`）来分配内存，并在适当的时候使用了`free`来释放内存，以防止内存泄漏。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值