RAII内存管理

原创

喜欢打篮球的普通人 2023-04-06 13:38:30 博主文章分类：C++ and mysql ©著作权

文章标签 c++ #include ios Pig 文章分类 代码人生

©著作权归作者所有：来自51CTO博客作者喜欢打篮球的普通人的原创作品，请联系作者获取转载授权，否则将追究法律责任

文章目录

1.C++发展史
2.C++面向对象的思想
3.RAII：离不开构造函数
4.使用 {} 和 () 调用构造函数，有什么区别？
5.编译器默认生成的构造函数：无参数（POD 陷阱！）
6.编译器默认生成的构造函数：拷贝构造函数
7.编译器默认生成的特殊函数：拷贝赋值函数
8.编译器自动生成的函数
9.编写我们自己的 vector 类
10.C++11区分拷贝和移动？

（1）触发“移动”的情况
（2）移动构造函数：缺省实现

13.智能指针

（1）RAII 解决内存管理的问题：unique_ptr
（2）更智能的指针：shared_ptr
（3）智能指针：作为类的成员变量
（4）那是不是只要 shared_ptr 就行，不用 unique_ptr 了？

14.三五法则：什么时候需要担心

（1）类型安全vs类型不安全
（2）成员都是安全的类型：五大函数，一个也不用声明
（3）函数参数类型优化规则：按引用还是按值？
（4）如何避免不经意的隐式拷贝

15.扩展
19.为什么很多面向对象语言，比如 Java，都没有构造函数全家桶这些概念？

1.C++发展史

问题：求一个列表中所有数的和：
eg：course/02/01

a = [4, 3, 2, 1]
print(sum(a))

古代C语言

#include <stdlib.h>
#include <stdio.h>

int main() {
    size_t nv = 4;
    int *v = (int *)malloc(nv * sizeof(int));
    v[0] = 4;
    v[1] = 3;
    v[2] = 2;
    v[3] = 1;

    int sum = 0;
    for (size_t i = 0; i < nv; i++) {
        sum += v[i];
    }

    printf("%d\n", sum);

    free(v);
    return 0;
}

近代：C++98 引入 STL 容器库

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v(4);
    v[0] = 4;
    v[1] = 3;
    v[2] = 2;
    v[3] = 1;

    int sum = 0;
    for (size_t i = 0; i < v.size(); i++) {
        sum += v[i];
    }

    std::cout << sum << std::endl;
    return 0;
}

近现代：C++11 引入了 {} 初始化表达式

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {4, 3, 2, 1};

    int sum = 0;
    for (size_t i = 0; i < v.size(); i++) {
        sum += v[i];
    }

    std::cout << sum << std::endl;
    return 0;
}

近现代：C++11 引入了 range-based for-loop

#include <vector>
#include <iostream>

int main() {
    std::vector<int> v = {4, 3, 2, 1};

    int sum = 0;
    for (int vi: v) {
        sum += vi;
    }

    std::cout << sum << std::endl;
    return 0;
}

使用 for_each 这个算法模板

#include <vector>
#include <iostream>
#include <algorithm>

int sum = 0;

void func(int vi) {
    sum += vi;
}

int main() {
    std::vector<int> v = {4, 3, 2, 1};

    std::for_each(v.begin(), v.end(), func);

    std::cout << sum << std::endl;
    return 0;
}

近现代：C++11 引入了 lambda 表达式

#include <vector>
#include <iostream>
#include <algorithm>

int main() {
    std::vector<int> v = {4, 3, 2, 1};

    int sum = 0;
    std::for_each(v.begin(), v.end(), [&] (auto vi) {
        sum += vi;
    });

    std::cout << sum << std::endl;
    return 0;
}

现代：C++14 的 lambda 允许用 auto 自动推断类型

#include <vector>
#include <iostream>
#include <algorithm>

int main() {
    std::vector v = {4, 3, 2, 1};

    int sum = 0;
    std::for_each(v.begin(), v.end(), [&] (auto vi) {
        sum += vi;
    });

    std::cout << sum << std::endl;
    return 0;
}

当代：C++17 CTAD / compile-time argument deduction / 编译期参数推断

#include <vector>
#include <iostream>
#include <algorithm>

int main() {
	//这里没有<int>
    std::vector v = {4, 3, 2, 1};

    int sum = 0;
    std::for_each(v.begin(), v.end(), [&] (auto vi) {
        sum += vi;
    });

    std::cout << sum << std::endl;
    return 0;
}

对应的CmakeLists.txt

cmake_minimum_required(VERSION 3.12)
set(CMAKE_CXX_STANDARD 17)
project(hellocpp LANGUAGES CXX)

add_executable(cpptest 7.cpp)

当代：C++17 引入常用数值算法

#include <vector>
#include <iostream>
#include <numeric>

int main() {
    std::vector v = {4, 3, 2, 1};

    auto sum = std::reduce(v.begin(), v.end());
    auto sum = std::reduce(v.begin(), v.end(), std::plus{});
    int sum = std::reduce(v.begin(), v.end(), 0, [] (int x, int y) {
        return x + y;
    });

    std::cout << sum << std::endl;
    return 0;
}

未来：C++20 引入区间（ranges）

#include <vector>
#include <iostream>
#include <numeric>
#include <ranges>
#include <cmath>

int main() {
    std::vector v = {4, 3, 2, 1, 0, -1, -2};

    for (auto &&vi: v
         | std::views::filter([] (auto &&x) { return x >= 0; })
         | std::views::transform([] (auto &&x) { return sqrtf(x); })
         ) {
        std::cout << vi << std::endl;
    }

    return 0;
}

未来：C++20 引入模块（module）

import <vector>;
import <iostream>;
import <numeric>;
import <ranges>;
import <cmath>;

int main() {
    std::vector v = {4, 3, 2, 1, 0, -1, -2};

    for (auto &&vi: v
         | std::views::filter([] (auto &&x) { return x >= 0; })
         | std::views::transform([] (auto &&x) { return sqrtf(x); })
         ) {
        std::cout << vi << std::endl;
    }

    return 0;
}

未来：C++20 允许函数参数为自动推断（auto）

import <vector>;
import <iostream>;
import <numeric>;
import <ranges>;
import <cmath>;

void myfunc(auto &&v) {
    for (auto &&vi: v
         | std::views::filter([] (auto &&x) { return x >= 0; })
         | std::views::transform([] (auto &&x) { return sqrtf(x); })
         ) {
        std::cout << vi << std::endl;
    }
}

int main() {
    std::vector v = {4, 3, 2, 1, 0, -1, -2};
    myfunc(v);
    return 0;
}

未来：C++20 引入协程（coroutine）和生成器（generator）

import <vector>;
import <iostream>;
import <numeric>;
import <ranges>;
import <cmath>;
import <generator>;
import <format>;

std::generator<int> myfunc(auto &&v) {
    for (auto &&vi: v
         | std::views::filter([] (auto &&x) { return x >= 0; })
         | std::views::transform([] (auto &&x) { return sqrtf(x); })
         ) {
        co_yield vi;
    }
}

int main() {
    std::vector v = {4, 3, 2, 1, 0, -1, -2};
    for (auto &&vi: myfunc(v)) {
        std::format_to(std::cout, "number is {}\n", vi);
    }
    return 0;
}

