C++小知识

int cnt = 0;
class MyClassB
{
public:
    MyClassB(){std::cout << "constructorB called" << cnt++ << std::endl;}
    ~MyClassB(){std::cout << "destructorB called" << cnt++ << std::endl;}
    MyClassB &operator=(MyClassB b)
    {
        std::cout << "operator= called" << cnt++ << std::endl;
        return *this;
    }
};

class MyClassA
{
public:
    MyClassA(MyClassB b)
        //或初始化列表 :bina(b)
    {
        bina=b;
        std::cout << "constructorA called" << cnt++ << std::endl;
    }
    ~MyClassA(){std::cout << "destructorA called" << cnt++ << std::endl;}
    MyClassB bina;
};

int main()
{
    MyClassB b;
    MyClassA a(b);
}

constructorB called0 main.B构建
constructorA called1 main.A构建
destructorB called2  析构形参B
destructorA called3  析构main.A 对应1
destructorB called4  A.B 析构自己
destructorB called5  析构main.B 对应0

constructorB called0 main.B构建
* constructorB called1 A.B初始化构建
* operator= called2    A.B赋值
* destructorB called3  A.B初始化时的类析构 对应1
constructorA called4 main.A构建
destructorB called5  析构形参B
destructorA called6  main.A析构 对应4
destructorB called7  A.B析构
destructorB called8  main.B析构 对应0

template<typename T>//或template<class T>，二者完全相同
void func(T arg){}

template<typename T>
void func(T arg){}

//重新声明
template<typename T>
void func(T arg1, T arg2){}

template<typename T>
class my_class {
    // 类模板成员定义
};

// 显式具体化
template<>
class my_class<int> { // 语法上，在实现的<>里明确类型, 用不到前面的就不要加
    // 对 int 类型的实现
};

// 显式具体化
template<typename T>
class my_class<T*> {
    // 对 T* 类型的实现
};

// 重载约等于显式具体化+实例化, 不要混用显式具体化和重载！
template<typename T>
void my_func(const T& t) {
    // 函数模板代码实现
}
void my_func(double t) {
    // 重载代码实现
}

template<typename T>
void my_func(const T& t) {
    // 函数模板代码实现
}

int main() {
    int x = 42;
    my_func(x); // 隐式具体化+实例化，会自动生成 my_func<int>(const int&) 实例化版本
}

template void my_func<int>(int); // 语法上，template后面没有<>
//在其他文件里 需要 extern template void my_func<int>(int); 
template void my_func<int>(int){}// 错误

template<typename T>
void my_func(const T& t) {
    // 函数模板代码实现
}

int main() {
    int x = 42;
    my_func(x); // 隐式具体化+实例化，会自动生成 my_func<int>(const int&) 实例化版本
}

// 基础模板
template<typename TA, typename TB>
class MyClass {

};

// 全特化
template<>
class MyClass<int, int> {

};

// 偏特化
template<typename TA>
class MyClass<TA, int> {

};

template<typename TA, typename TB>
void func(TA a, TB b) {

}

// 全特化 正确
template<>
void func(int a, int b) {

}

// 偏特化 错误！
template<typename TA>
void func<TA, int>(TA a, int b) {

}

// 偏特化 错误！
template<typename TA, typename TB>
void func<TA, TA>(TA a, TA b) {

}

// 属于重载 因为语法上 func后面没有<>来指定具体类型 否则就属于具体化
template<typename TA>
void func(TA a, TA b) {

}

auto varname = value;  //auto的语法格式
decltype(exp) varname [= value];  //decltype的语法格式

template<typename T1, typename T2>
auto add(T1 t1, T2 t2) -> decltype(t1 + t2)
{
    return t1 + t2;
}

auto add(int a, float b) -> double
{
    return a + b;
}

template<typename T>
class MyClass{};

template<typename T>
void my_func(T t);

//必须<>指明类型
MyClass<int> mc;

my_func<int>(1);
//或者
my_func(1);

template<typename T>
using VecWrap = std::vector<T>;

