C++ 备忘清单
===
提供基本语法和方法的 [C++](https://zh.cppreference.com/) 快速参考备忘单
入门
--------
### hello.cpp
```cpp
#include <iostream>
int main() {
std::cout << "Hello Quick Reference\n";
return 0;
}
```
编译运行
```shell
$ g++ hello.cpp -o hello
$ ./hello
Hello Quick Reference
```
### 变量
```cpp
int number = 5; // 整数
float f = 0.95; // 浮点数
double PI = 3.14159; // 浮点数
char yes = 'Y'; // 特点
std::string s = "ME"; // 字符串（文本）
bool isRight = true; // 布尔值
// 常量
const float RATE = 0.8;
```
----
```cpp
int age {25}; // 自 C++11
std::cout << age; // 打印 25
```
### 原始数据类型
数据类型 | 大小 | 范围
:- | -- | --
`int` | 4 bytes | -2<sup>31</sup> 到 2<sup>31</sup>-1
`float` | 4 bytes | _N/A_
`double` | 8 bytes | _N/A_
`char` | 1 byte | -128 到 127
`bool` | 1 byte | `true` / `false`
`void` | _N/A_ | _N/A_
`wchar_t` | 2 到 4 bytes | 1 个宽字符
<!--rehype:className=show-header-->
### 用户输入
```cpp
int num;
std::cout << "Type a number: ";
std::cin >> num;
std::cout << "You entered " << num;
```
### 交换
```cpp
int a = 5, b = 10;
std::swap(a, b);
// 输出: a=10, b=5
std::cout << "a=" << a << ", b=" << b;
// 整数交换的奇技淫巧
(x ^= y), (y ^= x), (x ^= y);
// 注意！ 以下操作会造成 undefined behavior
x ^= y ^= x ^= y;
```
### 注释
```cpp
// C++中的单行注释
/* 这是一个多行注释
在 C++ 中 */
```
### If 语句
```cpp
if (a == 10) {
// do something
}
```
查看: [条件](#c-条件)
### 循环
```cpp
for (int i = 0; i < 10; i++) {
std::cout << i << "\n";
}
```
查看: [循环 Loops](#c-循环)
### 函数
<!--rehype:wrap-class=row-span-2-->
```cpp
#include <iostream>
void hello(); // 声明
int main() { // 主函数
hello(); // 执行函数
}
void hello() { // 定义
std::cout << "Hello Quick Reference!\n";
}
```
查看: [函数 Functions](#c-函数)
### 引用
```cpp
int i = 1;
int& ri = i; // ri 是对 i 的引用
ri = 2; // i 现在改为 2
std::cout << "i=" << i;
i = 3; // i 现在改为 3
std::cout << "ri=" << ri;
```
`ri` 和 `i` 指的是相同的内存位置
### 命名空间
```cpp
#include <iostream>
namespace ns1 {int val(){return 5;}}
int main()
{
std::cout << ns1::val();
}
```
----
```cpp
#include <iostream>
namespace ns1 {int val(){return 5;}}
using namespace ns1;
using namespace std;
int main()
{
cout << val();
}
```
名称空间允许名称下的全局标识符
C++ 数组
------
### 定义
```cpp
std::array<int, 3> marks; // 定义
marks[0] = 92;
marks[1] = 97;
marks[2] = 98;
// 定义和初始化
std::array<int, 3> = {92, 97, 98};
// 有空成员
std::array<int, 3> marks = {92, 97};
std::cout << marks[2]; // 输出: 0
```
### 操控
```cpp
┌─────┬─────┬─────┬─────┬─────┬─────┐
| 92 | 97 | 98 | 99 | 98 | 94 |
└─────┴─────┴─────┴─────┴─────┴─────┘
0 1 2 3 4 5
```
----
```cpp
std::array<int, 6> marks = {
92, 97, 98, 99, 98, 94
};
// 打印第一个元素
std::cout << marks[0];
// 将第 2 个元素更改为 99
marks[1] = 99;
// 从用户那里获取输入
std::cin >> marks[2];
```
### 展示
```cpp
char ref[5] = {'R', 'e', 'f'};
// 基于范围的for循环
for (const int &n : ref) {
std::cout << std::string(1, n);
}
// 传统的for循环
for (int i = 0; i < sizeof(ref); ++i) {
std::cout << ref[i];
}
```
### 多维
```cpp
j0 j1 j2 j3 j4 j5
┌────┬────┬────┬────┬────┬────┐
i0 | 1 | 2 | 3 | 4 | 5 | 6 |
├────┼────┼────┼────┼────┼────┤
i1 | 6 | 5 | 4 | 3 | 2 | 1 |
└────┴────┴────┴────┴────┴────┘
```
----
```cpp
int x[2][6] = {
{1,2,3,4,5,6}, {6,5,4,3,2,1}
};
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 6; ++j) {
std::cout << x[i][j] << " ";
}
}
// 输出: 1 2 3 4 5 6 6 5 4 3 2 1
```
C++ 条件
------------
### If Clause
```cpp
if (a == 10) {
// do something
}
```
----
```cpp
int number = 16;
if (number % 2 == 0)
{
std::cout << "even";
}
else
{
std::cout << "odd";
}
// 输出: even
```
### Else if 语句
```cpp
int score = 99;
if (score == 100) {
std::cout << "Superb";
}
else if (score >= 90) {
std::cout << "Excellent";
}
else if (score >= 80) {
std::cout << "Very Good";
}
else if (score >= 70) {
std::cout << "Good";
}
else if (score >= 60)
std::cout << "OK";
else
std::cout << "What?";
```
### 运算符
<!--rehype:wrap-class=row-span-2-->
#### 关系运算符
:--|--
:--|--
`a == b` | a 等于 b
`a != b` | a 不等于 b
`a < b` | a 小于 b
`a > b` | a 大于 b
`a <= b` | a 小于或等于 b
`a >= b` | a 大于或等于 b
#### 赋值运算符
范例 | 相当于
:--|--
`a += b` | _Aka_ `a = a + b`
`a -= b` | _Aka_ `a = a - b`
`a *= b` | _Aka_ `a = a * b`
`a /= b` | _Aka_ `a = a / b`
`a %= b` | _Aka_ `a = a % b`
#### 逻辑运算符
| Example | Meaning |
|----------------|------------------------|
| `exp1 && exp2` | Both are true _(AND)_ |
| `exp1 || exp2` | Either is true _(OR)_ |
| `!exp` | `exp` is false _(NOT)_ |
#### 位运算符
| Operator | Description |
|----------|-------------------------|
| `a & b` | Binary AND |
| `a | b` | Binary OR |
| `a ^ b` | Binary XOR |
| `a ~ b` | Binary One's Complement |
| `a << b` | Binary Shift Left |
| `a >> b` | Binary Shift Right |
### 三元运算符
```
┌── True ──┐
Result = Condition ? Exp1 : Exp2;
└───── False ─────┘
```
----
```cpp
int x = 3, y = 5, max;
max = (x > y) ? x : y;
// 输出: 5
std::cout << max << std::endl;
```
----
```cpp
int x = 3, y = 5, max;
if (x > y) {
max = x;
} else {
max = y;
}
// 输出: 5
std::cout << max << std::endl;
```
### switch 语句
```cpp
int num = 2;
switch (num) {
case 0:
std::cout << "Zero";
break;
case 1:
std::cout << "One";
break;
case 2:
std::cout << "Two";
break;
case 3:
std::cout << "Three";
break;
default:
std::cout << "What?";
break;
}
```
C++ 循环
------------
### While
```cpp
int i = 0;
while (i < 6) {
std::cout << i++;
}
// 输出: 012345
```
### Do-while
```cpp
int i = 1;
do {
std::cout << i++;
} while (i <= 5);
// 输出: 12345
```
### Continue 语句
```cpp
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue;
}
std::cout << i;
} // 输出: 13579
```
### 无限循环
```cpp
while (true) { // true or 1
std::cout << "无限循环";
}
```
----
```cpp
for (;;) {
std::cout << "无限循环";
}
```
----
```cpp
for(int i = 1; i > 0; i++) {
std::cout << "infinite loop";
}
```
### for_each (C++11 起)
```cpp
#include <iostream>
int main()
{
auto print = [](int num) {
std::cout << num << std::endl;
};
std::array<int, 4> arr = {1, 2, 3, 4};
std::for_each(arr.begin(), arr.end(), print);
return 0;
}
```
<!--rehype:className=wrap-text-->
### 基于范围 (C++11 起)
```cpp
for (int n : {1, 2, 3, 4, 5}) {
std::cout << n << " ";
}
// 输出: 1 2 3 4 5
```
----
```cpp
std::string hello = "Quick Reference.ME";
for (char c: hello)
{
std::cout << c << " ";
}
// 输出: Q u i c k R e f . M E
```
### 中断语句
```cpp
int password, times = 0;
while (password != 1234) {
if (times++ >= 3) {
std::cout << "Locked!\n";
break;
}
std::cout << "Password: ";
std::cin >> password; // input
}
```
### Several variations
```cpp
for (int i = 0, j = 2; i < 3; i++, j--){
std::cout << "i=" << i << ",";
std::cout << "j=" << j << ";";
}
// 输出: i=0,j=2;i=1,j=1;i=2,j=0;
```
### auto
```cpp
std:: string s = "hello world";
for(auto c: s){
std:: cout << c << " ";
}
// 输出: h e l l o w o r l d
```
C++ 函数
------------
### 参数和返回
```cpp
#include <iostream>
int add(int a, int b) {
return a + b;
}
int main() {
std::cout << add(10, 20);
}
```
`add` 是一个接受 2 个整数并返回整数的函数
### 重载
```cpp
void fun(string a, string b) {
std::cout << a + " " + b;
}
void fun(string a) {
std::cout << a;
}
void fun(int a) {
std::cout << a;
}
```
### 内置函数
```cpp
#include <iostream>
#include <cmath> // 导入库
int main() {
// sqrt() 来自 cmath
std::cout << sqrt(9);
}
```
### Lambda 表达式
<!--rehype:wrap-class=col-span-2-->
Lambda 表达式可以在函数内定义，可以理解为在函数内定义的临时函数。格式：
```cpp
auto func = []() -> return_type { };
```
- `[]`为捕获列表，能够捕获其所在函数的局部变量
- 一个空的捕获列表代表Lambda表达式不捕获任何的变量
- 对于值捕获，直接在中括号中填写要捕获的变量即可：
```cpp
int val = 5;
auto func = [val]() -> return_type { };
```
- 对于引用捕获，需要在捕获的变量前添加`&`：
```cpp
string str("hello world!");
auto func = [&str]() -> return_type { };
```
- 如果变量太多，需要编译器根据我们编写的代码自动捕获，可以采用隐式捕获的方式。
- 全部值捕获：
```cpp
int val1, val2;
auto func = [=]() -> int
{
return val1 + val2;
};
```
- 全部引用捕获：
```cpp
string str1("hello"), str2("word!");
auto func = [&]() -> string
{
return str1 + str2;
};
```
- 混合隐式捕获：
如果希望对一部分变量采用值捕获，对其他变量采用引用捕获，可以混合使用：
```cpp
int val1 = 123, val2 = 456;
string str1("123"), str2(456);
auto func1 = [=, &str1]() -> int
{
return val1 == std::stoi(str1)
? val1 : val2;
};
auto func2 = [&, val1]() -> int
{
return str1 == std::to_string(val1)
? str1 : str2;
};
```
- `()` 是参数列表，我们只需要按照普通函数的使用方法来使用即可
- `return_type` 是函数的返回类型，`-> return_type` 可以不写，编译器会自动推导
- `{}` 中的内容就是函数体，依照普通函数的使用方法使用即可
<!--rehype:className=style-timeline-->
此处给出一个 Lambda 表达式的实际使用例子(当然可以使用 `str::copy`):
```cpp
// vec中包含1, 2, 3, 4, 5
std::vector<int> vec({1, 2, 3, 4, 5});
std::for_each(vec.begin(), vec.end(),
[](int& ele) -> void
{
std::cout << ele
<< " ";
});
```
## C++多线程
### 多线程介绍
g++编译选项：`-std=c++11`。包含头文件：
- `#include <thread>`：C++多线程库
- `#include <mutex>`：C++互斥量库
- `#include <future>`：C++异步库
### 线程的创建
<!--rehype:wrap-class=row-span-2-->
以普通函数作为线程入口函数：
```cpp
void entry_1() { }
void entry_2(int val) { }
std::thread my_thread_1(entry_1);
std::thread my_thread_2(entry_2, 5);
```
以类对象作为线程入口函数：
```cpp
class Entry
{
void operator()() { }
void entry_function() { }
};
Entry entry;
// 调用operator()()
std::thread my_thread_1(entry);
// 调用Entry::entry_function
std::thread my_thread_2(&Entry::entry_function, &entry);
```
以lambda表达式作为线程入口函数：
```cpp
std::thread my_thread([]() -> void
{
// ...
});
```
### 线程的销毁
```cpp
thread my_thread;
// 阻塞
my_thread.join();
// 非阻塞
my_thread.detach();
```
### `this_thread`
```cpp
// 获取当前线程ID
std::this_thread::get_id();
// 使当前线程休眠一段指定时间
std::this_thread::sleep_for();
// 使当前线程休眠到指定时间
std::this_thread::sleep_until();
// 暂停当前线程的执行，让别的线程执行
std::this_thread::yield();
```
### 锁
<!--rehype:wrap-class=row-span-3-->
> `#include <mutex>`
#### 锁的基本操作
创建锁
```cpp
std::mutex m;
```
上锁
```cpp
m.lock();
```
解锁
```cpp
m.unlock();
```
尝试上锁：成功返回`true`，失败返回`false`
```cpp
m.try_lock();
```
解锁
```cpp
m.unlock();
```
#### 更简单的锁 —— `std::lock_guard<Mutex>`
构造时上锁，析构时解锁
```cpp
std::mutex m;
std::lock_guard<std::mutex> lock(m);
```
额外参数：`std::adopt_lock`：只需解锁，无需上锁
```cpp
// 手动上锁
m.lock();
std::lock_guard<mutex> lock(m,
std::adopt_lock);
```
#### `unique_lock<Mutex>`
构造上锁，析构解锁
```cpp
std::mutex m;
std::unique_lock<mutex> lock(m);
```
##### `std::adopt_lock`
只需解锁，无需上锁
```cpp
// 手动上锁
m.lock();
std::unique_lock<mutex> lock(m,
std::adopt_lock);
```
##### `std::try_to_lock`
尝试上锁，可以通过`std::unique_lock<Mutex>::owns_lock()`查看状态
```cpp
std::unique_lock<mutex> lock(m,
std::try_to_lock);
if (lock.owns_lock())
{
// 拿到了锁
}
else
{
// 没有
}
```
##### `std::defer_lock`
绑定锁，但不上锁
```cpp
std::unique_lock<mutex> lock(m,
std::defer_lock);
lock.lock();
lock.unlock();
```
##### `std::unique_lock<Mutex>::release`
返回所管理的`mutex`对象指针，**释放所有权。**一旦释放了所有权，那么如果原来互斥量处于互斥状态，程序员有责任手动解锁。
#### `std::call_once`
当多个线程通过这个函数调用一个可调用对象时，只会有一个线程成功调用。
```cpp
std::once_flag flag;
void foo() { }
std::call_once(flag, foo);
```
### `std::condition_variable`
#### 创建条件变量
```cpp
std::condition_variable cond;
```
#### 等待条件变量被通知
```cpp
std::unique_lock<std::mutex>
lock;
extern bool predicate();
// 调用方式 1
cond.wait(lock);
// 调用方式 2
cond.wait(lock, predicate);
```
----
- `wait`不断地尝试重新获取并加锁该互斥量，如果获取不到，它就卡在这里并反复尝试重新获取，如果获取到了，执行流程就继续往下走
- `wait`在获取到互斥量并加锁了互斥量之后：
- 如果`wait`被提供了可调用对象，那么就执行这个可调用对象：
- 如果返回值为`false`，那么`wait`继续加锁，直到再次被 notified
- 如果返回值为`true`，那么`wait`返回，继续执行流程
- 如果`wait`没有第二个参数，那么直接返回，继续执行
#### `std::condition_variable::notify_one`
`notify_one` 唤醒一个调用 `wait` 的线程。注意在唤醒之前要解锁，否则调用 `wait` 的线程也会因为无法加锁而阻塞。
#### `std::condition_variable::notify_all`
唤醒所有调用 `wait` 的线程。
### 获取线程的运行结果
<!--rehype:wrap-class=row-span-2-->
> `#include <future>`
#### 创建异步任务
```cpp
double func(int val);
// 使用std::async创建异步任务
// 使用std::future获取结果
// future模板中存放返回值类型
std::future<double> result =
std::async(func, 5);
```
#### 获取异步任务的返回值
等待异步任务结束，但是不获取返回值：
```cpp
result.wait();
```
获取异步任务的返回值：
```cpp
int val = result.get();
```
注：
- `get()`返回右值，因此只可调用一次
- 只要调用上述任意函数，线程就会一直阻塞到返回值可用（入口函数运行结束）
#### `std::async` 的额外参数
额外参数可以被放在 `std::async` 的第一个参数位置，用于设定 `std::async` 的行为：
- `std::launch::deferred`：入口函数的运行会被推迟到`std::future<T>::get()`或者`std::future<T>::wait()`被调用时。此时调用线程会直接运行线程入口函数，换言之，**不会创建子线程**
- `std::launch::async`：立即创建子线程，并运行线程入口函数
- `std::launch::deferred | std::launch::async`：默认值，由系统自行决定
#### 返回值的状态
让当前线程等待一段时间（等待到指定时间点），以期待返回值准备好：
```cpp
extern double foo(int val) {}
std::future<double> result =
async(foo, 5);
//返回值类型
std::future_status status;
// 等待一段时间
status = result.wait_for(
std::chrono::seconds(1)
);
// 等待到某一时间点
status = result.wait_for(
std::chrono::now() +
std::chrono::seconds(1)
);
```
在指定的时间过去后，可以获取等待的结果：
```cpp
// 返回值已经准备好
if (status ==
std::future_status::ready)
{
}
// 超时：尚未准备好
else if (status ==
std::future_status::timeout)
{ }
// 尚未启动: std::launch::deferred
else if (status ==
std::future_status::deferred)
{ }
```
#### 多个返回值
```cpp
std::shared_future<T> result;
```
如果要多次获取结果，可以使用`std::shared_future`，其会返回结果的一个**拷贝**。
对于不可拷贝对象，可以在`std::shared_future`中存储对象的指针，而非指针本身。
C++ 预处理器
------------
### 预处理器
<!--rehype:wrap-class=row-span-3-->
- [if](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [elif](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [else](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [endif](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [ifdef](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [ifndef](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [define](https://zh.cppreference.com/w/cpp/preprocessor/replace)
- [undef](https://zh.cppreference.com/w/cpp/preprocessor/replace)
- [include](https://zh.cppreference.com/w/cpp/preprocessor/include)
- [line](https://zh.cppreference.com/w/cpp/preprocessor/line)
- [error](https://zh.cppreference.com/w/cpp/preprocessor/error)
- [pragma](https://zh.cppreference.com/w/cpp/preprocessor/impl)
- [defined](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [__has_include](https://zh.cppreference.com/w/cpp/feature_test)
- [__has_cpp_attribute](https://zh.cppreference.com/w/cpp/feature_test)
- [export](https://zh.cppreference.com/w/cpp/keyword/export)
- [import](https://zh.cppreference.com/mwiki/index.php?title=cpp/keyword/import&action=edit&redlink=1)
- [module](https://zh.cppreference.com/mwiki/index.php?title=cpp/keyword/module&action=edit&redlink=1)
<!--rehype:className=style-none cols-2-->
### Includes
```cpp
#include "iostream"
#include <iostream>
```
### Defines
```cpp
#define FOO
#define FOO "hello"
#undef FOO
```
### If
<!--rehype:wrap-class=row-span-2-->
```cpp
#ifdef DEBUG
console.log('hi');
#elif defined VERBOSE
...
#else
...
#endif
```
### Error
```cpp
#if VERSION == 2.0
#error Unsupported
#warning Not really supported
#endif
```
### 宏
```cpp
#define DEG(x) ((x) * 57.29)
```
### 令牌连接
```cpp
#define DST(name) name##_s name##_t
DST(object); #=> object_s object_t;
```
### 字符串化
```cpp
#define STR(name) #name
char * a = STR(object); #=> char * a = "object";
```
<!--rehype:className=wrap-text-->
### 文件和行
```cpp
#define LOG(msg) console.log(__FILE__, __LINE__, msg)
#=> console.log("file.txt", 3, "hey")
```
<!--rehype:className=wrap-text-->
各种各样的
-------------
### 转义序列
转义序列 | 说明
:--|--
`\b` | 退格键
`\f` | 换页
`\n` | 换行
`\r` | 返回
`\t` | 水平制表符
`\v` | 垂直制表符
`\\` | 反斜杠
`\'` | 单引号
`\"` | 双引号
`\?` | 问号
`\0` | 空字符
### 关键字
<!--rehype:wrap-class=row-span-2 col-span-2-->
- [alignas](https://zh.cppreference.com/w/cpp/keyword/alignas)
- [alignof](https://zh.cppreference.com/w/cpp/keyword/alignof)
- [and](https://zh.cppreference.com/w/cpp/keyword/and)
- [and_eq](https://zh.cppreference.com/w/cpp/keyword/and_eq)
- [asm](https://zh.cppreference.com/w/cpp/keyword/asm)
- [atomic_cancel](https://zh.cppreference.com/w/cpp/keyword/atomic_cancel)
- [atomic_commit](https://zh.cppreference.com/w/cpp/keyword/atomic_commit)
- [atomic_noexcept](https://zh.cppreference.com/w/cpp/keyword/atomic_noexcept)
- [auto](https://zh.cppreference.com/w/cpp/keyword/auto)
- [bitand](https://zh.cppreference.com/w/cpp/keyword/bitand)
- [bitor](https://zh.cppreference.com/w/cpp/keyword/bitor)
- [bool](https://zh.cppreference.com/w/cpp/keyword/bool)
- [break](https://zh.cppreference.com/w/cpp/keyword/break)
- [case](https://zh.cppreference.com/w/cpp/keyword/case)
- [catch](https://zh.cppreference.com/w/cpp/keyword/catch)
- [char](https://zh.cppreference.com/w/cpp/keyword/char)
- [char8_t](https://zh.cppreference.com/w/cpp/keyword/char8_t)
- [char16_t](https://zh.cppreference.com/w/cpp/keyword/char16_t)
- [char32_t](https://zh.cppreference.com/w/cpp/keyword/char32_t)
- [class](https://zh.cppreference.com/w/cpp/keyword/class)
- [compl](https://zh.cppreference.com/w/cpp/keyword/compl)
- [concept](https://zh.cppreference.com/w/cpp/keyword/concept)
- [const](https://zh.cppreference.com/w/cpp/keyword/const)
- [consteval](https://zh.cppreference.com/w/cpp/keyword/consteval)
- [constexpr](https://zh.cppreference.com/w/cpp/keyword/constexpr)
- [constinit](https://zh.cppreference.com/w/cpp/keyword/constinit)
- [const_cast](https://zh.cppreference.com/w/cpp/keyword/const_cast)
- [continue](https://zh.cppreference.com/w/cpp/keyword/continue)
- [co_await](https://zh.cppreference.com/w/cpp/keyword/co_await)
- [co_return](https://zh.cppreference.com/w/cpp/keyword/co_return)
- [co_yield](https://zh.cppreference.com/w/cpp/keyword/co_yield)
- [decltype](https://zh.cppreference.com/w/cpp/keyword/decltype)
- [default](https://zh.cppreference.com/w/cpp/keyword/default)
- [delete](https://zh.cppreference.com/w/cpp/keyword/delete)
- [do](https://zh.cppreference.com/w/cpp/keyword/do)
- [double](https://zh.cppreference.com/w/cpp/keyword/double)
- [dynamic_cast](https://zh.cppreference.com/w/cpp/keyword/dynamic_cast)
- [else](https://zh.cppreference.com/w/cpp/keyword/else)
- [enum](https://zh.cppreference.com/w/cpp/keyword/enum)
- [explicit](https://zh.cppreference.com/w/cpp/keyword/explicit)
- [export](https://zh.cppreference.com/w/cpp/keyword/export)
- [extern](https://zh.cppreference.com/w/cpp/keyword/extern)
- [false](https://zh.cppreference.com/w/cpp/keyword/false)
- [float](https://zh.cppreference.com/w/cpp/keyword/float)
- [for](https://zh.cppreference.com/w/cpp/keyword/for)
- [friend](https://zh.cppreference.com/w/cpp/keyword/friend)
- [goto](https://zh.cppreference.com/w/cpp/keyword/goto)
- [if](https://zh.cppreference.com/w/cpp/keyword/if)
- [inline](https://zh.cppreference.com/w/cpp/keyword/inline)
- [int](https://zh.cppreference.com/w/cpp/keyword/int)
- [long](https://zh.cppreference.com/w/cpp/keyword/long)
- [mutable](https://zh.cppreference.com/w/cpp/keyword/mutable)
- [namespace](https://zh.cppreference.com/w/cpp/keyword/namespace)
- [new](https://zh.cppreference.com/w/cpp/keyword/new)
- [noexcept](https://zh.cppreference.com/w/cpp/keyword/noexcept)
- [not](https://zh.cppreference.com/w/cpp/keyword/not)
- [not_eq](https://zh.cppreference.com/w/cpp/keyword/not_eq)
- [nullptr](https://zh.cppreference.com/w/cpp/keyword/nullptr)
- [operator](https://zh.cppreference.com/w/cpp/keyword/operator)
- [or](https://zh.cppreference.com/w/cpp/keyword/or)
- [or_eq](https://zh.cppreference.com/w/cpp/keyword/or_eq)
- [private](https://zh.cppreference.com/w/cpp/keyword/private)
- [protected](https://zh.cppreference.com/w/cpp/keyword/protected)
- [public](https://zh.cppreference.com/w/cpp/keyword/public)
- [reflexpr](https://zh.cppreference.com/w/cpp/keyword/reflexpr)
- [register](https://zh.cppreference.com/w/cpp/keyword/register)
- [reinterpret_cast](https://zh.cppreference.com/w/cpp/keyword/reinterpret_cast)
- [requires](https://zh.cppreference.com/w/cpp/keyword/requires)
- [return](https://zh.cppreference.com/w/cpp/language/return)
- [short](https://zh.cppreference.com/w/cpp/keyword/short)
- [signed](https://zh.cppreference.com/w/cpp/keyword/signed)
- [sizeof](https://zh.cppreference.com/w/cpp/keyword/sizeof)
- [static](https://zh.cppreference.com/w/cpp/keyword/static)
- [static_assert](https://zh.cppreference.com/w/cpp/keyword/static_assert)
- [static_cast](https://zh.cppreference.com/w/cpp/keyword/static_cast)
- [struct](https://zh.cppreference.com/w/cpp/keyword/struct)
- [switch](https://zh.cppreference.com/w/cpp/keyword/switch)
- [synchronized](https://zh.cppreference.com/w/cpp/keyword/synchronized)
- [template](https://zh.cppreference.com/w/cpp/keyword/template)
- [this](https://zh.cppreference.com/w/cpp/keyword/this)
- [thread_local](https://zh.cppreference.com/w/cpp/keyword/thread_local)
- [throw](https://zh.cppreference.com/w/cpp/keyword/throw)
- [true](https://zh.cppreference.com/w/cpp/keyword/true)
- [try](https://zh.cppreference.com/w/cpp/keyword/try)
- [typedef](https://zh.cppreference.com/w/cpp/keyword/typedef)
- [typeid](https://zh.cppreference.com/w/cpp/keyword/typeid)
- [typename](https://zh.cppreference.com/w/cpp/keyword/typename)
- [union](https://zh.cppreference.com/w/cpp/keyword/union)
- [unsigned](https://zh.cppreference.com/w/cpp/keyword/unsigned)
- [using](https://zh.cppreference.com/w/cpp/keyword/using)
- [virtual](https://zh.cppreference.com/w/cpp/keyword/virtual)
- [void](https://zh.cppreference.com/w/cpp/keyword/void)
- [volatile](https://zh.cppreference.com/w/cpp/keyword/volatile)
- [wchar_t](https://zh.cppreference.com/w/cpp/keyword/wchar_t)
- [while](https://zh.cppreference.com/w/cpp/keyword/while)
- [xor](https://zh.cppreference.com/w/cpp/keyword/xor)
- [xor_eq](https://zh.cppreference.com/w/cpp/keyword/xor_eq)
- [final](https://zh.cppreference.com/w/cpp/language/final)
- [override](https://zh.cppreference.com/w/cpp/language/override)
- [transaction_safe](https://zh.cppreference.com/w/cpp/language/transactional_memory)
- [transaction_safe_dynamic](https://zh.cppreference.com/w/cpp/language/transactional_memory)
<!--rehype:className=style-none cols-5-->
### 预处理器
- [if](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [elif](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [else](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [endif](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [ifdef](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [ifndef](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [define](https://zh.cppreference.com/w/cpp/preprocessor/replace)
- [undef](https://zh.cppreference.com/w/cpp/preprocessor/replace)
- [include](https://zh.cppreference.com/w/cpp/preprocessor/include)
- [line](https://zh.cppreference.com/w/cpp/preprocessor/line)
- [error](https://zh.cppreference.com/w/cpp/preprocessor/error)
- [pragma](https://zh.cppreference.com/w/cpp/preprocessor/impl)
- [defined](https://zh.cppreference.com/w/cpp/preprocessor/conditional)
- [__has_include](https://zh.cppreference.com/w/cpp/feature_test)
- [__has_cpp_attribute](https://zh.cppreference.com/w/cpp/feature_test)
- [export](https://zh.cppreference.com/w/cpp/keyword/export)
- [import](https://zh.cppreference.com/mwiki/index.php?title=cpp/keyword/import&action=edit&redlink=1)
- [module](https://zh.cppreference.com/mwiki/index.php?title=cpp/keyword/module&action=edit&redlink=1)
<!--rehype:className=style-none cols-2-->
另见
----
- [C++ Infographics & Cheat Sheets](https://hackingcpp.com/cpp/cheat_sheets.html) _(hackingcpp.com)_
- [C++ reference](https://zh.cppreference.com/w/) _(cppreference.com)_
- [C++ Language Tutorials](http://www.cplusplus.com/doc/tutorial/) _(cplusplus.com)_
# 数据结构与开发技巧
## map和set
```cpp
#include<iostream>
#include<map> // 注意map的key会自动排序, 所以在遇到排序问题时参考
#include<algorithm>
#include<vector>
#include <unordered_map>
using namespace std;
// map中 所有元素都是pair
// pair中 第一个元素为key(键值) 用于索引 第二个元素value(实值)
// 所有元素都会根据键值自动排序
// 本质：
// map /mulmap底层都是二叉树
// 优点：
// 可根据key值快速找到value值
// map不允许容器中出现相同的值
// mulmap中允许出现重复的值2
// map大小和交换：
// .size() //返回容器中元素的数目
// .empty() //判断容器是否为空
// .swap(st) //交换两个容器
// 插入和删除：
// insert(elem) //容器中插入元素 inseert(pair<int,int> ( , ));
// clear() //清除所有元素
// erase(pos) //删除pos迭代器所指的元素 返回下一个迭 代器位置
// erase(key) 删除键值为key的元素
void map_test(){
// https://blog.csdn.net/tcx1992/article/details/80928790
// https://blog.csdn.net/sevenjoin/article/details/81937695
typedef map<int, string> myMap; // 这其实就是将map里面的数据格式给固定下来而已, map<int, string> = myMap
myMap test;
//插入
test.insert(pair<int, string>(3, "a"));
test.insert(pair<int, string>(4, "b"));
test.insert(pair<int, string>(5, "c"));
test.insert(pair<int, string>(8, "d"));
test.insert(pair<int, string>(50, "e"));
//遍历（二叉搜索树的中序遍历，按照key值递增顺序）
cout << "遍历" << endl;
// for(auto i : test){ // 将temp里面的每个值, 放到i中, 这个i是新建的
// for(auto &i : test){ // 将temp里面的每个值, 软连接到i, 修改i就是在修改temp中的值
for(const auto &i : test){ // 将temp里面的每个值, 软连接到i, 禁用修改, 防止在遍历过程中出现改值
cout << i.second << endl;
cout << endl;
auto iter = test.rbegin();//最大的N个数
for (int i = 0; i < 3; i++)
cout << iter++->second << endl;
//查找
cout << "查找" << endl;
// 使用find，返回的是被查找元素的位置，没有则返回map.end()。
auto it = test.find(50); //查找key=50的数据是, find(key)返回的是pair格式, 也就是(50, e), 所以it->second=
if (it != test.end())
cout << it->second << endl;
// 使用count，返回的是被查找元素的个数。如果有，返回1；否则，返回0
cout << test.count(3) << endl;
//删除
cout << "删除" << endl;
if (test.erase(3))
cout << "delete success" << endl;
for (auto &i : test)
cout << i.second << endl;
}
void map_test2(){
map<int, string> myMap; // 创建
myMap.insert(pair<int, string>(3, "a")); // 插入
myMap.insert(pair<int, string>(5, "b"));
myMap.insert(pair<int, string>(50, "d"));
for (auto &i : myMap) cout <<i.first <<"value="<< i.second<<"; "; cout<<endl; // 遍历
//返回map最后一个值
map<int, string>::reverse_iterator iter = myMap.rbegin();
if (iter != myMap.rend()) cout<<"最后一个值是"<<iter->first << "-" << iter->second <<endl;
// cout<<"最后一个值是"<<myMap.end()->first << "-" << myMap.end()->second <<endl; //这样是错误的, 因为rend()和end()这两个函数只是标记找没找到 不是返回最后一个元素
// 最大的2个数
auto iter1 = myMap.rbegin();
for (int i = 0; i < 2; i++)
cout << iter1++->second << endl;
// 查找find
auto it = myMap.find(50); //查找key=50的数据是, find(key)返回的是pair格式, 也就是(50, e), 所以it->second=
if (it != myMap.end())
cout <<it->first << "-"<<it->second << endl;
// 判断存在,
cout << "3有" << myMap.count(3) << endl;
}
int main()
{
// map_test2();
unordered_map<int, string> map1{{1, "hel"}, {2, "ahskg"}, {3, "world"}};
cout<<map1.at(1)<<endl; // 最简单的查找
// cout<<map1.at(5)<<endl; // 最简单的查找
return 0;
}
```
## string
```cpp
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <vector>
#include <sstream> // 为了使用stringsteam
using namespace std;
// 题目描述: 给定字符串S,T, 求S中包含T所有字符的最短连续子字符串的长度, 时间复杂度不能超过O(n)
// 输入样例:
// Input: S = "ADOBECODEBANC", T = "ABC"
// Output: "BANC"
string String_test(){
string str="hello world";
//直接打印字符串
cout<<"str="<<str<<endl;
// printf("%s\n", str); //这里会报错, 需要将string转化为const char*类型
const char *p = str.c_str();
printf("str=%s\n", p);
// 求字符串长度:
cout<<"字符串长度等于: "<<str.length()<<endl;
// 打印字符串最后一位
cout<<"字符串最后一位"<<str[str.length()-1]<<endl;
cout<<"字符串最后一位"<<str.back()<<endl;
// string切片 substr(起始位置, 长度)
cout<<"切片"<<str.substr(0, 5)<<endl;
//比较字符串
if (0 == str.compare("hello world")){
printf("字符串等于hello world\n");
}
// 字符串判断空
if(!str.empty()){
printf("字符串不为空\n");
}
// 字符串翻转
// reverse(str.begin(), str.end()); // algorithm定义
// char*、char[]转换为string
const char* pszName = "liitdar";
char pszCamp[] = "alliance";
string strName = pszName;
string strCamp = pszCamp;
cout << "strName is: " << strName << endl; //strName is: liitdar
cout << "strCamp is: " << strCamp << endl; //strCamp is: alliance
// find检测是否存在
// size_t find (const string& str, size_t pos = 0) const;
// size_t find (const char* s, size_t pos = 0) const;
// size_t find (const char* s, size_t pos, size_t n) const;
// size_t find (char c, size_t pos = 0) const;
string str2 = "world";
size_t son_location = str.find(str2);
if (son_location != string::npos){
cout<<"找到子串str2, 在str位置是: "<<son_location<<endl; //找到子串str2, 在str位置是: 6
}
// 插入方法 insert
str.insert(6, "zjq's "); //hello zjq's world
str.insert(5, 4, 'a'); //在5的位置, 插入4个a
cout<<str<<endl;
// int2string stringstream
int n1 = 1234;
// n1.str(); // 这肯定不对
stringstream str3; //注意这里导入头文件<sstream>
str3 << n1;
string str4 = str3.str();
cout<<"将int类型转化为string类型: "<<str4<<endl;
string str5;
str3 >> str5;
cout<<str5<<endl; //总之都要将int转化为string类型
// 方法2 to_string
int numb2 = 456;
string str6;
str6 = to_string(numb2); // C++11 标准
cout << "str6 is: " << str6 << endl; //str6 is: 456
return str6;
}
int main(int argc, char const *argv[])
{
string str = String_test();
cout<<str<<endl;
return 0;
}
```
## 指针
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <stdio.h>
using namespace std;
// 指针和引用
void test1(int*a, int b, int &c){
cout<<"函数参数输入是: *a="<<*a<<" b="<<b<<" c="<<c<<endl;
*a = 10;
b = 23;
c = 25;
cout<<"函数参数修改后的结果是: *a="<<*a<<" b="<<b<<" c="<<c<<endl;
}
void pointor_test1(){
int x=0, y=1, z=3;
int *z1 = &z; //指向z地址的指针z1
cout<<"原始数据值是: *z1="<<*z1<<" x="<<x<<" y="<<y<<" z="<<z<<endl;
test1(z1,x,y);
cout<<"经过函数洗礼后的结果是: *z1="<<*z1<<" x="<<x<<" y="<<y<<" z="<<z<<endl;
/*
总结: 引用&跟指针的原理都是一样, 就是传递的是指针,所以当函数参数使用&时,该参数的改变就会影响到调用的值
*z1和y的引用: 根据结果可以看出来, 其实指针*跟引用&有着异曲同工之妙呀, \
因为指针*z1指向的地址, 传递给函数后, 函数对这个地址的内容进行了修改\
但是由于*z1指向的地址的参数z的作用于是main函数, 也就是只有等到main函数结束后, \
回收机制才会将z回收, 所以当*z1去函数test的作用域走了一圈以后, 他指向的地址依然有效;"
x的调用: 虽然x的作用域是main, 但是传递到test的x, 其实只是值传递给了b, 而b的作用域只是函数test1, 当test1执行完毕, \
b自然就废了, 所以即使b的值改变了, 但是并没有影响到x的值变化
*/
}
int * addition(int a, int b){
// new函数和malloc函数申请的内存在堆, 因此函数即使执行完毕, 堆不会回收
int *sum = new int(a+b); //创建指针, 指针指向一块新开辟的内存(这块内存是new开辟出来的), 内存的里面的值是a+b
return sum;
// 这里之所以返回的地址虽然正确, 但是内容错误,
// 这是因为在函数中创建的c是在栈中创建, 作用域只有在函数内有效, 等函数执行完毕,c被回收,
// 因此即使地址还是那个地址, 但是c已经不再是那个c了
// int c = a+b;
// int *sum = &c; //sum 指向c这块地址
// cout<<"sum="<<*sum<<" 地址是:"<<sum<<endl;
// return sum;
// int *c = a+b; //这个错误出在了a+b是一个值, 不是一个地址
// return c;
}
int subtraction(int a, int b){
return a-b;
}
int operation(int x, int y, int(*func)(int,int)){
return (*func)(x,y);
}
int main(int argc, char const *argv[])
{
pointor_test1(); // 指针和引用的基础使用
int *p = addition(2,3); //函数指针, 返回指针, 同时证明new int(a+b)开辟的空间在堆上, 需要手动回收或者程序执行完毕才会回收
cout<<"返回来的值和地址是:"<< *p<<" 地址:"<< p <<endl;
int x = 3;
int *p1 = &x; //此时p1指向一块内存, 内存里面存的是3,
const int *p2=&x; // 指针能修改, 但是值不能被修改
int * const p3 = &x; // 指针不能被修改, 但是值可以
const int * const p4 = &x; // 指针不能被修改, 值也不能
// 指针函数minus, 指向函数的指针
int (*minus)(int, int) = subtraction; // minus指向函数subtraction
int *m = addition(1,2); // 返回的是addition结果保存的地址
int n = operation(3, *m, minus); // x=3, y=1+2=3, 函数执行minus,即subtraction
cout<<"结果是:"<<n<<endl;
return 0;
}
```
## sstream类处理字符串
```cpp
#include <vector>
#include <iostream>
#include <unordered_map>
#include <unordered_map>
#include <sstream> // C++引入了ostringstream、istringstream、stringstream这三个类
/*
istringstream类用于执行C++风格的串流的输入操作。 string str="i am a boy"; 该类可以搞出来一个队列分解这四个单词
ostringstream类用于执行C风格的串流的输出操作。
strstream类同时可以支持C风格的串流的输入输出操作。
*/
using namespace std;
int main(int argc, char const *argv[])
{
// 这里打印出来的东西主要是看s的类型,
// 如果s是int, 就打印出12,3,4,5,67
// 如果s是char, 就打印出所有字符
// 如果s是string, 就直接将整行打印出来
string a = "12+3-4+5*67";
istringstream s1(a);
int i;
// 12 3 -4 5
while(s1 >> i){
cout<<i<<" ";
}cout<<endl;
istringstream s2(a);
char c;
// 1 2 + 3 - 4 + 5 * 6 7
while(s2 >> c){
cout<<c<<" ";
}cout<<endl;
string b = "hello world, my name is zjq, hello worldB, my name is xixi";
istringstream s3(b);
string s;
// hello//world,//my//name//is//zjq//
while(s3 >> s){
cout<<s<<"//";
}cout<<endl;
// 统计b里面的单词和数量
istringstream s4(b);
string str1;
unordered_map<string , int> counts;
// hello//world,//my//name//is//zjq//
while(s4 >> str1){
counts[str1]++;
}cout<<endl;
for(const auto& count: counts){
cout<<count.first<<":"<<count.second<<endl;
}
}
```
## 技巧
```cpp
// 子串表示连续的, 子序列表示不连续
// 没有特别需要排序的要求, 最好使用unordered_map和unordered_set, 底层是hash, 索引速度快, 没有排序的过程
// 能使用&进行参数传递, 尽可能使用&, 提高内存使用效率
#include <string> // getline
string str;
getline(cin, str); //可以将带空格的字符放入到str中
cout<<str<<endl;
```
# 面试知识点
## [C++编译流程](https://www.cnblogs.com/ericling/articles/11736681.html)
[C/C++程序编译过程详解](C/C++程序编译过程详解)
1. 预处理: **预处理用于将所有的#include头文件以及宏定义替换成其真正的内容**
2. 编译: **将经过预处理之后的程序转换成特定汇编代码**
3. 汇编: **汇编过程将上一步的汇编代码转换成机器码**
4. 链接: **链接过程将多个目标文件以及所需的库文件(.so等)链接成最终的可执行文件(executable file)**。
## [说一下 static 关键字的作用](https://www.runoob.com/w3cnote/cpp-static-usage.html)
1. 静态局部变量只初始化一次, 延长局部变量生命周期
2. 全局, 只能本文件中使用, 不能在其他文件中访问, 既是extern也不行 等于是在每个源文件中都定义了该变量一次
3. 头文件中定义: 每个CPP文件中会拷贝一份对应的变量
4. 修饰函数: 该函数只能本文件访问
5. 不想被释放时, 比如修饰函数中存放栈空间的数组, 可以加static
6. 类
```c
class A{
int a=0;
static int b=0;
static int c;
public:
void fun1(){}
static void fun2(){}
// 这句话本来就是错误的, 以为fun3比对象先实现, 但是a还没init
static void fun3(){ cout<< a <<endl; } // err
static void fun4(){ cout << b << endl; } // 通过, 因为fun4和b一起初始化
void fun5(){ cout << b << endl; } // 通过, 因为b先初始化, 创建对象实例的时候才初始化fun5
}
A::fun1(); // 1. err 因为类实例化对象后才能使用成员函数
A::fun2(); // 2. 通过 因为类实例化对象之前已经给静态成员函数分配了空间
A::fun3(); // 3. err 因为完成成员函数, 但是此时类成员变量还没有初始化, 因此错误
A a = new A;
a.fun3(); // 4. err 跟3一个道理, fun3先初始化, 但是里面包含的成员变量a未初始化, 编译错误
总结:
1. 静态成员函数不能使用非静态成员(函数和变量)
2. 非静态成员函数可以调用静态成员
3. 静态成员变量必须在初始化先 比如 int A::c = 20;
```
***
## 说一下 C++和 C 的区别
1. 思想: 面向对象, 面向过程的结构化编程语言
2. 语法: 封装(隐藏实现细节,代码模块化) 继承(派生类可以继承父类数据和方法,扩展已存在的模块, 代码重用) 多态(一个接口, 多种实现, 派生类重写父类虚函数, 实现接口重用)三种特性, 更安全:强制类型转化
3. 动态管理内存方法不一样: C是malloc和free, C++除此之外还有new/delete
4. 支持范式, 模板类, 函数模板等
***
## 指针和引用
| 指针 | 引用 |
| ---------------------------------------------------- | ------------------------------------------ |
| 有自己的一块空间 | 引用只是一个别名 |
| sizeof 看一个指针的大小是 4 | 被引用对象的大小 |
| 可以被初始化为 NULL | 引用必须被初始化且必须是一个已有对象的引用 |
| 作为参数传递时, 指针需要被解引用才可以对对象进行操作 | 直接对引用的修改都会改变引用所指向的对象 |
| 可以有 const 指针 | 无 |
| 指针在使用中可以指向其它对象 | 只能是一个对象的引用, 不能被改变 |
| 多级指针（**p） | 引用只有一级 |
| 指针和引用使用++运算符的意义不一样 | |
| 返回动态内存分配的对象或者内存, 必须使用指针 | |
## 智能指针? 为何使用智能指针
减少内存泄漏等问题
### 解决的问题
1. 空指针和野指针
2. 对象重复释放
3. 内存泄漏
4. 不匹配new和delete
### unique_ptr, shared_ptr, weak_ptr
unique_ptr 注意: 初始化相当于一个空指针, 再用make_unique初始化; 唯一指针, 不允许共享, 禁止拷贝复制; 相当于当我相对一个对象进行操作, 但是我不想别的指针操作这个对象, 就可以用unique_ptr; 尽量不要对其赋值操作, 让他自生自灭
shared_ptr 允许多个指针指向, 类似原始指针, 继承了`p->name` 和 ` (*p).name`注意: 降低程序运行效率, shared_ptr析构函数不能太复杂, 特别慢, 当他析构的时候, 整个线程会阻塞,
weak_ptr 打破循环引用, 只做观察指针, 看一下对象对象存不存在
auto_ptr已经不用了
[智能指针是线程安全的么?](http://www.cppblog.com/Solstice/archive/2013/01/28/197597.html) 显然智能指针控制写不是,因为智能指针操作不是原子性, 当赋值语句执行时, 其实智能指针拷贝对象同时还得对对象的计数进行+1操作, 这两步就会被其他线程钻空子了
C++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11 支持，并且第一个已经被 11 弃用。
1. 作用是管理一个指针; 申请空间在函数结束时忘记释放, 造成内存泄漏, 而使用智能指针, 一旦智能指针超出类的作用域, 类会自动调用析构函数, 释放资源, 所以智能指针的作用原理在函数结束后, 自动释放内存空间;
2. auto_ptr<string> p1 (new string ("I reigned lonely as a cloud.”));
auto_ptr<string> p2;
p2 = p1; //auto_ptr 不会报错. 此时p2掠夺了p1所有权, 使用p1的时候, 内存崩溃
3. unique_ptr<string> p3 (new string ("auto"));
unique_ptr<string> p4;
p4 = p3;// 报错, 非法, 避免内存崩溃
4. shared_ptr共享拥有, 多个智能指针可以指向同一个对象, 该对象和其相关资源会在最后一个引用被销毁后释放
5. weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象, 作为管理指针; 为了解决循环引用导致的内存泄漏, 构造函数不会改变引用计数, 不会对对象内存进行管理, 像是一个普通指针, 但会检测所管理的对象是否被释放, 从而避免内存泄漏;
**
***
## #define和const区别
| const |
| ---------------------------- |
| 有类型有名字, 放到静态存储 |
| 编译时确定, 只有一个拷贝 |
| 可以用指针去指向该变量的地址 |
| 不能定义函数 |
## 重载overload，覆盖（重写）override，隐藏（重定义）overwrite，这三者之间的区别
1. overload，将语义相近的几个函数用同一个名字表示，但是参数列表（参数的类型，个数，顺序不同）不同，这就是==函数重载==，返回值类型可以不同
特征：相同范围（同一个类中）、函数名字相同、参数不同、virtual关键字可有可无
2. override，派生类覆盖基类的虚函数，实现接口的重用，==返回值类型必须相同==
特征：==不同范围（基类和派生类）、函数名字相同、参数相同、基类中必须有virtual关键字==（必须是虚函数）
3. overwrite，派生类屏蔽了其同名的基类函数，返回值类型可以不同
特征：不同范围（基类和派生类）、函数名字相同、参数不同或者参数相同且无virtual关键字
## 多态
### [动态多态和静态多态](https://www.cnblogs.com/lizhenghn/p/3667681.html)
多态的实现分为==静态多态和动态多态==
1. 静态多态: 主要是 ==重载== ，在编译的时候就已经确定；
2. 静态多态设计思想: 对于相关的对象类型，直接实现它们各自的定义，不需要共有基类，甚至可以没有任何关系。只需要各个具体类的实现中要求相同的接口声明，这里的接口称之为隐式接口。客户端把操作这些对象的函数定义为模板，当需要操作什么类型的对象时，直接对模板指定该类型实参即可（或通过实参演绎获得）。
3. 动态多态: 用虚函数机制实现的，在运行期间动态绑定
4. 动态多态设计思想: 对于相关的对象类型，确定它们之间的一个共同功能集，然后在基类中，把这些共同的功能声明为多个公共的虚函数接口。各个子类重写这些虚函数，以完成具体的功能。客户端的代码（操作函数）通过指向基类的引用或指针来操作这些对象，对虚函数的调用会自动绑定到实际提供的子类对象上去。
如动物音乐大赛, 乌鸦和狗和猫报名, 但是这三个对象都指向动物类(这是一个基类), 使用动物指针对乌鸦, 狗, 猫进行方法调用, 就是多态
### 动态多台和静态多态的比较
| | 静态多态 | 动态多态 |
| ------ | ------------------------------------------------------------ | ---------------------------------------------- |
| 优点 | 编译期完成, 效率高, 编译器可优化 | 运行期动态绑定, |
| | 强适配性和松耦合性, 通过偏特化,全特化处理特殊类型 | 实现与接口分离, 可以复用 |
| | 静态多态通过模板编程为C++带来了泛型设计概念, 如STL库 | 处理同一继承体系下异质对象集合的强大威力 |
| 缺点 | 用模板实现静态多态, 模板不足, 调试困难,编译耗时, 代码膨胀, 编译器支持的兼容性, | 运行期绑定, 运行开销大 |
| | 不能处理异质对象集合 | 编译器无法对虚函数进行优化 |
| | | 笨重的类继承体系, 对接口的修改影响整个类的层次 |
| 不同点 | 本质不同, 静态多态,编译阶段, 模板实现, 动态多态,运行阶段, 继承虚函数实现 | |
| | 动态多态接口是显式, 静态是隐式, | |
https://www.cnblogs.com/zkfopen/p/11061414.html
### 虚函数表
```cpp
class B {
virtual int f1 (void); // 0
virtual void f2 (int); // 1
virtual int f3 (int); // 2
};
// 虚函数表
vptr -> [B::f1, B::f2, B::f3]
0 1 2
```
首先对于包含虚函数的类, 编译器会为每个包含虚函数的类生成一张虚函数表，即存放每个虚函数地址的函数指针的数组，简称虚表(vtbl)，每个虚函数对应一个虚函数表中的下标。
除了为包含虚函数的类生成虚函数表以外，编译器还会为该类增加一个隐式成员变量，通常在该类实例化对象的起始位置，用于存放虚函数表的首地址，
该变量被称为虚函数表指针，简称虚指针(vptr)。例如：
```cpp
B* pb = new B; /
pb->f3 (12);
// 被编译为
pb->vptr[2] (pb, 12); // B::f3 参数pb是this指针, 他首先找到虚函数表, 调用对应的f3函数
// 注意：虚表是一个类一张,而不是一个对象一张,同一个类的多个对象,通过各自的虚指针,共享同一张虚表。
vptr-> | vptr1 | vptr2 | vptr3 |
```
## 多态的工作原理(底层实现机制)
```cpp
// 继承自B的子类
class D : public B {
int f1 (void);
int f3 (int);
virtual void f4 (void);
};
// 虚函数表
// 子类覆盖了基类的f1和f3,继承了基类的f2,增加了自己的f4,编译器同样会为子类生成一张专属于它的虚表。
// 如下所示, 当基类指向子类时, vptr->vptr(子类)->D::f3, 这是因为他根据动态绑定原则, 先不直接加载基类自身函数, 编译器在运行时, 根据基类指向的子类的vptr函数进行加载指令, 这就实现了多态
vptr(子类)-> D::f1, B::f2, D::f3, D::f4
0 1 2 3
```
```cpp
// 指向子类虚表的虚指针就存放在子类对象的基类子对象中。例如：
B* pb = new D; // 父类指向子类, 调用子类的方法
pb->f3 (12);
// 被编译为
pb->vptr(子类)[2] (pb, 12); // D::f3 pb是基类指针, 他首先找基类的虚函数表vptr,
```
```cpp
// 示例
class A{
public:
A():m_ch('A'){}
virtual void foo() {
cout << m_ch << "::foo()" << endl ;
}
virtual void bar(){
cout << m_ch << "::bar()" << endl ;
}
private:
char m_ch ;
} ;
class B:public A{
public:
B():m_ch('B'){}
void foo(){
cout << "B::foo()" <<endl ;
}
private:
char m_ch ;
} ;
int main(){
A a ;
void(**vptr_a)(A*) = *(void(***)(A*))&a ;
cout << (void *)vptr_a <<endl ; //0x8048bb0
cout << "foo():"<<(void *)vptr_a[0] <<endl ; //foo():0x8048992
cout << "bar():" <<(void *)vptr_a[1] <<endl ; //bar():0x80489d4
vptr_a[0](&a) ; //A::foo()
vptr_a[1](&a) ; //A::bar()
cout << "-----------------------------------------" <<endl ;
B b ;
void(**vptr_b)(B*) = *(void(***)(B*))&b ;
cout << (void *)vptr_b <<endl ; //0x8048ba0
cout << "foo():"<<(void *)vptr_b[0] <<endl ; //foo():0x8048a3a
cout << "bar():" <<(void *)vptr_b[1] <<endl ; //bar():0x80489d4
vptr_b[0](&b) ; //B::foo()
vptr_b[1](&b) ; //A::bar()
}
```
上述程序说明了虚函数表是真实存在的：
void(**vptr_a)(A*) = *(void(***)(A*))&a ;建立一个vptr_a的虚函数表，如下图：
### 动态绑定
当编译器“看到”通过指针或者引用调用基类中的虚函数时，并不急于生成有关函数调用的指令，相反它会用一段代码替代该调用语句，这段代码在运行时被执行，完成如下操作：
1)根据调用指针或引用的目标对象找到其内部的虚表指针；
2)根据虚表指针找到其所指向的虚函数表；
3)根据虚函数名和函数指针在虚函数表中的索引，找到所调用虚函数的入口地址；
4)在完成函数调用的准备工作以后，直接跳转到虚函数入口地址处顺序执行函数体指令序列，直到从函数中返回。
3.动态绑定对性能的影响
1)虚函数表和虚指针的存在势必要增加内存空间的开销。
2)和普通函数调用相比，虚函数调用要多出一个步骤，增加运行时间的开销。
3)动态绑定会妨碍编译器通过内联优化代码，虚函数不能内联。
## 析构函数为何为虚函数:
父类设置为虚函数,保证new子类时,使用父类指针指向子类对象,释放父类指针时, 会自动释放子类空间, 防止内存泄漏
也就是父类指针释放的应该是子类对象的父类成员, 但是由于虚函数的特点, 同时会调用子类的析构函数
## map和set的实现
| | map/set | unordered_map/unordered_set |
| -------- | ------------------------------ | --------------------------- |
| 底层 | 红黑树 | 哈希表 |
| 有序性 | 自动排序 | 无序, key映射 |
| 查找时间 | O(logn) | O(1) |
| | 空间占用率高(保存父子节点关系) | 空间占用率低 |
1. C++关联容器,红黑树,map是KV对,K索引,V数据, set中K为集合;
2. map修改V不改K, 因为红黑树底层按照K排列,保证有序,如果可以修改K,首先需要删除K,调节树平衡,在插入修改后的K,调节平衡, 将会破坏map和set的结构;
3. map支持下标查询,不存在默认值, 因此慎用, 建议find
***
## 指针和数组的区别?
```cpp
int arr[4] = {1,2,3,4};
int* p1 = arr;
int *p2 = &arr[0];
cout<<arr<<" "<< p1 << " "<<p2<<endl;
*(p1+4) // 越界, 你不能更改
// 0x7fffeebfabf0 0x7fffeebfabf0 0x7fffeebfabf0
```
| 指针 | 数组 arr=[1,2,3], arr表示数组的首地址 |
| -------------------------- | ------------------------------------------------------------ |
| 数据的地址 | 保存数据 |
| 间接访问数据, 获得指针内容 | 直接访问数据 |
| 动态数据结构 | 固定数目, 数据类型相同 |
| malloc分配内存和free释放 | 隐式分配和删除 |
| 指向匿名数据, 操作匿名函数 | 自身作为数据名 |
| | *(arr+1) 表示第2个元素, 也就是数组的这个指针支持加减法, 加减的是元素位置 |
| | |
***
## [深浅拷贝](https://www.zhihu.com/question/36370072/answer/99839254)
==浅拷贝==实际上是对类成员的引用，==深拷贝==是对类成员的复制并且重新分配了内存
## 定义字符串的区别
const char * arr = "123"; char * brr = "123"; const char crr[] = "123"; char drr[] = "123"; 区别
const 常量区
\* brr 地址存放
## [类型转换? cast](https://mp.weixin.qq.com/s/6YW7VX787X7kZiRBLbVn-Q)
1. reinterpret_cast：任意类型的指针之间的转换，对转换的结果不做任何保证(不建议使用)
2. dynamic_cast：只能用于存在虚函数的父子关系的强制类型转换
3. const_cast：删除变量的const属性方便再次赋值
4. static_cast：完成基础数据类型；同一个继承体系中类型的转换；任意类型与空指针类型 void* 之间的转换。不能对其他指针类型进行转换
```cpp
int i = 10;
double d2 = static_cast<double>(i); //相当于创建一个static_cast<double>类型的匿名对象赋值给d2
float *p4 = static_cast<float*>(&i); // err
int* p2 = reinterpret_cast<int*>(i); // 任意类型转换
int *p = const_cast<int*>(&i);
```
***
## [const指针](https://blog.csdn.net/xixihaha331/article/details/51280263)
1. 常量指针和指针常量
```cpp
int a = 20;
int b=40;
//------------------------------------------------
const int *p; // 常量指针值不变, 对象可变, 这就是为何 for(const auto &a : arr){}
p=&a;
// (*p)++; // 这里会报错, 因为不能修改指向的值
p=&b; // 这里不会报错, 因为可以指向别的对象
printf("a=%d, b=%d, *p=%d\n", a, b, *p); //a=20, b=40, *p=40
//------------------------------------------------
int* const p1 = &a; // 指针常量, 对象不可变, 值可变
// p1=&b; // 会报错, 因为指针是常量, 对象不能变
(*p1)++; // 这里不会报错, 因为可以改值, 但是不可以改对象
printf("a=%d, b=%d, *p1=%d\n", a, b, *p1); //a=21, b=40, *p1=40
//------------------------------------------------
const int* const p2 = &b; // 常量指针常量值,
// p2=&a; // 会报错, 因为指针是常量, 对象不能变
// (*p2)++; // 会报错, 因为值是常量, 值不能变
printf("a=%d, b=%d, *p2=%d\n", a, b, *p2); //a=21, b=40, *p2=40
```
2. 常量参数 `void func(char *dest_str, const char *src_str)`
3. 修饰函数返回值 `const char *get_string(void)` 注意只能是指针传递, 如果是值传递就没用了
4. 修饰成员函数 `int get_count(void) const;` 不可以修改对象的成员变量
## [new/delete 与 malloc/free 的区别是什么](https://blog.csdn.net/linux_ever/article/details/50533149)
| | new/delete | malloc/free |
| ------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| 类型 | C++的关键字 | C语言库函数 |
| 返回类型安全性 | 只需要对象名即可创建对象, 返回的是对象类型指针, 类型严格与对象匹配, 无需进行类型转换 | 开辟空间大小严格, 返回的是(void*), 需要通过强制类型转换成需要的类型 |
| | ==new调用构造函数, delete调用析构函数, 能保证对象的初始化和回收内存== | 不会调用构造析构函数, 无法满足动态对象要求 |
| | ==由于new对象返回的指针, 在底层空间还存储了这个对象开辟空间的大小, 因此在析构的时候能够根据这个存储进行回收内存== | |
| 内存分配失败 | ==抛出bac_alloc异常try { int *a = new int(); } catch (bad_alloc) { }== | 返回NULL |
| 是都需要指定内存 | ==new无需指定, 编译器会根据类型自行计算== | 需要显式指出所需内存 |
| 实际创建步骤 | 1, 调用operator new函数, 分配一块足够大的内存, 方便存储特定类型对象, 2, 编译器运行相应的构造函数, 构造对象, 并传入初始值, 3, 对象构造完成, 返回一个指向该对象的指针 | |
| delete释放对象步骤 | 1, 调用对象析构函数, 2, 编译器调用operator delete函数释放内存空间 | |
new/delete 是 C++的关键字，而 malloc/free 是 C 语言的库函数，后者使用必须指明申请内存空间的大小，对于类类型的对象，后者不会调用构造函数和析构函数
***
## 构造函数和析构函数
| 构造函数 | 析构函数 |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| 无类型, 没有返回值, 名字和类名相同, 可重载 | 无类型, 无返回值, 名字和类名相同, 不带参数, 不可重载, 析构函数只有一个, 前面加个`~` |
| 作用: 完成对象的初始化 | 对象被删除前有系统自动执行清理工作 |
| 当对象d被创建时, 会自动调用构造函数, 当未定义构造函数时,编译器会自动假设存在两个默认构造函数cdata::cdata(){} | |
| Cdate::Cdate(const Cdate& a) | |
| 对象的析构函数在被销毁前调用, 对象何时销毁与其作用域相关 | |
| 全局对象在程序运行结束时销毁 | |
| 自动对象在离开作用域时销毁 | |
| 动态对象使用delete时销毁 | |
## allocator 内存分配和释放?
1. STL分配器封装与STL容器在内存管理上的底层细节;
2. new(调用operate new配置内存,调用对象构造函数构造对象内容)delete(调用析构函数, 释放内存);
3. allocator将两个阶段操作区分开来,内存配置有alloc::allocate()负责, 释放alloc::deallocate(); 对象构造由construct负责,内存析构由destroy负责;
4. 为了提升内存管理效率, 减少申请小内存内存碎片问题, STL采用两级配置器, 当分配大小空间超过128B, 使用一级空间配置器(malloc, realloc, free进行内存管理和内存空间分配和释放),大于128B, 二级(内存池技术,通过空闲链表来管理内存)
***
## malloc 的原理
malloc函数用于动态分配内存; 为了减少内存碎片和系统调用开销, malloc采用内存池的方式, 首先申请大块内存作为堆, 再将堆分成多个内存块, 以块作为内存管理的基础单位; 当用户申请内存时, 直接从堆区分配一块合适的空闲块; malloc采用隐式链表结构将堆区分成连续,大小不一的块, 包含已分配和未分配块; 同时malloc采用显示链表结构管理所有空闲块, 双向链表, 每个空闲块记录一个连续的, 未分配的地址;
当进行内存分配时，Malloc 会通过隐式链表遍历所有的空闲块，选择满足要求的块进行分配；当进行内存合并时，malloc 采用边界标记法，根据每个块的前后块是否已经分配来决定是否进行块合并。
Malloc 在申请内存时，一般会通过 brk 或者 mmap 系统调用进行申请。其中当申请内存小于128K 时，会使用系统函数 brk 在堆区中分配；而当申请内存大于 128K 时，会使用系统函数 mmap在映射区分配。
## STL迭代器删除元素:
1. 对于序列容器vector,deque来讲,使用erase, 后面元素前移一位,erase返回下一个有效的迭代器;
2. 对于map,set,使用erase,当前元素迭代器失效,但是因为结构为红黑树,所以删除元素不会影响下一元素迭代器,在调用erase之前,记录下一个元素的迭代器即可,
3. 对于list,使用不连续分配内存, erase返回下一个有效迭代器
## vector和list 的区别
| Vector | List |
| :----------------------------------------------------------: | :------------------------------------------------------: |
| 连续存储的容器，动态数组，在堆上分配空间, 两倍容量增长, 顺序内存 | 动态双向链表, 堆上空间, 每删除一个元素会释放一个空间 |
| 访问：O(1)(随机访问);插入:后插快, 中间需要内存拷贝, 内存申请和释放; 删除: 后删快, 中间需要内存拷贝 | 访问: 随机访问差, 只能开头和结尾; 插入和删除快, 常数开销 |
| 适用场景：经常随机访问，且不经常对非尾节点进行插入删除 | 适用于经常插入和删除 |
| 下面是区别 | |
| 数组 | 双向链表 |
| 支持随机访问 | 不支持随机访问 |
| 顺序内存 | 离散内存 |
| 中间节点插入删除会导致拷贝 | 不会 |
| 一次性分配好内存, 二倍扩容 | list每次在新节点插入会进行内存申请 |
| 随机访问性能好,插入性能差 | 相反 |
## STL迭代器的作用, 为何不用指针而用迭代器?
1. 迭代器提供一种方法顺序访问一个聚合对象各个元素, 而又不暴露该对象的内部表示; 或者说运用这种方法, 是的我们可以在不知道对象内部结构情况下, 按照一定顺序规则直接反问聚合对象的各个元素
2. 与指针的区别: 迭代器不是指针, 而是类模板, 表现像指针,模拟指针功能,重载指针操作符如->, *, ++等, 相当于一种智能指针, 根据不同类型的数据结构实现不同的操作
3. 迭代器类的访问方式就是把不同集合类的访问逻辑抽象出来, 是的不用暴露集合内部的结构而达到循环遍历的效果;
## C++中类成员的访问权限
C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表示公有的、受保护的、私有的，被称为成员访问限定符
类内部, 不区分, 无限制
子类, 能访问父类的private以外的属性和方法
其他类, 只能访问public
## struct和class的区别
在 C++中，可以用 struct 和 class 定义类，都可以继承。区别在于：structural 的默认继承权限和默认访问权限是 public，而 class 的默认继承权限和默认访问权限是 private。另外，class 还可以定义模板类形参，比如 template <class T, int i>
## C++源文从文本到可执行文件经历过程
1. 预处理: 源代码文件包含的头文件, 预编译语句, 分析替换, 生成预编译文件
2. 编译阶段: 特定编码
3. 汇编阶段: 转化为机器码, 重定位目标文件
4. 链接阶段: 多个目标文件及所需要的库链接成为最终可执行文件
## include "" 和include <>的区别
1. 编译器预处理阶段查找头文件的路径不一样
2. 双引号查找路径: 当前头文件目录, 编译器设置的头文件路径, 系统变量路径path指定的路径
3. <>查找路径: 编译器设置的头文件, 系统变量
## fork,wait,exec 函数
父进程产生子进程使用 fork 拷贝出来一个父进程的副本，此时只拷贝了父进程的页表，两个进程都读同一块内存，当有进程写的时候使用写实拷贝机制分配内存，exec 函数可以加载一个 elf文件去替换父进程，从此父进程和子进程就可以运行不同的程序了。fork 从父进程返回子进程的 pid，从子进程返回 0.调用了 wait 的父进程将会发生阻塞，直到有子进程状态改变,执行成功返回 0，错误返回-1。exec 执行成功则子进程从新的程序开始运行，无返回值，执行失败返回-1
## STL 里 resize 和 reserve 的区别
1. resize(): 改变当前容器内含有元素的数量
vector<int>v;
v.resize(20);
v.push_back(2); // 此时的2是21位置
2. reserve(len): 改变当前容器最大容量, 不会生成元素; 如果reserve大于capacity, 重新分配个len的对象空间, 原始对象复制过来
## BSS端等六段: C++的内存管理?
在C++中, 虚拟内存分为代码段,数据段, BSS段, 堆区, 文件映射区, 栈区六个部分
1. 代码段: 包括只读存储区(字符串常量)和文本区(程序的机器代码), 只读
2. 数据段: 存储程序中已初始化的全局变量和静态变量; 属于静态内存分配
3. BSS段: 存储未初始化或初始化为0的全局变量和静态变量(局部+全局); 属于静态分配, 程序结束后静态变量资源由系统自动释放。
4. 堆区: 调用 new/malloc 函数时在堆区动态分配内存，同时需要调用 delete/free 来手动释放申请的内存。频繁的malloc free造成内存空间不连续, 产生碎片, 因此堆比栈效率低
5. 映射区:存储动态链接库以及调用 mmap 函数进行的文件映射
6. 栈区: 存储函数的返回地址,返回值, 参数, 局部变量; 编译器自动释放,
## 内存泄漏
1. 堆内存泄漏, 如果malloc, new, realloc从堆分配的内存, 由于程序错误造成内存未释放, 产生的
2. 系统资源泄漏: 程序使用系统资源: bitmap, handle, socket忘记释放, 将导致系统效能和稳定差
3. 没有将基类析构函数定义为虚函数, 基类指针指向子类对象后, 释放基类时, 子类资源不会被正确释放
## 判断内存泄漏:
1. 内存泄漏原因: 通常调用malloc/new等内存申请操作, 缺少对应的free/delete
2. 判断内存是否泄漏, 可以使用Linux环境下的内存泄漏检测工具, 也可以在写代码时添加内存申请和释放统计功能, 统计申请和释放是否一致, 以此判断内存泄漏
varglind，mtrace 检测
## 如何采用单线程的方式处理高并发?
I/O 复用 异步回调
## 大端小端?
大端是指低字节存储在高地址；小端存储是指低字节存储在低地址。我们可以根据联合体来判断该系统是大端还是小端。因为联合体变量总是从低地址存储。
## 设计一个server, 实现多个客户端请求
1. 多线程,
2. 线程池 ,
3. IO复用
## [C++的线程锁你知道几种?](https://www.cnblogs.com/steamedbun/p/9376458.html)
### 互斥锁mutex
用于控制多线程对他们共享资源互斥访问的一个信号量, 也就是说为了避免多个线程同一个时刻操作一个共同资源;例如线程池中的多个空闲线程核一个任务队列, 任何一个线程都要使用互斥锁互斥访问任务队列, 避免多个线程同时访问任务队列发生错乱, 如果其他线程想要获取互斥锁, 只能阻塞等待
### 条件锁
条件锁就是所谓的条件变量, 某一个线程因为某个条件未满足时, 可以使用条件变量是程序处于阻塞状态, 一旦条件满足以信号量的方式唤醒一个因为该条件而被阻塞的线程
### 自旋锁
假设我们有一个两个处理器core1和core2计算机，现在在这台计算机上运行的程序中有两个线程：T1和T2分别在处理器core1和core2上运行，两个线程之间共享着一个资源。
首先我们说明互斥锁的工作原理，互斥锁是是一种sleep-waiting的锁。假设线程T1获取互斥锁并且正在core1上运行时，此时线程T2也想要获取互斥锁（pthread_mutex_lock），但是由于T1正在使用互斥锁使得T2被阻塞。当T2处于阻塞状态时，T2被放入到等待队列中去，处理器core2会去处理其他任务而不必一直等待（忙等）。也就是说处理器不会因为线程阻塞而空闲着，它去处理其他事务去了。
而自旋锁就不同了，自旋锁是一种busy-waiting的锁。也就是说，如果T1正在使用自旋锁，而T2也去申请这个自旋锁，此时T2肯定得不到这个自旋锁。与互斥锁相反的是，此时运行T2的处理器core2会一直不断地循环检查锁是否可用（自旋锁请求），直到获取到这个自旋锁为止。
### 读写锁
说到读写锁我们可以借助于“读者-写者”问题进行理解。首先我们简单说下“读者-写者”问题。计算机中某些数据被多个进程共享，对数据库的操作有两种：一种是读操作，就是从数据库中读取数据不会修改数据库中内容；另一种就是写操作，写操作会修改数据库中存放的数据。因此可以得到我们允许在数据库上同时执行多个“读”操作，但是某一时刻只能在数据库上有一个“写”操作来更新数据。这就是一个简单的读者-写者模型。
1 如果一个线程用读锁锁定了临界区，那么其他线程也可以用读锁来进入临界区，这样可以有多个线程并行操作。这个时候如果再用写锁加锁就会发生阻塞。写锁请求阻塞后，后面继续有读锁来请求时，这些后来的读锁都将会被阻塞。这样避免读锁长期占有资源，防止写锁饥饿。
2 如果一个线程用写锁锁住了临界区，那么其他线程无论是读锁还是写锁都会发生阻塞。
## 什么类不能被继承
1. 将自身的构造函数与析构函数放在private作用域
2. 友元类 friend
3. class FinalClass final { };
## 结构体和类大小
空的为1, 内存对齐, int double, char 则4,8,1+3, 后面的char需要对齐
## 类的什么方法不能是虚函数
普通函数, 友元函数, 构造函数, 内联成员, 静态态成员函数
## hash扩容
HashMap初始容量大小16，扩容因子为0.75，扩容倍数为2；
底层是数组加链表, 随着数据的增加, hash冲突会增加, 因此设置扩容因子, 当数据数量到达hash容量的扩容因子倍, 就会以二倍扩容, 16*2=32, 然后重新计算每个元素在数组中的位置.
## C++派生类的构造函数和析构函数执行顺序及其构造形式
### 派生类的构造函数和析构函数的执行顺序
<font color=red>先执行基类的构造函数，随后执行派生类的构造函数，当撤销派生类对象时，先执行派生类的析构函数，再执行基类的析构函数。</font>
### 派生类构造函数和析构函数的构造原则
1）派生类不能继承基类中的构造函数和析构函数。
当基类含有带参数的构造函数时，派生类必须定义构造函数，以提供把参数传递给基类构造函数的途径。
2）当派生类中还有对象成员时，其构造函数的一般形式为：
### 注意
1. 当基类构造函数不带参数时，派生类不一定需要定义构造函数，然而当基类的析构函数哪怕只有一个参数，也要为派生类定义构造函数，甚至所定义的派生类析构函数的函数体可能为空，仅仅起到传递参数的作用
2. 当基类使用缺省构造函数时或不带参数的构造函数时，则在派生类中定义构造函数时，可以省略：基类构造函数名（参数表），此时若派生类不需要构造 函数，则可以不定义构造函数。
3. 如果派生类的基类也是一个派生类，则每个派生类只需负责其直接基类的 构造，依次上溯。
4. 如果析构函数是不带参数的，在派生类中是否要定义析构函数与它所属的 基类无关，故基类的析构函数不会因为派生类没有析构函数而得不到执行，他们各自是独立的
## 虚函数调用的工作原理 基于虚函数多态的机制
### 虚函数和纯虚函数
虚函数: C++中用于实现多态的机制, 核心理念是通过基类访问派生类定义的函数, 是C++中多态的一个重要体现; 利用基类指针访问派生类中的虚函数, 这种情况采用的是动态绑定技术;
纯虚函数: 基类声明的虚函数, 基类无定义, 要求任何派生类都需要定义自己的实现方法, 在基类中实现纯虚函数的方法是在函数原型后面加 `=0` 纯虚函数不能实例化对象;
### 抽象类
特殊类, 为了抽象和设计的目的建立的, 处于继承层次结构的较上层;
定义: 带有纯虚函数的类为抽象类
作用: 将有关操作作为结果接口组织在一个继承层次结构中, 由他来为派生类提供一个公共根, 派生类将具体实现在其积累中作为接口的操作. 所以派生类实际上刻画了一组子类的操作接口的通用语义, 这些语义传给子类, 子类可以具体实现这些语义, 在将这些语义传给自己的子类
注意: 抽象类只能作为基类, 纯虚函数的实现由派生类给出; 如果派生类中没有重新定义纯虚函数，而只是继承基类的纯虚函数，则这个派生类仍然还是一个抽象类。如果派生类中给出了基类纯虚函数的实现，则该派生类就不再是抽象类了，它是一个可以建立对象的具体的类。
### 虚函数表
```cpp
class B {
virtual int f1 (void); // 0
virtual void f2 (int); // 1
virtual int f3 (int); // 2
};
// 虚函数表
vptr -> [B::f1, B::f2, B::f3]
0 1 2
```
首先对于包含虚函数的类, 编译器会为每个包含虚函数的类生成一张虚函数表，即存放每个虚函数地址的函数指针的数组，简称虚表(vtbl)，每个虚函数对应一个虚函数表中的下标。
除了为包含虚函数的类生成虚函数表以外，编译器还会为该类增加一个隐式成员变量，通常在该类实例化对象的起始位置，用于存放虚函数表的首地址，
该变量被称为虚函数表指针，简称虚指针(vptr)。例如：
```cpp
B* pb = new B;
pb->f3 (12);
// 被编译为
pb->vptr[2] (pb, 12); // B::f3 参数pb是this指针
// 注意：虚表是一个类一张,而不是一个对象一张,同一个类的多个对象,通过各自的虚指针,共享同一张虚表。
vptr-> | vptr1 | vptr2 | vptr3 |
```
### 多态的工作原理(底层实现机制)
```cpp
// 继承自B的子类
class D : public B {
int f1 (void);
int f3 (int);
virtual void f4 (void);
};
// 虚函数表
// 子类覆盖了基类的f1和f3,继承了基类的f2,增加了自己的f4,编译器同样会为子类生成一张专属于它的虚表。
vptr(子类)-> D::f1, B::f2, D::f3, D::f4
0 1 2 3
```
```cpp
// 指向子类虚表的虚指针就存放在子类对象的基类子对象中。例如：
B* pb = new D; // 父类指向子类, 调用子类的方法
pb->f3 (12);
// 被编译为
pb->vptr(子类)[2] (pb, 12); // D::f3
```
```cpp
// 示例
class A{
public:
A():m_ch('A'){}
virtual void foo() {
cout << m_ch << "::foo()" << endl ;
}
virtual void bar(){
cout << m_ch << "::bar()" << endl ;
}
private:
char m_ch ;
} ;
class B:public A{
public:
B():m_ch('B'){}
void foo(){
cout << "B::foo()" <<endl ;
}
private:
char m_ch ;
} ;
int main(){
A a ;
void(**vptr_a)(A*) = *(void(***)(A*))&a ;
cout << (void *)vptr_a <<endl ; //0x8048bb0
cout << "foo():"<<(void *)vptr_a[0] <<endl ; //foo():0x8048992
cout << "bar():" <<(void *)vptr_a[1] <<endl ; //bar():0x80489d4
vptr_a[0](&a) ; //A::foo()
vptr_a[1](&a) ; //A::bar()
cout << "-----------------------------------------" <<endl ;
B b ;
void(**vptr_b)(B*) = *(void(***)(B*))&b ;
cout << (void *)vptr_b <<endl ; //0x8048ba0
cout << "foo():"<<(void *)vptr_b[0] <<endl ; //foo():0x8048a3a
cout << "bar():" <<(void *)vptr_b[1] <<endl ; //bar():0x80489d4
vptr_b[0](&b) ; //B::foo()
vptr_b[1](&b) ; //A::bar()
}
```
上述程序说明了虚函数表是真实存在的：
### 动态绑定
当编译器“看到”通过指针或者引用调用基类中的虚函数时，并不急于生成有关函数调用的指令，相反它会用一段代码替代该调用语句，这段代码在运行时被执行，完成如下操作：
1)根据调用指针或引用的目标对象找到其内部的虚表指针；
2)根据虚表指针找到其所指向的虚函数表；
3)根据虚函数名和函数指针在虚函数表中的索引，找到所调用虚函数的入口地址；
4)在完成函数调用的准备工作以后，直接跳转到虚函数入口地址处顺序执行函数体指令序列，直到从函数中返回。
3.动态绑定对性能的影响
1)虚函数表和虚指针的存在势必要增加内存空间的开销。
2)和普通函数调用相比，虚函数调用要多出一个步骤，增加运行时间的开销。
3)动态绑定会妨碍编译器通过内联优化代码，虚函数不能内联。
# ref
[nwu_zjq](https://gitee.com/nwu_zjq)