C++智能指针: shared_ptr 实现详解
生活随笔
收集整理的這篇文章主要介紹了
C++智能指针: shared_ptr 实现详解
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
文章目錄
- shared_ptr描述
- 聲明
- 作用
- 原理實現
- 函數使用
- 關于shared_ptr循環引用問題
shared_ptr描述
聲明
shared_ptr屬于C++11特性中新加的一種智能指針，它的實現方式是模版類，頭文件<memory>
template <class T> class shared_ptr
所以使用shared_ptr的聲明方式即為
std::shared_ptr<type_id> statement 其中type_id為類型（可以是基本數據類型或者類），statement即為模版類對象
作用
shared_ptr 的理解如下：
- 使用一種叫做RAII（Resource Acquisition Is Initialization）的技術作為實現基礎：
在對象構造時獲取資源，接著控制對資源的訪問使之在對象的生命周期內始終保持有效，最后在對象析構的時候釋放資源
raii技術的好處是：- 不需要顯式釋放資源
- 對象所擁有的資源在其生命周期內始終有效
- 防止忘記調用delete釋放內存或者程序異常退出時沒有釋放內存。
- 同時它能夠將值語義轉為引用語義（即shared_ptr可以讓多個指針指向相同的對象，共享同一塊地址空間），shared_ptr使用引用技術方式來統計當前對象被引用的次數，每一次執行析構函數，引用計數就會-1，當引用計數減為0時自動刪除所指對象，回收對象空間。
原理實現
常用操作以及源碼實現如下：
類聲明如下
temple<typename T>
class SharedPtr {
public:...
private:T *_ptr;int *_refCount; //這里使用int型指針是為了保證拷貝構造時同一個地址空間的引用計數增加
};
constructor構造函數，初始化的時候默認引用計數為0
在使用普通指針初始化兩個shared_ptr的時候,兩個shared_ptr的引用計數都為1SharedPtr() : _ptr((T *)0), _refCount(0) {}
在進行拷貝構造的時候，使用shared_ptr去初始化另一個shared_ptr的時候引用計數會+1SharedPtr(T *obj) : _ptr(obj), _refCount(new int(1)) { }SharedPtr(SharedPtr &other) : _ptr(other._ptr), _refCount(&(++*other._refCount)) { }destructor析構函數，析構的時候在指針不為空且引用計數為0的時候釋放空間~SharedPtr() {if (_ptr && --*_refCount == 0) {delete _ptr;delete _refCount;} }operator =當使用一個shared_ptr給另一個shared_ptr賦值的時候這里需要注意- 由于指針指向發生變化，原來的_ptr指針的引用計數要–，且當達到了0的時候要注意回收原來指針的空間
- _ptr又指向了新的_ptr,則新的_ptr指針的引用計數要++
SharedPtr &operator=(SharedPtr &other) {if(this==&other)return *this;//新指針引用計數要++ ++*other._refCount;//原指針引用計數要--，如果為0，則釋放空間if (--*_refCount == 0) {delete _ptr;delete _refCount;}//重新進行指向 _ptr = other._ptr;_refCount = other._refCount;return *this; }operator*解引用運算符，直接返回底層指針的引用，即共享的地址空間內容T &operator*() {if (_refCount == 0)return (T*)0;return *_ptr; }operator ->指針運算符T *operator->() {if(_refCount == 0)return 0;return _ptr; }
函數使用
主要案例如下
- 構造函數
constructor,std::shared_ptr初始化案例如下，以及對應的refcount打印
輸出如下#include <iostream> #include <memory>struct C {int* data;};int main () {std::shared_ptr<int> p1;//默認構造函數，refcount為0std::shared_ptr<int> p2 (nullptr);//使用一個空的對象初始化時refcount也為0//普通指針初始化是引用計數為1，p3,p4std::shared_ptr<int> p3 (new int);std::shared_ptr<int> p4 (new int, std::default_delete<int>());//擁有allocator的時候初始化同樣引用計數為1//但是緊接著又用改智能指針拷貝構造初始化其他智能指針p6，//所以最后其引用計數為2,p5std::shared_ptr<int> p5 (new int, [](int* p){delete p;}, std::allocator<int>());//這里p6本身為1，但是因為使用std::move去初始化p7,將p6指向轉給了p7//則p6智能指針recount--變為0，p7 ++由1變為2std::shared_ptr<int> p6 (p5);std::shared_ptr<int> p7 (std::move(p6));std::shared_ptr<int> p8 (std::unique_ptr<int>(new int));std::shared_ptr<C> obj (new C);std::shared_ptr<int> p9 (obj, obj->data);std::cout << "use_count:\n";std::cout << "p1: " << p1.use_count() << '\n';std::cout << "p2: " << p2.use_count() << '\n';std::cout << "p3: " << p3.use_count() << '\n';std::cout << "p4: " << p4.use_count() << '\n';std::cout << "p5: " << p5.use_count() << '\n';std::cout << "p6: " << p6.use_count() << '\n';std::cout << "p7: " << p7.use_count() << '\n';std::cout << "p8: " << p8.use_count() << '\n';std::cout << "p9: " << p9.use_count() << '\n';return 0; }use_count: p1: 0 p2: 0 p3: 1 p4: 1 p5: 2 p6: 0 p7: 2 p8: 1 p9: 2 - 析構函數
輸出如下// shared_ptr destructor example #include <iostream> #include <memory>int main () {auto deleter = [](int*p){std::cout << "[deleter called]\n"; delete p;};//使用特殊的delete函數去構造，析構的時候會執行改delete 中lamada表達式內容.即構造函數案例中的p5初始化方式std::shared_ptr<int> foo (new int,deleter);std::cout << "use_count: " << foo.use_count() << '\n';return 0; // [deleter called] }use_count: 1 [deleter called] - =賦值運算符
輸出如下// shared_ptr::operator= example #include <iostream> #include <memory>int main () {std::shared_ptr<int> foo;std::shared_ptr<int> bar (new int(10));/*此時foo的引用計數為0，bar初始化后引用計數為1這里進行賦值操作，即foo的指向發生了變化，指向了bar1.foo引用計數--，因為已經為0了，此時直接釋放foo原來的空間2.bar引用計數++變為23.更改foo的引用計數和bar引用計數相等，并使得foo指向bar.因為他們共享同一個空間執行完之后fool和bar引用計數都相等，且解引用后數值都為0*/foo = bar; // copystd::cout << "*foo: " << *foo << " foo.count " << foo.use_count() << '\n';std::cout << "*bar: " << *bar << " bar.count " << bar.use_count() << '\n';/*這里重新對bar進行了初始化，即原先的指向發生了更改，所以它的引用計數--，并且內容變為新的地址空間內容20foo繼續指向原先空間，但是內容并未變化。同時原先地址因為bar并不引用了，所以foo的引用計數--*/bar = std::make_shared<int> (20); // movestd::cout << "*foo: " << *foo << " foo.count " << foo.use_count() << '\n';std::cout << "*bar: " << *bar << " bar.count " << bar.use_count() << '\n';std::unique_ptr<int> unique (new int(30));foo = std::move(unique); // move from unique_ptrstd::cout << "*foo: " << *foo << " foo.count " << foo.use_count() << '\n';std::cout << "*bar: " << *bar << " bar.count " << bar.use_count() << '\n';return 0; }*foo: 10 foo.count 2 *bar: 10 bar.count 2 *foo: 10 foo.count 1 *bar: 20 bar.count 1 *foo: 30 foo.count 1 *bar: 20 bar.count 1 - shared_ptr::swap,交換兩個shared_ptr地址空間內容，但并不破壞各自引用計數
輸出如下// shared_ptr::swap example #include <iostream> #include <memory>int main () {std::shared_ptr<int> foo (new int(10));std::shared_ptr<int> bar (new int(20));std::cout << "befor swap" << '\n';std::cout << "*foo: " << *foo << " foo.count " << foo.use_count() << '\n';std::cout << "*bar: " << *bar << " bar.count " << bar.use_count() << '\n';foo.swap(bar);std::cout << "after swap" << '\n';std::cout << "*foo: " << *foo << " foo.count " << foo.use_count() << '\n';std::cout << "*bar: " << *bar << " bar.count " << bar.use_count() << '\n';return 0; }befor swap *foo: 10 foo.count 1 *bar: 20 bar.count 1 after swap *foo: 20 foo.count 1 *bar: 10 bar.count 1 - shared_ptr::reset 替換所管理的對象
輸出如下,可以看到reset之后的地址發生了變化，即更改了指針的指向// shared_ptr::reset example #include <iostream> #include <memory>int main () {std::shared_ptr<int> sp; // emptysp.reset (new int); // 替換所管理對象，讓其更換地址指向std::cout << *sp << " " << sp.use_count() << " " << sp << '\n';*sp=10;std::cout << *sp << " " << sp.use_count() << " " << sp << '\n';sp.reset (new int); // 清除上一個指針指向的內容，重新進行更換std::cout << *sp << " " << sp.use_count() << " " << sp << '\n';*sp=20;std::cout << *sp << " " << sp.use_count() << " " << sp << '\n';sp.reset(); // deletes managed object//std::cout << *sp << " " << sp.use_count() << '\n';return 0; }0 1 0x434cd50 10 1 0x434cd50 0 1 0x434cd90 20 1 0x434cd90 - shared_ptr::get獲取初始指針
輸出如下：// shared_ptr::get example #include <iostream> #include <memory>int main () {int* p = new int (10);std::shared_ptr<int> a (p);std::shared_ptr<int> b (new int(20));//此時a和p共享同一個地址空間，所以a和p的內容都為0，地址空間一樣if (a.get()==p)std::cout << "a and p point to the same location " << a << " " << p << '\n';std::cout << *a.get() << "\n";std::cout << *a << "\n";std::cout << *p << "\n";//此時a將共享空間釋放，重新更換指向b，但是*p為普通指針，并無法跟隨a更換指，所以p的地址內容變為0a=b;std::cout << "a and p after copy " << a << " " << b << '\n';// three ways of accessing the same address:std::cout << *a.get() << "\n";std::cout << *a << "\n";std::cout << *p << "\n";return 0; }a and p point to the same location 0x21cf2f0 0x21cf2f0 10 10 10 a and p after copy 0x21cf330 0x21cf330 20 20 0
關于shared_ptr循環引用問題
循環引用是指兩個shared_ptr初始化之后相互指向，在函數作用域結束之后由于兩個指針都保持相互的指向，引用計數都為1，此時各自占用的內存空間無法釋放，最終產生內存泄露
舉例如下：
#include<iostream>
#include<memory> using namespace std; class B;
class A{ public: shared_ptr<B> ptr_A; ~A(){ cout << "refcount " << ptr_A.use_count() << '\n';cout<<"~A()"<<endl; }
};
class B{ public: //shared_ptr<A> ptr_B;//當采用shared_ptr指向A時會形成循環引用，則什么都不會輸出說明對象沒有被析構，可怕的內存泄露.... shared_ptr<A> ptr_B;//當采用弱引用時，避免了循環引用，有輸出，說明對象被析構了 ~B(){ cout << "refcount " << ptr_B.use_count() << '\n';cout<<"~B()"<<endl; }
};
int main(){ shared_ptr<A> a(new A); shared_ptr<B> b(new B); a->ptr_A=b; b->ptr_B=a;//若是循環引用：當a、b退出作用域的時候，A對象計數不為1(b保留了個計數呢),同理B的計數也不為1,那么對象將不會被銷毀，內存泄露了... cout << a.use_count() << " " << b.use_count()<< endl;return 0;
}
輸出如下,可以看到釋放的之前兩個智能指針的引用計數都為2，析構的時候各自引用計數執行–到·1，最終無法釋放
2 2
將classB中的shared_ptr更改為weak_ptr即可成功釋放
#include<iostream>
#include<memory> using namespace std; class B;
class A{ public: shared_ptr<B> ptr_A; ~A(){ cout << "refcount " << ptr_A.use_count() << '\n';cout<<"~A()"<<endl; }
};
class B{ public: //shared_ptr<A> ptr_B;//當采用shared_ptr指向A時會形成循環引用，則什么都不會輸出說明對象沒有被析構，可怕的內存泄露.... weak_ptr<A> ptr_B;//當采用弱引用時，避免了循環引用，有輸出，說明對象被析構了 ~B(){ cout << "refcount " << ptr_B.use_count() << '\n';cout<<"~B()"<<endl; }
};
int main(){ shared_ptr<A> a(new A); shared_ptr<B> b(new B); a->ptr_A=b; b->ptr_B=a;//若是循環引用：當a、b退出作用域的時候，A對象計數不為1(b保留了個計數呢),同理B的計數也不為1,那么對象將不會被銷毀，內存泄露了... return 0;
}
輸出如下,調用析構函數之前引一個智能指針的引用計已經將為1，執行析構之后即為0
1 2
refcount 1
~A()
refcount 0
~B()
參考文檔：
http://www.cplusplus.com/reference/memory/shared_ptr/
https://www.xuebuyuan.com/3190713.html
總結
以上是生活随笔為你收集整理的C++智能指针: shared_ptr 实现详解的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 花仙子是谁画的呢？
- 下一篇： C++智能指针：weak_ptr实现详解