// 对std::vector进行了封装 使其模板参数只有一个入参 并且自带了reserve
template<template<typename Inner> typename Outer, int Num> // Inner只是一个占位符 模板参数如果是模板则不能看作一整个typename, 需要写出整个模板参数的模板声明
class MyVector {
public:
    MyVector() {
        myVector.reserve(Num);
    }

    Outer<int> myVector;
};


int main() {
    MyVector<VecWrap, 10> v;
    //MyVector<std::vector<int>, int> myTemplate2; //Outer模板只有一个参数需要using进行类型定义
    std::cout << v.myVector.capacity() << std::endl; //10
}

template<typename T>
class Base {
public:
    void f() {};
    int a;
};

template<typename T>
class Derived : public Base<T> {
public:
    void b() {
        //f(); //错误, 对于依赖模板参数的名字， 编译时会在模板实例化时(运行时)查找
        //a; //错误
        this->f();
        this->a;
        Base<T>::f();
    }
};

class Derived2 : public Base<int> {
public:
    void b() {
        f(); //正确, 运行到这里《 已经实例化了
    }
};

template <typename Fn, typename... Args>
struct result_of_impl {
    using type = typename std::result_of<Fn(Args...)>::type; //std::result_of 判断函数调用的返回值类型
};

template <typename Fn, typename... Args>
using result_of_t = typename result_of_impl<Fn, Args...>::type;

int main() {
    using F = int (*)(double);	//函数指针的类型
    using R = result_of_t<F, double>;
    static_assert(std::is_same_v<R, int>); //编译期间判断
    return 0;
}

#include <iostream>

template <typename T>
T max(T a, T b, bool use_a = true) {
    return use_a ? a : b;
}

template <typename T>
T max(T a, T b) {
    return max(a, b, a >= b);
}

int main(){
    std::cout << max(1, 2, false) << std::endl; // 手动输入
    return 0;
}

#include <iostream>

template<typename T1, typename T2>
struct is_same {
    static const bool value = false;
};

template<typename T>
struct is_same<T, T> {
    static const bool value = true;
};

template<typename T1, typename T2>
using select_type = typename std::conditional<is_same<T1, T2>::value, T1, T2>::type;

int main() {
    std::cout << typeid(select_type<int, int>).name() << std::endl;
    return 0;
}

#include <iostream>

template <typename T1, typename T2>
typename std::enable_if<std::is_same<T1, T2>::value, T1>::type //如果条件不成立则不选择这个模板
select_type(T1 a, T2 b) {
    return a;
}

template <typename T1, typename T2>
typename std::enable_if_t<!std::is_same<T1, T2>::value, T2> //std::enable_if_t自带::type, 不需自行添加 
select_type(T1 a, T2 b) {
    return b;
}

int main() {
    int x = 42;
    double y = 3.14;
    auto p = select_type(x, x); // p 的类型为 int
    auto q = select_type(x, y); // q 的类型为 double
    std::cout << p << " " << q << std::endl; // 输出 42 3.14
    return 0;
}

#include <iostream>
#include <type_traits>

template<typename T, typename = void>
struct has_size : std::false_type {};

template<typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>> : std::true_type {}; //SFINAE 去实例化其他的

int main()
{
    std::cout << std::boolalpha;
    std::cout << has_size<std::string>::value << std::endl;  // 输出 true，因为 std::string 有 size() 成员函数
    std::cout << has_size<int>::value << std::endl;  // 输出 false，因为 int 没有 size() 成员函数
    return 0;
}

#include <iostream>
#include <type_traits>

template <typename... Ts>
using void_t = void;

//#1 否则就实例化这个
//typename=void 就是一个开关，如果第二选项存在就不使用这个
template <typename T, typename = void>
struct has_typedef_foobar : std::false_type {};

//#2 T::foobar获取成功，那么自然就选择这个进行实例化
template <typename T>
struct has_typedef_foobar<T, void_t<typename T::foobar>> : std::true_type {};

struct foo {
  using foobar = float;
};

int main() {
  std::cout << std::boolalpha;
  std::cout << has_typedef_foobar<int>::value << std::endl;//int::foobar失败 进入#1
  std::cout << has_typedef_foobar<foo>::value << std::endl;//foo::foobar成功 进入#2
}

#include <iostream>

template<typename... Args>
auto UniLeft(Args... args) {
    return (... + args); // (((E1 op E2) op E3) op E4)
}

template<typename... Args>
auto UniRight(Args... args) {
    return (args + ...); // (E1 op (E2 op (E3 op E4)))
}

template<typename T, typename... Args>
auto PrintWithSeq(T sep, Args... args) {
    ((std::cout << args << sep), ...); // (std::cout << args[0] << sep) , (std::cout << args[1] << sep)
}

template<typename T, typename... Args>
auto PrintWithSeq2(T sep, Args... args) {
    (..., (std::cout << args << sep)); // (std::cout << args[0] << sep) , (std::cout << args[1] << sep)
}

template<typename... Args>
auto DubLeft(Args... args) {
    (std::cout << ... << args); // (((I op E2) op E3) op E4)
}

template<typename... Args>
auto DubRight(Args... args) {
    return (args = ... = 0); // (E1 op (E2 op (E3 op I)))
}

int main() {
    int sumLeft = UniLeft(1, 2, 3, 4, 5);
    int sumRight = UniRight(1, 2, 3, 4, 5);
    DubLeft(1, 2, 3, 4, 5);                 //12345
    DubRight(1, 2, 3, 4, 5);
    PrintWithSeq(',', 1, 2, 3, 4, 5);       //1,2,3,4,5,
    PrintWithSeq2(',', 1, 2, 3, 4, 5);      //1,2,3,4,5,
    return 0;
}

//通用格式：
ReturnType (*NickName)(PramType1, PramType2);
//实例
int (*func)(int a, int b);
//或者迷惑人一下
int (*f)();

int (*(*pf())())();

typedef int (*T2)();
typedef T2 (*T)();
typedef T pf();

auto pf() -> auto (*)() -> int (*)();
//进行一个实现
auto pf() -> auto (*)() -> int (*)()
{
    return []() -> int (*)()
    {
        return []() -> int
        {
            return 0;
        };
    };
}

int (*(*(*(*fn())(int))())())();

typedef int (*(*(*(*T)(int))())())();
typedef int (*(*(*T2)())())();
typedef int (*(*T3)())();
typedef int (*T4)();
T fn();
//或者
auto fn() -> auto (*)(int) -> auto (*)() ->auto (*)() -> int (*)();

 #include <bits/stdc++.h>
using namespace std;

//仿函数
struct MyLess{
    bool operator()(const int& a, const int& b) const{
        return a < b;
    }
};

int main(){
    vector<int> v {8,9,0,7,4,5,6,3,2,1};
    priority_queue<int, vector<int>,MyLess> pq(v.begin(), v.end());
    pq.push(-1);
    while (!pq.empty()){
        cout << pq.top() << endl;
        pq.pop();
    }
}

int globalA = 0;
static int staticGlobalA = 0;

void Fn() {}
static void  StaticFn() {}

extern int globalA;
//extern int staticGlobalA;  can not use

void Fn(); 
//或 extern void Fn()

//extern void StaticFn();   can not use

class C
{
    void change() const
    {
        a = 1;//错误
        b = 2;//正确
    }
    
    int a;
    mutable int b;
};

class C
{
public:
    int operator+(int a) const
    {
        return num + a;
    }

private:
    int num;
};

int main()
{
    C c;
    cout << c + 1;//可以
    //cout << 1 + c;//不可以
}

class C
{
public:
    int operator+(int a) const
    {
        return num + a;
    }
    
    friend int operator+(int a, C c);

private:
    int num;
};

int operator+(int a, C c)
{
    return a + c.num;
}

/*更优雅的实现
int operator+(int a, C c)
{
    return c + a;
}
*/

int main()
{
    C c;
    cout << c + 1;//可以
    cout << 1 + c;//可以了
}

#pragma pack(8)
struct A {
    char a;
    int b;
    double c;
};//16

struct B {
    char a;
    double c;
    int b;
};//24

struct C {
    int a;
    char b;
    double c;
};//16

struct D {
    char b;
};//1

struct E {
    char b;
    int a;
};//4+4=8

