智能指针主要有三种: shared_ptr,unique_ptr 和 weak_ptr.
shared_ptr
shared_ptr 是最常用的智能指针 (项目中我只用过 shared_ptr).shared_ptr 采用了引用计数器, 多个 shared_ptr 中的 T *ptr 指向同一个内存区域 (同一个对象), 并共同维护同一个引用计数器. shared_ptr 定义如下, 记录同一个实例被引用的次数, 当引用次数大于 0 时可用, 等于 0 时释放内存.
注意避免循环引用, shared_ptr 的一个最大的陷阱是循环引用, 循环, 循环引用会导致堆内存无法正确释放, 导致内存泄漏. 循环引用在 weak_ptr 中介绍.
- temple<typename T>
- class SharedPtr {
- public:
- ...
- private:
- T *_ptr;
- int *_refCount; //should be int*, rather than int
- };
shared_ptr 对象每次离开作用域时会自动调用析构函数, 而析构函数并不像其他类的析构函数一样, 而是在释放内存是先判断引用计数器是否为 0. 等于 0 才做 delete 操作, 否则只对引用计数器左减一操作.
- ~SharedPtr()
- {
- if (_ptr && --*_refCount == 0) {
- delete _ptr;
- delete _refCount;
- }
- }
接下来看一下构造函数, 默认构造函数的引用计数器为 0,ptr 指向 NULL:
- SharedPtr() : _ptr((T *)0), _refCount(0)
- {
- }
用普通指针初始化智能指针时, 引用计数器初始化为 1:
- SharedPtr(T *obj) : _ptr(obj), _refCount(new int(1))
- {
- } // 这里无法防止循环引用, 若我们用同一个普通指针去初始化两个 shared_ptr, 此时两个 ptr 均指向同一片内存区域, 但是引用计数器均为 1, 使用时需要注意.
拷贝构造函数需要注意, 用一个 shared_ptr 对象去初始化另一个 shared_ptr 对象时, 引用计数器加一, 并指向同一片内存区域:
- SharedPtr(SharedPtr &other) : _ptr(other._ptr), _refCount(&(++*other._refCount))
- {
- }
赋值运算符的重载
当用一个 shared_ptr<T> other 去给另一个 shared_ptr<T> sp 赋值时, 发生了两件事情:
一, sp 指针指向发生变化, 不再指向之前的内存区域, 所以赋值前原来的_refCount 要自减
二, sp 指针指向 other.ptr, 所以 other 的引用计数器_refCount 要做 ++ 操作.
- SharedPtr &operator=(SharedPtr &other)
- {
- if(this==&other)
- return *this;
- ++*other._refCount;
- if (--*_refCount == 0) {
- delete _ptr;
- delete _refCount;
- }
- _ptr = other._ptr;
- _refCount = other._refCount;
- return *this;
- }
定义解引用运算符, 直接返回底层指针的引用:
- T &operator*()
- {
- if (_refCount == 0)
- return (T*)0;
- return *_ptr;
- }
定义指针运算符 ->
- T *operator->()
- {
- if(_refCount == 0)
- return 0;
- return _ptr;
- }
二, 测试
- int main(int argc, const char * argv[])
- {
- SharedPtr<string> pstr(new string("abc"));
- SharedPtr<string> pstr2(pstr);
- SharedPtr<string> pstr3(new string("hao"));
- pstr3 = pstr2;
- return 0;
- }
为了让测试结果更明显, 我在方法中加入了一些输出, 测试结果如下:
源码链接:
智能指针
来源: http://www.bubuko.com/infodetail-3231424.html