管理C++類中的指針成員

圖論看的頭大…於是翻了翻抱佛腳必備書：《程序員面試寶典》，這書編的確實不怎么樣，邊邊角角的題目有點多，有些題目的解答思路很不清晰，當做題庫看看也就罷了。今天翻到一道標准容器復制含有指針成員的類導致重復解析的問題，專門回憶了下這方面的知識，在這里做個總結。

C++最諷刺的地方就是“用指針實現了面向對象”這點，所以C++壓根不是什么面向對象，說是面向指針更恰當一點。內存管理這塊一直是C++最復雜的地方之一，也是很多人討厭C++的最大原因之一（我猜C風格字符串是另外一個原因之一）。復制（或使用隱含復制的操作）含有指針成員的類，必須對指針成員做一些特殊的處理，主要方法包括以下幾種：

①值型類，在復制指針成員時，重新分配內存，復制對象。使得不同的對象之間完全無耦合，配合C++11引入的右值引用，高效又省事。

②使用C++11中引入的新技術，包括shared_ptr,unique_ptr和weak_ptr（#include <memory>)。

③自己定義智能指針類，實現②中的功能。

我個人最喜歡還是用①，這么干最簡單，如果加上垃圾回收器，基本就成了java。但是對於大規模數據運算的類，還是不要這么干為妙。方法②是比較方便的方法，前提是對這三個smart pointer有比較好的理解，而且你個人喜歡這個風格的書寫。（其實我看着感覺不是很爽…）

其中unique_ptr被設計出來是用來取代auto_ptr的，shared_ptr就是一個使用計數類，配合weak_ptr來使用。詳細的介紹可以直接看微軟的文檔，或者這個翻譯的版本：http://kheresy.wordpress.com/2012/03/05/c11_smartpointer_p2/

如果討厭stl的智能指針類，最后的方法就是自己實現這個玩意。C++prime 4th在13.5.1和15.8.1兩節介紹了兩個方法來實現使用計數，總結一下:

class U_Ptr;
class HasPtr
{
public:
    HasPtr(int *p,int i):ptr(new U_Ptr(p)),val(i){}
    HasPtr(const HasPtr &orig):
        ptr(orig.ptr),val(orig.val)
    {
        ++ptr->use;
    }
    HasPtr& operator=(const HasPtr&);
    ~HasPtr(){if (--ptr->use==0)delete ptr;}
    int *get_ptr()const{return ptr->ip;}
    int get_int()const{return val;}
    void set_ptr(int *p){ptr->ip=p;}
    void set_int(int i){val=i;}
    int get_ptr_val()const{return *ptr->ip;}
    int set_ptr_val(int i)const{*ptr->ip=i;}
private:
    U_Ptr *ptr;
    int val;
};
class U_Ptr
{
    friend class HasPtr;
    int *ip;
    size_t use;
    U_Ptr(int *p):ip(p),use(1){}
    ~U_Ptr(){delete ip;}
};

HasPtr& HasPtr::operator=(const HasPtr& other)
{
    ++other.ptr->use;
    if(--ptr->use==0)delete ptr;
    ptr=other.ptr;
    val=other.val;
    return *this;
}

這里使用了一個計數類，用來實際存放本來應該在HasPtr中保存的指針，然后又使用了友元。這種設計風格會破壞掉類的封裝，也就是所謂侵入式智能指針，故一般不推薦。

#include <exception>
#include <iostream>
class BasePtr;
class HandlePtr
{
public:
    HandlePtr():ptr(nullptr),use(new size_t(1)){}
    HandlePtr(const HandlePtr& i)
        :ptr(i.ptr),use(i.use)
    {
        ++*use;
    }
    HandlePtr(HandlePtr&& i)
        :ptr(i.ptr),use(i.use)
    {
    }
    HandlePtr(const BasePtr&);
    ~HandlePtr(){decr_use();}
    HandlePtr& operator=(const HandlePtr&);
    const BasePtr* operator->()const
    {
        if(ptr)return ptr;
        else throw std::logic_error("unbound HandlePtr");
    }
    const BasePtr& operator*()const
    {
        if(ptr)return *ptr;
        else throw std::logic_error("unbound HandlePtr");
    }
private:
    BasePtr* ptr;
    size_t *use;
    void decr_use()
    {
        if(--*use==0){delete ptr;delete use;}
    }
};
class BasePtr 
{
public:
    virtual BasePtr* clone()const
    {
        return new BasePtr(*this);
    } 
};

