[c++] 智能指针(shared_ptr, weak_ptr, unique

c++ 中的智能指针让 c++ 看起来像 java，go 这种带 GC 的语言，但和 GC 又不完全相同。c++ 中的智能指针使用引用计数，当引用计数减为 0 的时候就会立即释放资源，释放资源具有实时性；而像 java，go 这样的 GC 语言，当对象不被引用时，可能不会立即释放资源，资源的释放有滞后性。

如果不使用智能指针，需要开发者使用 new 和 delete 创建和销毁对象。

使用智能指针，开发者不需要手动来释放资源，当引用计数变为 0 时自动释放。

就这一个好处。

使用智能指针需要包含头文件 memory。

1 shared_ptr 和 weak_ptr

1.1 shared_ptr

shared_ptr 是共享指针，对于一个对象来说，可以有多个 shared_ptr 指针指向它，每多一个指针指向它，这个对象的引用计数就会增加 1。shared_ptr 有一个函数是 reset()，每 reset() 一次，对象的引用计数就会减去 1，当引用计数变为 0 的时候，就会释放对象。

shared_ptr 的常用方法：

use_count()	获取对象的引用计数
get()	获取对象的原始指针
reset()	引用计数减 1，或者使用一个新的对象重置这个智能指针

shared_ptr 示例代码如下：

#include <iostream>
#include <string>
#include <memory>class Test {
public:Test() {std::cout << "Test()" << std::endl;}~Test() {std::cout << "~Test()" << std::endl;}void Do() {std::cout << "Test() Do()" << std::endl;}
};void SharedParam(std::shared_ptr<Test> t) {std::cout << "SharedParam, t.use_count() = " << t.use_count() << std::endl;
}void SharedRefParam(std::shared_ptr<Test> &t) {std::cout << "SharedRefParam, t.use_count() = " << t.use_count() << std::endl;
}int main() {std::shared_ptr<Test> t1 = std::make_shared<Test>();std::shared_ptr<Test> t2 = t1;std::shared_ptr<Test> t3 = t1;std::cout << "t1.use_count() = " << t1.use_count() << std::endl;std::cout << "t2.use_count() = " << t2.use_count() << std::endl;std::cout << "t3.use_count() = " << t3.use_count() << std::endl;std::cout << std::endl;SharedParam(t1);SharedRefParam(t1);t3.reset();std::cout << "after t3 reset" << std::endl;std::cout << "t1.use_count() = " << t1.use_count() << std::endl;std::cout << "t2.use_count() = " << t2.use_count() << std::endl;std::cout << "t3.use_count() = " << t3.use_count() << std::endl;std::cout << std::endl;t2.reset();t1.reset();std::cout << "after t2, t1 reset" << std::endl;std::cout << "t1.use_count() = " << t1.use_count() << std::endl;std::cout << "t2.use_count() = " << t2.use_count() << std::endl;std::cout << "t3.use_count() = " << t3.use_count() << std::endl;std::cout << std::endl;std::shared_ptr<Test> t4;t4.reset(new Test);std::cout << "t2.use_count() = " << t2.use_count() << std::endl;std::cout << "t4.use_count() = " << t4.use_count() << std::endl;std::cout << std::endl;Test *t5 = t4.get();t5->Do();return 0;
}

代码编译之后，运行结果如下：

1.2 weak_ptr

1.2.1 shared_ptr 存在的问题：循环引用，无法自动释放资源

要了解为什么需要 weak_ptr 就需要了解 shared_ptr 存在的问题。

shared_ptr 的问题示例代码如下，按我们的理解，main() 函数返回的时候，a，b 两个共享指针会自动释放。代码中即使分别对 a 和 b 进行了 reset，也不能自动释放。

