shared_ptr<string> p1;	   //shared_ptr，可以指向string
shared_ptr<list<int>> p2;  //shared_ptr，可以指向list<int>

//若p1不為空且指向一個空string
if(p1 && p1->empty()){
    *p1 = "hi";   //對p1重新賦值
}

//指向一個值為42的int的shared_ptr
shared_ptr<int> p1 = make_shared<int>(42);
//指向一個值為"999"的string的shared_ptr
shared_ptr<string> p2 = make_shared<string>(3, '9');
//指向一個值為0的int的shared_ptr
shared_ptr<int> p3 = make_shared<int>();

auto p4 = make_shared<string>(); //p4指向空string

auto r = make_shared<int>(42);
r = q; //給r賦值，使它指向另一個地址
	   //遞增q指向的對象的引用計數(shù)
	   //遞減r指向的對象的引用計數(shù)
       //如果計數(shù)器為0，自動釋放

//factory返回一個share_ptr,指向一個動態(tài)分配的對象
shared_ptr<Foo> factory(T arg){
    //對arg的操作
    return make_shared<Foo>(arg);
}

void ues_factory(T arg){
    shared_ptr<Foo> p = factory(arg);
    //使用p
}
//p離開了作用域，由于引用計數(shù)由1減到0，對象被銷毀，內(nèi)存釋放

//factory和上述一致
//ues_factory返回shared_ptr的拷貝
void use_factory(T arg){
    shared_ptr<Foo> p = factory(arg);
    //使用p
    return p; //返回p的拷貝，此時遞增了計數(shù)器，引用數(shù)為2
}//p離開作用域，對象計數(shù)器引用2-1=1，對象內(nèi)存沒有釋放

Blob<string> b1; //空Blob
{
    //新作用域
    Blob<string> b2 = {"a","an","the"};
    b1 = b2; //b1和b2共享數(shù)據(jù)
}//b2離開作用域，被銷毀了，但b2的數(shù)據(jù)不能被銷毀
//b1指向b2的原數(shù)據(jù)

class StrBlob{
public:
    //拷貝控制
    StrBlob();//默認構(gòu)造函數(shù)
    StrBlob(initializer_list<string> il); //列表初始化
    StrBlob(const StrBlob& strb);
    //查詢
    int size() const {return data->size();}
    bool empty() const {return data->empty();}
    //添加和刪除元素
    void push_back(const string &t) {data->push_back(t);}
    void pop_back() {data->pop_back();}
    //訪問元素
    string& front();
    string& back();
private:
    shared_ptr<vector<string>> data;
    //如果data[i]不合法，拋出異常
    void check(int i, const string &msg) const;
};

StrBlob::StrBlob() : data(make_shared<vector<string>>())
        {cout<<"in StrBlob dafault"<<endl;};
StrBlob::StrBlob(initializer_list<string> il) :
    data(make_shared<vector<string>>(il))
    {cout<<"in StrBlob initializer_list"<<endl;}

void StrBlob::check(int i, const string& msg) const{
    if(i >= data->size())
        throw out_of_range(msg);
}

string& StrBlob::front(){
    //如果vector為空，check會拋出一個異常
    check(0, "front on empty StrBlob");
    return data->front();
}
string& StrBlob::back(){
    check(0, "back on empty StrBlob");
    return data->back();
}

//由于data是private的
//在StrBlob中設置一個接口look_data
//look_data返回data的引用
class StrBlob{
public:
    //...
    shared_ptr<vector<string>>& look_data()
    {return data;} //返回引用，避免對象拷貝
private:
    //其余部分都不變
};

//測試程序
int main(){
    StrBlob b1;
    {//新作用域
        StrBlob b2 = {"first element","second element"};
        cout<<"before assignment : "
            <<b2.look_data().use_count()<<endl;
        b1 = b2;
        cout<<"after assignment  : "
            <<b2.look_data().use_count()<<endl;
    }//b2被銷毀，計數(shù)器遞減
    //b1仍指向b2的原數(shù)據(jù)
    cout<<b1.front()<<endl;
    //打印此時b1的計數(shù)器
    cout<<"b2 has been dstoryed : "
        <<b1.look_data().use_count()<<endl;
    return 0;
}

