智能指针

• 解决内存泄漏的问题

shared_ptr

1. 智能指针是不是线程安全的？
   • 引用计数是线程安全的（原子计数）
   • 指向的内容是线程不安全的，需要自己添加锁机制

1
2
3
4
5
6
7
8
9
10

auto sp1 = make_shared<int>(100); // 优先使用
// 相当于 
shared_ptr<int> sp2(new int(100));

std::shared_ptr<int> p2; // 可以先声明
p1.reset(new int(1)); // 分配资源
p1.reset(); // 清空
if(p1){
    // 判断有没有具体指向
} 

2. 指定删除器

   1 2 3 4 5 6 7 8 9 10 11 12 13

   ##include <iostream> ##include <memory> using namespace std; void DeleteIntPtr(int *p) { cout << "call DeleteIntPtr" << endl; delete p; } int main() { std::shared_ptr<int> p(new int(1), DeleteIntPtr); return 0; }

3. 同一个裸指针不要托管给两个智能指针

   1 2 3 4 5 6

   int *ptr = new int; shared_ptr<int> p1(ptr); shared_ptr<int> p2(ptr); cout << "p1.use_count()= " << p1.use_count() << endl; // ==1 cout << "p2.use_count()= " << p2.use_count() << endl; // ==1 // 会出现逻辑错误，会有两次析构同一个内容

4. 不要在函数实际参数中创建智能指针

   1 2 3 4

   function(shared_ptr<int>(new int), g()); // 不要这样, 编译器有可能先调用g，也有可能先new int，然后调用g()，如果g()发生异常，而shared_ptr没有创建完成，会发生内存泄漏 // 可以这样 shared_ptr<int> p(new int); function(p, g());

5. 不要返回shared_ptr(this)，使用shared_from_this();

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   class A { public: shared_ptr<A> GetSelf(){ return shared_ptr<A>(this); // 不要这样，使用shared_from_this(); } ~A(){ cout << "Destructor A" << endl; } } int main(){ shared_ptr<A> sp1(new A); shared_ptr<A> sp2 = sp1->GetSelf(); return 0; // 输出两次析构，this本质上也是一个裸指针，这样直接返回相当于托管了两次 }

6. 避免循环引用

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

   class A; class B; class A{ public: std::shared_ptr<B> bptr; ~A(){ cout << "A is deleted" << endl; } } class B{ public: std::shared_ptr<A> aptr; ~B(){ cout << "B is deleted" << endl; } } int main(){ { std::shared_ptr<A> ap(new A); std::shared_ptr<B> bp(new B); ap->bptr = bp; bp->aptr = ap; } // 循环引用导致ap和bp都没有正确释放 cout << "main leave " << endl; return 0; }

unique_ptr

• 独占，不允许赋值，不能与shared_ptr混用

weak_ptr

• 用于避免循环引用，需要结合shared_ptr使用

1. 使用前一定要检查合法性

   1 2 3 4 5 6 7 8

   weak_ptr<int> wp; { shared_ptr<int> sp(new int(1)); // sp.use_count() == 1 wp = sp; // wp不会改变引用计数，所以sp.use_count() == 1 shared_ptr<int> sp_ok = wp.lock(); } shared_ptr<int> sp_null = wp.lock(); // sp_null.use_count == 0 // 因为离开作用域时，sp_ok所指向的内容已经释放掉了，所以再次wp.lock不会得到任何东西

右值引用与移动语义

1. 左值——取地址，位于等号左边；右值——不可取地址，位于等号右边；
2. 右值引用

   1 2 3

   int &&ref = 5; // 右值引用 int a = 4; int &&ref2 = a; // 右值引用不能指向左值

3. std::move——将左值强制转换成右值

   1 2 3 4 5 6 7 8 9 10 11 12

   /* 拷贝构造函数————相当于拷贝操作 移动构造函数————相当于剪切操作 std::move的作用： std::move --生成--> 右值引用 --触发调用--> 移动构造函数 移动构造函数需要自己实现，不然会默认调用拷贝构造函数 */ int temp = 5; int &&ref_a = std::move(temp); ref_a = 6; cout << "temp==" << temp << endl; // 打印结果6

4. 完美转发forward

   1 2	// 目的：在进行函数参数传递时，按照原本的参数左右值类型传递

5. emplace_back原理

匿名函数lambda

1
2
3
4
5
6
7
8
9
10
11

// 语法
// [捕获列表](参数列表)->返回类型{函数体};
// [] 空捕获列表，外面的变量都不能使用
// [=] 安值传递外部参数，所以当定义lambda的时候，捕获的值就已经有一份拷贝了，假设没有调用lambda函数，就修改了某值，那不会影响捕获列表的值
// [&] 按照引用传递外部参数，可以修改外部参数的值
// [a, b, &c]，即a，b的值已经有拷贝了，而c的值是引用传递的

auto Add = [](int a, int b) -> int{
    return a+b;
};
std::cout << Add(1,2) << endl;

• 泛型lambda（C++14以后）

  1 2 3 4 5

  auto add = [auto x, auto y]{ return x + y; }; std::cout << add(1, 2) << std::endl; std::cout << add(1.1, 1.2) << std::endl;