#pragma pack(1)
struct E2{
    char b;
    char c;
    char a;
};//3

#pragma pack(4)
struct F {
    char a;
    E2 e;
};//4 //将E2拆开，重新计算pack

int a;
float b = (int)a;

class Base {
public:
    virtual void Eat() {} // 需要存在虚函数才能向上转换
};

class Derived : public Base {
};

int main() {
    Derived d;
    Base *b = dynamic_cast<Base *>(&d);
    Base *b1 = &d; // 自动转化

    Base *bb = new Derived();
    Derived *dd = dynamic_cast<Derived *>(bb);
}

int a;
float b = static_cast<float>(a);

int* a;
float* b = reinterpret_cast<float*>(a);

int main() {
    int b=1;
    const int *a = &b;
    int* pb = const_cast<int*>(a);
    *pb=2;
     //int *c = &(*a);
    //Cannot initialize a variable of type 'int *' with an rvalue of type 'const int *'
    cout << *a << endl; // 2
}

#include <iostream>

using namespace std;

class A {
public:
    virtual void PrintA() {
        cout << "A" << endl;
    }
};

class B : public A {
public:
    void PrintB() {
        cout << "B" << endl;
    }

    void PrintA() {
        cout << "Derived A" << endl;
    }
};

int main() {
    A a, *pa;
    B b, *pb;
    //子类使用父类方法 天经地义
    //直接使用
    b.PrintA();
    //dynamic cast
    dynamic_cast<A *>(&b)->PrintA();
    //static cast
    static_cast<A *>(&b)->PrintA();

    //父类使用子类方法
    //直接使用，当然不行
    //a.PrintB();
    //隐式类型转换 不可以
    //pa = &b;pa->PrintB();

    //dynamic_cast 可以， 但是需要父类有virtual方法，否则编译不通过，
    // dynamic_cast 进行类型转换，vptr的值会指向新的类的虚函数表，从而保证了动态绑定的正确性。因此可以调用，a中没有B的数据，若B的方法使用数据则UB/
    dynamic_cast<B *>(&a)->PrintB();
    //dynamic_cast<B *>(&a)->PrintA(); 出错，转换后发现应当调用B override的PrintA，但是a中没有B的数据
    //强制类型转换 不可以
    //((A*)b)->PrintA();
    //static_cast 可以
    static_cast<B *>(&a)->PrintB();
}

class C {
public:
    C() {}
    ~C() {}
    
    C(const C &) {}
    C(C &&) {}

    C &operator=(const C &) { return *this; }
    C &operator=(C &&) { return *this; }
};

#include <iostream>
#include <vector>

class C {
public:
    C() = default;

    ~C() = default;

    C(const C &) {
        std::cout << "copy constructor" << std::endl;
    }

    C(C &&) noexcept /*显式声明noexcept才会被容器默认调用*/ {
        std::cout << "move constructor" << std::endl;
    }

};

int main() {
    std::vector<C> v;
    v.reserve(3);                   // 为了避免内存重新分配造成额外move
    C c1, c2;
    v.emplace_back(c1);             // copy constructor
    v.emplace_back(std::move(c2));  // move constructor
    v.emplace_back(C());            // move constructor
    v.emplace_back(C());            // move constructor
    /*
     * 触发扩容，重新分配内存，将原来的元素
     * 1. 若是有noexcept的move constructor，就会调用move constructor
     * 2. 若是没有noexcept的move constructor，就会调用copy constructor
     */
    return 0;
}

#include <iostream>
#include <vector>

class A {
public:
    A() {
        std::cout << "A()" << std::endl;
    }

    ~A() {
        std::cout << "~A()" << std::endl;
    }
};

