c++动态内存管理与智能指针的相关知识点

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指向的对象的引用计数
	   //递减r指向的对象的引用计数
       //如果计数器为0，自动释放

//factory返回一个share_ptr,指向一个动态分配的对象
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离开了作用域，由于引用计数由1减到0，对象被销毁，内存释放

//factory和上述一致
//ues_factory返回shared_ptr的拷贝
void use_factory(T arg){
    shared_ptr<Foo> p = factory(arg);
    //使用p
    return p; //返回p的拷贝，此时递增了计数器，引用数为2
}//p离开作用域，对象计数器引用2-1=1，对象内存没有释放

Blob<string> b1; //空Blob
{
    //新作用域
    Blob<string> b2 = {"a","an","the"};
    b1 = b2; //b1和b2共享数据
}//b2离开作用域，被销毁了，但b2的数据不能被销毁
//b1指向b2的原数据

class StrBlob{
public:
    //拷贝控制
    StrBlob();//默认构造函数
    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被销毁，计数器递减
    //b1仍指向b2的原数据
    cout<<b1.front()<<endl;
    //打印此时b1的计数器
    cout<<"b2 has been dstoryed : "
        <<b1.look_data().use_count()<<endl;
    return 0;
}

//pi指向一个动态分配，默认初始化的无名对象
int *pi = new int;
/)
{
	connection c = connect(&d);//打开链接
	unique_ptr<connection, decltype(end_connection)*>
		p(&c, end_connection);
	//使用链接
	//当f退出时（即使是由于异常而退出）
	//connection会调用end_connection正常退出
}