未来：C++20 标准库加入 format 支持

import <vector>;
import <iostream>;
import <numeric>;
import <ranges>;
import <cmath>;
import <generator>;
import <format>;

std::generator<int> myfunc(auto &&v) {
    for (auto &&vi: v
         | std::views::filter([] (auto &&x) { return x >= 0; })
         | std::views::transform([] (auto &&x) { return sqrtf(x); })
         ) {
        co_yield vi;
    }
}

int main() {
    std::vector v = {4, 3, 2, 1, 0, -1, -2};
    for (auto &&vi: myfunc(v)) {
        std::format_to(std::cout, "number is {}\n", vi);
    }
    return 0;
}

总结

基于 C++17 标准， C++20 作为扩展。

2.C++面向对象的思想

（1）C++思想：封装

将多个逻辑上相关的变量包装成一个类
eg：比如要表达一个数组，需要：起始地址指针v，数组大小nv，因此 C++ 的 vector 将他俩打包起来，避免程序员犯错

（2）封装：不变性

比如当我要设置数组大小为 4 时，不能只 nv = 4，还要重新分配数组内存，从而修改数组起始地址 v
常遇到：当需要修改一个成员时，其他也成员需要被修改，否则出错，这种情况出现时，就意味着你需要把成员变量的读写封装为成员函数

（3）不变性：请勿滥用封装

仅当出现“修改一个成员时，其他也成员要被修改，否则出错”的现象时，才需要getter/setter 封装。
各个成员之间相互正交，比如数学矢量类 Vec3，就没必要去搞封装，只会让程序员变得痛苦，同时还有一定性能损失：特别是如果 getter/setter 函数分离了声明和定义，实现在另一个文件时！

（4）C++思想：RAII（Resource Acquisition Is Initialization）

资源获取视为初始化，反之，资源释放视为销毁
C++ 除了用于初始化的构造函数（constructor）
还包括了用于销毁的解构函数（destructor）

RAII的作用：避免犯错误

如果没有解构函数，则每个带有返回的分支都要手动释放所有之前的资源:

RAII内存管理_Pig

与 Java，Python 等垃圾回收语言不同，C++ 的解构函数是显式的，离开作用域自动销毁，毫不含糊（有好处也有坏处，对高性能计算而言利大于弊）

RAII内存管理_#include_02

RAII作用：异常安全（exception-safe）

C++ 标准保证当异常发生时，会调用已创建对象的解构函数。因此 C++ 中没有（也不需要） finally 语句。
eg：如果此处不关闭，则可等待稍后垃圾回收时关闭。
虽然最后还是关了，但如果对时序有要求或对性能有要求就不能依靠 GC。
比如 mutex 忘记 unlock 造成死锁等等……
eg：产生异常的同时，文件也会被关闭，所以文件内容正常写出来了，所以cpp没有finally

3.RAII：离不开构造函数

（1）自定义构造函数：无参数

eg：course/02/03a/0.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight;

    Pig()
    {
        m_name = "佩奇";
        m_weight = 80;
    }
};

int main() {
    Pig pig;

    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;

    return 0;
}

（2）自定义构造函数：无参数（使用初始化表达式）

为什么需要初始化表达式？

1. 假如类成员为 const 和引用
2. 假如类成员没有无参构造函数
3. 避免重复初始化，更高效

eg：course/02/03a/1.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight;

    Pig() : m_name("佩奇"), m_weight(80)
    {}
};

int main() {
    Pig pig;

    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;

    return 0;
}

（3）自定义构造函数：多个参数

eg：course/02/03a/2.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight;

    Pig(std::string name, int weight) : m_name(name), m_weight(weight)
    {}
};

int main() {
    Pig pig("佩奇", 80);

    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;

    return 0;
}

（4）自定义构造函数：单个参数

eg：course/02/03a/3.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight;

    Pig(int weight)
        : m_name("一只重达" + std::to_string(weight) + "kg的猪")
        , m_weight(weight)
    {}
};

int main() {
    Pig pig(80);

    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;

    return 0;
}

自定义构造函数：单个参数（陷阱）

eg：course/02/03a/4.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight;

    Pig(int weight)
        : m_name("一只重达" + std::to_string(weight) + "kg的猪")
        , m_weight(weight)
    {}
};

int main() {
    Pig pig = 80;

    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;

    return 0;
}

自定义构造函数：单个参数（避免陷阱）

eg：course/02/03a/5.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight;

    explicit Pig(int weight)
        : m_name("一只重达" + std::to_string(weight) + "kg的猪")
        , m_weight(weight)
    {}
};

int main() {
    // Pig pig = 80;  // 编译错误
    Pig pig(80);      // 编译通过

    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;

    return 0;
}

测试：
eg：my_course/course/02/03a/6.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight;

    explicit Pig(int weight)
        : m_name("一只重达" + std::to_string(weight) + "kg的猪")
        , m_weight(weight)
    {}
};

void show(Pig pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    // show(80);    // 编译错误
    show(Pig(80));  // 编译通过

    return 0;
}

避免陷阱体现在哪里？

加了 explicit 表示必须用 () 强制转换（就是强制初始化）。否则 show(80) 也能编译通过！
所以，如果你不希望这种隐式转换（就是隐式构造，也是一个构造函数，虽然等价于Pig pig(80)，但是编译器认为类型不一样，看上面截图）：Pig pig = 80;，请给单参数的构造函数加上explicit。
比如 std::vector 的构造函数 vector(size_t n) 也是 explicit 的。

std::vector<int> a=100//error
std::vector<int> a{100};//ok
std::vector<int> a(100);//ok

explicit 对多个参数也起作用！

多个参数时，explicit 的作用体现在禁止从一个 {} 表达式初始化。={}也是隐式构造
Pig pig2{“佩奇”,80}; Pig pig3(“佩奇”,80);都是显式构造
如果你希望在一个返回 Pig 的函数里用：

return {“佩奇”, 80};的话，就不要加 explicit。
顺便一提，上一个例子中 show(80) 和 show({80}) 等价。调用时等价于：Pig pig=80;Pig pig={80};

RAII内存管理_ios_03

4.使用 {} 和 () 调用构造函数，有什么区别？

int(3.14f) 不会出错，但是 int{3.14f} 会出错，因为 {} 是非强制转换。（防止变窄转换）
Pig(“佩奇”, 3.14f) 不会出错，但是 Pig{“佩奇”, 3.14f} 会出错，原因同上，更安全。
可读性：Pig(1, 2) 则 Pig 有可能是个函数，Pig{1, 2} 看起来更明确。

其实谷歌在其 Code Style 中也明确提出别再通过 () 调用构造函数，需要类型转换时应该用：

static_cast<int>(3.14f) 而不是 int(3.14f)
reinterpret_cast<void *>(0xb8000) 而不是 (void *)0xb8000。将地址直接转换为指针
更加明确用的哪一种类型转换（cast），从而避免一些像是 static_cast<int>(ptr) 的错误。

5.编译器默认生成的构造函数：无参数（POD 陷阱！）

除了我们自定义的构造函数外，编译器还会自动生成一些构造函数。