//pi指向一個動態(tài)分配，默認初始化的無名對象
int *pi = new int;
//*pi的值是未定義的
cout<<*pi<<endl;

//pi指向?qū)ο蟮闹禐?2
int *pi = new int(42); 
//"9999999999"
string *ps = new string(10, '9'); 
//vector有5個元素，依次為0,1,2,3,4
vector<int> *pv = new vector<int>{0,1,2,3,4};

string *ps1 = new string(); //值初始化為空string
string *ps = new string;    //默認初始化為空string
int *pi1 = new int;         //默認初始化，值未定義
int *pi  = new int();       //值初始化，*pi = 0;

//分配并初始化const int
const int *pi = new const int(1024);
//分配并默認初始化const string
const string *ps = new const string;

int *p1 = new int; //返回空指針，拋出異常
int *p2 = new (nothrow) int; //如果分配失敗，new返回空指針

int i, *pi = &i;
int *pd = new int();
delete pd; //正確：釋放pd內(nèi)存
pd = nullptr; //好習慣：指出pd不再指向動態(tài)內(nèi)存
delete pi; //未定義：pi沒有指向動態(tài)分配的內(nèi)存
delete pd; //未定義：pd內(nèi)存已經(jīng)被釋放

Foo* factory(T arg){
    //處理arg
    return new Foo(arg);
}//調(diào)用者負責釋放

void ues_factory(T arg){
    Foo *p = factory(arg);
    //使用p但不delete它
}//p離開了作用域，但它所指向的內(nèi)存沒有被釋放?。?/pre>

void use_factory(T arg){
    Foo *p = factory(arg);
    //使用p
    delete p;  //記得釋放p
}

shared_ptr<int> p1(new int(42)); //正確：使用直接初始化
shared_ptr<int> p2 = new int(30);//錯誤：new產(chǎn)生的指針

shared_ptr<int> clone(int p){
    //錯誤：構(gòu)造函數(shù)為explicit，無法轉(zhuǎn)換
    //return new int(p);  
    //正確：顯式地用int*構(gòu)造shared_ptr<int>
    return shared_ptr<int>(new int(p));
}

unique_ptr<double> p1;  //可以指向double的一個unique_ptr
unique_ptr<int> p2(new int(42)); //p2指向一個值為42的int

unique_ptr<string> p1(new string("hello"));
unique_ptr<string> p2(p1); //錯誤：不支持拷貝
unique_ptr<string> p3;
p3 = p1; //錯誤：不支持賦值

//將所有權(quán)從p1，轉(zhuǎn)移到p2
unique_ptr<string> p1(new string("hello"));
unique_ptr<string> p2(p1.release()); //release將p1置空
cout<<*p2<<endl; //輸出 hello
unique_ptr<string> p3(new string("world"));
//p2綁定的對象被釋放，p3置空，p2指向p3原來指向的對象
p2.reset(p3.release());
cout<<*p2<<endl; //輸出： world

unique_ptr<int> clone(int p){
    //正確：從int*創(chuàng)建一個unique_ptr<int>
    return unique_ptr<int>(new int(p));
}

unique_ptr<int> clone(int p){
    unique_ptr<int> ret(new int(p));
    return ret;
}

//p指向一個類型為objT的對象
//并使用一個類型為delT的可調(diào)用對象釋放objT
//p會使用一個名為fcnd的delT對象來刪除objT
unique_ptr<objT, delT> p(new objT, fcn);

void f(destination &d /*其他需要的參數(shù)*/)
{
	connection c = connect(&d);//打開鏈接
	unique_ptr<connection, decltype(end_connection)*>
		p(&c, end_connection);
	//使用鏈接
	//當f退出時（即使是由于異常而退出）
	//connection會調(diào)用end_connection正常退出
}