#include <iostream>
#include <string>
#include <memory>class B;class A {
public:A() {std::cout << "A()" << std::endl;}~A() {std::cout << "~A()" << std::endl;}std::shared_ptr<B> b_;
};class B {
public:B() {std::cout << "B()" << std::endl;}~B() {std::cout << "~B()" << std::endl;}std::shared_ptr<A> a_;
};int main() {std::shared_ptr<A> a = std::make_shared<A>();std::shared_ptr<B> b = std::make_shared<B>();a->b_ = b;b->a_ = a;a.reset();b.reset();return 0;
}

运行结果如下，类 A 和类 B 的析构函数并没有被调用。

main() 函数返回时的析构过程：

（1）a 和 b 析构，a 和 b 的引用计数减 1

（2）销毁 a 中的 b，这个时候 b 的引用计数要减为 0，减为 0 的时候就要销毁 b 中的成员 a；销毁 b 中的 a，同理 b 中的 a 的引用计数要减为 0。两者死锁，最终到是 a 和 b 都无法析构。

1.2.2 weak_ptr

weak_ptr 不会增加对象的引用计数，当有循环引用这种情况时，可以使用 weak_ptr 来代替 shared_ptr，以此来解决 shared_ptr 不能自动释放的问题。

本来 shared_ptr 是用来简化开发工作的，这里又引入了 weak_ptr，通过 weak_ptr 又不能直接访问对象，还要使用 lock 来获取对象。开发工作并没有简化多少。

本来 c++ 中的引用是为了减少指针操作的，但是 c++ 中的引用又分左值引用，右值引用，导致用起来并不比指针简单。

代码如下所示，A 中对 B 的引用由 shared_ptr 改成了 weak_ptr。

#include <iostream>
#include <string>
#include <memory>class B;class A {
public:A() {std::cout << "A()" << std::endl;}~A() {std::cout << "~A()" << std::endl;}std::weak_ptr<B> b_;
};class B {
public:B() {std::cout << "B()" << std::endl;}~B() {std::cout << "~B()" << std::endl;}std::shared_ptr<A> a_;
};int main() {std::shared_ptr<A> a = std::make_shared<A>();std::shared_ptr<B> b = std::make_shared<B>();a->b_ = b;b->a_ = a;int a_use_count = a.use_count();int b_use_count = b.use_count();std::cout << "a use count = " << a_use_count << ", b use count = " << b_use_count << std::endl;a.reset();b.reset();return 0;
}

代码编译之后，运行结果如下，可以看到 A 和 B 的析构函数都被调用了。

因为 A 中对 B 的引用是 weak_ptr，weak_ptr 不会增加引用计数，所以 b 的引用计数是 1。

通过 weak_ptr 不能直接访问对象，要通过 lock() 获取 shared_ptr，lock() 不为空，则可用；为空，说明对象已经释放了。通过 expired() 方法也能确定 shared_ptr 是不是已经过期了。

#include <iostream>
#include <string>
#include <memory>class B;class A {
public:A() {std::cout << "A()" << std::endl;}~A() {std::cout << "~A()" << std::endl;}void Do() {std::cout << "Do()" << std::endl;}
};int main() {std::shared_ptr<A> a = std::make_shared<A>();std::weak_ptr<A> b = a;std::cout << "1, a use count = " << a.use_count() << ", b use count = " << b.use_count() << std::endl;a.reset();std::cout << "2, a use count = " << a.use_count() << ", b use count = " << b.use_count() << std::endl;if (b.lock()) {std::cout << "shared a exists" << std::endl;} else {std::cout << "shared a not exists" << std::endl;}std::cout << "b.expired() = " << b.expired() << std::endl;a.reset(new A);b = a;std::cout << "3, a use count = " << a.use_count() << ", b use count = " << b.use_count() << std::endl;b.reset();std::cout << "4, a use count = " << a.use_count() << ", b use count = " << b.use_count() << std::endl;if (b.lock()) {std::cout << "shared a exists" << std::endl;} else {std::cout << "shared a not exists" << std::endl;}b = a;if (b.lock()) {auto sp = b.lock();sp->Do();}return 0;
}

运行结果如下：

2 unique_ptr

unique_ptr 是独占智能指针，永远只能有一个指针指向这个对象。

