54 跟踪内存泄漏

最新推荐文章于 2023-01-15 21:07:44 发布
最新推荐文章于 2023-01-15 21:07:44 发布
阅读量348 收藏
点赞数
分类专栏： C++ 文章标签： 内存泄漏跟踪
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Leone9689/article/details/51057058
版权

自己实现malloc，在里面进行跟踪
valgrind、dmalloc、efence （linux）
visual leak detector（windows）

operator new
operator delete

new operator <=>operator new + 构造函数

头文件包含次序
C库、C++库、其他库.h 、项目中.h

//Tracer.h
#ifndef _TRACER_H_
#define _TRACER_H_

#include <map>

#ifndef NDEBUG
void* operator new(size_t size, const char* file, long line);
//void* operator new(size_t size);
void* operator new[](size_t size, const char* file, long line);
void* operator new[](size_t size);
void operator delete(void* p, const char*, long);
void operator delete(void* p);//重载
void operator delete[](void* p, const char*, long);//重载
void operator delete[](void* p);//重载

class Tracer
{
private:
    class Entry
    {
    public:
        Entry(const char* file = 0, long line = 0)
            :file_(file), line_(line){}
        const char* File() const { return file_; }
        long Line() const { return line_; }
    private:
        const char* file_;
        long line_;
    };
public:
    Tracer();
    ~Tracer();
    static bool Ready;

    void Add(void* p, const char* file, long line);
    void Remove(void* p);
    void Dump(); 
private:
    std::map<void*, Entry>mapEntry_;
};

extern Tracer NewTrace;

#endif//NDEBUG
#endif

//Tracer.cpp
#include <iostream>
#include "Tracer.h"

#ifndef NDEBUG
bool Tracer::Ready = false;

Tracer::Tracer()
{
    Ready = true;
}


Tracer::~Tracer()
{
    Ready = false;
    Dump();
}


void Tracer::Add(void* p, const char* file, long line)
{
    mapEntry_[p] = Entry(file,line);
}
void Tracer::Remove(void* p)
{
    std::map<void*, Entry>::const_iterator it;
    it = mapEntry_.find(p);
    if (it != mapEntry_.end())
    {
        mapEntry_.erase(it);
    }
}
void Tracer::Dump()
{
    if (mapEntry_.size()>0)
    {
        std::cout << "*** Memory leak(s):" << std::endl;
        std::map<void*, Entry>::const_iterator it;
        for (it = mapEntry_.begin(); it != mapEntry_.end(); ++it)
        {
            const char* file = it->second.File();
            long line = it->second.Line();
            int addr = reinterpret_cast<int>(it->first);
            std::cout << "0x" << std::hex << addr << ": "
                << file << ", line " << std::dec << line << std::endl;
        }
        std::cout << std::endl;

    }
}

Tracer NewTrace;

void* operator new(size_t size, const char* file, long line)
{
    void* p = malloc(size);
    if (Tracer::Ready)
    {
        NewTrace.Add(p, file, line);
    }
    return p;
}
void* operator new[](size_t size, const char* file, long line)
{
    void* p = malloc(size);
    if (Tracer::Ready)
    {
        NewTrace.Add(p, file, line);
    }
    return p;
}
void* operator new[](size_t size)
{
    void* p = malloc(size);
    if (Tracer::Ready)
    {
        NewTrace.Add(p, "?", 0);
    }
    return p;
}
//void* operator new(size_t size)
//{
//  void* p = malloc(size);
//  if (Tracer::Ready)
//  {
//      NewTrace.Add(p, "?", 0);
//  }
//  return p;
//}
void operator delete(void*p, const char*, long)
{
    if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}

void operator delete(void* p)
{
    if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}
void operator delete[](void*p, const char*, long)
{
    if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}
void operator delete[](void*p)
{
    if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}

#endif

//DebugNew.h
#ifndef _DEBUG_NEW_H_
#define _DEBUG_NEW_H_

#ifndef NDEBUG
#include "Tracer.h"

#define new new(__FILE__, __LINE__)

#endif
#endif

//main.cpp
#include<iostream>
using namespace std;

#include"DebugNew.h"



int main(void)
{
    int* p = new int;//堆栈开辟四个字节的空间
    //delete p;

    int* p2 = new int[5];
    //delete[] p2;

    return 0;
}