class B {
...
class D{
...定义类似于A

C c;

int main() {
    A *pa = new A();
    B b;
    static D d;
    delete pa;
    return 0;
}
/*
 * C()
 * A()
 * B()
 * D()
 * ~A()
 * ~B()
 * ~D() D晚于局部变量B析构 
 * ~C()
 */

template <class T>
Class MyClass
{
  typename T::SubType * ptr;
  ...
};

#include <tuple>

using namespace std;

using Ty1 = int;
using Ty2 = float;

int main() {
    Ty1 e1;
    Ty2 e2;
    tuple<Ty1,Ty2> t1(e1,e2);       //直接构造
    auto t2 = make_tuple(e1,e2);    //通过make_tuple构造
    get<0>(t1);                     //通过get获取元素
    size_t v1 = tuple_size<tuple<Ty1,Ty2>>::value;        //获取元素个数
    size_t v2 = tuple_size_v<tuple<Ty1,Ty2>>;             //c++14 获取元素个数
    tuple_element<0, tuple<int,float>>::type t;           //获取类型
    auto cat = tuple_cat(t1,t2);    //合并元组, 编译期运作
}

std::multimap<int, int> m;
std::multimap<int, int>::iterator lower, upper;
std::tie(lower, upper) = m.equal_range(5);
auto [lower2, upper2] = m.equal_range(5); // c++17 结构化绑定

#include <cstdio>
using namespace std;
int my_main(){
    printf("my_main");
    exit(0);//此处必须有此代码，否则会segment fault，因为之后要进行堆空间分配
}

int main(){
	printf("main");
}

gcc -e my_main test.c

---------------------
|next  | data       |
---------------------
---------------------
|next  | data       |
---------------------
---------------------
|      data         |
---------------------

#include <iostream>

class C {
public:
    C() { std::cout << "C::C()" << std::endl; }

    ~C() { std::cout << "C::~C()" << std::endl; }

    C(const C &) { std::cout << "C::C(const C&)" << std::endl; }

    C(C &) { std::cout << "C::C(C&)" << std::endl; }

    C(C &&) noexcept { std::cout << "C::C(C&&)" << std::endl; }

    C &operator=(const C &) {
        std::cout << "C::operator=(const C&)" << std::endl;
        return *this;
    }

    C &operator=(C &&) {
        std::cout << "C::operator=(C&&)" << std::endl;
        return *this;
    }


};

// 无命名的，直接在指定位置构造
C nrvo() {
    return C();
}

// 有名字的，看情况优化，以下可预测的是同无命名的情况相同。正常会调用移动构造（优先）和拷贝构造。
C rvo() {
    C c;
    return c;
}

int main() {
//    C c = nrvo(); /*C::C() C::~C()*/
    C c2 = rvo();
    /*
     *  C::C()
        C::C(C&&)
        C::~C()
        C::~C()
     */
    return 0;
}

const auto&& a =expr;
//==
template<typename T>
void func(const T&&);

decltype(auto) a = anyRef;

std::array a = {1, 2, 3}; // c++17开始
std::array<int,3> a = {1, 2, 3}; // c++11必须这样

// 调用构造函数
int a{1};
int a{}; // POD类型 memreset为0 a=0
std::string s{}; // 默认构造
std::string s{"Hello"}; // const char* 构造
struct M{}; // POD类型 memreset为0

// 构造后类型隐式转换
int a = {};
int a = {1};

class Point {
public:
    explicit Point(double x, double y) : x(x), y(y) {}

    Point(double x) : x(x), y(0) {}

    double x;
    double y;
};

int main() {
    Point p11 = {5, 6}; // 不可以, 因为声明了explicit, iniliazer_list不会被隐式转换为Point
    Point p12 = {5};    // 可以, 因为没有声明explicit, iniliazer_list会被隐式转换为Point

    Point p21{5, 6};    // 可以, 直接调用构造函数不受explicit影响
    Point p21{5};
    std::vector<Point> points1{{1, 2}, {3, 4}}; //同p11
    std::vector<Point> points2{{1}, {3}};

    return 0;
}

#include <iostream>
#include <vector>

class Example {
public:
    // 使用initializer_list将数组参数初始化转移到数组
    Example(int a, int b, std::initializer_list<int> c) : m_a(a), m_b(b), m_c(c) {}

private:
    int m_a;
    int m_b;
    std::vector<int> m_c;
};

int main() {
    Example ex(1, 2, {3, 4, 5});
    return 0;
}

char const *
unsigned long long
long double
char const *, size_t
wchar_t const *, size_t
char16_t const *, size_t
char32_t const *, size_t

int operator ""_cm(unsigned long long a) {
    return a;
}

int operator ""_m(unsigned long long a) {
    return a * 100;
}

int main() {
    auto a = 1_cm + 1_m;
    std::cout << a;
    return 0;
}

#include <bitset>
#include <cassert>
#include <cstddef>
#include <iostream>
 
int main()
{
    typedef std::size_t length_t, position_t; // the hints
 
    // constructors:
    constexpr std::bitset<4> b1;
    constexpr std::bitset<4> b2{0xA}; // == 0B1010
    std::bitset<4> b3{"0011"}; // can also be constexpr since C++23
    std::bitset<8> b4{"ABBA", length_t(4), /*0:*/'A', /*1:*/'B'}; // == 0B0000'0110
 

 
    // bitset supports bitwise operations:
    b3 |= 0b0100; assert(b3 == 0b0111);
    b3 &= 0b0011; assert(b3 == 0b0011);
    b3 ^= std::bitset<4>{0b1100}; assert(b3 == 0b1111);
 
    // operations on the whole set:
    b3.reset(); assert(b3 == 0);
    b3.set(); assert(b3 == 0b1111);
    assert(b3.all() && b3.any() && !b3.none());
    b3.flip(); assert(b3 == 0);
 
    // operations on individual bits:
    b3.set(position_t(1), true); assert(b3 == 0b0010);
    b3.set(position_t(1), false); assert(b3 == 0);
    b3.flip(position_t(2)); assert(b3 == 0b0100);
    b3.reset(position_t(2)); assert(b3 == 0);
 
    // subscript operator[] is supported:
    b3[2] = true; assert(true == b3[2]);
 
    // other operations:
    assert(b3.count() == 1);
    assert(b3.size() == 4);
    assert(b3.to_ullong() == 0b0100ULL);
    assert(b3.to_string() == "0100");
}

int a = rand();
static_assert(a == 4, "a is not 4"); // 错误Static_assert expression is not an integral constant expression
static_assert(sizeof(int) == 4, "int is not 4 bytes");

enum class Color : uint8_t {
    RED = 0,
    GREEN = 1,
    BLUE = 2
};


int main() {
    Color c1 = Color::RED;
    //Color c2 = 0; //错误
    Color c3 = static_cast<Color>(0); //可以
}

#include <chrono>
#include <iostream>

int main() {
    // 获取当前系统时钟上的时间点
    auto now = std::chrono::system_clock::now();

    // 将时间点转换为 time_t 类型
    auto now_time_t = std::chrono::system_clock::to_time_t(now);

    // 输出当前时间
    std::cout << "Current time: " << std::ctime(&now_time_t);

    // 计算程序运行时间
    auto start = std::chrono::steady_clock::now();
    for (int i = 0; i < 1000000; ++i) {
        // do something
    }
    auto end = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    std::cout << "Elapsed time: " << elapsed.count() << " microseconds." << std::endl;

    return 0;
}

#include <random>

int main() {
    std::mt19937_64 rng(std::random_device{}());        // 随机数引擎
    std::ranlux48 rng2(std::random_device{}());         // 随机数引擎

    std::uniform_int_distribution<int> dist(0, 100);    // 随机数分布器-均匀分布
    std::normal_distribution<double> dist2(0, 1);       // 随机数分布器-正态分布
    
    int a = dist(rng); // 生成随机数
    return 0;
}

std::any a = 1; // 声明对象
std::cout << std::any_cast<int>(a) << std::endl;
if(a.type() == typeid(int)){
    std::cout << "int" << std::endl;
}

std::optional<int> divide(int a, int b) {
    if (b == 0) {
        return std::nullopt; // 没有值
    }
    return a / b;
}

int main() {
    std::optional<int> result = divide(10, 2);
    if (result.has_value()) {

    }
    return 0;
}

std::variant<int, double> v = 2.0;  // 定义一个 variant 对象, 若初始化时不赋值则初始化第0个的类型

if (v.index() == 0) {               // 判断当前存储的值类型，并进行对应操作
    int i = std::get<int>(v);
    std::cout << "stored int value: " << i << std::endl;
} else if (v.index() == 1) {
    double d = std::get<double>(v);
    std::cout << "stored double value: " << d << std::endl;
}

if (auto ptr = std::get_if<int>(&v)) {
    std::cout << "stored int value: " << *ptr << std::endl;
}
    
/***********类似实现, 适用于POD***********/
struct FloatIntChar {
    enum {
        Float,
        Int,
        Char
    } type;
    union {
        float f;
        int i;
        char c;
    };
};
FloatIntChar fic;
fic.type = FloatIntChar::Float;
fic.f = 1.0f;

std::errc              -> std::posix_error_code
std::error_code        -> std::platform_dependent_error
std::error_condition   -> std::platform_independent_error
std::error_category    -> std::error_domain/utility/mapper
std::system_category   -> std::platform_dependent_error_domain
std::generic_category  -> std::platform_independent_error_domain
std::future_errc       -> std::future_error_code
std::future_category   -> std::future_error_domain
std::io_errc           -> std::iostream_error_code
std::iostream_category -> std::iostream_error_domain

