智能指针的概念
智能指针是C++中的一个重要概念,用于管理动态分配的对象内存。它是一个类模板,通过封装原始指针,并在对象生命周期结束时自动释放内存,从而避免了内存泄漏和资源管理的繁琐工作。
C++标准库提供了多种常见的智能指针,目前常用的有:unique_ptr , shared_ptr , weak_ptr。(头文件: < memory >
为什么需要智能指针?
看一个例子:
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;
}
RAll
RAII(Resource Acquisition Is Initialization)的核心思想是资源的获取和释放应该与对象的生命周期绑定在一起。当一个对象被创建时,它应该获取所需要的资源;当对象被销毁时,它应该释放已经获取的资源。这样可以确保资源在不再需要时被正确释放,从而避免资源泄漏。
利用RAll原理做出智能指针
代码:
template<class T>
class SmartPtr
{
public://RALLSmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){cout << "delete: " << _ptr<< endl;delete _ptr;}//解引用T& operator*(){return *_ptr;}//指针形式T* operator->(){return _ptr;}
private:T* _ptr;
};
利用RAll原理制作智能指针:
测试:
auto_ptr
简单使用
由于这种智能指针不能对实际应用起到作用,所以现在大多数程序员都没有用到它。
要模拟实现一个auto_ptr时,只需要在上面代码的赋值拷贝中加上:
unique_ptr
unique_ptr与常规指针的一个主要区别就是:它拥有对指向对象的独占拥有权。这意味着同一时间只能有一个unique_ptr指向某个对象,不能进行复制操作,只能进行移动操作。当unique_ptr被销毁或重置时,他所指向的对象也会自动删除。
模拟实现
template<class T>class unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}unique_ptr(unique_ptr<T>& p)= delete;unique_ptr operator=(const unique_ptr<T>& p) = delete;~unique_ptr(){cout << "delete:" << _ptr << endl;delete _ptr;}// 像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
实现时只需要对默认拷贝构造和默认赋值构造给它删除了,那么就实现了不能对它进行复制了。
测试:
shared_ptr
为什么不能用static成员来进行计数?
模拟实现
template<class T>class shared_ptr{public://常规使用的构造函数shared_ptr(T* ptr = nullptr): _ptr(ptr),_count(new int(1)){}//sp2(sp1)shared_ptr(const shared_ptr<T>& sp){_ptr = sp._ptr;_count = sp._count;//拷贝后将count+1++(*_count);}//sp3=sp1shared_ptr<T>& operator=(const shared_ptr<T>& sp){if (_ptr != sp._ptr){//使用赋值时,要考虑之前的智能指针指向的空间release();_ptr = sp._ptr;_count = sp._count;//拷贝后将count+1++(*_count);}return *this;}//释放资源void release(){if (--(*_count) == 0){cout << "delete:" << _ptr << endl;delete _ptr;delete _count;}}~shared_ptr(){//当count为0时触发release();}int use_count(){return *_count;}// 像指针一样T& operator*(){return *_ptr;}T* operator->(){return _ptr;}T* get() const{return _ptr;}private:T* _ptr;int* _count;};
解释:
测试:
赋值时必须要对之前智能指针指向的空间进行检查:
验证解引用:
定制删除器
在类中添加一个成员:
添加一个构造函数的重载:
释放时的修改:
template <class T>
struct ArrayDelete
{void operator()(T* ptr){delete[] ptr;}
};
//定制删除器
int main()
{fnc::shared_ptr<ListNode> n(new ListNode(10));fnc::shared_ptr<ListNode> n1(new ListNode[10],ArrayDelete<ListNode>());fnc::shared_ptr<FILE> n2(fopen("FileName.cpp", "r"), [](FILE* file) {fclose(file); });
}
智能指针的缺陷
struct ListNode
{int _val;fnc::shared_ptr<ListNode> _next;fnc::shared_ptr<ListNode> _prev;ListNode(int val=0):_val(val){}
};int main()
{fnc::shared_ptr<ListNode> n1(new ListNode(10));fnc::shared_ptr<ListNode> n2(new ListNode(20));cout << n1.use_count() << endl;cout << n2.use_count() << endl;n1->_next = n2;n2->_prev = n1;cout << n1.use_count() << endl;cout << n2.use_count() << endl;//delete n1;//delete n2;return 0;
}
结果:
weak_ptr
weak_ptr就是用于解决循环引用的问题。它与shared_ptr配合使用,可以指向一个由shared_ptr管理的对象,但不会增加该对象的引用计数。
weak_ptr不拥有所指对象的拥有权,当指向对象被释放时,weak_ptr会自动失效,不再指向有效的对象。
template<class T>class weak_ptr{public:// RAllweak_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;};
将LIstNode的next指针和prev指针类型改为weak_ptr的:
结果: