[CPP] 智能指针
介绍 C++ 的智能指针 (Smart Pointers) 相关 API。
C++ 中的智能指针是为了解决内存泄漏、重复释放等问题而提出的,它基于 RAII (Resource Acquisition Is Initialization),也称为“资源获取即初始化” 的思想实现。智能指针实质上是一个类,但经过封装之后,在行为语义上的表现像指针。
参考资料:
- [1] https://en.cppreference.com/w/cpp/memory
- [2] https://docs.microsoft.com/zh-cn/cpp/cpp/smart-pointers-modern-cpp?view=msvc-160
shared_ptr
shared_ptr
能够记录多少个 shared_ptr
共同指向一个对象,从而消除显式调用 delete
,当引用计数变为零的时候就会将对象自动删除。
注意,这里使用 shared_ptr
能够实现自动 delete
,但是如果使用之前仍需要 new
的话,代码风格就会变得很「奇怪」,因为 new/delete
总是需要成对出现的,所以尽可能使用封装后的 make_shared
来「代替」new
。
shared_ptr
基于引用计数实现,每一个 shared_ptr
的拷贝均指向相同的内存。如果某个 shared_ptr
被析构(生命周期结束),那么引用计数减 1 ,当引用计数为 0 时,自动释放指向的内存。
shared_ptr
的所有成员函数,包括拷贝构造函数 (Copy Constructor) 和拷贝赋值运算 (Copy Assignment Operator),都是线程安全的,即使这些 shared_ptr
指向同一对象。但如果是多线程访问同一个 non-const 的 shared_ptr
,那有可能发生资源竞争 (Data Race) 的情况,比如改变这个 shared_ptr
的指向,因此这种情况需要实现多线程同步机制。当然,可以使用 shared_ptr overloads of atomic functions 来防止 Data Race 的发生。
内部实现
如下图所示,shared_ptr
内部仅包括 2 个指针,一个指针指向共享对象,另外一个指针指向 Control block .
![](https://github.com/Sin-Kinben/PicGo/raw/master/img/20210116193758.png)
初始化
- 通过构造函数初始化(
废话)
下面是正确的方式。
void func1()
{
int *a = new int[10];
shared_ptr<int[]> p(a);
// a is same as p.get()
cout << a << endl;
cout << p.get() << endl;
for (int i = 0; i < 10; i++) p[i] = i;
for (int i = 0; i < 10; i++) cout << a[i] << ' ';
}
// Output: 1-9
下面是错误的方式,因为 ptr
析构时会释放 &a
这个地址,但这个地址在栈上(而不是堆),因此会发生运行时错误。
int main()
{
int a = 10;
shared_ptr<int> ptr(&a);
// a is same as p.get(), but runs fail
cout << &a << endl;
cout << ptr.get() << endl;
}
- 如果通过
nullptr
初始化,那么引用计数的初始值为 0 而不是 1 。
shared_ptr<void *> p(nullptr);
cout << p.use_count() << endl;
- 不允许通过一个原始指针初始化多个
shared_ptr
。
int main()
{
int *p = new int[10];
shared_ptr<int> ptr1(p);
shared_ptr<int> ptr2(p);
cout << p << endl;
cout << ptr1.get() << endl;
cout << ptr2.get() << endl;
}
上述方式是错误的。可以通过编译,三行 cout
也能正常输出,但会发生运行时错误,因为 ptr2
会先执行析构函数,释放 p
,然后 ptr1
进行析构的时候,就会对无效指针 p
进行重复释放。
0x7feefd405a10
0x7feefd405a10
0x7feefd405a10
a.out(6286,0x113edde00) malloc: *** error for object 0x7feefd405a10: pointer being freed was not allocated
a.out(6286,0x113edde00) malloc: *** set a breakpoint in malloc_error_break to debug
- 通过
make_shared
初始化
make_shared
的参数可以时一个对象,也可以是跟该类的构造函数匹配的参数列表。
auto ptr1 = make_shared<vector<int>>(10, -1);
auto ptr2 = make_shared<vector<int>>(vector<int>(10, -1));
与通过构造函数初始化不同的是,make_shared
允许传入一个临时对象,如以下代码:
int main()
{
vector<int> v = {1, 2, 3};
auto ptr = make_shared<vector<int>>(v);
// &v = 0x7ffeef698690
// ptr.get() = 0x7fc03ec05a18
cout << &v << endl;
cout << ptr.get() << endl;
// v[0] is still 1
ptr.get()->resize(3, -1);
cout << v[0] << endl;
}
通过 ptr.get()
获取指针并修改指向的内存,并不会影响局部变量 v
的内容。
自定义 deleter
在初始化时传入一个函数指针,shared_ptr
在释放指向的对象时,会调用自定义的 deleter
处理释放行为。
int main()
{
int *p = new int[10];
auto func = [](int *p) {
delete[] p;
cout << "Delete memory at " << p << endl;
};
shared_ptr<int> ptr(p, func);
}
那么 deleter
有什么用呢?假如我们有这么一段代码:
class Basic
{
public:
Basic() { cout << "Basic" << endl; }
~Basic() { cout << "~Basic" << endl; }
};
int main()
{
Basic *p = new Basic[3];
shared_ptr<Basic> ptr(p);
}
这段代码会发生运行时错误。因为 shared_ptr
默认是使用 delete
去释放指向的对象,但定义了析构函数的对象数组,必须要通过 delete[]
析构,否则产生内存错误。
因此,为了使上述代码正常工作,需要自定义 delete
函数:
shared_ptr<Basic> ptr(p, [](Basic *p){ delete[] p; });
或者(C++17 及其之后的标准支持):
shared_ptr<Base[]> ptr(p);
指向一个函数
根据参考资料 [1] ,shared_ptr
指向一个函数,有时用于保持动态库或插件加载,只要其任何函数被 shared_ptr
引用:
void func() { cout << "hello" << endl; }
int main()
{
shared_ptr<void()> ptr(func, [](void (*)()) {});
(*ptr)();
}
注意,这里自定义的 deleter
是必不可少的,否则不能通过编译。
例子
#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>
using namespace std;
class Base
{
public:
Base() { cout << "Base" << endl; }
~Base() { cout << "~Base" << endl; }
};
class Derived : public Base
{
public:
Derived() { cout << " Derived" << endl; }
~Derived() { cout << " ~Derived" << endl; }
};
void worker(shared_ptr<Base> ptr)
{
this_thread::sleep_for(std::chrono::seconds(1));
shared_ptr<Base> lp = ptr;
{
static std::mutex io_mutex;
lock_guard<mutex> lock(io_mutex);
cout << "local pointer in a thread:\n"
<< " lp.get() = " << lp.get() << ", "
<< " lp.use_count() = " << lp.use_count() << "\n";
}
}
int main()
{
shared_ptr<Base> ptr = make_shared<Derived>();
cout << "Created a shared Derived (as a pointer to Base)\n"
<< "ptr.get() = " << ptr.get() << ", "
<< "ptr.use_count() = " << ptr.use_count() << '\n';
thread t1(worker, ptr), t2(worker, ptr), t3(worker, ptr);
this_thread::sleep_for(std::chrono::seconds(2));
ptr.reset();
std::cout << "Shared ownership between 3 threads and released\n"
<< "ownership from main:\n"
<< " p.get() = " << ptr.get()
<< ", p.use_count() = " << ptr.use_count() << '\n';
t1.join(), t2.join(), t3.join();
}
输出:
Base
Derived
Created a shared Derived (as a pointer to Base)
ptr.get() = 0x7fcabc405a08, ptr.use_count() = 1
Shared ownership between 3 threads and released
ownership from main:
p.get() = 0x0, p.use_count() = 0
local pointer in a thread:
lp.get() = 0x7fcabc405a08, lp.use_count() = 6
local pointer in a thread:
lp.get() = 0x7fcabc405a08, lp.use_count() = 4
local pointer in a thread:
lp.get() = 0x7fcabc405a08, lp.use_count() = 2
~Derived
~Base
lp.use_count
也可能是 {5,3,2}
这样的序列。在 worker
传入参数过程中,ptr
被拷贝了 3 次,并且在进入 worker
后,三个线程的局部变量 lp
又把 ptr
拷贝了 3 次,因此 user_count
的最大值是 7 。
unique_ptr
unique_ptr
保证同一时刻只能有一个 unique_ptr
指向给定对象。发生下列情况之一时,指定对象就会被释放:
unique_ptr
被销毁(生命周期消亡,被delete
等情况)unique_ptr
调用reset
或者进行ptr1 = move(ptr2)
操作
基于这 2 个特点,non-const 的 unique_ptr
可以把管理对象的所有权转移给另外一个 unique_ptr
:
![](https://github.com/Sin-Kinben/PicGo/raw/master/img/20210118181818.png)
示例代码:
class Base
{
public:
Base() { cout << "Base" << endl; }
~Base() { cout << "~Base" << endl; }
};
int main()
{
auto p = new Base();
cout << p << endl;
unique_ptr<Base> ptr(p);
unique_ptr<Base> ptr2 = std::move(ptr);
cout << ptr.get() << endl;
cout << ptr2.get() << endl;
}
/* Output is :
Base
0x7fd81fc059f0
0x0
0x7fd81fc059f0
~Base
*/
在上述代码中,存在 U = move(V)
,当执行该语句时,会发生两件事情。首先,当前 U 所拥有的任何对象都将被删除;其次,指针 V 放弃了原有的对象所有权,被置为空,而 U 则获得转移的所有权,继续控制之前由 V 所拥有的对象。
如果是 const unique_ptr
,那么其指向的对象的作用域 (Scope) 只能局限在这个 const unique_ptr
的作用域当中。
此外,unique_ptr
不能通过 pass by value 的方式传递参数,只能通过 pass by reference 或者 std::move
。
初始化
与 shared_ptr
类似。但由于 unique_ptr
的特点,它没有拷贝构造函数,因此不允许 unique_ptr<int> ptr2 = ptr
这样的操作。
下面是 unique_ptr
正确初始化的例子。
- 指向对象
class Base
{
public:
Base() { cout << "Base" << endl; }
~Base() { cout << "~Base" << endl; }
void printThis() { cout << this << endl; }
};
int main()
{
auto p = new Base();
unique_ptr<Base> ptr(p);
ptr->printThis();
}
/* Output is:
Base
0x7fbe0a4059f0
~Base
*/
- 指向数组
int main()
{
auto p = new Base[3];
unique_ptr<Base[]> ptr(p);
for (int i = 0; i < 3; i++)
ptr[i].printThis();
}
/* Output is:
Base * 3
0xc18c28 0xc18c29 0xc18c2a
~Base * 3
*/
make_unique
与 make_shared
类似,允许向 make_unique
传入一个临时变量。
void func3()
{
auto ptr = make_unique<vector<int>>(5, 0);
for (int i = 0; i < 5;i++) (*ptr)[i] = i;
for (int x : *ptr) cout << x << ' ';
}
// Output: 0 1 2 3 4
自定义 deleter
unique_ptr
的 deleter
与 shared_ptr
不同,它是基于模版参数实现的。
使用仿函数
struct MyDeleter
{
void operator()(Base *p)
{
cout << "Delete memory[] at " << p << endl;
delete[] p;
}
};
unique_ptr<Base[], MyDeleter> ptr(new Base[3]);
// unique_ptr<Base, MyDeleter> ptr(new Base[3]);
// both of them is okay
使用普通函数
unique_ptr<Base[], void (*)(Base * p)> ptr(new Base[3], [](Base *p) {
cout << "Delete memory[] at " << p << endl;
delete[] p;
});
使用 std::function
unique_ptr<Base[], function<void(Base *)>> ptr(new Base[3], [](Base *p) { delete[] p; });
注意到,使用普通函数时,模版参数为 void (*)(Base *p)
,这是一种数据类型,该类型是一个指针,指向一个返回值为 void
, 参数列表为 (Base *p)
的函数,而 void *(Base *p)
则是在声明一个函数(看不懂可以忽略)。
作为函数参数或返回值
unique_ptr
作为函数参数,只能通过引用,或者 move
操作实现。
下列操作无法通过编译:
void func5(unique_ptr<Base> ptr) {}
int main()
{
unique_ptr<Base> ptr(new Base());
func5(ptr);
}
需要改成:
void func5(unique_ptr<Base> &ptr) {}
func(ptr);
或者通过 move
转换为右值引用:
void func5(unique_ptr<Base> ptr)
{
cout << "ptr in function: " << ptr.get() << endl;
}
int main()
{
auto p = new Base();
cout << "p = " << p << endl;
unique_ptr<Base> ptr(p);
func5(move(ptr));
cout << "ptr in main: " << ptr.get() << endl;
}
/* Output is:
Base
p = 0xa66c20
ptr in function: 0xa66c20
~Base
ptr in main: 0
*/
把 unique_ptr
作为函数返回值,会自动发生 U = move(V)
的操作(转换为右值引用):
unique_ptr<Base> func6()
{
auto p = new Base();
unique_ptr<Base> ptr(p);
cout << "In function: " << ptr.get() << endl;
return ptr;
}
int main()
{
auto ptr = func6();
cout << "In main: " << ptr.get() << endl;
}
成员函数
函数 | 作用 |
---|---|
release | returns a pointer to the managed object and releases the ownership (will not delete the object) |
reset | replaces the managed object (it will delete the object) |
swap | swaps the managed objects |
get | returns a pointer to the managed object |
get_deleter | returns the deleter that is used for destruction of the managed object |
operator bool | checks if there is an associated managed object (more details) |
operator = | assigns the unique_ptr , support U = move(V) , U will delete its own object |
例子
#include <vector>
#include <memory>
#include <iostream>
#include <fstream>
#include <functional>
#include <cassert>
#include <cstdio>
using namespace std;
// helper class for runtime polymorphism demo
class B
{
public:
virtual void bar() { cout << "B::bar\n"; }
virtual ~B() = default;
};
class D : public B
{
public:
D() { cout << "D::D\n"; }
~D() { cout << "D::~D\n"; }
void bar() override { cout << "D::bar\n"; }
};
// a function consuming a unique_ptr can take it by value or by rvalue reference
unique_ptr<D> passThrough(unique_ptr<D> p)
{
p->bar();
return p;
}
// helper function for the custom deleter demo below
void close_file(FILE *fp) { std::fclose(fp); }
// unique_ptr-base linked list demo
class List
{
public:
struct Node
{
int data;
unique_ptr<Node> next;
Node(int val) : data(val), next(nullptr) {}
};
List() : head(nullptr) {}
~List() { while (head) head = move(head->next); }
void push(int x)
{
auto t = make_unique<Node>(x);
if (head) t->next = move(head);
head = move(t);
}
private:
unique_ptr<Node> head;
};
int main()
{
cout << "unique ownership semantics demo\n";
{
auto p = make_unique<D>();
auto q = passThrough(move(p));
assert(!p), assert(q);
}
cout << "Runtime polymorphism demo\n";
{
unique_ptr<B> p = make_unique<D>();
p->bar();
cout << "----\n";
vector<unique_ptr<B>> v;
v.push_back(make_unique<D>());
v.push_back(move(p));
v.emplace_back(new D());
for (auto &p : v) p->bar();
}
cout << "Custom deleter demo\n";
ofstream("demo.txt") << "x";
{
unique_ptr<FILE, decltype(&close_file)> fp(fopen("demo.txt", "r"), &close_file);
if (fp) cout << (char)fgetc(fp.get()) << '\n';
}
cout << "Linked list demo\n";
{
List list;
for (long n = 0; n != 1000000; ++n) list.push(n);
cout << "Pass!\n";
}
}
weak_ptr
weak_ptr
指针通常不单独使用(因为没有实际用处),只能和 shared_ptr
类型指针搭配使用。
当 weak_ptr
类型指针的指向和某一 shared_ptr
指针相同时,weak_ptr
指针并不会使所指堆内存的引用计数加 1;同样,当 weak_ptr
指针被释放时,之前所指堆内存的引用计数也不会因此而减 1。也就是说,weak_ptr
类型指针并不会影响所指堆内存空间的引用计数。
此外,weak_ptr
没有重载 *
和 ->
运算符,因此 weak_ptr
只能访问所指的堆内存,而无法修改它。
weak_ptr
作为一个 Observer 的角色存在,可以获取 shared_ptr
的引用计数,可以读取 shared_ptr
指向的对象。
成员函数:
函数 | 作用 |
---|---|
operator = | weak_ptr 可以直接被 weak_ptr 或者 shared_ptr 类型指针赋值 |
swap | 与另外一个 weak_ptr 交换 own objetc |
reset | 置为 nullptr |
use_count | 查看与 weak_ptr 指向相同对象的 shared_ptr 的数量 |
expired | 判断当前 weak_ptr 是否失效(指针为空,或者指向的堆内存已经被释放) |
lock | 如果 weak_ptr 失效,则该函数会返回一个空的 shared_ptr 指针;反之,该函数返回一个和当前 weak_ptr 指向相同的 shared_ptr 指针。 |
例子:
#include <memory>
#include <iostream>
using namespace std;
// global weak ptr
weak_ptr<int> gw;
void observe()
{
cout << "use count = " << gw.use_count() << ": ";
if (auto spt = gw.lock()) cout << *spt << "\n";
else cout << "gw is expired\n";
}
int main()
{
{
auto sp = make_shared<int>(233);
gw = sp;
observe();
}
observe();
}
// Output:
// use count = 1: 233
// use count = 0: gw is expired
循环引用
对于 shared_ptr
的使用,要注意避免循环引用的问题,否则智能指针同样能造成内存泄漏的问题。
考虑如下场景:A parent has a child, a child knows his/her parent .
class Parent;
class Child;
class Parent
{
public:
shared_ptr<Child> childptr;
Parent() { cout << "Parent" << endl; }
~Parent() { cout << "~Parent" << endl; }
};
class Child
{
public:
shared_ptr<Parent> parentptr;
Child() { cout << "Child" << endl; }
~Child() { cout << "~Child" << endl; }
};
int main()
{
shared_ptr<Parent> parent(new Parent());
shared_ptr<Child> child(new Child());
parent->childptr = child;
child->parentptr = parent;
}
在上述代码中,只输出了 "Parent"
和 "Child"
,并没有输出 "~Parent"
和 "~Child"
,说明析构函数没有执行,shared_ptr
离开作用域后没有释放 2 个对象。这是为什么呢?
parent child
| |
V V
+---Parent---+ +---Child---+
| childptr |---------->| |
| |<----------| parentptr |
+------------+ +-----------+
在 parent, child
这 2 个指针离开作用域后,在堆上的 2 个对象依然在相互引用,导致它们的 use_count
依然为 1 ,因此无法释放。
可以通过下面的代码验证:
int main()
{
weak_ptr<Parent> wp1;
weak_ptr<Child> wp2;
{
shared_ptr<Parent> parent(new Parent());
shared_ptr<Child> child(new Child());
parent->childptr = child, child->parentptr = parent;
wp1 = parent, wp2 = child;
cout << "Parent: " << wp1.use_count() << endl; // 2
cout << "Child: " << wp2.use_count() << endl; // 2
}
cout << "Parent: " << wp1.use_count() << endl; // 1
cout << "Child: " << wp2.use_count() << endl; // 1
}
解决办法:把 2 个类中的成员变量改为 weak_ptr<>
。
总结
使用智能指针的几个重要原则是:
- 永远不要试图去动态分配一个智能指针,相反,应该像声明函数的局部变量那样去声明智能指针。
- 使用
shared_ptr
要注意避免循环引用