当一个类没有定义任何构造函数，且所有成员都有无参构造函数时，编译器会自动生成一个无参构造函数 Pig()，他会调用每个成员的无参构造函数。
但是请注意，这些类型不会被初始化为 0：

1）int, float, double 等基础类型
2）void *, Object * 等指针类型
3）完全由这些类型组成的类

这些类型被称为 POD（plain-old-data）。
POD 的存在是出于兼容性和性能的考虑。

Pig pig;会随机初始化

eg：course/02/03a/8.cpp，weight：<< 取决于内存的随机值

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight;
};

void show(Pig pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    Pig pig;

    show(pig);
    return 0;
}

测试：

编译器默认生成的构造函数：无参数（POD 陷阱解决方案）

不过我们可以手动指定初始化 weight 为0。
方式1：通过 {} 语法指定的初始化值，会在编译器自动生成的构造函数里执行。
eg：my_course/course/02/03a/9.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight{0};
};

void show(Pig pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    Pig pig;

    show(pig);
    return 0;
}

方式2：通过 {} 语法指定的初始化值，不仅会在编译器自动生成的构造函数里执行，也会用户自定义构造函数里执行！
eg：my_course/course/02/03a/a.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight{0};

    Pig(std::string name) : m_name(name)
    {}
};

void show(Pig pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    Pig pig("佩奇");

    show(pig);
    return 0;
}

编译器默认生成的构造函数：无参数（类成员初始化很方便）

类成员的 {} 中还可以有多个参数，甚至能用 =。
除了不能用 () 之外，和函数局部变量的定义方式基本等价。

顺便一提：
int x{};
void *p{};
与
int x{0};
void *p{nullptr};
等价，都会零初始化。但是你不写那个空括号就会变成内存中随机的值。

再比如：std::cout << int{}; 会打印出 0
eg：my_course/course/02/03a/b.cpp

#include <iostream>
#include <string>

struct Demo {
    explicit Demo(std::string a, std::string b) {
        std::cout << "Demo(" << a << ',' << b << ')' << std::endl;
    }
};

struct Pig {
    std::string m_name{"佩奇"};
    int m_weight = 80;
    Demo m_demo{"Hello", "world"};        // 编译通过
    // Demo m_demo = {"Hello", "world"};  // 编译出错
};

void show(Pig pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    Pig pig;

    show(pig);
    return 0;
}

测试：

编译器默认生成的构造函数：初始化列表（感谢 C++11）

当一个类（和他的基类）没有定义任何构造函数，这时编译器会自动生成一个参数个数和成员一样的构造函数。
他会将 {} 内的内容，会按顺序赋值给对象的每一个成员。
目的是为了方便程序员不必手写冗长的构造函数一个个赋值给成员。
不过初始化列表的构造函数只支持通过 {} 或 = {} 来构造，不支持通过 () 构造。其实是为了向下兼容 C++98
eg：my_course/course/02/03a/c.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight;
};

void show(Pig pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    Pig pig1 = {"佩奇", 80};   // 编译通过
    Pig pig2{"佩奇", 80};      // 编译通过
    Pig pig3("佩奇", 80);   // 编译错误！

    show(pig1);
    return 0;
}

测试：

编译器默认生成的构造函数：初始化列表（初始化一部分，剩余的为默认值）

这个编译器自动生成的初始化列表构造函数，除了可以指定全部成员来构造以外，还可以指定部分的成员，剩余没指定的保持默认。
不过你得保证那个没指定的有在类成员定义里写明 {} 初始化，否则有可能会变成内存里的随机值。
顺便一提，C++20中还可以通过指定名称来跳顺序：
eg：my_course/course/02/03a/d.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight{0};
};

void show(Pig pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    Pig pig{"佩奇"};  // m_weight 没指定，使用 {0} 指定的默认值

    show(pig);
    return 0;
}

测试：

编译器默认生成的构造函数：初始化列表（妙用，解决函数多返回值）

没有explicit
典型的例子包括，图形学某知名应用中，可以简化函数具有多个返回值的处理。
和 std::tuple 相比，最大的好处是每个属性都有名字，不容易搞错。举个例子：
auto [hit, pos, …] = intersect(…)
每增加一个属性都要全部改一次代码。
更加fancy的写法：

编译器默认生成的构造函数：初始化列表（妙用，处理函数的复杂类型参数）

还有，函数的参数，如果是很复杂的类型，你不想把类型名重复写一遍，也可以利用 {} 初始化列表来简化：

有自定义构造函数时仍想用默认构造函数：= default

一旦我们定义了自己的构造函数，编译器就不会再生成默认的无参构造函数。
有自定义构造函数时仍想用默认构造函数：= default（续）

6.编译器默认生成的构造函数：拷贝构造函数

除了无参和初始化列表构造函数外，编译器默认还会生成这样一个特殊的构造函数：

Pig(Pig const &other);
可见他的参数是一个 Pig 类型，他的功能就是拷贝 Pig 对象，故称为拷贝构造函数。

调用方式如下：

拷贝构造函数：用户自定义

除了编译器可以自动生成拷贝构造函数外，如果有需要，用户也可以自定义拷贝构造函数。
比如：

不想要编译器自动生成拷贝构造函数怎么办：= delete

如果想要让编译器不要自动生成拷贝构造函数，可以用 = delete 语法删除：
注：= delete 和 = default 是一对。如果你不确定某个函数有没有被编译器默认生成，可以都用这两个显式地声明一下。

7.编译器默认生成的特殊函数：拷贝赋值函数

除了拷贝构造函数外，编译器默认还会生成这样一个重载’=’这个运算符的函数：

Pig &operator=(Pig const &other);

拷贝构造函数的作用是在Pig尚未初始化时，将另一个Pig拷贝进来，以初始化当前Pig。

Pig pig = pig2;  // 拷贝构造

拷贝赋值函数的作用是在Pig已经初始化时，将当前Pig销毁，同时将另一个Pig拷贝进来。

Pig pig;             // 无参构造
pig = pig2;        // 拷贝赋值

追求性能时推荐用拷贝构造，因为可以避免一次无参构造，拷贝赋值是出于需要临时修改对象的灵活性需要。
这个函数同样可以由 = delete 和 = default 控制是否默认生成。
注：return *this 是为了支持连等号 a = b = c;

8.编译器自动生成的函数

除了拷贝构造和拷贝赋值，编译器会自动生成的特殊函数还有这些：

这在其他面向对象语言中是看不到的

RAII内存管理_Pig_04

eg：my_course/course/02/03a/g.cpp

#include <iostream>
#include <string>

struct Pig {
    std::string m_name;
    int m_weight{0};

    Pig(std::string name, int weight)
        : m_name(name), m_weight(weight)
    {}

    Pig()
    {}

    Pig(Pig const &other)
        : m_name(other.m_name)
        , m_weight(other.m_weight)
    {}

    Pig &operator=(Pig const &other) {
        m_name = other.m_name;
        m_weight = other.m_weight;
        return *this;
    }

    Pig(Pig &&other)
        : m_name(std::move(other.m_name))
        , m_weight(std::move(other.m_weight))
    {}

    Pig &operator=(Pig &&other) {
        m_name = std::move(other.m_name);
        m_weight = std::move(other.m_weight);
        return *this;
    }

    ~Pig() {}
};

void show(Pig pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    Pig pig;

    show(pig);
    return 0;
}

解释：

顺便一提，如果其中一个成员（比如m_name）不支持拷贝构造函数，那么 Pig 类的拷贝构造函数将不会被编译器自动生成。
其他函数同理。
拷贝就把每个属性拷贝一遍；
赋值就把每个属性赋值一遍；
移动就把每个属性移动一遍；
C++除了智能指针，其他都是深拷贝，所以有的类删除拷贝构造函数，让智能指针管理这个类，so这类的拷贝就变成智能指针的浅拷贝了，目的是避免拷贝所需的时间

9.编写我们自己的 vector 类

eg：这个Vector类有哪些问题？
my_course/course/02/04

三五法则：规则类怪谈

如果一个类定义了解构函数，那么您必须同时定义或删除拷贝构造函数和拷贝赋值函数，否则出错。
如果一个类定义了拷贝构造函数，那么您必须同时定义或删除拷贝赋值函数，否则出错，删除可导致低效。
如果一个类定义了移动构造函数，那么您必须同时定义或删除移动赋值函数，否则出错，删除可导致低效。
如果一个类定义了拷贝构造函数或拷贝赋值函数，那么您必须最好同时定义移动构造函数或移动赋值函数，否则低效。

更多参考见：CppCoreGuidelines，C++ Core Guidelines

RAII内存管理_Pig_05

（1）三五法则：拷贝构造函数

在 = 时，默认是会拷贝的(编译器默认生成的是浅拷贝的，成员带指针的一定要注意！！)。
比如右边这样，这样对我们当前 Vector 的实现造成一个很大的问题。其 m_data 指针是按地址值浅拷贝的，而不深拷贝其指向的数组！
这就是说，在退出 main 函数作用域的时候，v1.m_data 会被释放两次！更危险的则是 v1 被解构而 v2 仍在被使用的情况。
这就是为什么“如果一个类定义了解构函数，那么您必须同时定义或删除拷贝构造函数和拷贝赋值函数，否则出错。”
eg：my_course/course/02/05

RAII内存管理_ios_06

RAII内存管理_c++_07

解决方案：要么删除
最简单的办法是，直接禁止用户拷贝这个类的对象，在 C++11 中可以用 = delete 表示这个函数被删除，让编译器不要自动生成一个默认的（会导致指针浅拷贝的）拷贝构造函数了。
这样就可以在编译期提前发现错误：

RAII内存管理_#include_08

RAII内存管理_ios_09

解决方案：要么定义

如果需要允许用户拷贝你的 Vector 类对象，我们还是需要实现一下的。
发现了吗？其实不管是 size/resize 这样的 get/set 模式也好；自定义的拷贝构造函数也好；RAII 保证异常安全也好；都是在为面向对象思想的“封装：不变性”服务。
即：保证任何单个操作前后，对象都是处于正确的状态，从而避免程序读到错误数据（如空悬指针）的情况。
eg：my_course/course/02/07

（2）三五法则：拷贝赋值函数

编译器默认生成的拷贝赋值函数也是浅拷贝！
区分两种拷贝可以提高性能。

int x = 1;   // 拷贝构造函数
x = 2;        // 拷贝赋值函数

拷贝赋值函数≈解构函数+拷贝构造函数
拷贝构造：直接未初始化的内存上构造 2
拷贝赋值：先销毁现有的 1，再重新构造 2
因此若对提高性能不感兴趣，可以这样写：my_course/course/02/08/main.cpp

RAII内存管理_ios_10

拷贝赋值函数：提高性能
区分两种拷贝可以提高性能。
内存的销毁重新分配可以通过realloc，从而就地利用当前现有的m_data，避免重新分配。
因此拷贝赋值函数还是自定义下比较好：
这解释了“如果一个类定义或删除了拷贝构造函数，那么您必须同时定义或删除拷贝赋值函数，否则出错。”
eg：my_course/course/02/09/main.cpp

RAII内存管理_c++_11

10.C++11区分拷贝和移动？

有时候，我们需要把一个对象 v2 移动到 v1 上。而不需要涉及实际数据的拷贝。

时间复杂度：移动是 O(1)，拷贝是 O(n)。

拷贝赋值

v1=v2;是深拷贝，指向了不同的内存地址，v1里面的指针独立于v2，只是数据从v2跑到v1了，析构时是析构了2个不同的内存块，也没有双重free问题

我们可以用 std::move 实现移动。

v2 被移动到 v1 后，原来的 v2 会被清空，因此仅当 v2 再也用不到时才用移动。
(把v2指针移动到v1里，然后将v2指针清零，这样的话还是只有一个对象，就不会出现双重free了)
拷贝应该是深的(浅拷贝会导致双重free)，移动应该都是浅的；
eg：v2 的内容被移走，所以只剩0个元素了，my_course/course/02/10/main.cpp

移动进阶：交换两者的值

除了 std::move 可以把 v2 移动到 v1 外，
还可以通过 std::swap 交换 v1 和 v2。
swap 在高性能计算中可以用来实现双缓存（ping-pong buffer）。
eg：my_course/course/02/10/main.cpp
swap 可能是这样实现的：

小结：

善用移动和交换能让复杂度贬低

（1）触发“移动”的情况

这些情况下编译器会调用移动：

return v2                                                    // v2 作返回值,返回值优化（rvo优化）始终是移动语义
v1 = std::vector<int>(200)                         // 就地构造的 v2，当场创建的vector对象
v1 = std::move(v2)                                    // 显式地移动

这些情况下编译器会调用拷贝：

return std::as_const(v2)                            // 显式地拷贝，希望返回时调用拷贝
v1 = v2                                                      // 默认拷贝

注意，以下语句没有任何作用：

这两个函数只是负责转换类型，实际产生移动/拷贝效果的是在类的构造/赋值函数里。

std::move(v2)                                            // 不会清空 v2，需要清空可以用 v2 = {} (调用默认构造函数和移动赋值函数)或 v2.clear()
std::as_const(v2)                                      // 不会拷贝 v2，需要拷贝可以用 { auto _ = v2; }

std::move(t)       相当于 (T &&)t
std::as_const(t) 相当于 (T const &)t

（2）移动构造函数：缺省实现

同样，如果对降低时间复杂度不感兴趣：

移动构造≈拷贝构造+他解构+他默认构造
移动赋值≈拷贝赋值+他解构+他默认构造
只要不定义移动构造和移动赋值，编译器会自动这样做。虽然低效，但至少可以保证不出错。
移动构造相当于我拷贝了了它，然后把它清零；
如果不定义移动构造，编译器也会这么做；
移动时，只有一个对象，所以可以使用浅移动
Eg：下图移动是浅移动，不用调用malloc，直接把大小和指针一过来就行，移过来后，把other的对象给清零

若自定义了移动构造，对提高性能不感兴趣：

移动赋值≈解构+移动构造
eg：my_course/course/02/11/main.cpp

RAII内存管理_Pig_12

注：
降低时间复杂度：O(n) >>> O(1)
提高性能： O(1) >>> O(0.1)

小技巧：如果有移动赋值函数，可以删除拷贝赋值函数

其实：如果你的类已经实现了移动赋值函数，那么为了省力你可以删除拷贝赋值函数。

这样当用户调用：
v2 = v1;时，因为拷贝赋值被删除，编译器会尝试：v2 = List(v1)

从而先调用拷贝构造函数，然后因为 List(v1) 相当于就地构造的对象，从而变成了移动语义，从而进一步调用移动赋值函数。

如果拷贝构造是explicit，则必须使用： v2 = List(v1)

RAII内存管理_c++_13

构造函数全家桶

eg:my_course/course/02/11/zongjie.cpp

13.智能指针

C++98：令人头疼的内存管理

在没有智能指针的 C++ 中，我们只能手动去 new 和 delete 指针。这非常容易出错，一旦马虎的程序员忘记释放指针，就会导致内存泄露等情况，更可能被黑客利用空悬指针篡改系统内存从而盗取重要数据等。
eg：my_course/course/02/12/main.cpp

#include <cstdio>
#include <cstdlib>

struct C {
    C() {
        printf("分配内存!\n");
    }

    ~C() {
        printf("释放内存!\n");
    }
};

int main() {
    C *p = new C;

    if (rand() != 0) {
        printf("出了点小状况……\n");
        // delete p;   // 程序员粗心忘记释放指针
        return 1;
    }

    delete p;
    return 0;
}

测试：
编译
my_course/course/02/12/run.sh

set -e

cmake -B build
cmake --build build
build/cpptest

my_course/course/02/12/CMakeLists.txt

cmake_minimum_required(VERSION 3.12)
set(CMAKE_CXX_STANDARD 17)
project(hellocpp LANGUAGES CXX)

add_executable(cpptest main.cpp)

（1）RAII 解决内存管理的问题：unique_ptr

因此，C++11 引入了 unique_ptr 容器，他的解构函数中会调用 delete p，因此不会有马虎犯错的问题。
这里 make_unique(…) 可以理解为和之前的 new C(…) 等价，括号里也可以有其他构造函数的参数。
eg:my_course/course/02/13/main.cpp

#include <cstdio>
#include <memory>

struct C {
    C() {
        printf("分配内存!\n");
    }

    ~C() {
        printf("释放内存!\n");
    }
};

int main() {
    std::unique_ptr<C> p = std::make_unique<C>();

    if (1 + 1 == 2) {
        printf("出了点小状况……\n");
        return 1;  // 自动释放 p
    }

    return 0;  // 自动释放 p
}

RAII内存管理_ios_14

unique_ptr：封装的智慧

在旧时代 C++ 里，常常听到这样的说法：

“释放一个指针后，必须把这个指针设为 NULL，防止空悬指针！”
delete p;
p = nullptr;

unique_ptr 则把他们封装成一个操作：只需要

p = nullptr;      // 等价于：p.reset()
也不会保留着一个空悬指针，体现了面向对象“封装：不变性”的思想。

eg:my_course/course/02/14/main.cpp

#include <cstdio>
#include <memory>

struct C {
    C() {
        printf("分配内存!\n");
    }

    ~C() {
        printf("释放内存!\n");
    }
};

int main() {
    std::unique_ptr<C> p = std::make_unique<C>();

    printf("提前释放……\n");
    p = nullptr;
    printf("……释放成功\n");

    return 0;  // p 不会再释放一遍
}

测试：

unique_ptr：禁止拷贝

unique_ptr 删除了拷贝构造函数。为什么他要删除拷贝构造函数？
原因还是三五法则，如果拷贝了指针，那么就会出现之前 Vector 那样重复释放（double free）的问题。
因为unique_ptr 自定义拷贝函数是delete的，所以它必须删除拷贝函数，否则拷贝就是一个浅拷贝，浅拷贝容易出现double free问题
eg：my_course/course/02/15/main.cpp

#include <cstdio>
#include <memory>

struct C {
    C() {
        printf("分配内存!\n");
    }

    ~C() {
        printf("释放内存!\n");
    }

    void do_something() {
        printf("成员函数!\n");
    }
};

void func(std::unique_ptr<C> p) {
    p->do_something();
}

int main() {
    std::unique_ptr<C> p = std::make_unique<C>();
    func(p);  // 出错
    return 0;
}

测试：

RAII内存管理_ios_15

解决方案1：获取原始指针（C * 这种类型的指针）

解决这个问题需要分两种情况讨论。
第一种是，你的 func() 实际上并不需要“夺走”资源的占有权（ownership）。
比如刚才这个例子，func() 只是调用了 p 的某个成员函数而已，并没有接过掌管对象生命周期的大权。

eg：my_course/course/02/16/main.cpp

#include <cstdio>
#include <memory>

struct C {
    C() {
        printf("分配内存!\n");
    }

    ~C() {
        printf("释放内存!\n");
    }

    void do_something() {
        printf("成员函数!\n");
    }
};

void func(C *p) {
    p->do_something();
}

int main() {
    std::unique_ptr<C> p = std::make_unique<C>();
    func(p.get());
    return 0;
}

测试：

RAII内存管理_Pig_16

解决方案2：unique_ptr 不能拷贝，但可以移动

第二种是，你的 func() 需要“夺走”资源的占有权。
比如右边这个例子，func 把指针放到一个全局的列表里，
p 的生命周期将会变得和 objlist 一样长。因此需要接过掌管对象生命周期的大权。

请根据你的具体情况，决定要选用哪一种解决方案。

eg：my_course/course/02/17/main.cpp

#include <cstdio>
#include <memory>
#include <vector>

struct C {
    C() {
        printf("分配内存!\n");
    }

    ~C() {
        printf("释放内存!\n");
    }
};

std::vector<std::unique_ptr<C>> objlist;

void func(std::unique_ptr<C> p) {
    objlist.push_back(std::move(p));  // 进一步移动到 objlist
}

int main() {
    std::unique_ptr<C> p = std::make_unique<C>();
    printf("移交前：%p\n", p.get());  // 不为 null
    func(std::move(p));    // 通过移动构造函数，转移指针控制权
    printf("移交后：%p\n", p.get());  // null，因为移动会清除原对象
    return 0;
}

测试：

移交控制权后仍希望访问到 p 指向的对象

解决方案2中，有时候我们会遇到移交控制权后，仍希望访问到对象的需求。
如果还是用 p 去访问的话，因为被移动构造函数转移了，p 已经变成空指针，从而出错。
eg：my_course/course/02/18/main.cpp

#include <cstdio>
#include <memory>
#include <vector>

struct C {
    int m_number;

    C() {
        printf("分配内存!\n");
        m_number = 42;
    }

    ~C() {
        printf("释放内存!\n");
        m_number = -2333333;
    }

    void do_something() {
        printf("我的数字是 %d!\n", m_number);
    }
};

std::vector<std::unique_ptr<C>> objlist;

void func(std::unique_ptr<C> p) {
    objlist.push_back(std::move(p));  // 进一步移动到 objlist
}

int main() {
    std::unique_ptr<C> p = std::make_unique<C>();
    func(std::move(p));

    p->do_something();  // 出错，p 已经为空了！

    return 0;
}

测试：

RAII内存管理_c++_17

