std::numeric_limits<T>::lowest();//给出T的最小取值（有符号时为绝对值最大的负数）
std::numeric_limits<T>::min();//对于整数，给出最小取值，对于浮点数，给出最小的正数
std::numeric_limits<T>::max();//给出T的最大取值
std::numeric_limits<T>::epsilon();//浮点数给出最小精度，比如第一个大于1的数和1的差

float a = 1.5f;
float b {1.5f};

int i = 2.5f;//编译器无warning
float f = 2.5f;
int j {f};//编译器产生warning，有时候类型收窄确实可能导致错误。
int k {2.5f};//编译器会直接给出error

void normalize(vec3f & v);//把v变成单位向量
vec3f normalized(vec3f const & v);//返回v的单位向量，但v不变

std::string_view sv2 {"std::string Literal"s};
cout << sv2;

template<class T>
int f(T&& x){                  // x 是转发引用
    return g(std::forward<T>(x)); // 从而能被转发

std::string s1 = "test";
std::string const & s2 = s1+s1; // 这个右值的生命周期被延长到和s2一样，但是不可修改
std::string && s3 = s1+s1; // 同上，但是可修改

std::vector<int> v1{1,2,3,4,5,6};
std::vector<int> v2(std::move(v1));

int& fun(int x){
    int y = x+1;
    return y;

std::vector<int> fun(){...}
auto const & v = fun();//现在fun的返回值的周期延长到和v一样，通常不会造成问题
auto const & v2 = fun()[0];//这是最危险的情况，fun的返回值其实生命周期已结束，v2引用的元素已经变成了无效内存，对v2的操作是UB

struct St{
    int x;
    double y;
St st{1, 2.0};//也可以St st = {1, 2.0};

struct Point{
    double x,y;
Point p1{1.0, 2.0};
Point p2 = p1;

int main(int argc, char* argv[]){
    //...

./g++.exe 1.cpp -o 1.exe -Wall

#include <fstream>
int main(){
    std::ofstream os{"1.txt"};
    if(os.good()){//在每次使用时都应该确保good
        os<<"hello world\n";
    return 0;

#include <fstream>
int main(){
    std::ifstream is{"2.txt"};
    if(is.good()){//在每次使用时都应该确保good
        double x,y;
        is>>x>>y;
        std::cout<<x<<" "<<y<<"\n";
    return 0;

std::ofstream os{"out.txt", std::ios::app}; //append而不是覆盖
std::ifstream is2{"in.tga", std::ios::binary}; //写二进制
std::ofstream os2{"out.tga", std::ios::binary}; //读二进制

struct Vec{
    double x,y;
std::istream& operator>>(std::istream& is, Vec& v){
    return is>>v.x>>v.y;
std::ostream& operator<<(std::ostream& os, Vec& v){
    return os<<v.x<<" "<<v.y;
std::cout<<Vec(2.0,3.0)<<"\n";//可以像对int一样使用cin cout

class Vec{
public:
    double x,y;
    Vec():y(0),x(0){}

Vec(int x_, int y_){ //而不是写:x(x_),y(y_)
    x = x_;
    y = y_;

class Vec{
public:
    double x=0.0, y=0.0;
    Vec(){}

class Cl{
public:
    int n;
    explicit Cl(int n_):n(n_){}
void foo (Cl a) {}
foo(1);  //隐式调用Cl的构造函数，但因为其构造函数是explicit的，会报错
foo(Cl(1));//正常

Class Vec{
public:
    double x, y;
    Vec():Vec(0){}
    Vec(double a):Vec(a,a){}
    Vec(double x_, double y_):x(x_),y(y_){}

void foo(int n){}
void foo(void *n){}

foo(NULL);

if(p){}
if(p!=NULL){}
if(p!=nullptr){}

Derive* d1 = new Derive();
cout << "d1: " << d1 << endl;
Base* b1 = dynamic_cast<Base*>(d1);
cout << "b1: " << b1 << endl; // 这里的内存地址和上面的是一样的
Base* b2 = new Base();
cout << "b2: " << b2 << endl;
Derive* d2 = dynamic_cast<Derive*>(b2);
cout << "d2: " << d2 << endl; // 这里是nullptr，而非b2的地址。
// 如果使用是父类引用转化为子类引用，会抛出std::bad_cast
// 只有当b2本来就指向一个Derive时，转化才会成功
// 如果是static_cast，则不会抛出，也不会在失败时nullptr。只有当b2指向Derive时，程序才会符合预期。否则之后可能会调用不存在的成员。

class A{
public:
    void foo() {}
    void foo() const {}
    void foo() volatile {}
    void foo() const volatile {}

int n;
std::cin>>n;
int const sz = n;
std::array<int, sz> ar; // 报错

class Vec{
public:
    double x,y;
    int mutable sth;
    int sth2;
    void foo() const {
        sth++;//不会报错
    void bar() const{
        sth2++;//会报错

#include <iostream>
struct S
    void f() &  { std::cout << "左值\n"; }
    void f() && { std::cout << "右值\n"; }
int main()
    s.f();            // 打印“左值”
    std::move(s).f(); // 打印“右值”
    S().f();          // 打印“右值”

constexpr int foo(int n){
    return n+1;
int main(){
    constexpr int n = foo(1);
    std::array<int, n> ar;
    return 0;
C++11后只有三种智能指针，unique_ptr，shared_ptr，weak_ptr。还有一种auto_ptr已经移除。智能指针可以方便管理资源的所有权，以及提供对于资源的RAII。
unique_ptr，如同名字一样，是独占资源的。在实现上，他只能移动构造和赋值，而不能拷贝构造和赋值，保证了其所有权无法复制，同一时间只能有一个unique_ptr拥有该资源的所有权。
std::unique_ptr<int> p = std::make_unique<int>(1);
std::cout<<*p<<"\n"; // 输出1
这里的p就独占了一个int对象的所有权。
auto p2 = p; // 报错，无法拷贝构造
auto p3 = std::move(p); // 可以编译，p3获得所有权而p失去所有权
在make_unique时（C++14之后），相当于调用了unique_ptr<T>(new T(std::forward<Args>(args)...))。然后在unique_ptr生命周期结束（和所有权转移）时，会自动调用删除器来释放资源。默认的删除器通过delete实现，即对其包装的指针进行delete。
shared_ptr，也如同名字一样，允许多个shared_ptr拥有同一个资源。在实现上，他可以移动构造移动赋值，也可以拷贝构造和拷贝赋值。其RAII的实现方法是，加入一个引用计数器，表明有多少shared_ptr在使用这个资源，每次复制时计数器加一，每当一个shared_ptr析构时计数器减一。如果计数器归零，那么销毁分配的对象。
weak_ptr，它的出现是为了解决shared_ptr中的一个问题。假如我们有一个双向链表，它支持多个线程来读数据，所以我们理所当然地使用shared_ptr来管理其中的指针（例如next和prev）。但是在某种情况下就有问题，假设我们在局部作用域分配了一个链表，插入两个元素，然后就等待作用域结束后析构。此时会发生内存泄漏，为什么呢？
我们就分析这两个节点的引用计数。其中第一个节点被head和第二个节点的prev指针指向，而第二个节点被tail和第一个节点的next指针指向。当list析构时，list只包含head和tail指针，这两个shared_ptr析构，将两个节点的计数器各减一，但是两个节点仍然互相有指针指向对面，所以两个节点的计数器都为一。所以两个节点无法自动销毁，造成内存泄漏。
weak_ptr的思想在于，创建一个弱引用，不增加引用计数器的值。当我们需要使用被管理的对象时，手动转换成shared_ptr（此时计数器加一），再进行使用。而使用结束后再变回弱引用（计数器减一）。
std::weak_ptr<int> wp;
    auto sp = std::make_shared<int>(42);
    wp = sp;
    std::cout<<wp.use_count()<<"\n";// 输出1
    if(std::shared_ptr<int> spt = wp.lock()) // 需要手动转化shared_ptr
        std::cout<<*spt<<"\n";
std::cout<<wp.use_count()<<"\n";// 输出0
if(std::shared_ptr<int> spt = wp.lock()) // spt为nullptr
    std::cout<<*spt<<"\n";
对于上面所说的链表，只需要把内部的next和prev换成weak_ptr即可解决问题。
make_shared和make_unique
https://zh.cppreference.com/w/cpp/memory/unique_ptr/make_unique，其中指出，make_unique和unique_ptr<T>(new ...)是等价的。但我觉得下面关于make_shared的几点也适用于make_unique
而https://zh.cppreference.com/w/cpp/memory/shared_ptr/make_shared中指出，make_shared和shared_ptr<T>(new ...)是有略微的区别的：
因为shared_ptr有引用计数器，所以使用shared_ptr<T>(new ...)会先new出一个对象，然后再new一个控制块。这就是两次new，并且这两次的内存是可能不连续的。而make_shared只进行一次new并且控制块和对象连续分配（标准推荐而非强制）
make_shared创造出来的资源，在所有shared_ptr生命期结束后，如果还有weak_ptr引用，则该资源会持续存在，直到所有weak_ptr结束。
如果当前语境可以访问非公开构造函数，那么shared_ptr<T>(new ...)可以正常使用。但make_shared只能调用公开的构造函数。
make_shared不能自定义删除器
make_shared使用::new，如果类重载了new运算符，则不同于shared_ptr<T>(new ...)
placement new
A *p = new A;完成了两个操作首先是在堆上分配了一块内存，然后将A在这块内存上默认构造。
而placement new做的操作是，给定一块内存的首地址，在这块内存上构造对象。这样，我们就可以在栈上构造对象了。这样做的好处可以参考内存池，如果有一块内存可以复用，就不用反复分配内存了，节约开销。
char mem[100];
A *p = new (mem) A;





    
this指针
有点类似于Python里的self参数，都是只能用在类里的。是一个指向对象自己的指针。
析构函数的析构顺序
在析构函数执行完毕后，类成员变量的析构顺序，是按照其声明顺序的反方向进行的。
有时候可以尝试集中处理Exception
void handle_errors(){
    try{
        throw; //必要的，进行re-throw
    catch(...){}
    catch(...){}
    catch(...){}
void foo(...){
    try{
    catch(...){
        handle_errors();
void bar(...){
    try{
    catch(...){
        handle_errors();
这可以复用代码，尤其是你的东西可能会抛出一样的exception的时候。
RAII思想和其对于Exception内存泄漏的保护
RAII是Resource Acquisition Is Initialization的缩写，意为资源获取就是初始化。
其要求，对象在构造函数中获取资源，在析构函数中释放资源。为什么这是好的呢？他可以减少你管理内存的工作量，你不需要手动去到处写delete来释放内存。它会在对象生命周期结束的时候自动释放，也就避免了内存泄漏。
而对于Exception，它也可以很好的保护内存。C++的Exception在throw的时候，保证可以释放创建的局部对象。于是就可以自动释放内存，而不用担心是否在throw前正确处理了内存。
像C语言这样的东西，申请完内存需要free才能释放，如果在函数中提前返回了，无法运行到free这一行，那么内存就泄漏了。如下例
void foo(){
    int *a = malloc(...);
    if(...){
        return; // 这里没有释放内存，产生泄漏
    free(a);
    return;
所以如果C++调用了某个C库，又没有很好的释放内存，就可能会造成泄漏。如果你想避免这个，可能可以尝试用C++的类包装一下，提供析构函数。
上例在exception结构中类似下例
void foo(){
    int *a = new...;
    if(...){
        throw ...;// 这里没有释放内存，产生泄漏。但是如果有析构函数则可以避免
    delete a;
    return;
另外，RAII也就要求你，不能在析构函数本身中出现提前的throw。
noexcept修饰
修饰函数时，如果给出noexcept，则意味着你保证：
函数的操作不会失败
从外部来看，任何Exception是不可见的。或者说所有Exception都在内部处理了。
如果noexcept函数还是抛出了一个Exception，那么程序会终止。
我们可以给noexcept提供一个条件，满足条件是函数才是noexcept的。
void foo() noexcept(n<9){...} // 当n<9时noexcept
void bar() noexcept( noexcept(foo) ){...} // 当foo是noexcept时，bar是noexcept
注意给assert的参数加上括号
因为assert其实是宏，所以
assert(min(a,b)==a); //不好
assert((min(a,b)==a)); //好
否则，宏替换可能会出问题，而且你无法察觉。
static_assert
assert是给运行时用的，而static_assert就是给编译时用的。
static_assert(bool_exp, "msg"); // C++11可用
static_assert(bool_exp); //C++17可用
用-DNDBUG忽略所有assert
这是g++的编译选项，只需使用这个参数即可
g++ -DNDBUG ...
编译器warning的编译参数
默认编译并不会打开很多warning，在生产环境中，推荐使用
-Wall -Wextra -Wpedantic -Wshadow -Werror -fsanitize=undefined,address
来开启更多warning。
Cmake使用
doctest/catch2/gtest使用
不要在调试的时候到处写cout、cerr
首先这会干扰到原本的代码逻辑，你删除的时候可能会删错、忘删。另外，这并不适合写测试样例来检测是否正确，更好的办法是，定义一个函数
void log(std::ostream& os, ...) {...}
把要输出测试的东西放到ostream里，方便测试样例获取
std::ostringstream oss;
log(oss, ...);
ASSERT_STREQ(oss.str(), "123");
如果要调试最好使用GDB等工具。
GDB使用
使用g++/clang检测内存错误使用、未定义行为等
即之前介绍到的，只需要添加-fsanitize=undefined,address编译选项即可。在运行的时候，如果出现这种错误，就会提供报错信息。
使用valgrind检测内存泄漏、死锁问题等
我们首先编译好程序，然后通过
valgrind [options] ./program [program options]
来执行检查。可选参数有
--tool=memcheck，用来检查内存泄漏、对无效内存读写等
--tool=helgrind，用来检查死锁
--leak-check=full，用来显示内存泄漏的详细信息
-v/--verbose，用来显示额外信息
使用end迭代器的值是未定义行为
std::vector<int> vec;
auto it = vec.end();
std::cout<<*it; // UB
std::distance
求得左闭右开区间[it1, it2)的大小。
std::vector<int> vec{1,2,3};
auto x = std::distance(std::begin(vec), std::end(vec)); // 3
如果满足老式随机访问迭代器，那么复杂度是常数。否则复杂度为线性。
所有序列容器都是所谓的regular types
也即下面四个特点：
深可拷贝：在拷贝赋值、拷贝构造的时候，都是把容器内的每个值拷贝到新容器中
深可赋值：即给容器内的元素赋值时，都是把源数据进行拷贝（而非移动）
深可比较：即两个容器相等时，当且仅当每个元素相等
深所有权：容器析构时会析构所有元素
std::span
C++20引入的功能。span对于vector、array，相当于string_view对于string。声明方法如下
std::span<int> // 声明一个可修改的
std::span<int const> // 声明一个不可更改的
std::span<int, 5> // 声明一个固定大小的，大小需要是编译期常数
和string_view一样，推荐只用在函数参数中。对于字面量，也会存在访问已经销毁的对象的问题。
void foo(std::span<int const> s);
std::vector<int> v{1,2,3,4};
foo(v);
foo({v.begin()+1, v.end()});
span可以使用size、empty等获取大小信息，可以通过[]获取数据。对于比较两个span是否相同，和其他序列容器略有不同
sv.data() == sw.data();  // 对比sv和sw是否是同一个内存位置上的对象
std::ranges::equal(sv,sw);  // 对比sv和sw的值是否都相同
Map和Set查询元素是否存在的新方法
在C++20之后，引入了contains函数。如下
std::set<int> s{1, 2, 3};
if (s.contains(7)) {…} 
比起find简单，比count不用转换类型。
用equal_range获取multiset中所有给定值
std::multiset<int> s {2,4,4,4,6};
auto e4 = s.equal_range(4);
cout << *(e4.first)
     << *(e4.second);// e4.first是第一个元素的迭代器，e4.second是最后一个元素之后的元素的迭代器
不要用迭代器遍历unordered_map和unordered_set
这两个容器的begin和end迭代器指向的是bucket，而不是元素。所以用迭代器遍历是不能达到目的的。但是可以使用for(auto x:ust)来遍历
map和set的判断元素相同的依据
这两个容器一样，都不是按照equal的意义去判断两个元素是否相同，而是按照equivalent去判断。
a==b // equal
!(a<b) && !(b<a) // equivalent
所以说，我们只要重载小于运算符，就可以让map和set运行起来，不需要大于和等于运算符。
自定义unordered容器的哈希函数
一般都会新建一个类，重定义其函数调用运算符，返回值是size_t。
struct MyHash{
  constexpr std::size_t
  operator () (A const & a) const noexcept {
      //...
std::unordered_set<A, MyHash> s;





    
默认使用的是std::hash<Key>，设计新哈希时，可以考虑把自定义类型的各个成员变量的std::hash组合起来，形成新哈希。
标准库算法的执行策略
在C++17之后，许多标准库里的算法都可以选择执行策略，例如
sort(std::execution::par, begin(v), end(v), cmp);
这是sort函数的又一个重载，其函数声明为
template< class ExecutionPolicy, class RandomIt, class Compare > 
void sort( ExecutionPolicy&& policy,  
           RandomIt first, RandomIt last, Compare comp );
其中执行策略有四种：
std::execution::seq // 算法的执行不能并行化、向量化
std::execution::par // 算法的执行可以并行化，但是不能向量化
std::execution::par_unseq // 算法的执行可以并行化、向量化
std::execution::unseq // 算法的执行不可以并行化，但是可以向量化。C++20后可用
并行执行时，算法本身不会避免数据竞争，这是程序员需要考虑的事，例如
int a[] = {0, 1};
std::vector<int> v;
std::for_each(std::execution::par, std::begin(a), std::end(a), [&](int i)
  v.push_back(i*2+1); // 错误：数据竞争
新for循环反向遍历的方法
C++20可用，让for(:)也能反向遍历。
for (int x : v | std::views::reverse) { cout << x << '\n'; }
泛型Lambda
泛型lambda不需要template，只需要用auto即可，例如
[] (auto a, auto b){ return a+b;}
[] (auto const & a, auto const & b){ return a+b;}
std::memcpy的重叠问题
memcpy的定义如下：
void* memcpy( void* dest, const void* src, std::size_t count );
其把src中的字节复制到dest中，但是，如果src+count>dest，就会出现重叠的问题。根据cppreference，这是未定义的。此时我们要使用std::memmove。它可以规避这个问题，标准规定其要如同复制字符到临时数组，再从该数组到dest一般发生复制。
同时，cppreference补充说，尽管说明了“如同”使用临时缓冲区，此函数的实际实现并不会带来二次复制或额外内存的开销。对于小count，它可能加载并写入寄存器；对于更大的内存块，常用方法是若目标在源之前开始，则从缓冲区开始正向复制，否则从末尾反向复制，完全无重叠时回落到更高效的std::memcpy。
我自己看过gnu实现的标准库，确实是这样。内存中，若dest在src之前，就正向复制，否则，逆向复制类似于如下的循环
for(int i=count-1;i>=0;i--){
    dest[i] = src[i];
std::copy的重叠问题
类似于上一节的纯C库，这个C++库也有这个问题。
template< class InputIt, class OutputIt >
OutputIt copy( InputIt first, InputIt last,
               OutputIt d_first );
如果d_first在[first, last)中，行为未定义。此时用std::copy_backward替代（如果d_last在[first, last)中，则未定义，应该用std::copy）。
std::random_shuffle随机重排数组
std::vector<int> v {0,1,2,3,4,5,6,7,8};
std::random_shuffle(begin(v)+2, begin(v)+7);  
在pytorch中打乱数据集用到了类似的东西。
std::fill
在某种意义上是比memset好的，memset是按字节赋值的，而std::fill是按元素赋值。比如
int arr[100];
std::fill(arr, arr+100, 100000);
这个是memset不方便做到的。
std::generate
auto gen = [i=0]() mutable { i += 2; return i; };
std::vector<int> v(7, 0);
generate(begin(v)+1, begin(v)+5, gen);
for (int x : v) { cout << x << ' '; }  // 0 2 4 6 8 0 0
即在迭代器的这个范围内，每个元素使用一次gen并对其赋值。
std::transform
template< class InputIt, class OutputIt, class UnaryOp >
OutputIt transform( InputIt first1, InputIt last1,
                    OutputIt d_first, UnaryOp unary_op );
对每一个[first1, last1)中的元素使用一元函数unary_op，然后将值依次赋值给d_first开始的元素。
template< class InputIt1, class InputIt2,
          class OutputIt, class BinaryOp >
OutputIt transform( InputIt1 first1, InputIt1 last1, InputIt2 first2,
                    OutputIt d_first, BinaryOp binary_op );
对每一个[first1, last1)中的元素，和first2开始的对应元素，使用二元函数binary_op，然后将值依次赋值给d_first开始的元素。
std::accumulate和std::reduce
二者都是进行[first, last)的加和（或自定义运算）的操作，区别在于std::reduce是可以并行化的。
reduce(v.begin(), v.end()); // 执行累加，返回累加和，初值默认为T()
reduce(v.begin(), v.end(), 1.0, std::multiplies<>{}); // 第三个参数为初值，第四个参数为运算。这里就是累乘
std::tuple
可以说是一个扩展维度的std::pair。使用例如下
std::tuple<double, int, char> t{1.2, 3, 'a'};
std::cout<<std::get<0>(t);
std::cout<<std::get<1>(t);
std::cout<<std::get<2>(t);
比std::array好的地方在于其可以有不同的元素类型。但是，用作函数返回值、参数可能不是一个很好的想法。因为可读性较差，不如struct。
std::tie可以返回左值引用的元组。如下场景会比较好用
struct S
    int n;
    std::string s;
    float d;
    friend bool operator<(const S& lhs, const S& rhs) noexcept
        // 比较 lhs.n 与 rhs.n,
        // 然后为 lhs.s 与 rhs.s,
        // 然后为 lhs.d 与 rhs.d
        // 返回这个次序中第一个不相等的结果
        // 或者当所有元素都相等时返回 false
        return std::tie(lhs.n, lhs.s, lhs.d) < std::tie(rhs.n, rhs.s, rhs.d);
以及，拆包函数返回值，
std::tuple<int, int, double> foo(){
    return {1, 2, 0.3};
int main(){
    int a, b;
    double c;
    std::tie(a, b, c) = foo(); // 或者可以写 auto [a, b, c] = foo()，只不过前者可以在c++11后使用，后者只能在c++17后使用
    return 0;





    
std::optional
C++17引入的新工具，在以前，我们生成新的资源时，通常会返回指向该资源的指针。如果返回的是nullptr，则说明分配失败。更现代的方法是使用std::optional
std::optional<std::string> create(bool b)
    if (b)
        return "test";
    return {}; // 等价于返回 std::nullopt
检测返回的东西是否有效，可以像bool类型一样使用
auto r = create(true);
if(r){
    //...
else{
    //...
也可以使用r.has_value()。如果要使用其包装的值，则可以使用如下两种办法
r->push_back('b'); // 像指针一样使用
r.value().push_back('c'); // 把值拿出来，再使用
std::variant
是在C++17提供的一种类型安全的联合体。一个 std::variant 的实例在任意时刻要么保有它的可选类型之一的值，要么在错误情况下无值。union的问题是，如果成员之一需要析构函数来释放资源，那么union定义的变量在结束生命周期时，不会自动调用析构函数。或者类似于，三个成员分别为int,double,char*的union，其被分配了一个new char[]给char *，那么在生命周期末尾时，不会自动调用delete []去释放空间。std::variant的出现解决了这个问题
std::variant<int, double, std::string> x, y;
x = 1;
y = "test";
x = 2.0;
std::variant的变量在同时只能拥有一个具体的类型。如上，x不是int，就是double或者std::string。不过，可以方便地通过重新赋值的方式改变其具体类型。如果要知道当前的是哪种类型，可以通过
x.index()
来获取，是int就返回0，double就返回1，即为声明时的下标，以此类推。
获取值可以用
std::get<double>(x);
std::get<1>(x);
来获取当前的值。如果试图获取非当前类型的值，就会抛出异常
    std::get<int>(x); // x 含 double 而非 int：会抛出异常
catch (const std::bad_variant_access& ex)
    std::cout << ex.what() << '\n';

int *i = std::get_if<int>(&x);
if(i==nullptr){}
else{}

std::any a = 1;
std::cout << a.type().name() << ": " << std::any_cast<int>(a) << '\n';
a = 3.14;
std::cout << a.type().name() << ": " << std::any_cast<double>(a) << '\n';
a = true;
std::cout << a.type().name() << ": " << std::any_cast<bool>(a) << '\n';

g++ -E A.cpp -o A.i # 生成预处理后的结果
g++ -S A.cpp -o A.s # 生成编译后的汇编代码
g++ -c A.cpp -o A.o # 生成编译后的目标文件

// a.h
void foo(){}

// b.h
#include "a.h"
void bar(){
    foo();

// c.cpp
#include "a.h"
#include "b.h"
int main(){
    foo();
    bar();

//这部分来源于a.h
void foo(){}
//这部分来源于b.h
void foo(){}
void bar(){
    foo();
int main(){
    foo();
    bar();
    return 0;

// a.h
#ifndef A_H
#define A_H
void foo(){}
#endif

// b.h
#ifndef B_H
#define B_H
#include "a.h"
void bar(){
    foo();
#endif

// foo.h
void foo(){}

// a.cpp
#include "foo.h"
void bar1(){
    foo();

// b.cpp
#include "foo.h"
void bar2(){
    foo();

inline void foo(){}

namespace{
    void foo(){}

namespace n1{
    class set{...};
namespace n2{
    class set{...};

namespace n1{
    inline namespace current{
        class A{...};
    namespace old{
        class A{...};
n1::A a; // 调用的current的A
n1::old::A aa;

class A{
    friend class B;
    friend void foo(A const &);

class A{
    friend void bar(){} // 非成员函数
bar();// 直接调用

class A : public B{
public:
    void print() const override final;

class A{
public:
    // 只定义一些函数接口
class Data{};
class B : public A{
public:
    // ...
private:
    Data d_;
class C : public A{
public:
    // ...
    // 假设C无须数据，就不需要声明

array& operator=(array const & other){
    if(this==&other) return *this;
    delete [] data_;
    data_ = nullptr;
    size_ = other.size_;
    data_ = mSize_ ? new int[size_] : nullptr;
    std::copy(other.data_, other.data_ + size_, data_);

class array{
public:
    //...
    friend void swap(array& first, array& second) noexcept {
        using std::swap;
        swap(first.size_, second.size_);
        swap(first.data_, second.data_);
    array(array const & other): size_(other.size_), 
                                data_(size_?new int[size_]:nullptr){
        std::copy(other.data_, other.data_ + size_, data_);
    } // 即使分配失败，也不会内存泄漏，更不会改变原有的状态（因为没有原有的状态）
    array& operator=(array other){ // 在参数中拷贝构造了，少写代码
        swap(*this, other); 
        return *this;
private:
    std::size_t size_;
    int* data_;

array(array && other) noexcept
    : array(){
    swap(*this, other);

#include <iostream>
int main()
    std::cout << "测试\n"; // 全局命名空间中没有 operator<<，但 ADL 检验 std 命名空间，
                           // 因为左实参在 std 命名空间中
                           // 并找到 std::operator<<(std::ostream&, const char*)
    operator<<(std::cout, "测试\n"); // 同上，用函数调用记法
    // 然而，
    std::cout << endl; // 错误：'endl' 未在此命名空间中声明。
                       // 这不是对 endl() 的函数调用，所以不适用 ADL
    endl(std::cout); // OK：这是函数调用：ADL 检验 std 命名空间，
                     // 因为 endl 的实参在 std 中，并找到了 std::endl
    (endl)(std::cout); // 错误：'endl' 未在此命名空间声明。
                       // 子表达式 (endl) 不是函数调用表达式

template<class T>
void f(T&& x){                  // x 是转发引用
    g(std::forward<T>(x)); // 从而能被转发

void g(int& x) { std::cout << "int &\n"; }
void g(int&& x) { std::cout << "int &&\n"; }
template <class T>
void f(T&& x) {
    g(x);
void solve() {
    int a;
    f(a); // 打印int &
    f(std::move(a)); // 还是打印int &

template<class T>
void f1(T&& x);                 // x 是转发引用
struct A{
    template<class T>
    void f2(T&& x);                 // x 是转发引用
template<class U>
struct B{
    void f3(U&& x);                 // 这个x不是转发引用
    template<class T>
    void f4(T&& x);                 // x 是转发引用

template<class T, class... Args>
auto f(Args&&... args){
    return std::pari<T, int>{std::forward<Args>(args)..., 0};

template<class T>
struct Point{
    using value_type = T; // 外部可以使用typename Point::value_type;来获取类型

// 模板的声明
template<class T>
struct container
    container(T t) {}
    template<class Iter>
    container(Iter beg, Iter end);
// 额外的推导指引
template<class Iter>
container(Iter b, Iter e) -> container<typename std::iterator_traits<Iter>::value_type>;
// 使用
container c(7); // OK：用隐式生成的指引推导出 T=int
std::vector<double> v = {/* ... */};
auto d = container(v.begin(), v.end()); // OK：推导出 T=double
container e{5, 6}; // 错误：std::iterator_traits<int>::value_type 不存在

template<class T>
class A{
    // ...
A<int> a;

template<class T>
class A{
    // ...
template<>
class A<int>{
    // ...

template<class T>
class A;
template<>
class A<int>{
    //...
template<>
class A<double>{
    //...

// B.h
template<class T>
class B{
public:
	void foo(T x);

// B.cpp
#include "B.h"
#include <iostream>
template<class T>
void B<T>::foo(T x){
	std::cout<<x<<"\n";

// A.cpp
#include "B.h"
int main(){
	B<int> b;
	b.foo(666);
	return 0;

	.file	"A.cpp"
	.text
	.def	__main;	.scl	2;	.type	32;	.endef
	.globl	main
	.def	main;	.scl	2;	.type	32;	.endef
	.seh_proc	main
main:
.LFB0:
	pushq	%rbp
	.seh_pushreg	%rbp
	movq	%rsp, %rbp
	.seh_setframe	%rbp, 0
	subq	$48, %rsp
	.seh_stackalloc	48
	.seh_endprologue
	call	__main
	leaq	-1(%rbp), %rax
	movl	$666, %edx
	movq	%rax, %rcx
	call	_ZN1BIiE3fooEi # 调用b.foo(666)
	movl	$0, %eax
	addq	$48, %rsp
	popq	%rbp
	.seh_endproc
	.ident	"GCC: (Rev7, Built by MSYS2 project) 13.1.0"
	.def	_ZN1BIiE3fooEi;	.scl	2;	.type	32;	.endef

	.file	"B.cpp"
	.text
	.section .rdata,"dr"
_ZNSt8__detail30__integer_to_chars_is_unsignedIjEE:
	.byte	1
_ZNSt8__detail30__integer_to_chars_is_unsignedImEE:
	.byte	1
_ZNSt8__detail30__integer_to_chars_is_unsignedIyEE:
	.byte	1
	.ident	"GCC: (Rev7, Built by MSYS2 project) 13.1.0"

// B.cpp
#include "B.h"
#include <iostream>
template<class T>
void B<T>::foo(T x){
	std::cout<<x<<"\n";
template class B<int>;

	.file	"B.cpp"
	.text
	.section .rdata,"dr"
.LC0:
	.ascii "\12\0"
	.section	.text$_ZN1BIiE3fooEi,"x"
	.linkonce discard
	.align 2
	.globl	_ZN1BIiE3fooEi
	.def	_ZN1BIiE3fooEi;	.scl	2;	.type	32;	.endef
	.seh_proc	_ZN1BIiE3fooEi
_ZN1BIiE3fooEi:
.LFB2470:
	pushq	%rbp
	.seh_pushreg	%rbp
	movq	%rsp, %rbp
	.seh_setframe	%rbp, 0
	subq	$32, %rsp
	.seh_stackalloc	32
	.seh_endprologue
	movq	%rcx, 16(%rbp)
	movl	%edx, 24(%rbp)
	movl	24(%rbp), %eax
	movl	%eax, %edx
	movq	.refptr._ZSt4cout(%rip), %rax
	movq	%rax, %rcx
	call	_ZNSolsEi
	movq	%rax, %rcx
	leaq	.LC0(%rip), %rax
	movq	%rax, %rdx
	call	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
	addq	$32, %rsp
	popq	%rbp
	.seh_endproc
	.section .rdata,"dr"
_ZNSt8__detail30__integer_to_chars_is_unsignedIjEE:
	.byte	1
_ZNSt8__detail30__integer_to_chars_is_unsignedImEE:
	.byte	1
_ZNSt8__detail30__integer_to_chars_is_unsignedIyEE:
	.byte	1
	.ident	"GCC: (Rev7, Built by MSYS2 project) 13.1.0"
	.def	_ZNSolsEi;	.scl	2;	.type	32;	.endef
	.def	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc;	.scl	2;	.type	32;	.endef
	.section	.rdata$.refptr._ZSt4cout, "dr"
	.globl	.refptr._ZSt4cout
	.linkonce	discard
.refptr._ZSt4cout:
	.quad	_ZSt4cout

int i = 1;
int &j = i;
int const & k = i;
auto x = i; // int
auto y = j; // int
auto z = k; // int

auto x = i; // int
auto &y = i; // int &
auto const & y = i; // int const &

auto x = {3}; // 推断为std::initializer_list<int>
auto y{3}; // 推断为std::initializer_list<int>
auto z{3, 4}; // 推断为std::initializer_list<int>

int i = 1;
int &j = i;
int const & k = i;
using T1 = decltype(i); // int
using T2 = decltype(j); // int &
using T3 = decltype(k); // int const &

int i = 1;
int &j = i;
int const & k = i;
decltype(auto) x = i; // int
decltype(auto) y = j; // int &
decltype(auto) z = k; // int const &

#include <iostream>
#include <utility>
struct Default
    int foo() const { return 1; }
struct NonDefault
    NonDefault() = delete;
    int foo() const { return 1; }
int main()
    decltype(Default().foo()) n1 = 1;                   // n1 的类型是 int
//  decltype(NonDefault().foo()) n2 = n1;               // 错误：无默认构造函数
    decltype(std::declval<NonDefault>().foo()) n2 = n1; // n2 的类型是 int
    std::cout << "n1 = " << n1 << '\n'
              << "n2 = " << n2 << '\n';

template<class T>
void foo(T const& x){
    constexpr bool check = std::is_unsigned<T>::value; // C++11
    constexpr bool check2 = std::is_unsigned_v<T>;// C++17后

#include <type_traits>
template<typename T, typename U>
constexpr bool is_decay_equ = std::is_same_v<std::decay_t<T>, U>;
// c++14可用
// c++11为typename std::decay<T>::type
int main()
    static_assert
        is_decay_equ<int, int> &&
        ! is_decay_equ<int, float> &&
        is_decay_equ<int&, int> &&
        is_decay_equ<int&&, int> &&
        is_decay_equ<const int&, int> &&
        is_decay_equ<int[2], int*> &&
        ! is_decay_equ<int[4][2], int*> &&
        ! is_decay_equ<int[4][2], int**> &&
        is_decay_equ<int[4][2], int(*)[2]> &&
        is_decay_equ<int(int), int(*)(int)>
    return 0;

struct S
    double operator()(char, int&);
    float operator()(int) { return 1.0; }
std::result_of<S(char, int&)>::type d = 3.14; // d 拥有 double 类型

double f(char c, int& a){
	return 0.1;
std::result_of<decltype(&f)(char, int&)>::type d = 3.14;

std::invoke_result<S,char,int&>::type b = 3.14;
std::invoke_result<decltype(f), char, int&>::type d = 3.14;
奇特重现模板模式（Curiously Recurring Template Pattern, CRTP）是一种惯用手法。
主要就是父类是一个模板类，而子类继承父类，并且在模板实参里面填写子类。
template<class T>
class Y {};
class X : public Y<X> {};
主要用来实现编译期多态。
template <class Derived>
struct Base { void name() { (static_cast<Derived*>(this))->impl(); } };
struct D1 : public Base<D1> { void impl() { std::puts("D1::impl()"); } };
struct D2 : public Base<D2> { void impl() { std::puts("D2::impl()"); } };
void test()
    // Base<D1> b1; b1.name(); // 未定义行为
    // Base<D2> b2; b2.name(); // 未定义行为
    D1 d1; d1.name();
    D2 d2; d2.name();
可以看https://zhuanlan.zhihu.com/p/460497652学一些使用例。
typename消歧
template<class T>
class B{
public:
    typedef int type;
template<class T>
class A{
    typename B<T>::type a; // 在C++不那么先进的版本，不加typename会报错
这被称作待决名的typename消歧义符，因为B<T>::type一般会被理解为静态成员。这里它作为一个typedef，需要我们用typename来消除歧义。
SFINAE
“替换失败不是错误” (Substitution Failure Is Not An Error)
首先举个例子，即函数重载中
class A {};
class B: public A {};
class C {};
void foo(A const&) {}
void foo(B const&) {}
void bar() {
  foo(A());
  foo(B());
  foo(C());
其中foo(A());匹配void foo(B const&) {}失败了，但是不报错。而匹配void foo(A const&) {}成功了，所以调用了这个重载。foo(B());两个都能匹配成功，但是void foo(B const&) {}更特殊，所以调用这个重载。而foo(C());的所有匹配的失败了，才会进行编译报错。
模板替换也是类似的，一个模板替换失败了，并不会直接导致编译错误，编译器会继续查询其他可以替换的模板，只要有一个成功，编译就可以通过。用cppreference的话来说：
在函数模板的重载决议中会应用此规则：当模板形参在替换成显式指定的类型或推导出的类型失败时，从重载集中丢弃这个特化，而非导致编译失败。
struct A{
    typedef int t;
template<class T>
void foo(typename T::t);
template<class T>
void foo(T);
void bar(){
    foo<A>(10); // 调用第一个重载，第二个重载匹配失败，因为10不能被隐式转化为A
    foo<int>(10); // 调用第二个重载，第一个重载匹配失败，因为int没有t成员
这只是最简单的使用例子，更为复杂一点的，STL提供了std::enable_if，来在编译时求值，从而开启或关闭某个特定的函数重载。
template< bool B, class T = void >
struct enable_if;
如果B是true，那么enable_if含有typedef type，否则不含有。
template<class T>
void destroy(
    T*, 
    typename std::enable_if<
        std::is_trivially_destructible<T>::value
    >::type* = 0)
    std::cout << "销毁可平凡析构的 T\n";
这里，如果T不是可平凡析构的，那么他就没有type这个成员，匹配就会失败，这个模板就会从重载集中移除。
C++11中还添加了一个表达式SFINAE，例如：
struct X {};
struct Y { Y(X){} }; // X 可以转换到 Y
template<class T>
auto f(T t1, T t2) -> decltype(t1 + t2); // 重载 #1
X f(Y, Y);                               // 重载 #2
X x1, x2;
X x3 = f(x1, x2);  // 推导在 #1 上失败（表达式 x1+x2 非良构）
                   // 重载集中只有 #2，调用它
这里由于X没有重载加法运算符，所以重载1的decltype(t1 + t2)非良构。在C++11时，这会被SFINAE使用，而在之前，这会直接导致编译错误。
极简concept
如果我们要限定template里面的泛型T的性质，要怎么做呢？C++20提供了一个新的方法，即concept
他有很多种使用方法，例如假设我们要求一个类型是可排序的，我们假设这个concept叫做Sortable，以有以下几种使用方法
template<class T> requires Sortable<T>
void sort(T& s);
template<class T>
void sort(T& s) requires Sortable<T> ; // 换了下位置而已
template<Sortable T>
void sort(T& s);
void sort(Sortable auto& s); // 当然也可以用在返回值上，据说Stroustrup最喜欢这种
如何定义一个概念（concept）？
template < 模板形参列表 >
concept 概念名 属性 (可选) = 约束表达式;





    
其中这个约束表达式，是一个在编译期可以被eval为bool的表达式或者编译期函数。如果代入模板形参，可以得到true的值，则返回成功，否则不成功。
template <class T>
concept always_satisfied = true;  // 永远成功
template <class T>
concept integral = std::is_integral_v<T>; // 整型时成功
template <class T>
concept signed_integral = integral<T> && std::is_signed_v<T>; // 满足两者时成功
这里，一个概念不能提到自己，也不能用另一个概念来约束这个概念，例如
template <class T>
concept integral = std::is_integral_v<T>;
template <integral T>
concept signed_integral = std::is_signed_v<T>;
就是不行的。必须通过逻辑运算（包括与、或、非）得到复合的概念。同样的，requires语句也可以加入逻辑运算
template <class T>
requires Integral<T> && std::is_signed_v<T>
T add(T a, T b);
可以通过requires语句定义概念
template <class T>
concept Addable = requires (T a, T b) { a+b; };
template <class T>
requires requires (T x) { x + x; } // ad-hoc式定义
T add(T a, T b) {
  return a + b;
它不会检查是否返回true，只要里面的表达式合法，就可以成功。我们还可以写出
template<class C>
concept cpt1 = requires{
    typename C::value_type;
    typename C::iterator;
    typename std::vector<C>;
这样的代码，来判断其符不符合这样的使用方法。
#include <cstdarg>
#include <iostream>
int add_nums(int count...)
    int result = 0;
    std::va_list args;
    va_start(args, count);
    for (int i = 0; i < count; ++i)
        result += va_arg(args, int);
    va_end(args);
    return result;
int main()
    std::cout << add_nums(4, 25, 25, 50, 50) << '\n';
这里int count...就是一个变长实参的声明。我们通过cstdarg中的函数来访问变长实参，首先要用std::va_list来声明一个变量，用来访问实参。然后通过va_start来开启遍历，其中第一个参数为std::va_list，第二个参数为我们的变长实参。之后我们用va_arg来访问下一个实参，传入的是std::va_list和希望转为的类型。用va_end来结束遍历。
这里指的是变长模板形参，例如
template<class... Types>
struct Tuple {};
Tuple<> t0;           // Types 不包含实参
Tuple<int> t1;        // Types 包含一个实参：int
Tuple<int, float> t2; // Types 包含两个实参：int 与 float
Tuple<0> error;       // 错误：0 不是类型
在有模板实参推导后，可以使用：
template<class... Types>
void f(Types... args);
f();       // OK：args 不包含实参
f(1);      // OK：args 包含一个实参：int
f(2, 1.0); // OK：args 包含两个实参：int 与 double
上面的Types... args是一个包展开。后随省略号且其中至少有一个形参包的名字的模式会被展开_成零个或更多个逗号分隔的模式实例 ，其中形参包的名字按顺序被替换成包中的各个元素。
template<class... Us>
void f(Us... pargs) {}
template<class... Ts>
void g(Ts... args)
    f(&args...); // “&args...” 是包展开
                 // “&args” 是它的模式
g(1, 0.2, "a"); // Ts... args 会展开成 int E1, double E2, const char* E3
                // &args... 会展开成 &E1, &E2, &E3
                // Us... 会展开成 int* E1, double* E2, const char** E3
sizeof...运算符，用于获取形参包的长度，例如sizeof...(args)，在上例中返回3
内存池和Allocators
PIMPL
Pointer to implementation，也就是指向实现的指针。具体来说，我们不再在某个类中直接定义它的变量，例如：
// A.h
class A{
public:
    void foo();
private:
    int x, y;
//A.cpp
A::A() = default;
void A::foo(){}
而是，我们加一个私有的struct和unique_ptr，在这个struct中去定义它的变量。
class A{
public:
    void foo();
private:
    struct Impl;
    unique_ptr<Impl> const p_;
//A.cpp
struct A::Impl{
    int x, y;
A::A():p_(make_unique<Impl>(0, 0)){}
void A::foo(){} // 对p_中的变量进行种种操作
这样做有什么好处？如果是之前的代码，当我们修改这个类的成员变量时，所有#include了这个头文件的翻译单元都要重新编译，大大增加了编译时间。而后者，其成员变量是在翻译单元中，我们只需要重新编译这个cpp，然后在链接的时候重新链接即可。
目前来说，上面的代码还无法通过编译，因为析构函数需要知道完整的类型，而Impl是不完整的类型，所以我们也需要把析构函数拿出来。
//A.cpp
A::~A()=default;
类似的，你也需要把其他构造函数移出来。
返回值优化
推荐在函数返回对象的时候，直接在return语句上构造对象。例如
A foo(){
    return A(1,2);
int main(){
    auto a = foo();
（大多数）编译器即使关闭优化，也只会调用一次构造函数，而不会有复制和移动。如果改成
A foo(){
    A a(1,2);
    return a;
则部分编译器可能就不会只调用一次构造了，可能会进行移动。如果
A foo(int x){
    A a1;
    A a2;
    if(x>3){
        return a1;
    else{
        return a2;
这样更复杂的情况，编译器可能都不能进行返回值优化了。
所以，还是推荐直接在return语句中构造对象（如果可能）
虽然争议颇多，但是C++确实支持多继承
class B1{};
class B2{};
class D : public B1, public B2{}
如上，类D同时继承了B1,B2，而D的构造函数
D():B1(), B2(){}
其构造顺序，类似于之前提到的构造顺序，其并不是以初始化列表的顺序进行的，而是以继承的顺序进行的。
在多继承下有命名冲突的问题，需要用::来指定使用哪个继承
class B1{
public:
    void foo(){}
class B2{
public:
    void foo(){}
class D : public B1, public B2{};
void bar(){
    d.foo(); // 错误，不知道使用B1还是B2的foo
    d.B1::foo();
    d.B2::foo();
菱形继承是多继承的一种特殊情况，如
class B{
public:
    int age = 100;
class B1 : public B{};
class B2 : public B{};
class D : public B1, public B2{};
这里D间接地继承了B两次，有什么问题呢？
d.age = 10;

class B1 : virtual public B{};
class B2 : virtual public B{};
class D : public B1, public B2{};