前言

現(xiàn)在開發(fā)的項目中用到了大部分 C++ 代碼险毁，由于 Swift 和 C++ 混編不是很方便， 依然選擇用 OC 混編劣坊， 只需要將 .m文件 修改為 .mm文件即可拉一。

OC 里的對象大部分都會加入自動釋放池中，所以這些都不用手動釋放唧龄，但是 C++ 對象不會被加入自動釋放池,必須要手動釋放兼砖，否則會造成內(nèi)存泄漏。

.mm文件中可以隨意的 new CppObject(), 但是要記得 delete 既棺。當cpp指針被當前對象引用時讽挟，當前對象的dealloc 方法里要記得釋放該資源。

借助這個機會丸冕，重溫一下 C++的內(nèi)存管理 以及 智能指針的使用耽梅。

普通指針

單獨的對象

ComparePooling* mPool = new ComparePooling();
// 釋放mPool
delete mPool;

這是最簡單的。胖烛。眼姐。

釋放 C++ 數(shù)組

TestA * aList = new TestA[10];
// 釋放數(shù)組對象
delete []aList;

釋放vector (stack)對象

for(vector<MidiPart *>::iterator it = this->mParts.begin(); it != this->mParts.end(); it ++){
    if (NULL != *it) {
        delete *it;
        *it = NULL;
    }
}
this->mParts.clear();

現(xiàn)在考慮下面情況

void func()
{
    int *p = new int(5);
    do something...
    throw "exception occured";
    delete p;
}
int main(){
    try {
        func();
    } catch (const char* str) {
        std::cout<<str <<std:endl;
    }
}

func函數(shù) 中 可能會觸發(fā)異常诅迷，是函數(shù)提前退出，這樣有可能資源不會得到釋放众旗。有效使用 智能指針 可以解決這一問題罢杉。

智能指針

智能指針的原理就是將你 new 出來的一個指針ptr傳給他，它返回一個棧上的對象 A 給你贡歧。這個對象保存著你傳入的 ptr滩租。 當 A 離開作用域（無論是命名空間還是函數(shù)，還是拋出異常提前退出）艘款， A 的析構函數(shù)都會被調(diào)用持际，析構函數(shù)內(nèi)部會 釋放ptr指針。所以使用智能指針會為資源管理提供方便哗咆。

auto_ptr

class ObjectA {
    public:
    ~ObjectA(){
        std::cout<<"TestA did release"<<std::endl;
    }
    ObjectA(int age): mAge(age) {}
    int mAge;
};
int main(int argc, const char * argv[]) {
    // insert code here...
    std::auto_ptr<ObjectA> ptr_a( new ObjectA(20) );
    std::cout<< ptr_a->mAge << std::endl;
    return 0;
}

outPut如下

20
TestA did release

若要手動釋放可以調(diào)用 reset() 函數(shù)

int main(int argc, const char * argv[]) {
    std::auto_ptr<ObjectA> ptr_a( new ObjectA(20) );
      ptr_a.reset();
    std::cout<< ptr_a->mAge << std::endl; // Crash !!!
    return 0;
}

對象已被釋放蜘欲，再次訪問就會變成野指針，程序會崩潰晌柬。
當reset() 方法傳入?yún)?shù)時會替換掉內(nèi)部保持的指針

int main(int argc, const char * argv[]) {
    std::auto_ptr<ObjectA> ptr_a( new ObjectA(20) );
      ptr_a.reset(new ObjectA(40));
    std::cout<< ptr_a->mAge << std::endl; // outPut : 40
    return 0;
}

另外 auto_ptr 不能指向一個數(shù)組對象姥份，會直接crash。因為它內(nèi)部 使用的 delete ptr , 而不是 delete[] ptr年碘。

shared_ptr