解决方案：提前获取原始指针
最简单的办法是，在移交控制权给 func 前，提前通过 p.get() 获取原始指针：
eg：my_course/course/02/19/main.cpp

#include <cstdio>
#include <memory>
#include <vector>

struct C {
    int m_number;

    C() {
        printf("分配内存!\n");
        m_number = 42;
    }

    ~C() {
        printf("释放内存!\n");
        m_number = -2333333;
    }

    void do_something() {
        printf("我的数字是 %d!\n", m_number);
    }
};

std::vector<std::unique_ptr<C>> objlist;

void func(std::unique_ptr<C> p) {
    objlist.push_back(std::move(p));  // 进一步移动到 objlist
}

int main() {
    std::unique_ptr<C> p = std::make_unique<C>();

    C *raw_p = p.get();
    func(std::move(p));

    raw_p->do_something();  // 正常执行，raw_p 保留了转移前的指针

    return 0;
}

测试：
不过你得保证 raw_p 的存在时间不超过 p 的生命周期，否则会出现危险的空悬指针。比如右边这样：
eg：my_course/course/02/20/main.cpp

#include <cstdio>
#include <memory>
#include <vector>

struct C {
    int m_number;

    C() {
        printf("分配内存!\n");
        m_number = 42;
    }

    ~C() {
        printf("释放内存!\n");
        m_number = -2333333;
    }

    void do_something() {
        printf("我的数字是 %d!\n", m_number);
    }
};

std::vector<std::unique_ptr<C>> objlist;

void func(std::unique_ptr<C> p) {
    objlist.push_back(std::move(p));  // 进一步移动到 objlist
}

int main() {
    std::unique_ptr<C> p = std::make_unique<C>();

    C *raw_p = p.get();
    func(std::move(p));

    raw_p->do_something();  // 正常执行，raw_p 保留了转移前的指针

    objlist.clear();        // 刚刚 p 移交给 func 的生命周期结束了！

    raw_p->do_something();  // 错误！raw_p 指向的对象已经被释放！

    return 0;
}

测试：

（2）更智能的指针：shared_ptr

使用起来很困难的原因，在于 unique_ptr 解决重复释放的方式是禁止拷贝，这样虽然有效率高的优势，但导致使用困难，容易犯错等。
相比之下，牺牲效率换来自由度的 shared_ptr 则允许拷贝，他解决重复释放的方式是通过引用计数：

当一个 shared_ptr 初始化时，将计数器设为1。
当一个 shared_ptr 被拷贝时，计数器加1。
当一个 shared_ptr 被解构时，计数器减1。减到0时，则自动销毁他指向的对象。

从而可以保证，只要还有存在哪怕一个指针指向该对象，就不会被解构。
eg：my_course/course/02/21/main.cpp

#include <cstdio>
#include <memory>
#include <vector>
#include <iostream>

struct C {
    int m_number;

    C() {
        printf("分配内存!\n");
        m_number = 42;
    }

    ~C() {
        printf("释放内存!\n");
        m_number = -2333333;
    }

    void do_something() {
        printf("我的数字是 %d!\n", m_number);
    }
};

std::vector<std::shared_ptr<C>> objlist;

void func(std::shared_ptr<C> p) {
    objlist.push_back(std::move(p));  // 这里用移动可以更高效，但不必须
}

int main() {
    std::shared_ptr<C> p = std::make_shared<C>(); // 引用计数初始化为1

    func(p);  // shared_ptr 允许拷贝！和当前指针共享所有权，引用计数加1
    func(p);  // 多次也没问题~ 多个 shared_ptr 会共享所有权，引用计数加1

    p->do_something();  // 正常执行，p 指向的地址本来就没有改变

    objlist.clear();    // 刚刚 p 移交给 func 的生命周期结束了！引用计数减2

    std::cout<<"p use_count="<<p.use_count()<<std::endl;
    p->do_something();  // 正常执行，因为引用计数还剩1，不会被释放

    return 0;  // 到这里最后一个引用 p 也被释放，p 指向的对象才终于释放
}

测试：

RAII内存管理_Pig_18

我们可以使用 p.use_count() 来获取当前指针的引用计数，看看他是不是在智能地增减引用计数器。
注意 p.func() 是 shared_ptr 类型本身的成员函数，而 p->func() 是 p 指向对象（也就是 C）的成员函数，不要混淆。
eg：my_course/course/02/22/main.cpp

#include <cstdio>
#include <memory>
#include <vector>

struct C {
    int m_number;

    C() {
        printf("分配内存!\n");
        m_number = 42;
    }

    ~C() {
        printf("释放内存!\n");
        m_number = -2333333;
    }

    void do_something() {
        printf("我的数字是 %d!\n", m_number);
    }
};

std::vector<std::shared_ptr<C>> objlist;

void func(std::shared_ptr<C> p) {
    objlist.push_back(std::move(p));  // 这里用移动可以更高效，但不必须
}

int main() {
    std::shared_ptr<C> p = std::make_shared<C>(); // 引用计数初始化为1

    printf("use count = %ld\n", p.use_count());   // 1

    func(p);  // shared_ptr 允许拷贝！和当前指针共享所有权，引用计数加1

    printf("use count = %ld\n", p.use_count());   // 2

    func(p);  // 多次也没问题~ 多个 shared_ptr 会共享所有权，引用计数加1

    printf("use count = %ld\n", p.use_count());   // 3

    p->do_something();  // 正常执行，p 指向的地址本来就没有改变

    objlist.clear();    // 刚刚 p 移交给 func 的生命周期结束了！引用计数减2

    printf("use count = %ld\n", p.use_count());   // 1

    p->do_something();  // 正常执行，因为引用计数还剩1，不会被释放

    return 0;  // 到这里最后一个引用 p 也被释放，p 指向的对象才终于释放
}

测试：

不影响 shared_ptr 计数：弱引用 weak_ptr

有时候我们希望维护一个 shared_ptr 的弱引用 weak_ptr，即：弱引用的拷贝与解构不影响其引用计数器。
之后有需要时，可以通过 lock() 随时产生一个新的 shared_ptr 作为强引用。但不 lock 的时候不影响计数。
如果失效（计数器归零）则 expired() 会返回 false，且 lock() 也会返回 nullptr。
可以把 C * 理解为 unique_ptr 的弱引用。weak_ptr 理解为 shared_ptr 的弱引用。但 weak_ptr 能提供失效检测，更安全。
eg：my_course/course/02/23/main.cpp

#include <cstdio>
#include <memory>
#include <vector>

struct C {
    int m_number;

    C() {
        printf("分配内存!\n");
        m_number = 42;
    }

    ~C() {
        printf("释放内存!\n");
        m_number = -2333333;
    }

    void do_something() {
        printf("我的数字是 %d!\n", m_number);
    }
};

std::vector<std::shared_ptr<C>> objlist;

void func(std::shared_ptr<C> p) {
    objlist.push_back(std::move(p));  // 这里用移动可以更高效，但不必须
}

