C++基础（二十二）：智能指针

未来可期，静待花开~

于 2024-07-15 19:31:59 发布

阅读量416

点赞数 14

分类专栏： C++面向对象编程文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/weixin_47040031/article/details/140430179

版权

C++面向对象编程专栏收录该内容

22 篇文章 1 订阅

订阅专栏

智能指针是C++11引入的一种用于自动化管理动态内存的工具，极大简化了内存管理的复杂性。智能指针包括std::unique_ptr、std::shared_ptr和std::weak_ptr。std::unique_ptr实现独占式拥有，确保同一时间只有一个指针可以指向某个动态分配的对象；std::shared_ptr实现共享式拥有，通过引用计数来管理对象的生命周期，多个指针可以同时指向同一个对象；std::weak_ptr用于解决std::shared_ptr循环引用的问题，它不影响引用计数，可以安全地观察和使用由std::shared_ptr管理的对象。通过使用智能指针，开发者可以避免内存泄漏和悬空指针等常见的内存管理问题，从而编写出更加健壮和可靠的代码。

一、为什么需要智能指针？

二、内存泄漏

2.1 什么是内存泄漏，内存泄漏的危害（面试题）

3.3 std::auto_ptr （C++98提出的：管理权转移）

3.4 std::unique_ptr（C++11提出的防拷贝）

3.5 std::shared_ptr（C++11提出的引用计数的共享拷贝）

四、C++11和boost中智能指针的关系

一、为什么需要智能指针？

C++中new和malloc申请出来的资源，是需要我们进行手动释放的，因此，很容易发生两个问题：第一，申请的资源忘记释放，第二：会发生异常安全问题。最终都会导致内存或者资源泄漏！

#include <iostream>
#include <string>
using namespace std;


int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	// 1、如果p1这里new 抛异常会如何？
	// 2、如果p2这里new 抛异常会如何？
	// 3、如果div调用这里又会抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

上述代码存在的问题：

如果p1这里new抛异常会如何？

如果p1 = new int;抛出异常（例如内存分配失败），则控制流会跳转到main函数中的catch块。此时，p1和p2都没有被分配内存，程序不会进入到delete p1;和delete p2;，所以不会有内存泄漏的问题。然而，由于p1和p2都未被分配，直接访问它们将是未定义行为。

如果p2这里new抛异常会如何？

如果p2 = new int;抛出异常，控制流同样会跳转到main函数中的catch块。此时，p1已经被成功分配内存，但p2没有分配。因此，会导致p1的内存泄漏，因为在异常发生时delete p1;没有被调用。

如果div调用这里又会抛异常会如何？

div()函数可能会抛出invalid_argument异常，如果用户输入的第二个值为0。在这种情况下，控制流将跳转到main函数中的catch块。然而，这会导致p1和p2的内存泄漏，因为在div()抛出异常后，delete p1;和delete p2;不会被执行。

二、内存泄漏

2.1 什么是内存泄漏，内存泄漏的危害（面试题）

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;

	// 2.异常安全问题
	int* p3 = new int[10];

	Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.

	delete[] p3;
}

2.2 内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

堆内存泄漏(Heap leak)

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏

指程序使用系统分配的资源，比如套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

2.3 如何检测内存泄漏（了解）

在linux下内存泄漏检测：Linux下几款C++程序中的内存泄露检查工具_c++内存泄露工具分析-CSDN博客

在windows下使用第三方工具：

VS编程内存泄漏：VLD(Visual LeakDetector)内存泄露库_visual leak detector vs2020-CSDN博客

2.4 如何避免内存泄漏

工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
采用RAII思想或者智能指针来管理资源。
有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
出问题了使用内存泄漏工具检测。

总结一下: 内存泄漏非常常见，解决方案分为两种：

1、事前预防型。如智能指针等。

2、事后查错型。如泄漏检测工具。

三、智能指针的使用及原理

3.1 RAII思想

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

主要思想：

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。

这种做法有两大好处：

不需要显式地释放资源。
采用这种方式，对象所需的资源在其生命期内始终保持有效。

如下代码通过设计SmartPtr类，确保了在Func函数中即使发生异常，也能正确释放动态分配的内存，避免了内存泄漏的问题。SmartPtr的析构函数在对象销毁时自动释放内存，体现了RAII思想。在main函数中，使用try-catch块捕获Func中的异常，并处理异常

#include <iostream>
#include <string>
using namespace std;


// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}
    ~SmartPtr()
    {
        if (_ptr)
            delete _ptr;
    }


