什么是智能指针
智能指针是C++中的重点之一，这也是在笔试面试中爱考的知识点
理清智能指针十分重要
说起智能指针最先要提的就是RAII
RAII全称Resource Acquistion Is Initialization
定义一个类来封装资源的分配和释放，在构造函数完成资源 的分配和初始化，
在析构函数完成资源的清理，可以保证资源的正确初始化和释放。
那么什么是智能指针？为什么会有智能指针？
智能指针的引入是因为：在编程中常会有动态内存的开辟，而用完后会忘记释放；在逻辑处理时也要十分谨慎；还有野指针问题。因为一不小心就会有内存泄漏问题。内存泄漏会引发占用存储空间越来越多，最终用尽全部存储空间，整个系统崩溃。智能指针就是为了防止内存泄漏而引入的。
所谓的智能指针就是帮你管理指针，用完后自动释放。
本次提到的主要智能指针有auto_ptr/scoped_ptr/shared_ptr/weak_ptr
其中第一种智能指针是98/03C++提出
但是效果不好，于是就有其他的C++高手依次研究出其他指针，scoped_ptr，shared_ptr,scoped_array_ptr,shared_array_ptr等(这些智能指针是C++第三方库boost里的)
C++11加入了shared_ptr,unique_ptr,和weak_ptr
因为shared_ptr有循环引用的问题，weak_ptr就是为了解决循环引用而产生的
auto_ptr
第一种：管理权转移——auto_ptr 这是失败的设计，现已明确规定不能使用
sp1创建的一个空间，交给智能指针管理。sp2拷贝sp1或sp1赋值给sp2时，就将sp2指向这个空间，sp1置空。sp1就不能再访问这个空间。
模拟实现auto_ptr
代码：
template <class T>
class AutoPtr
{
public:
AutoPtr(T* ptr)//构造函数
:_ptr(ptr)
{}
~AutoPtr()//析构函数
{
if (_ptr)
{
delete _ptr;
}
}
AutoPtr(AutoPtr <T>& ap)//拷贝构造
:_ptr(ap._ptr)
{
ap._ptr = NULL;
}
AutoPtr<T>& operator=(AutoPtr<T>& ap)//赋值运算符重载
{
if (this != &ap)
{
delete _ptr;
_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
T& operator*()//*运算符重载
{
return *_ptr;
}
T* operator->()//->运算符重载
{
return _ptr;
}
protected:
T* _ptr;
};
scoped_ptr
第二种：防拷贝—— scoped_ptr 就是好的设计，简单粗暴（不让拷贝）但是只适用于部分场景
注：就是把拷贝构造和赋值运算符重载只声明不定义，声明成私有或保护。
模拟实现 scoped_ptr
代码：
template <class T>
class ScopedPtr
{
public:
ScopedPtr(T* ptr)//构造函数
:_ptr(ptr)
{}
~ScopedPtr()//析构函数
{
delete _ptr;
}
T& operator*()//*运算符重载
{
return *_ptr;
}
T* operator->()//->运算符重载
{
return _ptr;
}
protected:
ScopedPtr(const ScopedPtr<T>& sp);//拷贝构造
ScopedPtr<T>& operator=(const ScopedPtr<T>& sp);//赋值运算符重载
protected:
T* _ptr;
}
shared_ptr
第三种：引入引用计数—— shared_ptr用引用计数实现，功能强大，适用的场景多，但是复杂，循环引用
模拟实现 shared_ptr
代码：
template <class T>
class SharedPtr
{
public:
SharedPtr(T* ptr)//拷贝构造
:_ptr(ptr)
, _refCount(new int(1))
{}
~SharedPtr()//析构函数
{
if (--(*_refCount) == 0)
{
delete _ptr;
delete _refCount;
}
}
SharedPtr(const SharedPtr<T>& sp)//拷贝构造
:_ptr(sp._ptr)
, _refCount(sp._refCount)
{
++(*_refCount);
}
SharedPtr<T>& operator=(SharedPtr<T>& sp)//赋值运算符重载
{
if (_ptr != sp->_ptr)
{
this->Release();
this->_ptr = sp._ptr;
this->_refCount = sp._refCount;
++(*_refCount);
}
return *this;
}
T& operator*()//*运算符重载
{
return *_ptr;
}
T* operator->()//->运算符重载
{
return _ptr;
}
void Release()
{
if (--(*_refCount) == 0)
{
delete _ptr;
}
delete _refCount;
delete _ptr;
}
protected:
T* _ptr;
size_t* _refCount;
};
weak_ptr
第四种：为了解决shared_ptr循环引用的问题：
如：
struct ListNode
{
ListNode* _next;
ListNode* _prev;
int data;
};
int main()
{
ListNode* cur = new ListNode;
ListNode* next = new ListNode;
cur->_next = next;
next->_prev = cur;
//抛异常
delete cur;
delete next;
return 0;
}如果中途抛异常了，就会导致cur和next没有释放就会内存泄漏。
引入智能指针
如：
struct ListNode
{
shared_ptr<ListNode> _next;
shared_ptr<ListNode> _prev;
int data;
weak_ptr<ListNode> _next;
weak_ptr<ListNode> _prev;
~ListNode()
{
cout << "~ListNode()" << endl;
}
};
int main()
{
shared_ptr<ListNode> cur(new ListNode);
shared_ptr<ListNode> next(new ListNode);
cur->_next = next;
next->_prev = cur;
return 0;
}
但是会循环引用
在调析构函数时，析构next和cur，refCount减到1，cur和next的空间释放时就是refCount为0，next空间释放时，就等cur的_next释放，而_next的释放依赖于cur空间的释放，cur的空间释放就是等next的_prev释放，_prev的释放依赖于next的释放，这就是循环引用。为了解决这类问题就产生了weak_ptr。
解决，可以将结构定义为：
struct ListNode
{
/*shared_ptr<ListNode> _next;
shared_ptr<ListNode> _prev;*/
int data;
weak_ptr<ListNode> _next;
weak_ptr<ListNode> _prev;
~ListNode()
{
cout << "~ListNode()" << endl;
}
};weak_ptr就是用shared_ptr构造的
class WeakPtr
{
WeakPtr(SharedPtr sp)
:_ptr(sp._ptr)
{}
}定制删除器（仿函数）
对于shared_ptr还有就是定制删除器的问题
如：
class AA
{
public:
AA()
{
cout << "AA()" << endl;
}
~AA()
{
cout << "~AA()" << endl;
}
int _a;
};
int main()
{
shared_ptr<AA> sp1(new AA);
shared_ptr<AA> sp2(new AA[10]);
shared_ptr<int> sp3(new AA);
shared_ptr<int> sp4(new AA[10]);
shared_ptr<FILE> sp5(fopen("Test.txt","w"));
return 0;
}在调用shared_ptr时，如果构造一个数组就无法进行析构，这时就可以利用仿函数增加个定制删除器，用于析构数组。
打开一个文件，也就不能关闭了，同样可以用仿函数实现一个定制删除器。
如：
template <class T>
struct DeleteArray
{
void operator()(T* ptr)
{
delete[] ptr;
}
};
struct Fclose
{
void operator()(FILE* fp)
{
fclose(fp);
}
};
class AA
{
public:
AA()
{
cout << "AA()" << endl;
}
~AA()
{
cout << "~AA()" << endl;
}
int _a;
};
int main()
{
DeleteArray<AA> da;
shared_ptr<AA> sp1(new AA);
shared_ptr<AA> sp2(new AA[10],da);
shared_ptr<int> sp3(new AA[10]);
shared_ptr<int> sp4(new AA[10]);
Fclose f;
shared_ptr<FILE> sp5(fopen("Test.txt","w"),f);
return 0;
}这样SharePtr就可以模拟实现成带定制删除器
代码：
template <class T>
struct DeleteArray
{
void operator()(T* ptr)
{
delete[] ptr;
}
};
template <class T>
struct Delete
{
void operator()(T* ptr)
{
delete ptr;
}
};
template <class T,class D = Delete<T>>
class SharedPtr
{
public:
SharedPtr(T* ptr,D del = Delete<T>())//拷贝构造
:_ptr(ptr)
, _refCount(new int(1))
, _del(del)
{}
~SharedPtr()//析构函数
{
if (--(*_refCount) == 0)
{
delete _ptr;
delete _refCount;
}
}
SharedPtr(const SharedPtr<T>& sp)//拷贝构造
:_ptr(sp._ptr)
, _refCount(sp._refCount)
{
++(*_refCount);
}
SharedPtr<T>& operator=(SharedPtr<T>& sp)//赋值运算符重载
{
if (_ptr != sp->_ptr)
{
this->Release();
this->_ptr = sp._ptr;
this->_refCount = sp._refCount;
++(*_refCount);
}
return *this;
}
T& operator*()//*运算符重载
{
return *_ptr;
}
T* operator->()//->运算符重载
{
return _ptr;
}
void Release()
{
if (--(*_refCount) == 0)
{
_del(_ptr);
delete _refCount;
}
}
protected:
T* _ptr;
int* _refCount;
D _del;
};
class AA
{
public:
AA()
{
cout << "AA()" << endl;
}
~AA()
{
cout << "~AA()" << endl;
}
int _a;
};
int main()
{
SharedPtr<AA> sp1(new AA);
DeleteArray<AA> da;
SharedPtr<AA, DeleteArray<AA>> sp2(new AA[10], da);
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