HandlePtr::HandlePtr(const BasePtr& other)
    :ptr(other.clone()),use(new size_t(1)){}

上面則是更好的，也是比較常見的指針管理方式：使用句柄類。句柄類中包含指向管理的類和其子類的指針，句柄類重載了箭頭和解引用操作符，使其指向實際管理的指針，完成動態綁定。句柄類的可以直接由基類引用初始化， 但是由於基類引用可能指向子類，所以必須定義虛克隆來返回實際的類型。

以上兩個方法的核心思想都是“引用計數”，而shared_ptr也是這個原理。令人蛋疼的是，boost引入了大量智能指針，僅僅是掌握這些智能指針的用法就夠頭疼的，好在shared_ptr幾乎可以解決所有的問題，所以它得到了最廣泛的應用，掌握shared_ptr基本上可以解決大部分memory leak的問題（如果不需要考慮引用計數，可以使用unique_ptr）。

我試着用shared_ptr完成了書中sales_item的例子，如下：

#include <string>
#include <ostream>
class Basket;
class Item_base{
public:
    Item_base(const std::string& book="",
                double sales_price=0.0):
    isbn(book),price(sales_price){}
    std::string book()const
    {
        return isbn;
    }
    virtual double net_price(std::size_t n)const
    {
        return n*price;
    }
    virtual ~Item_base(){}
private:
    std::string isbn;
protected:
    double price;
};

class Bulk_item:public Item_base{
public:
    double net_price(std::size_t n)const;
private:
    std::size_t min_qty;
    double discount;
};
void print_total(std::ostream &os,const Item_base &item,std::size_t n);

#include "common.h"
#include <memory>
#include <set>
using namespace std;
double Bulk_item::net_price(std::size_t cnt)const
{
    if(cnt>=min_qty)
        return cnt*(1-discount)*price;
    else
        return cnt*price;
}
void print_total(ostream &os,const Item_base &item,size_t n)
{
    os<<"ISBN:"<<item.book()
        <<"\tnumber sold:"<<n<<"\ttotal price:"
        <<item.net_price(n)<<endl;
}
inline bool
    compare(const shared_ptr<Item_base>& lb1,const shared_ptr<Item_base>& lb2)
{
    return lb1->book() < lb2->book();
}
class Basket{
    typedef bool (*Comp)(const shared_ptr<Item_base>&,const shared_ptr<Item_base>&);
    multiset<shared_ptr<Item_base>,Comp> items;
public:
    typedef multiset<shared_ptr<Item_base>,Comp> set_type;
    typedef set_type::size_type size_type;
    typedef set_type::const_iterator const_iter;
    Basket():items(compare){}
    void add_item(const shared_ptr<Item_base> &pItem)
    {
        items.insert(pItem); 
    }
    size_type size(const shared_ptr<Item_base> &i)
    {
        return items.count(i);
    }
    double total()const
    {
        double sum=0.0;
        for(auto iter=items.begin();iter!=items.end()
            ;iter=items.upper_bound(*iter))
        {sum+=(*iter)->net_price(items.count(*iter));}
        return sum;
    }
};

大部分情況下，shared_ptr的使用比較簡單，當做一個自己書寫的句柄類使用即可。但是shared_ptr有一些陷阱，比如不能傳遞數組（但是可以用vector代替，或者指定刪除器）；不要在函數實參中初始化；最好不要把this指針傳給shared_ptr，如果需要返回this，可以考慮使用繼承std::enable_shared_from_this，然后返回shared_from_this()（但是這么做之前必須已經有一個正常產生的shared_ptr來存放這個返回的指針）；在可能出現循環引用時，使用weak_ptr打斷這種循環；如果是命名對象，最好不要使用new而使用make_shared；另外大量使用shared_ptr會產生碎片，需要自定義分配器進行內存管理。