类模板SmartPtr：这是一个类模板，可以管理任何类型的指针。
构造函数：SmartPtr(T* ptr = nullptr)，默认构造函数接受一个指针，默认为nullptr。
当对象创建时，保存传入的指针。
析构函数：~SmartPtr()，在对象销毁时，如果保存的指针不为nullptr，则删除指针指向的内存。


private:
    T* _ptr;
};



int div()
{
    int a, b;
    cin >> a >> b;
    if (b == 0)
        throw invalid_argument("除0错误");
    return a / b;
}



void Func()
{
    SmartPtr<int> sp1(new int);    //智能指针对象
    SmartPtr<int> sp2(new int);    //智能指针对象
    cout << div() << endl;
}


SmartPtr使用：sp1和sp2分别管理两块动态分配的int类型内存。
调用div函数：调用div函数，如果div抛出异常，则控制流会离开Func函数，转到main函数中的catch块。
内存管理：由于使用了SmartPtr，无论div是否抛出异常，sp1和sp2的析构函数都会被调用，
从而确保内存被正确释放。





int main()
{
    try {
        Func();
    }
    catch (const exception& e)
    {
        cout << e.what() << endl;
    }
    return 0;
}




在main函数中，try块调用了Func函数。如果Func函数中任何地方抛出了一个从std::exception派生的异常（例如invalid_argument），程序控制流将跳转到catch块。然后，catch块中的代码将捕获这个异常，并通过e.what()输出异常的描述信息。

RAII和智能指针的关系：RAII是一种托管资源的思想，像智能指针是依靠这种思想实现的， unique_lock/lock_guard也是利用这种思想。

智能指针可以用来解决内存泄漏和异常安全问题，主要思想如下：基于RAII思想设计的一个类，把需要释放的资源交给类对象，通过对象的生命周期来管理，在对象析构时释放资源。

3.2 智能指针的原理

上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。

#include <iostream>
#include <string>
using namespace std;

template<class T>
class SmartPtr 
{
public:

    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}


    ~SmartPtr()
    {
        if (_ptr)
            delete _ptr;
    }


    T& operator*() 
    { 
        return *_ptr; 
    }


    T* operator->() 
    { 
        return _ptr;
    }


private:
    T* _ptr;
};



struct Date
{
    int _year;
    int _month;
    int _day;
};



int main()
{
    SmartPtr<int> sp1(new int);
    *sp1 = 10;
    cout << *sp1 << endl;

    SmartPtr<Date> sparray(new Date);    //指针的类型为Date*

    // 需要注意的是这里应该是sparray.operator->()->_year = 2018;
    // 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
    sparray->_year = 2018;
    sparray->_month = 1;
    sparray->_day = 1;
}

总结一下智能指针的原理：

RAII特性
重载operator*和opertaor->，具有像指针一样的行为。

智能指针其实并没上面这么简单，它的坑如下：

#include <iostream>
#include <string>
using namespace std;

template<class T>
class SmartPtr 
{
public:

    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}


    ~SmartPtr()
    {
        if (_ptr)
            delete _ptr;
    }


    T& operator*() 
    { 
        return *_ptr; 
    }


    T* operator->() 
    { 
        return _ptr;
    }


private:
    T* _ptr;
};


int main()
{

     SmartPtr<int> sp1(new int);
     SmartPtr<int> sp2(sp1);      //拷贝构造

这里是拷贝构造智能指针对象，因为我们没有实现拷贝构造，
使用编译器默认生成的拷贝构造函数，它是一个浅拷贝，
因此会使得两个智能指针指向同一块内存空间，
这样两个对象生命周期结束会调用两次析构函数，
释放的是同一块内存空间，会出现指针崩溃！！！


     return 0;
}

如何解决？？？

深拷贝可以解决吗？不能！！为什么？因为智能指针只是托管这块内存空间！

解决办法1：管理权转移
解决办法2：防拷贝
解决办法3：引用计数的共享拷贝，存在循环引用的问题，又需要weak_ptr来解决

3.3 std::auto_ptr （C++98提出的：管理权转移）

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。 auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理

#include <iostream>
#include <string>
using namespace std;

// C++98 管理权转移 auto_ptr
namespace bit
{
	template<class T>
	class auto_ptr
	{
	public:

		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		
		//自己实现的拷贝构造：管理权转移         auto_ptr<int> sp2(sp1);
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)          //将sp的指针指向赋值给调用它的对象
		{
			// 管理权转移
			sp._ptr = nullptr;  //将自己的指针指向置空，我把这块空间的管理权交给你，我就不管了
		}