解决程序运行终止的问题

//Tracer.h
#ifndef _TRACER_H_
#define _TRACER_H_

#include <map>

#ifndef NDEBUG
void* operator new(size_t size, const char* file, long line);
void* operator new(size_t size);
void* operator new[](size_t size, const char* file, long line);
void* operator new[](size_t size);
void operator delete(void* p, const char*, long);
void operator delete(void* p);//重载
void operator delete[](void* p, const char*, long);//重载
void operator delete[](void* p);//重载

class Tracer
{
private:
    class Entry
    {
    public:
        Entry(const char* file = 0, long line = 0)
            :file_(file), line_(line){}
        const char* File() const { return file_; }
        long Line() const { return line_; }
    private:
        const char* file_;
        long line_;
    };

    class Lock
    {
    public:
        Lock(Tracer& tracer) :tracer_(tracer)
        {
            tracer_.lock();
        }
        ~Lock()
        {
            tracer_.unlock();
        }
    private:
        Tracer& tracer_;

    };
    friend class Lock;
public:
    Tracer();
    ~Tracer();
    static bool Ready;

    void Add(void* p, const char* file, long line);
    void Remove(void* p);
    void Dump(); 
private:
    std::map<void*, Entry>mapEntry_;
    int lockCount_;
    void lock(){ ++lockCount_; }
    void unlock(){ --lockCount_; }
};

extern Tracer NewTrace;

#endif//NDEBUG
#endif

//Tracer.cpp
#include <iostream>
#include "Tracer.h"

#ifndef NDEBUG
bool Tracer::Ready = false;

Tracer::Tracer() :lockCount_(0)
{
    Ready = true;
}


Tracer::~Tracer()
{
    Ready = false;
    Dump();
}


void Tracer::Add(void* p, const char* file, long line)
{
    if (lockCount_ > 0)
        return;
    Tracer::Lock lock(*this);
    mapEntry_[p] = Entry(file,line);

}
void Tracer::Remove(void* p)
{
    if (lockCount_ > 0)
        return;

    Tracer::Lock lock(*this);
    std::map<void*, Entry>::const_iterator it;
    it = mapEntry_.find(p);
    if (it != mapEntry_.end())
    {
        mapEntry_.erase(it);
    }

}
void Tracer::Dump()
{
    if (mapEntry_.size()>0)
    {
        std::cout << "*** Memory leak(s):" << std::endl;
        std::map<void*, Entry>::const_iterator it;
        for (it = mapEntry_.begin(); it != mapEntry_.end(); ++it)
        {
            const char* file = it->second.File();
            long line = it->second.Line();
            int addr = reinterpret_cast<int>(it->first);
            std::cout << "0x" << std::hex << addr << ": "
                << file << ", line " << std::dec << line << std::endl;
        }
        std::cout << std::endl;

    }
}

Tracer NewTrace;

void* operator new(size_t size, const char* file, long line)
{
    void* p = malloc(size);
    if (Tracer::Ready)
    {
        NewTrace.Add(p, file, line);
    }
    return p;
}
void* operator new[](size_t size, const char* file, long line)
{
    void* p = malloc(size);
    if (Tracer::Ready)
    {
        NewTrace.Add(p, file, line);
    }
    return p;
}
void* operator new[](size_t size)
{
    void* p = malloc(size);
    if (Tracer::Ready)
    {
        NewTrace.Add(p, "?", 0);
    }
    return p;
}
void* operator new(size_t size)
{
    void* p = malloc(size);
    if (Tracer::Ready)
    {
        NewTrace.Add(p, "?", 0);
    }
    return p;
}
void operator delete(void*p, const char*, long)
{
    if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}

void operator delete(void* p)
{
    if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}
void operator delete[](void*p, const char*, long)
{
    if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}
void operator delete[](void*p)
{
    if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}

#endif

//DebugNew.h
#ifndef _DEBUG_NEW_H_
#define _DEBUG_NEW_H_

#ifndef NDEBUG
#include "Tracer.h"

#define new new(__FILE__, __LINE__)

#endif
#endif

//main.cpp
#include<iostream>
using namespace std;

#include"DebugNew.h"



int main(void)
{
    int* p = new int;//堆栈开辟四个字节的空间
    //delete p;

    int* p2 = new int[5];
    //delete[] p2;

    return 0;
}
Leone9689
关注
专栏目录
C++运算符的重载
weixin_43610684的博客
04-28 466
一：二元算数运算符的重载
linux跟踪内存泄露的方法
最新发布
m0_74282605的博客
06-08 395
所以说没做过的还是自己做一下的好。结果是美好的，一下子就找到了内存重开没释放的逻辑，然后分析修改代码，问题就解决了。为什么会出现这次的内存泄露呢，就是因为代码不熟悉，不全是我写的。下面我把代码贴出来，修改调试了很久，里面做了很多注释，独立性相当强，不和任何模块相关。最近做rtmp推流的时候由于使用了很多librtmp和其他代码，逻辑混乱导致功能虽然都实现了，但是出现了内存泄露的现象。其实不改也不会影响使用，因为吃的一点也不厉害，反复大量的启动关闭才会出现泄露，实际使用没有那么变态的操作。
pta c++ 判断题
weixin_62566689的博客
01-15 3397
pta c++ 判断题 类与对象 数据共享与保护 数组 指针 字符串 继承与派生 多态性 群体类和群体数据的组织 泛型程序设计 流类库与输入输出 异常处理 stl 面向对象程序设计 成员函数 构造函数 析构函数 类的组合 作用域 静态 动态 友元 常对象 多文件结构 对象数组 this指针 动态内存分配 引用 虚函数 抽象类 运算符重载 函数模板 类模板 容器
C++运算符重载和友元函数用法
Invoker's Tower
04-04 9643
1.运算符重载定义： C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。 运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运
运算符重载为成员函数
niesen111的专栏
06-01 1025
#includeusing namespace std;class complex  //复数类定义{public: complex(double r=0.0,double i=0.0) {real=r;imag=i;}     complex operator + (complex c2); //运算符+重载成员函数 complex operator - (complex c2); //运算符-重载成员函数 void display();private: double real; double imag;
C++ 运算符重载：成员、非成员函数重载
JMW1407的博客
06-19 1万+
C++ 运算符重载运算符重载1、背景2、运算符函数重载的两种形式1、成员函数重载1、定义格式2、非成员函数重载（友元）1、定义格式3、重载原则4、参数和返回值5、成员函数重载1、双目运算符重载1、定义2、调用格式2、单目运算符重载1、定义2、调用格式6、非成员函数（友元）重载1、定义2、定义形式3、调用格式4、重载原则：+和 -运算符的重载实例++和--运算符的重载：重载输入输出操作符<< >>string类实例（重载综合说明）参考 运算符重载 1、背景 C++中标准运算符（如+、
Windows内存泄漏排查工具
07-18
4. **综合报告**：生成详细的分析报告，包括内存泄漏的时间线、大小、频率等，方便团队协作和问题跟踪。 **使用方法** 使用这两款工具，一般步骤如下： 1. **安装与配置**：下载并安装LeakDiag和LDGrapher，根据...
跟踪BSTR内存分配以查找内存泄漏
04-06
然而，如果在代码中出现了对BSTR的异常处理或复杂的引用计数逻辑，可能会导致BSTR未被正确释放，从而产生内存泄漏。 在《Tracking-BSTR-Memory-Allocations-to-Find-Memory-Leaks》这份文档中，可能会详细讲述如何...
如何排查Java内存泄漏？看完我给跪了！
01-20
Java内存管理是一个复杂而微妙的主题，尤其是当涉及到内存泄漏时。Java的自动垃圾回收机制虽然在大多数情况下工作得很好，但并不能完全防止内存泄漏的发生。内存泄漏通常发生在程序中，当不再需要的对象仍然被引用，...
Java中关于内存泄漏出现的原因汇总及如何避免内存泄漏（超详细版）
09-01
6. 使用Java 9及更高版本的强引用（Strong Reference）跟踪工具：Java 9引入了`-XX:+TraceReferences`和`-XX:+TraceReferenceGC`选项，可以追踪强引用，帮助定位内存泄漏。 了解Java的内存分配策略对于避免内存泄漏...
类成员函数形式的运算符重载
weixin_46011351的博客
08-18 1256
新的概念：类成员函数形式的运算符重载 运算符重载的方法是定义一个重载运算符的函数。运算符函数重载一般有两种形式：重载为类的成员函数和重载为类的非成员函数。 成员函数形式的运算符重载函数定义的一般形式为： <返回类型说明符> operator <运算符符号>(<参数表>) { <函数体> } 当运算符重载为成员函数时，函数的参数个数比原来的操作数要少一个（后增、后减单目运算符除外）。因为成员函数用this指针隐式地访问了类的一个对象，它就是运算符最左边的
C++学习：多态性
老肥码码码
01-19 2441
  运算符重载的规则 思考：用“+”、“-”能够实现复数的加减运算吗？ 实现复数加减运算的方法 ——重载“+”、“-”运算符 运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据时导致不同的行为。 C++ 几乎可以重载全部的运算符，而且只能够重载C++中已经有的。 不能重载的运算符：“.”、“.*”、“::”、“?:” 重载之后运算符的优先级和结合性都不会改变。...