shared_ptr 有一種共享所有權的概念澈歉，n 個指針可以同時指向一個對象，這個對象的引用計數(shù)就為 n屿衅，知道最后一個對象離開作用域時才會釋放該對象 埃难。所以當我第一次接觸 iOS 的 ARC 機制中的強引用(strong)時，感覺如此熟悉涤久。

int main(){
    {
        std::cout << "constructor with no managed object\n";
        std::shared_ptr<ObjectA> sh1;
    }
    {
        std::cout << "constructor with object\n";
        std::shared_ptr<ObjectA> sh2(new ObjectA);
        std::shared_ptr<ObjectA> sh3(sh2);
        std::cout << sh2.use_count() << '\n';
        std::cout << sh3.use_count() << '\n';
    }
    {
        std::cout << "constructor with object and deleter\n";
        std::shared_ptr<ObjectA> sh5(new ObjectA, [](auto p) {
            std::cout << "Call delete from lambda...\n";
            delete p;
        });
    }
}

outPut 如下

constructor with no managed object
constructor with object
2
2
ObjectA did release
constructor with object and deleter
Call delete from lambda...
ObjectA did release

shared_ptr 的構造函數(shù) 可以用一個deleter (lambada 表達式) 作為參數(shù)

template< class Y, class Deleter > shared_ptr( Y* ptr, Deleter d );
std::shared_ptr<ObjectA> sh5(new ObjectA, [](auto p) {
            std::cout << "Call delete from lambda...\n";
            delete p;
        });

那么我們想傳入一個數(shù)組對象時就可以如下操作

std::shared_ptr<ObjectA> sh5(new ObjectA, [](auto p) {
            delete[] p;
        });

循環(huán)引用

將shared_ptr 隨意強引用給其他對象涡尘，可能會造成循環(huán)引用

#include <iostream>
class ObjectB;
class ObjectA {
    public:
    ~ObjectA(){
        std::cout<<"ObjectA did release"<<std::endl;
    }
    ObjectA() {}
    std::shared_ptr<ObjectB> mPtrB;
};
class ObjectB {
public:
    ~ObjectB(){
        std::cout<<"ObjectB did release"<<std::endl;
    }
    ObjectB() {}
    std::shared_ptr<ObjectA> mPtrA;
};
int main(){
    {
        std::shared_ptr<ObjectA> ptr_a (new ObjectA);
        std::shared_ptr<ObjectB> ptr_b (new ObjectB);
        ptr_a->mPtrB = ptr_b;
        ptr_b->mPtrA = ptr_a;
    }
}

上面的 ObjectA 和 ObjectB 都不會被釋放.

ObjectA -> ptr_b -> ObjectB -> ptr_a -> ObjectA

造成了循環(huán)引用，所以為了解決這一問題响迂， C++ 提供了 弱指針 如下考抄。

weak_ptr

weak_ptr 是對源對象的弱引用，weak_ptr 指向該對象是蔗彤，該對象的 引用計數(shù)不會加一川梅。
weak_ptr 的創(chuàng)建一般用一個shared_ptr 對象 作為參數(shù)。

void main( ){
 shared_ptr<ObjectA> sptr( new ObjectA );
 weak_ptr<ObjectA> wptr( sptr );
 weak_ptr<ObjectA> wptr1 = wptr;
}

當 shared_ptr 離開了自己的定義域后然遏，shared_ptr 被釋放贫途。weak_ptr 指向的對象也就釋放了，weak_ptr 對象的引用計數(shù)為 0待侵。

void main(){
    std::weak_ptr<ObjectA> w_ptr;
    {
        std::shared_ptr<ObjectA> ptr(new ObjectA);
        w_ptr = ptr;
        std::cout << "w_ptr.use_count() inside scope: " << w_ptr.use_count() << '\n';
    }
    std::cout << "w_ptr.use_count() out of scope: " << w_ptr.use_count() << '\n';
    std::cout << "w_ptr.expired() out of scope: " << std::boolalpha << w_ptr.expired() << '\n';
}