    std::error_code ec = std::make_error_code(std::errc::no_such_file_or_directory);
    std::cout << "Error message: " << ec.message() << std::endl;
    std::cout << "Error category: " << ec.category().name() << std::endl;
    std::cout << "Error code: " << ec.value() << std::endl;
    std::error_condition ec2 = std::make_error_condition(std::errc::no_such_file_or_directory);
    std::cout << "Error message: " << ec2.message() << std::endl;
    std::cout << "Error category: " << ec2.category().name() << std::endl;
    std::cout << "Error code: " << ec2.value() << std::endl;

#include <system_error>
#include <iostream>
#include <variant>
#include <any>

enum class MyErrorType : int {
    success,
    error1
};

class my_error_category : public std::error_category {
public:

    // Return a short descriptive name for the category, 继承自基类std::error_category
    const char *name() const noexcept override {
        return "my_error_category";
    }

    // Return what each enum means in text, 继承自基类std::error_category
    std::string message(int i) const override {
        switch (i) {
            case static_cast<int>(MyErrorType::success):
                return "success";
            case static_cast<int>(MyErrorType::error1):
                return "error1";
        }
        return "Unknown error";
    }

    // 转换成std::error_condition, 继承自基类std::error_category
    std::error_condition default_error_condition(int i) const noexcept override {
        switch (i) {
            case static_cast<int>(MyErrorType::success):
                return {};
            case static_cast<int>(MyErrorType::error1):
                return make_error_condition(std::errc::invalid_argument);
        }
        return std::error_condition(i, *this);
    }