int main() {
    std::shared_ptr<C> p = std::make_shared<C>(); // 引用计数初始化为1

    printf("use count = %ld\n", p.use_count());   // 1

    std::weak_ptr<C> weak_p = p;        // 创建一个不影响计数器的弱引用

    printf("use count = %ld\n", p.use_count());   // 1

    func(std::move(p));  // 控制权转移，p 变为 null，引用计数加不变

    if (weak_p.expired())
        printf("错误：弱引用已失效！");
    else
        weak_p.lock()->do_something();  // 正常执行，p 的生命周期仍被 objlist 延续着

    objlist.clear();    // 刚刚 p 移交给 func 的生命周期结束了！引用计数减1，变成0了

    if (weak_p.expired())              // 因为 shared_ptr 指向的对象已释放，弱引用会失效
        printf("错误：弱引用已失效！");
    else
        weak_p.lock()->do_something();  // 不会执行

    return 0;  // 到这里最后一个弱引用 weak_p 也被释放，他指向的“管理块”被释放
}

测试：

（3）智能指针：作为类的成员变量

可以在类中使用智能指针作为成员变量。需要根据实际情况（主要是看所有权），判断要用哪一种智能指针：

类有智能指针的话，那么这个类很可能就变成浅拷贝的类了，

类中的unique_ptr是禁止拷贝的，那么这个类也会是禁止拷贝的了， 但是移动还是有的
(1)unique_ptr：当该对象仅仅属于我时。比如：父窗口中指向子窗口的指针。即：父窗口拥有子窗口
(2)原始指针：当该对象不属于我，但他释放前我必然被释放时。有一定风险。比如：子窗口中指向父窗口的指针。
(3)shared_ptr：当该对象由多个对象共享时，或虽然该对象仅仅属于我，但有使用 weak_ptr 的需要。
(4)weak_ptr：当该对象不属于我，且他释放后我仍可能不被释放时。比如：指向窗口中上一次被点击的元素。
初学者可以多用 shared_ptr 和 weak_ptr 的组合，更安全。但是有性能损耗，因为引用计数是原子的
原始指针没有失效检测的，waek_ptr是有失效检测的；1和2是一对，3和4是一对

shared_ptr 管理的对象生命周期，取决于所有引用中，最长寿的那一个。
unique_ptr 管理的对象生命周期长度，取决于他所属的唯一一个引用的寿命。

eg：my_course/course/02/24/pseudo.cpp

struct C {
    // 当一个类具有 unique_ptr 作为成员变量时：
    std::unique_ptr<D> m_pD;

    // 拷贝构造/赋值函数会被隐式地删除：
    // C(C const &) = delete;
    // C &operator=(C const &) = delete;

    // 移动构造/赋值函数不受影响：
    // C(C &&) = default;
    // C &operator=(C &&) = default;
};

（4）那是不是只要 shared_ptr 就行，不用 unique_ptr 了？

可以适当使用减轻初学者的压力，因为他的行为和 Python 等 GC 语言的引用计数机制很像。但从长远来看是不行的，因为：

shared_ptr 需要维护一个 atomic 的引用计数器，效率低，需要额外的一块管理内存，访问实际对象需要二级指针，而且 deleter 使用了类型擦除技术。
全部用 shared_ptr，可能出现循环引用之类的问题，导致内存泄露，依然需要使用不影响计数的原始指针或者 weak_ptr 来避免。比如右边这个例子：
C是一个窗口类，m_child指向它的子窗口，m_parent指向它的父窗口
eg：my_course/course/02/24/0.cpp

#include <memory>
#include <cstdio>
struct C
{
    std::shared_ptr<C> m_child;
    std::shared_ptr<C> m_parent;
};

int main()
{
    auto parent = std::make_shared<C>();
    auto child = std::make_shared<C>();

    // 建立相互引用：
    parent->m_child = child;
    child->m_parent = parent;
    printf("parent usecout :%ld\n", parent.use_count());
    printf("child usecout :%ld\n", child.use_count());
    parent = nullptr; // parent 不会被释放！因为 child 还指向他！
    child = nullptr;  // child 也不会被释放！因为 parent 还指向他！

    // 必须手动置为nullptr
    printf("manuaul set nullptr\n");
    printf("parent usecout :%ld\n", parent.use_count());
    printf("child usecout :%ld\n", child.use_count());
    return 0;
}

RAII内存管理_#include_19

循环引用：解决方案1

如何解决？只需要把其中逻辑上“不具有所属权”的那一个改成 weak_ptr 即可：
因为父窗口“拥有”子窗口是天经地义的，而子窗口并不“拥有”父窗口。
其实主要是一个父窗口可以有多个子窗口，只有规定子窗口从属于父窗口才能解决引用计数的问题……
让孩子指向父的这个指针为弱指针,

child->m_parent = parent;
孩子的释放与否不影响父类指针的引用计数的，所以parent已经变成0了

eg：my_course/course/02/24/1.cpp

#include <memory>
#include <cstdio>

struct C
{
    std::shared_ptr<C> m_child;
    std::weak_ptr<C> m_parent;
};

int main()
{
    auto parent = std::make_shared<C>();
    auto child = std::make_shared<C>();

    // 建立相互引用：
    parent->m_child = child;
    child->m_parent = parent;

    parent = nullptr; // parent 会被释放。因为 child 指向他的是 **弱引用**
    printf("parent usecout :%ld\n", parent.use_count());
    printf("child usecout :%ld\n", child.use_count());
    // child = nullptr; // child 会被释放。因为指向 child 的 parent 已经释放了
    printf("parent usecout :%ld\n", parent.use_count());
    printf("child usecout :%ld\n", child.use_count());
    return 0;
}

RAII内存管理_ios_20

循环引用：解决方案2

还有一种更适应“父子窗口”这一场景的解决方案。
刚才提到原始指针的应用场景是“当该对象不属于我，但他释放前我必然被释放时”。
这里我们可以发现父窗口的释放必然导致子窗口的释放。因此我们完全可以把 m_parent 变成原始指针。
这样也不需要 weak_ptr 判断是否 expired() 了。
eg：my_course/course/02/24/2.cpp

#include <memory>

struct C
{
    std::shared_ptr<C> m_child;
    C *m_parent;
};

int main()
{
    auto parent = std::make_shared<C>();
    auto child = std::make_shared<C>();

    // 建立相互引用：
    parent->m_child = child;
    child->m_parent = parent.get();

    parent = nullptr; // parent 会被释放。因为 child 指向他的是原始指针
    child = nullptr;  // child 会被释放。因为指向 child 的 parent 已经释放了

    return 0;
}

循环引用：解决方案3

还可以更好！刚才提到 unique_ptr 的应用场景是“当该对象仅仅属于我时”。
既然都用了原始指针（假定他释放前我必然被释放）。因为因此我们完全可以把 m_child 变成一个标志这“完全所有权”的 unique_ptr。
这样也不需要 shared_ptr 维护一个原子计数器的开销了。
用unique_ptr没有副本了，那么用原始指针就比较安全
eg：my_course/course/02/24/3.cpp

#include <memory>

struct C {
    std::unique_ptr<C> m_child;
    C *m_parent;
};

int main() {
    auto parent = std::make_unique<C>();
    auto child = std::make_unique<C>();

    // 建立相互引用：
    child->m_parent = parent.get();
    parent->m_child = std::move(child);  // 移交 child 的所属权给 parent

    parent = nullptr;  // parent 会被释放。因为 child 指向他的是原始指针
    // 此时 child 也已经被释放了，因为 child 完全隶属于 parent

    return 0;
}

