language

smart pointer

标准库提供了智能指针类型来更好地管理动态对象，其行为类似常规指针，但是会负责释放所指向的对象。其中，shared_ptr允许多个指针指向同一对象；unique_ptr则“独占”所指向的对象；weak_ptr是一种弱引用，指向shared_ptr所管理的对象。

shared_ptr

如果不初始化一个智能指针，它默认是一个空指针

1
2
shared_ptr<int> p;
cout << (p == nullptr) << endl; // output 1

当进行拷贝或赋值操作时，每个shared_ptr都会记录有多少个其他shared_ptr指向相同的对象。为了说明，定义一个简单的类，使用shared_ptr控制其分配和销毁。当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr类会自动销毁此对象——通过析构函数

1
2
3
4
5
6
7
8
9
10
class Obj
{
public:
    int count{};
    Obj(int c) : count(c) {}
    ~Obj()
    {
        cout << "call Obj destructor" << endl;
    }
};

通过赋值，两个shared_ptr共同操作一个对象

1
2
3
4
5
6
// a simple example
shared_ptr<Obj> p(new Obj(12));
cout << p.use_count() << ' ' << p->count << endl;
shared_ptr<Obj> q = p;
++q->count;
cout << q.use_count() << ' ' << q->count << endl;

输出显示为

1
2
3
4
> g++ main.cc -g -o main && ./main
1 12
2 13
call Obj destructor

包括调用函数时的参数和函数内部的局部变量，也会影响shared_ptr的计数

1
2
3
shared_ptr<Obj> p(new Obj(12));
foo(p);
cout << p.use_count() << ' ' << p->count << endl;

其中，foo的定义为

1
2
3
4
5
6
7
void foo(shared_ptr<Obj> ptr)
{
    cout << ptr.use_count() << endl;
    auto x = ptr;
    cout << x.use_count() << endl;
    x->count++;
}

输出如下：

1
2
3
4
5
> g++ main.cc -g -o main && ./main
2
3
1 13
call Obj destructor

可以使用new返回的指针初始化智能指针。接受指针参数的智能指针构造函数是explicit的，不支持隐式转换。默认情况下，一个用来初始化智能指针的普通指针必须指向动态内存。

1
2
3
4
5
6
7
8
9
shared_ptr<int> p = new int(1024); // error
shared_ptr<int> q(new int(1024));  // true

/*
munmap_chunk(): invalid pointer
fish: Job 1, './main' terminated by signal SIGABRT (Abort)
*/
int x;
shared_ptr<int> r(&x);

get()可以返回指向智能指针管理的对象的内置指针。注意，不要使用get()返回的内置指针初始化另一个智能指针，或尝试delete它

1
2
3
4
5
6
7
shared_ptr<int> p(new int(42));
int *q = p.get();

{ // new block
    shared_ptr<int> (q);
} // free the object pointed by q
int foo = *p; // undefined behaviro

use_count方法返回shared_ptr的用户个数，unique方法返回是否当前指针是唯一用户

1
2
3
4
shared_ptr<int> p(new int(42));
cout << p.use_count() << ' ' << p.unique() << endl; // 1 1
shared_ptr<int> q = p;
cout << p.use_count() << ' ' << p.unique() << endl; // 2 0

还可以调用自定义的可调用对象代替delete，通过shared_ptrp(q, d)，p接管q所指向的对象的所有权，调用d替代默认的delete。

1
2
3
4
5
6
7
8
9
10
11
12
13
void my_delete(Obj * po)
{
    cout << "this is my delete function" << endl;
    delete po;
}

int main()
{
    shared_ptr<Obj> p(new Obj(12), my_delete);
    cout << p.use_count() << ' ' << p->count << endl;

    return 0;
}

输出为

1
2
3
4
> g++ main.cc -g -o main && ./main
1 12
this is my delete function
call Obj destructor

unique_ptr

一个unique_ptr拥有它指向的对象，当我们定义一个unique_ptr时，需要将其绑定到一个new返回的指针上。且其不支持拷贝和赋值

1
2
3
4
5
6
7
unique_ptr<double> p1;            // default nullptr
cout << (p1 == nullptr) << endl;  // 1

unique_ptr<int> p2(new int(12));
unique_ptr<int> p3(p2);   // error
unique_ptr<int> p4;
p4 = p2;                 // error

可以通过release或reset将指针所有权从一个unique_ptr转移给另一个unique_ptr。

1
2
3
4
unique_ptr<Obj> p1(new Obj(12));       
unique_ptr<Obj> p2(p1.release());
unique_ptr<Obj> p3(new Obj(13));
p2.reset(p3.release());

输出为

1
2
3
> g++ main.cc -g -o main && ./main
call Obj destructor 12
call Obj destructor 13

有一种特殊情况，即当要返回的对象将要销毁时，可以执行一种特殊的拷贝。

1
2
3
4
5
6
7
8
9
10
11
12
unique_ptr<Obj> clone(int count)
{
    return unique_ptr<Obj>(new Obj(count));
}

int main()
{
    auto p = clone(1);
    cout << p->count <<endl;
    
    return 0;
}
1
2
3
> g++ main.cc -g -o main && ./main
1
call Obj destructor 1

weak_ptr

weak_ptr是一种不控制所指向对象生存期的智能指针，它指向由一个shared_ptr管理的对象。将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放，即使有weak_ptr指向它。
创建weak_ptr时需要一个shared_ptr初始化。

1
2
3
4
5
6
7
8
9
10
auto p = make_shared<Obj>(11);
weak_ptr<Obj> wp(p);
cout << p.use_count() << endl; // weak_ptr do not change the use count

if (auto np = wp.lock())
{
    cout << np.use_count() << endl;
    ++np->count;
}
cout << p->count << endl;

由于weak_ptr指向的对象可能不存在，需要调用lock函数检查weak_ptr指向的对象是否存在，如果存在则返回一个指向共享对象的shared_ptr，因此可以通过该函数使用weak_ptr访问指向的对象。

implement shared_ptr and weak_ptr