		//自己实现的赋值运算符重载：管理权转移       auto_ptr<int> sp2.operator=(sp1)
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			// 检测是否为自己给自己赋值
			if (this != &ap)
			{
				// 释放当前对象中资源
				if (_ptr)
					delete _ptr;

				// 转移ap中资源到当前对象中
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
		}



		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}



		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}


		T* operator->()
		{
			return _ptr;
		}


	private:
		T* _ptr;
	};
}


int main()
{

	auto_ptr<int> sp1(new int);
	auto_ptr<int> sp2(sp1);      //拷贝构造



结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
//此时sp1悬空

   // *sp2 = 10;           空指针解引用，指针崩溃！
  // cout << *sp2 << endl; 空指针解引用，指针崩溃！
 // cout << *sp1 << endl; 空指针解引用，指针崩溃！

	return 0;
}

缺陷：如果出现指针接管权交出后，仍利用这个指针进行访问，那么会出现指针崩溃！！！

3.4 std::unique_ptr（C++11提出的防拷贝）

C++11中开始提供更靠谱的unique_ptr，unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理

#include <iostream>
#include <string>
using namespace std;

// unique_ptr/scoped_ptr
// 原理：简单粗暴，推荐使用 -- 防拷贝
namespace bit
{
	template<class T>
	class unique_ptr
	{
	public:

		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}


		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}


		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}



		unique_ptr(const unique_ptr<T>&sp) = delete;                //不会生成默认的拷贝构造函数
		unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;  //不会生成默认的赋值运算符重载函数

	private:
		T* _ptr;
	};
}



int main()
{
       /*bit::unique_ptr<int> sp1(new int);
         bit::unique_ptr<int> sp2(sp1);*/

       std::unique_ptr<int> sp1(new int);
       //std::unique_ptr<int> sp2(sp1);

       return 0;
}

缺陷：如果有需要拷贝的场景，他就没办法使用！

3.5 std::shared_ptr（C++11提出的引用计数的共享拷贝）

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr，std::shared_ptr 是 C++ 标准库中的一种智能指针，用于自动管理动态内存的生命周期。它通过引用计数来跟踪指向同一块内存的所有 shared_ptr 对象，当最后一个 shared_ptr 对象被销毁时，内存会被自动释放。

#include <iostream>
#include <string>
using namespace std;

// shared_ptr/scoped_ptr

// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace bit
{
	template<class T>
	class shared_ptr
	{
	public:

		shared_ptr(T* ptr)
			:_ptr(ptr)
			,_pcount(new int(1))      //初始化引用计数
		{}



		shared_ptr( shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			,_pcount(sp._pcount)
		{
			++(*_pcount);          //引用计数自增
		}




		
		shared_ptr<T>& operator=( shared_ptr<T>& sp)
		{
			if (this != &sp)
			{
				//减减引用计数，如果我是最后一个管理资源的对象，则需要释放我本来管理的这块空间
				if (--(*_pcount) == 0)
				{
					delete _pcount;
					delete _ptr;
				}

				//我开始跟你一起管理资源
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				++(*_pcount);

			}
			return *this;

		}


		~shared_ptr()
		{
			if (--(*_pcount)==0 && _ptr)               //最后一个对这块内存空间进行管理的对象
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				_ptr = nullptr;

				delete _pcount;
				_pcount = nullptr;
			}
		}


		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	

	private:
		T* _ptr;
		int* _pcount;    //指向引用计数的指针（这个计数int整型变量由动态内存开辟），用来记录有多少个对象共享管理资源，最后一个析构释放资源
	};
}



int main()
{
	
	bit::shared_ptr<int> sp1(new int);
	bit::shared_ptr<int> sp2(sp1);

	bit::shared_ptr<int> sp3(new int);
	bit::shared_ptr<int> sp4(sp3);

	bit::shared_ptr<int> sp5(sp3);

	return 0;
}

std::shared_ptr的线程安全问题

通过下面的程序我们来测试shared_ptr的线程安全问题。需要注意的是shared_ptr的线程安全分为两方面：

智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以需要在引用计数进行++、--时进行加锁，也就是说加了锁之后的引用计数的操作是线程安全的。
智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

#include <iostream>
#include <mutex>

namespace bit
{
    using namespace std;

    template<class T>
    class shared_ptr
    {
    public:
        // 默认构造函数：初始化指针、引用计数和互斥锁
        shared_ptr(T* ptr = nullptr)
            : _ptr(ptr)
            , _pRefCount(new int(1))
            , _pmtx(new mutex)
        {}

初始化指针 _ptr，引用计数 _pRefCount 设为1，互斥锁 _pmtx 用于线程安全。