总结：

接下来你会发现，在智能指针的管理下，某些类型的对象并不是总是需要用到拷贝和移动。
C++中所有的对象都是深拷贝，只有shared_ptr和weak_ptr是浅拷贝，unique_ptr是禁止拷贝

14.三五法则：什么时候需要担心

（1）类型安全vs类型不安全

一般来说，可以认为符合三五法则的类型是安全的。
以下类型是安全的(不会double free)：

int id;                                        // 基础类型
std::vector<int> arr;                  // STL 容器
std::shared_ptr<Object> child; // 智能指针
Object *parent;                         // 原始指针，如果是从智能指针里 .get() 出来的

以下对象是不安全的（会double free）：

char *ptr;                                   // 原始指针，如果是通过 malloc/free 或 new/delete 分配的
GLint tex;                                  // 是基础类型 int，但是对应着某种资源
std::vector<Object *> objs;       // STL 容器，但存了不安全的对象

解决办法：弄成深拷贝或者禁止拷贝

（2）成员都是安全的类型：五大函数，一个也不用声明

如果你的类所有成员，都是安全的类型，那么五大函数都无需声明（或声明为 = default），你的类自动就是安全的。

最好的判断方式是：如果你不需要自定义的解构函数，那么这个类就不需要担心。
因为如果用到了自定义解构函数，往往意味着你的类成员中，包含有不安全的类型。
一般无外乎两种情况：
你的类管理着资源。你的类是数据结构。
eg：

管理着资源：删除拷贝函数，然后统一用智能指针管理

这个类管理着某种资源，资源往往不能被“复制”。比如一个 OpenGL 的着色器，或是一个 Qt 的窗口。
如果你允许 GLShader 拷贝，就相当于把 glCreateShader 返回的 int 拷贝两遍，解构时就会出现重复释放 (double free) 错误。
你会想“那我是不是可以在 GLShader 里加一个引用计数器呢，这样就可以算拷贝次数避免重复释放了！”
可以，但是既然标准库已经提供了 shared_ptr，还不如用 shared_ptr 来管理，省的每个类实现一遍原子引用计数器。
这样就可以实现任意没有拷贝函数的对象的浅拷贝了

是数据结构：如果可以，定义拷贝和移动

这个类是你精心设计的数据结构，包括我们刚刚发明的 Vector，还有链表，红黑树等。如果这些数据结构是可以支持拷贝的（比如 Vector 就可以），你可能需要自己一个个定义。如果不支持，那就删除（= delete）。

函数参数：如何避免不必要的拷贝

注意到，如果函数的参数声明为值类型，很可能会造成一次不必要的拷贝。
eg：02/25/main.cpp

#include <vector>
#include <iostream>

struct Pig {
    std::string m_name;
    int m_weight;

    Pig(std::string name, int weight)
        : m_name(name)
        , m_weight(weight)
    {}

    Pig(Pig const &other)
        : m_name(other.m_name)
        , m_weight(other.m_weight)
    {
        std::cout << "拷贝了一只猪！" << std::endl;
    }
};

void show(Pig const &pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    Pig pig{"佩奇", 80};
    show(pig);
    return 0;
}

#include <vector>
#include <iostream>

struct Pig {
    std::string m_name;
    int m_weight;

    Pig(std::string name, int weight)
        : m_name(name)
        , m_weight(weight)
    {}

    Pig(Pig const &other)
        : m_name(other.m_name)
        , m_weight(other.m_weight)
    {
        std::cout << "拷贝了一只猪！" << std::endl;
    }
};

// void show(Pig const &pig) {
//     std::cout << "name: " << pig.m_name << std::endl;
//     std::cout << "weight: " << pig.m_weight << std::endl;
// }

void show(Pig pig)
{
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

int main() {
    Pig pig{"佩奇", 80};
    show(pig);
    return 0;
}

RAII内存管理_Pig_21

如何避免不必要的拷贝：常引用

因此，可以把函数的参数类型声明为：
Pig const &pig
这样传递的就是 pig 对象的常引用，从而实际只传递了一个指针，避免了拷贝。
常见的有 std::vector const &arr 等。
注：有的教材喜欢这样：const Pig &pig，仅仅是个人喜好不同，没有实际区别。
eg：my_course/course/02/25/main.cpp

#include <vector>
#include <iostream>

struct Pig {
    std::string m_name;
    int m_weight;

    Pig(std::string name, int weight)
        : m_name(name)
        , m_weight(weight)
    {}

    Pig(Pig const &other)
        : m_name(other.m_name)
        , m_weight(other.m_weight)
    {
        std::cout << "拷贝了一只猪！" << std::endl;
    }
};

void show(Pig const &pig) {
    std::cout << "name: " << pig.m_name << std::endl;
    std::cout << "weight: " << pig.m_weight << std::endl;
}

// void show(Pig pig)
// {
//     std::cout << "name: " << pig.m_name << std::endl;
//     std::cout << "weight: " << pig.m_weight << std::endl;
// }

int main() {
    Pig pig{"佩奇", 80};
    show(pig);
    return 0;
}

RAII内存管理_ios_22

（3）函数参数类型优化规则：按引用还是按值？

如果是基础类型（比如 int，float）则按值传递：
float squareRoot(float val);

如果是原始指针（比如 int *，Object *）则按值传递：
void doSomethingWith(Object *ptr);

如果是数据容器类型（比如 vector，string）则按常引用传递：
int sumArray(std::vector<int> const &arr);

如果数据容器不大（比如 tuple<int, int>），则其实可以按值传递：
glm::vec3 calculateGravityAt(glm::vec3 pos);

如果是智能指针（比如 shared_ptr），且需要生命周期控制权，则按值传递：
void addObject(std::shared_ptr<Object> obj);

如果是智能指针，但不需要生命周期，则通过 .get() 获取原始指针后，按值传递：
void modifyObject(Object *obj);

（4）如何避免不经意的隐式拷贝

我们可以将拷贝构造函数声明为 explicit 的，这样隐式的拷贝就会出错，从而发现因为疏忽大意造成的不必要拷贝。
而当的确需要拷贝时，也可以改成 Pig(pig) 语法来强制拷贝（即：显式拷贝）。
eg：my_course/course/02/26/main.cpp

15.扩展

P-IMPL 模式:可以分离声明和定义，改变类里面的属性，其外面也不会重新编译
虚函数与纯虚函数
拷贝如何作为虚函数,拷贝构造函数是构造函数，构造函数不能为虚的，父类定义一个返回值为shared_ptr的虚函数，那么子类就可以进行拷贝了
std::unique_ptr::release()，获取原始指针而不删除
std::enable_shared_from_this，this变成了一个shared_ptr，限制在于：这个类必须通过make_shared去构建，自己不能去new或者去栈上分配了
dynamic_cast，把具有虚函数的类进行类型转换
std::dynamic_pointer_cast，智能指针版本的dynamic_cast，
运算符重载
右值引用 &&
std::shared_ptr<void>和  std::any
可以接收任何一个指针，也能智能的管理它，和C语言的void*一样；std:any是一个深拷贝版本的shared_ptr<void>,可以接收任何类型的对象