C++入门教程（七十二）：详述构造函数
小古银的博客
04-08 297
小古银的官方网站（完整教程）：http://www.xiaoguyin.com/ C++入门教程视频：https://www.bilibili.com/video/av20868986/ 目录 目录 面向对象编程中级知识——前言 详述构造函数 复制构造函数和默认复制构造函数 基础示例 1 基础讲解 1 基础示例 2 基础讲解 2 基础拓展 2 移动构造函数和默认移动构造函数 基础...
对于“检测内存错误”这一用法，我们可以用 valgrind 或者 dmalloc 或者 efence 来达到相同的目的，专业的除错工具比自己山寨一个内存检查器要靠谱。...
weixin_34184561的博客
02-17 156
不过我确实自己重写了 malloc 的宏,比较方便好用,源文件也很短.   --------------------------------------------------在应用程序中替换Linux中Glibc的malloc的四种方法http://blog.csdn.net/littlefang/article/details/6052563            打算优化系统的内存分...
运算符重载习题+解析
weixin_47312141的博客
07-14 2666
运算符重载习题+解析 1.C 2. B 3. C 4. C 5. B 6. A 7. A 8. A 9. D operator/(c1, c2) ++x 1．通过运算符重载，只能改变运算符原有的______。 A．优先级 B．操作数个数 C．操作数类型 D．结合性 C [解析] 重载运算符时，运算符的优先级、结合性或操作数数目不能改变，选项A、B、D是错误的；选项C正确。答案为C选项。 2．下列关于运算符函数的表述中，错误的是______。 A．运算符函数的参数表可
C++编程语言中重载运算符（operator）介绍
热门推荐
liitdar的博客
06-11 20万+
operator是C++的一个关键字，它和运算符（如“=”）一起使用，表示一个运算符重载函数，在理解时可将operator和待重载的运算符整体（如“operator=”）视为一个函数名。使用operator重载运算符，是C++扩展运算符功能的方法。使重载后的运算符的使用方法与重载前一致；扩展运算符的功能只能通过函数的方式实现。（实际上，C++中各种“功能”都是通过函数实现的）
c++中运算符重载为类成员函数
u010096085的专栏
04-09 3482
运算符重载是对已有的运算符赋予多重含义，在C++中预定义的运算符其运算对象是基本数据类型，而不适用于用户自定义类型（例如类），可以重载大多数c++已有的运算符（. :: ?: .*除外），但是运算符的重载不改变其优先级和结合性以及操作数的个数。     运算符重载的生命形式:                                          函数类型   operator 运算
C++运算符重载总结
wu5215080的专栏
09-06 644
 1、为什么要有运算符重载 对于基础类型运算符知道怎么计算，原因是编译器对于自定义类型不知道如何进行加减 所以编译器提供了一种机制，让用户自己去完成自定义类型的加减操作，这个机制就是运算符重载机制。其实该机制本身就是函数重写   C++怎么知道是编译器的+，-还是重载后的+，-呢？ 编译器是通过类型来检测的。 运算符重载的语法形式： 1、运算符函
掌握Java内存管理与内存泄漏排查
3. 问题诊断与定位：学习如何识别内存不足和内存泄漏的迹象，如内存使用监控工具的指示、垃圾回收日志等，以及如何通过分析堆转储（Heap Dump）和线程堆栈跟踪来定位问题。 4. 解决方案：除了手动调整内存配置外，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值