        // 拷贝构造函数：拷贝其他 shared_ptr，并增加引用计数
        shared_ptr(const shared_ptr<T>& sp)
            : _ptr(sp._ptr)
            , _pRefCount(sp._pRefCount)
            , _pmtx(sp._pmtx)
        {
            AddRef();
        }

拷贝构造函数会拷贝指针 _ptr、引用计数 _pRefCount 和互斥锁 _pmtx，并调用 AddRef 增加引用计数。



        // 释放函数：减少引用计数，当引用计数为0时，删除指针和引用计数
        void Release()
        {
            _pmtx->lock();
            bool flag = false;
            if (--(*_pRefCount) == 0 && _ptr)
            {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
                delete _pRefCount;
                flag = true;
            }
            _pmtx->unlock();
            if (flag == true)
            {
                delete _pmtx;
            }
        }


减少引用计数，当引用计数为0时，删除指针 _ptr 和引用计数 _pRefCount。最后删除互斥锁 _pmtx。



        // 增加引用计数：增加引用计数，使用互斥锁确保线程安全。
        void AddRef()
        {
            _pmtx->lock();
            ++(*_pRefCount);
            _pmtx->unlock();
        }

        // 赋值操作符重载：释放当前对象，拷贝新的 shared_ptr，并增加引用计数
        shared_ptr<T>& operator=(const shared_ptr<T>& sp)
        {
            if (_ptr != sp._ptr)
            {
                Release();
                _ptr = sp._ptr;
                _pRefCount = sp._pRefCount;
                _pmtx = sp._pmtx;
                AddRef();
            }
            return *this;
        }
重载赋值操作符，避免自赋值，先释放当前对象，然后拷贝新对象，增加引用计数。


        // 返回引用计数
        int use_count()
        {
            return *_pRefCount;
        }

        // 析构函数：释放对象
        ~shared_ptr()
        {
            Release();
        }

        // 重载*操作符，返回对象的引用
        T& operator*()
        {
            return *_ptr;
        }

        // 重载->操作符，返回对象的指针
        T* operator->()
        {
            return _ptr;
        }

        // 返回对象的指针
        T* get() const
        {
            return _ptr;
        }

    private:
        T* _ptr;           // 被管理对象的指针
        int* _pRefCount;   // 引用计数的指针
        mutex* _pmtx;      // 互斥锁，用于线程安全的引用计数操作
    };
}

int main() {
    using namespace bit;
    shared_ptr<int> sp1(new int(10));
    {
        shared_ptr<int> sp2 = sp1;
        cout << "use_count: " << sp1.use_count() << endl;
    }
    cout << "use_count: " << sp1.use_count() << endl;

    return 0;
}

shared_ptr智能指针是线程安全的吗？

是的，引用计数的加减是加锁保护的。但是指向资源不是线程安全的，指向堆上资源的线程安全问题是访问的人处理的，智能指针不管，也管不了，引用计数的线程安全问题，是智能指针要处理的。

shared_ptr引用计数，可以拷贝，但是存在一个问题：循环引用！

std::shared_ptr的循环引用

#include <iostream>
#include <mutex>
using namespace std;

struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;

	~ListNode()
	{ 
		cout << "~ListNode()" << endl;
	}
};


int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;


	node1->_next = node2;
	node2->_prev = node1;


	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

循环引用分析：

node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动 delete。
node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
也就是说_next析构了，node2就释放了。
也就是说_prev析构了，node1就释放了。
但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev 属于node2成员，所以这就叫循环引用，谁也不会释放。

在使用 std::shared_ptr 时，循环引用（circular reference）是一个常见的问题。当两个或多个对象通过 std::shared_ptr 相互引用时，会导致它们的引用计数无法归零，从而引起内存泄漏。为了打破循环引用，可以使用 std::weak_ptr 代替其中一个 std::shared_ptr。std::weak_ptr 不会增加引用计数，因此可以避免循环引用的问题。

#include <iostream>
#include <mutex>
using namespace std;


// 简化版本的weak_ptr实现
template<class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{}

	weak_ptr(const shared_ptr<T>& sp)
		:_ptr(sp.get())
	{}


	weak_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}

	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};






// 解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
// 原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和
//_prev不会增加node1和node2的引用计数。
struct ListNode
{
	int _data;
	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};


int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);

	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;

	node1->_next = node2;
	node2->_prev = node1;

	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

四、C++11和boost中智能指针的关系

至此，这一讲内容介绍完毕，内容简单，星光不问赶路人，加油吧，感谢阅读，如果对此专栏感兴趣，点赞加关注！

未来可期，静待花开~

关注

14
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
C++基础（二十二）：智能指针

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。// 1.内存申请了忘记释放// 2.异常安全问题Func();// 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
复制链接

扫一扫