outPut 如下

w_ptr.use_count() inside scope: 1
ObjectA did release
w_ptr.use_count() out of scope: 0
w_ptr.expired() out of scope: true

unique_ptr

unique_ptr 和 auto_ptr 類似潮饱。在任何時間點，對象只能被一個 unique_ptr 所持有诫给。unique_ptr 不支持普通的拷貝和賦值操作香拉。

void main() 
{
    // 創(chuàng)建一個unique_ptr實例
    unique_ptr<int> pInt(new int(5));
    unique_ptr<int> pInt2(pInt);    // 報錯
    unique_ptr<int> pInt3 = pInt;   // 報錯
}

unique_ptr雖然沒有支持普通的拷貝和賦值操作，但卻提供了一種移動機制來將指針的所有權從一個unique_ptr轉(zhuǎn)移給另一個unique_ptr中狂。如果需要轉(zhuǎn)移所有權凫碌，可以使用std::move()函數(shù)。

void main() 
{
    unique_ptr<int> pInt(new int(5));
    unique_ptr<int> pInt2 = std::move(pInt);    // 轉(zhuǎn)移所有權
    //cout << *pInt << endl; // 出錯胃榕，pInt為空
    cout << *pInt2 << endl;
    unique_ptr<int> pInt3(std::move(pInt2));
}

下面看個??子

#include <iostream>
#include <vector>
#include <memory>
#include <cstdio>
#include <cassert>
#include <functional>
 
struct B {
  virtual void bar() { std::cout << "B::bar\n"; }
  virtual ~B() = default;
};
struct D : B
{
    D() { std::cout << "D::D\n";  }
    ~D() { std::cout << "D::~D\n";  }
    void bar() override { std::cout << "D::bar\n";  }
};
 
// a function consuming a unique_ptr can take it by value or by rvalue reference
std::unique_ptr<D> pass_through(std::unique_ptr<D> p)
{
    p->bar();
    return p;
}
 
int main()
{
  std::cout << "unique ownership semantics demo\n";
  {
      auto p = std::make_unique<D>(); // p is a unique_ptr that owns a D
      auto q = pass_through(std::move(p)); 
      assert(!p); // now p owns nothing and holds a null pointer
      q->bar();   // and q owns the D object
  } // ~D called here
 
  std::cout << "Runtime polymorphism demo\n";
  {
    std::unique_ptr<B> p = std::make_unique<D>(); // p is a unique_ptr that owns a D
                                                  // as a pointer to base
    p->bar(); // virtual dispatch
 
    std::vector<std::unique_ptr<B>> v;  // unique_ptr can be stored in a container
    v.push_back(std::make_unique<D>());
    v.push_back(std::move(p));
    v.emplace_back(new D);
    for(auto& p: v) p->bar(); // virtual dispatch
  } // ~D called 3 times
 
  std::cout << "Custom lambda-expression deleter demo\n";
  {
    std::unique_ptr<D, std::function<void(D*)>> p(new D, [](D* ptr)
        {
            std::cout << "destroying from a custom deleter...\n";
            delete ptr;
        });  // p owns D
    p->bar();
  } // the lambda above is called and D is destroyed
 
  std::cout << "Array form of unique_ptr demo\n";
  {
      std::unique_ptr<D[]> p{new D[3]};
  } // calls ~D 3 times
}

Output:

unique ownership semantics demo
D::D
D::bar
D::bar
D::~D
Runtime polymorphism demo
D::D
D::bar
D::D
D::D
D::bar
D::bar
D::bar
D::~D
D::~D
D::~D
Custom lambda-expression deleter demo
D::D
D::bar
destroying from a custom deleter...
D::~D
Array form of unique_ptr demo
D::D
D::D
D::D
D::~D
D::~D
D::~D

總結
實際coding中盛险，還是shared_ptr 使用的多。代碼中避免不了將對象賦值給其他對象勋又。