    std::error_code make_error_code(MyErrorType e) const noexcept {
        return std::error_code(static_cast<int>(e), *this);
    }
};

int main() {
    std::error_condition e = my_error_category().default_error_condition(1);
    std::cout << e.message() << std::endl;              //Invalid argument
    std::cout << e.category().name() << std::endl;      //generic
    std::cout << e.value() << std::endl;                //22

    std::error_code ec = my_error_category().make_error_code(MyErrorType::error1);
    std::cout << ec.message() << std::endl;             //error1
    std::cout << ec.category().name() << std::endl;     //my_error_category
    std::cout << ec.value() << std::endl;               //1
}

std::string gen(std::string_view str) {
    std::string str2 = "hi ";
    return str2 + str.data();
}

int main() {
    std::cout << gen("Jack") << std::endl;
    std::string str = "Bob";
    std::cout << gen(str) << std::endl;

    return 0;
}

std::function<int(int, int)> add = [](int a, int b) { return a + b; };
add(1,2)

int sum(int a, int b) {
  return a + b;
}

auto new_sum = std::bind(sum, 1, std::placeholders::_1);

int sum(int a, int b, int c) {
  return a + b + c;
}
int a = sum(1,2,3);

auto curry_sum = [](int a) {
  return [a](int b) {
    return [a, b](int c) {
      return sum(a, b, c);
    };
  };
};
int b = curry_sum(1)(2)(3);

#include <iostream>
#include <type_traits>

template <typename T>
void Print(const T& data) {
    if constexpr (std::is_integral_v<T>) { //在编译期就可以判断了! 不需要额外去做模板去匹配
        std::cout << "Integer: " << data << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "Float: " << data << std::endl;
    } else {
        static_assert(std::is_same_v<T, void>, "Unsupported type!");
    }
}

int main() {
    int i = 42;
    float f = 3.14;
    Print(i); // 输出 "Integer: 42"
    Print(f); // 输出 "Float: 3.14"
    // Print("hello"); // 编译错误，不支持字符串类型
    return 0;
}

#include <iostream>
#include <thread>

void my_func() {
    std::cout << "Hello from thread" << std::endl;
}

void my_func_args(int a) {
    std::cout << "Hello from thread" << a << std::endl;
}

int main() {
    std::thread t(my_func);             //函数指针
    std::thread t2([]() {
        std::cout << "Hello from thread2" << std::endl;
    });                                 //lambda表达式
    std::thread t3(my_func_args, 3);    //带参数的函数


    // 必须进行join或者detach 否则会抛出异常
    t.join();
    t2.join();
    t3.join();
    return 0;
}

void task(std::promise<std::string> promise) {
    std::string result = "Task completed.";
    promise.set_value(result);
}

int main() {
    std::promise<std::string> promise; // 获取生产者
    std::future<std::string> future = promise.get_future(); // 获取消费者对象

    // 启动异步任务
    std::async(std::launch::async, task, std::move(promise));

    // 输出异步操作结果
    std::cout << future.get() << std::endl;

    return 0;
}

std::mutex g_mutex;
int g_counter = 0;

void increment_counter() {
    g_mutex.lock(); // 获取互斥锁
    ++g_counter;    // 修改共享资源
    g_mutex.unlock(); // 释放互斥锁
}

std::shared_mutex g_mutex;
int g_counter = 0;

void increment_counter() {
    std::unique_lock<std::shared_mutex> lock(g_mutex); // 获取共享锁
    ++g_counter; // 修改共享资源
    lock.unlock(); // 释放共享锁
}

void read_counter() {
    std::shared_lock<std::shared_mutex> lock(g_mutex); // 获取共享锁
    std::cout << "Counter value: " << g_counter << std::endl; // 读取共享资源
}

std::mutex g_mutex;

void foo(int id) {
    std::lock_guard<std::mutex> lock(g_mutex);
    std::cout << "Thread " << id << " start" << std::endl;
    // 执行一些需要互斥访问的操作
    std::cout << "Thread " << id << " end" << std::endl;
}

std::atomic<int> g_count(0);

void foo(int id) {
    for (int i = 0; i < 10000; ++i) {
        ++g_count;
        g_count.fetch_add(1, std::memory_order_relaxed);
    }
}

std::mutex g_mutex;
std::condition_variable g_cv;
bool g_ready = false; //此处g_ready是为了防止虚假唤醒

void worker_thread() {
    std::unique_lock<std::mutex> lock(g_mutex);
    // 小心虚假唤醒 应当使用while
    while (!g_ready) {
        g_cv.wait(lock); // 等待条件变量被唤醒
        // g_cv.wait(lock, g_ready); //等价
    }
    std::cout << "Worker thread is running!" << std::endl;
}

int main() {
    std::thread t(worker_thread);

    // 做一些计算... 比如文件读写 之后g_ready会为true

    {
        std::lock_guard<std::mutex> lock(g_mutex);
        g_ready = true;
        g_cv.notify_one(); // 唤醒一个等待线程
    }

    t.join();
    return 0;
}

#include <iostream>
#include <memory>
 
int main() {
    std::auto_ptr<int> ap1(new int(42)); // 创建一个 int 对象，并用 auto_ptr 管理它
    std::auto_ptr<int> ap2;
    
    ap2 = ap1; // 将 ap1 赋给 ap2，ap1 将失去对资源的所有权
    std::cout << "ap2 指向的整数值为：" << *ap2 << std::endl;
    
    // ap1 已经失去了对资源的所有权，因此不需要手动释放内存
    return 0;
}

std::shared_ptr<int> p = std::make_shared<int>(42);
std::unique_ptr<int> p = std::make_unique<int>(42);