在不同智能指针间传递需要通过 std::move() 来进行。

示例代码如下所示：

#include <iostream>
#include <string>
#include <memory>class A {
public:A() {std::cout << "A()" << std::endl;}~A() {std::cout << "~A()" << std::endl;}void Do() {std::cout << "Do()" << std::endl;}
};int main() {std::unique_ptr<A> u1 = std::make_unique<A>();std::unique_ptr<A> u2(new A);std::unique_ptr<A> u3(std::make_unique<A>());if (u1) {std::cout << "u1 Do()" << std::endl;u1->Do();}u1.reset();if (u1) {std::cout << "u1 Do() after u1.reset()" << std::endl;}if (u2) {std::cout << "u2 Do()" << std::endl;u2->Do();}std::unique_ptr<A> u4 = std::move(u2);if (u2) {std::cout << "u2 Do()i after u2 moved" << std::endl;u2->Do();}return 0;
}

unique_ptr 自己调用 reset() 或者使用 std::move() 转移之后，自己就会变为 nullptr。

3 自动析构

（1）[普通对象] 全局和局部的对象，在函数返回时析构

#include <iostream>
#include <string>
#include <memory>class A {
public:A() {std::cout << "A()" << std::endl;}~A() {std::cout << "~A()" << std::endl;}void Do() {std::cout << "Do()" << std::endl;}
};A a1;
void Test() {A a2;
}int main() {std::cout << "main" << std::endl;Test();A a3;return 0;
}

（2）[普通对象] 对象指针不会自动释放，需要调用 delete 手动释放

#include <iostream>
#include <string>
#include <memory>class A {
public:A() {std::cout << "A()" << std::endl;}~A() {std::cout << "~A()" << std::endl;}void Do() {std::cout << "Do()" << std::endl;}
};A *a1;
void Test() {A *a2 = new A;
}int main() {std::cout << "main" << std::endl;Test();A *a3 = new A;return 0;
}

（3）[普通对象] 对象释放的时候，对象中的对象成员会自动释放

#include <iostream>
#include <string>
#include <memory>class A {
public:A() {std::cout << "A()" << std::endl;}~A() {std::cout << "~A()" << std::endl;}void Do() {std::cout << "Do()" << std::endl;}
};class B {
public:B() {std::cout << "B()" << std::endl;}~B() {std::cout << "~B()" << std::endl;}A a;
};int main() {std::cout << "main" << std::endl;A a1;return 0;
}

（4）[智能指针] 全局智能指针，局部智能指针，对象中的智能指针会自动释放

#include <iostream>
#include <string>
#include <memory>class A {
public:A() {std::cout << "A()" << std::endl;}~A() {std::cout << "~A()" << std::endl;}void Do() {std::cout << "Do()" << std::endl;}
};class B {
public:B() {std::cout << "B()" << std::endl;}~B() {std::cout << "~B()" << std::endl;}std::shared_ptr<A> a1;std::unique_ptr<A> a2;
};std::shared_ptr<A> sa1;
std::unique_ptr<A> ua1;int main() {std::cout << "main" << std::endl;sa1 = std::make_shared<A>();ua1 = std::make_unique<A>();std::shared_ptr<A> sa2 = std::make_shared<A>();std::unique_ptr<A> ua2 = std::make_unique<A>();B b;b.a1 = std::make_shared<A>();b.a2 = std::make_unique<A>();return 0;
}

（5）[智能指针] 如果智能指针所在的对象或者容器不会自动析构，那么智能指针也不能析构

#include <iostream>
#include <string>
#include <memory>
#include <vector>class A {
public:A() {std::cout << "A()" << std::endl;}~A() {std::cout << "~A()" << std::endl;}void Do() {std::cout << "Do()" << std::endl;}
};class B {
public:B() {std::cout << "B()" << std::endl;}~B() {std::cout << "~B()" << std::endl;}std::shared_ptr<A> a;
};int main() {B *b = new B;b->a = std::make_shared<A>();return 0;
}