【C++】智能指针

港控/mmm° 2024-03-27 16:39 5阅读 0赞

### 1.智能指针的引入 ###

在了解异常之前，写程序时开辟的空间只要写了释放，基本上都会进行释放；熟悉异常之后，我发现指针存在**内存方面**的问题。

int div()
    {
    	int a, b;
    	cin >> a >> b;
    	if (b == 0)
    		throw invalid_argument("除0错误");
    	return a / b;
    }
    void Func()
    {
    	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;
    }

观察上面这段代码，思考并回答这三个问题：

1.如果这里的p1 new时抛异常会如何？

p1空间开辟失败，直接从Func跳转到main函数。

2.如果这里的p2 new时抛异常会如何？

p2空间开辟失败，但是p1空间开辟成功，并且因为异常导致的函数跳转，p1并未得到释放。

3.如果div调用时抛异常会如何？

p1，p2空间开辟成功，div中的异常由main函数中的try...catch捕获，导致p1和p2空间均未释放。

### 2.智能指针的使用及原理(RAII) ###

> *RAII，也称为“资源获取就是初始化”，是c++等[编程语言][Link 1]常用的[管理资源][Link 2]、避免内存泄露的方法。它[保证在][Link 3]任何情况下，使用对象时先[构造对象][Link 4]，最后析构对象。*

使用指针的时候在遇到异常的时候可能导致函数中的释放语句未执行，但是面向对象中的类却不用考虑这种情况，因为实例化出的对象出了作用域会自动调用析构函数释放空间。

下面是根据RAII思想设计出的SmartPtr类：

template<class T>
    class SmartPtr
    {
    public:
    	SmartPtr(T* ptr)
    		:_ptr(ptr)
    	{}
    
    	~SmartPtr()
    	{
    		cout << "delete:" << _ptr << endl;
    		delete _ptr;
    	}
    private:
    	T* _ptr;
    };

#### 智能指针的原理 ####

上面的SmartPtr还不能称之为智能指针，因为它还不具备指针的行为。指针可以解引用，也可以通过->访问所指空间中的内容，所以智能指针还需要重载operator\*和operator->才能像指针一样去使用。

T& operator*()
    	{
    		return *_ptr;
    	}
    
    	T* operator->()
    	{
    		return _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);
    	// 需要注意的是这里应该是sparray.operator->()->_year = 2018;
    	// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
    	sparray->_year = 2018;
    	sparray->_month = 1;
    	sparray->_day = 1;
    }

#### 3.std::auto\_ptr ####

C++98版本的库中提供了auto\_ptr的智能指针，但是auto\_ptr并不好用，多年来一直被挂在了耻辱柱上；下面就来看一下auto\_ptr相比于我们写的SmartPtr，还实现了什么功能？

SmartPtr并未考虑拷贝的问题，auto\_ptr考虑到了拷贝的问题，只不过拷贝的方法有点像是在抢劫(所以基本上都不用它)。

class A
    {
    public:
    	~A()
    	{
    		cout << "~A()" << endl;
    	}
    	int _a1 = 0;
    	int _a2 = 0;
    };
    
    
    int main()
    {
    	auto_ptr<A> ap1(new A);
    	ap1->_a1++;
    	ap1->_a2++;
    
    	auto_ptr<A> ap2(ap1);
    	return 0;
    }

![9a5f7839974c427a8efe14abdb0f0bca.png][]

实际上，auto\_ptr在拷贝的时候实现了资源的转移，转移之后被拷贝的对象就不能再被使用。

C++11中又出现了几种智能指针，像**unique\_ptr是不支持拷贝的，shared\_ptr则是使用计数的方法来防止空间的多次释放。**

[Link 1]: https://baike.baidu.com/item/%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80/9845131?fromModule=lemma_inlink
[Link 2]: https://baike.baidu.com/item/%E7%AE%A1%E7%90%86%E8%B5%84%E6%BA%90/4210544?fromModule=lemma_inlink
[Link 3]: https://baike.baidu.com/item/%E4%BF%9D%E8%AF%81%E5%9C%A8/13571740?fromModule=lemma_inlink
[Link 4]: https://baike.baidu.com/item/%E6%9E%84%E9%80%A0%E5%AF%B9%E8%B1%A1/10523427?fromModule=lemma_inlink
[9a5f7839974c427a8efe14abdb0f0bca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f5c01856e53d4310a29f46c547ae8774.png