#include <thread>  //线程类型在此头文件中定义
int main() {
    //定义线程函数，此函数接收两个参数
    auto t_fun(int t_id, int num) {
        for (size_t i = 0; i < num; i++) {
            cout<< to_string(t_id) + ":" + to_string(i) << endl;
        }
    }
    //开一个线程执行线程函数，给线程函数传入两个参数：0,6
    thread t(func, 0, 6);
    //开另一个线程执行线程函数，参数为1,6
    thread t2(func, 1, 6);
    //join方法可以等待线程结束，
    //如果线程不结束就开启另一个线程，那么两个线程是并行执行的
    //此处两个线程就是并行执行的
    t.join();
    t2.join();
    auto c = getchar();
}

std::vector<int> numbers;
if (numbers.empty()) {
    std::cout << "Vector is empty." << std::endl;
}

std::vector<int> numbers;
numbers.reserve(10);  // 预留空间，但不改变 size

std::vector<int> numbers = {1, 2, 3};
numbers.resize(5);  // 将容器的大小调整为5，多余的元素填充默认值

for (auto& item:myVector) {
	cout << item << endl;
}

#include <list>
#include <vector>
#include <deque>

// forward_list 单向链表
list<int> myList;  // 双向链表容器
myList.push_back(1);
myList.push_back(2);
myList.push_back(3);
//没办法执行myList.begin()+2这样的操作
myList.insert(++myList.begin(), 7);

deque<int> myDeque; // 双端队列
myDeque.push_back(1);
myDeque.push_front(1);
myDeque.push_back(2);
myDeque.push_back(3);
myDeque.insert(myDeque.begin()+2, 2);

#include <iostream>
#include <queue>
#include <stack>
using namespace std;

int main() {
    //队列容器（先进先出）
    queue<int> myQueue;
    myQueue.push(1);
    myQueue.push(2);
    myQueue.push(3);
    do {
        cout << myQueue.front() << endl; //输出 1 2 3
        myQueue.pop();
    } while (myQueue.size() > 0);

    //堆栈容器（后进先出）
    stack<int> myStack;
    myStack.push(1);
    myStack.push(2);
    myStack.push(3);
    do {
        cout << myStack.top() << endl; //输出 3 2 1
        myStack.pop();
    } while (myStack.size() > 0);

    auto c = getchar();
}

#include <iostream>
#include <string>
#include <format>
using namespace std;

//移除字符串左侧空白符
static inline void ltrim(std::string& s) {
    //从字符串左侧开始查找，找到第一个不是空白符的字符的位置
    auto endPosition = std::find_if(s.begin(), s.end(), [](unsigned char ch) {
        return !std::isspace(ch);
        });
    s.erase(s.begin(), endPosition);//移除字符串中指定位置区间的字符
}

//移除字符串右侧空白符
static inline void rtrim(std::string& s) {
    //从字符串右侧开始查找，找到第一个不是空白符的字符的位置
    //由于入参有两个reverse_iterator，所以最后要调用base
    auto startPosition = std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
        return !std::isspace(ch);
        }).base();
    s.erase(startPosition, s.end());//移除字符串中指定位置区间的字符
}

//移除字符串左侧和右侧的空白符
static inline void trim(std::string& s) {
    rtrim(s);
    ltrim(s);
}

int main() {
    auto str1{ "   liulun   "s }; //加了s尾缀，str1就是std:string类型，不然就是const char*
    trim(str1); //c++标准库中没有trim，使用的是自己实现的。
    cout << str1 << endl; //输出：liulun

    int num1 = stoi("1237"s); //字符串转整型
    double num2 = stod("123.45"s); //字符串转浮点型
    cout << num1 << " " << num2 << endl; //输出：1237 123.45

    auto str2 = to_string(num1); //数字转字符串
    auto str3 = to_string(num2); //数字转字符串
    cout << str2 << " " << str3 << endl; //输出：1237 123.450000

    auto str4{ "他1926年8月17日出生，2022年11月30日逝世，是江苏省扬州市人。"s };
    //获取子字符串，第一个参数是位置，第二个参数是数量，
    cout << str4.substr(21, 19) << endl; //输出：2022年11月30日逝世
    //查找子字符串的位置
    cout << str4.find("2022") << endl; //输出：21
    //格式化字符串
    cout << format("他{0}年8月17日出生，{1}年11月30日逝世，他{0}年8月17日出生，{1}年11月30日逝世。", "1926", "2022");
    //输出：他1926年8月17日出生，2022年11月30日逝世，他1926年8月17日出生，2022年11月30日逝世。
    auto c = getchar();
}

#include <iostream>
#include <regex>
using namespace std;

//匹配手机号
void isPhoneNumber() {
    //定义正则表达式，regex_constants::icase不区分大小写
    regex reg{ R"(^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8}$)" ,regex_constants::icase };
    //match是全文匹配，要求整个字符串都符合规则
    bool flag = regex_match("18158135758", reg);
    //输出：Is phone number:true
    cout << "Is phone number:" << (flag?"true":"false") << endl;
}
//使用正则表达式替换命中的匹配项
void replaceByRegex() {
    string str = "等忙完这一阵子，就可以接着忙下一阵子了。";
    //一个中文字符相当于两个英文字符
    regex reg{ R"(一.{2}子)" };
    //输出：等忙完这一会儿，就可以接着忙下一会儿了。
    cout << regex_replace(str, reg, "一会儿") << endl;
}
//使用正则表达式搜索字符串
void regexSearch() {
    string str = "他1926年8月17日出生，2022年11月30日逝世，是江苏省扬州市人。";
    smatch result;
    regex reg{ R"(\d{4})" };
    string::const_iterator iterStart = str.begin(); //这里不能用auto
    string::const_iterator iterEnd = str.end(); //这里不能用auto
    string temp;
    //输出：1926 2022
    while (regex_search(iterStart, iterEnd, result, reg))
    {
        cout << result[0] << " ";
        //更新搜索起始位置,搜索剩下的字符
        iterStart = result[0].second;
    }
}

int main() {
    isPhoneNumber();
    replaceByRegex();
    regexSearch();
    auto c = getchar();
}

#include <iostream>
#include <random>
using namespace std;

//获取一定范围内的随机数
void getRangeRnd(int min, int max) {
    random_device dev; //创建random_device对象
    int result = (dev() % (max + 1 - min)) + min; //可以是最小值min，也可以是最大值max
    cout << result << endl;
}
//使用rand方法连续获取5个随机数
void get5RandNumByRand() {
    srand(time(nullptr)); //使用当前时间设置rand的随机数种子
    cout << rand() << " "
        << rand() << " "
        << rand() << " "
        << rand() << " "
        << rand() << endl;
}
//使用random_device对象连续获取5个随机数
void get5RandNumByRandomDevice() {
    random_device dev; //创建random_device对象
    cout << dev() << " "
        << dev() << " "
        << dev() << " "
        << dev() << " "
        << dev() << " " << endl;
}
int main() {
    get5RandNumByRand();
    get5RandNumByRandomDevice();
    getRangeRnd(100, 200);
    auto c = getchar();
}

#include <iostream>
#include <chrono>
using namespace std;
using namespace chrono;
int main() {
    //获取当前时间 time_t为int64的值
    std::time_t time = std::time(nullptr);
    tm localTime;
    localtime_s(&localTime, &time); //转型为本地时间
    //获取当前时间，类型为system_clock:time_point
    system_clock::time_point now = system_clock::now();
    seconds::rep milliseconds = duration_cast<chrono::milliseconds>(now.time_since_epoch()).count() % 1000; //获取毫秒数
    //打印年份，当前年份距离1900年的差值
    cout << localTime.tm_year + 1900 << "-"
        << localTime.tm_mon + 1 << "-" //打印月份：tm_mon取值范围0到11
        << localTime.tm_mday << " " //打印日期：取值范围1到31
        << localTime.tm_hour << ":" //打印小时：取值范围0到23
        << localTime.tm_min << ":" //打印分钟：取值范围0到59
        << localTime.tm_sec << "." //打印秒：取值范围0到60
        << milliseconds << endl //打印毫秒：取值范围0到1000
        //打印星期：取值范围0-6，星期日为0
        << "星期：" << (localTime.tm_wday == 0 ? 7 : localTime.tm_wday) << endl
        //打印当前是一年中的第几天，取值范围：0到365
        << "今年的第" << localTime.tm_yday + 1 << "天" << endl;
    auto a = getchar();
    duration<double> span = system_clock::now() - now; //时间计算
    cout << span.count() << endl; //打印时间差值：输出：4.26886
    duration<double> span2 = hours(3); //表示3小时时间段
    cout << span2.count() << endl; //单位秒， 输出10800
    auto c = getchar();
    c = getchar();
}

#include <iostream>
#include <variant>
using namespace std;

int main() {
    //变体定义时必须指定它可能包含的类型
    variant<int, double, string> myVariant;
    //可以把不同类型的值赋给变体变量
    myVariant = 12;
    myVariant = 3.1415926;
    myVariant = "hello liulun";
    //holds_alternative方法可用于验证变体中是否存储着指定类型的值
    cout << holds_alternative<string>(myVariant) << endl; //输出 1
    //index方法用于查询存储在变体中值的类型的索引，string的索引为2
    cout << myVariant.index() << endl; //输出2
    //根据index获取myVariant内的值，如果没有值则抛出异常
    cout << get<2>(myVariant) << endl; //输出：hello liulun
    //尝试根据类型获取myVariant内的值，如果没有值也不会抛出异常，
    //get_if方法的输入参数是指针，返回值也是指针
    string* val = get_if<string>(&myVariant);
    cout << (val ? (*val) : "null") << endl; //输出：hello liulun
    auto c = getchar();
}

#include <iostream>
#include <optional>
using namespace std;

int main() {
    //默认myOptional变量内不存在值
    optional<int> myOptional;
    myOptional = 123;
    //把myOptional设置为空，除了使用nullopt外，还可以使用myOptional = {};
    myOptional = nullopt;
    //判断myOptional中是否有值
    cout << myOptional.has_value() << endl;//输出0
    //使用value_or获取myOptional中的值，如果值不存在，则使用789
    cout << myOptional.value_or(789) << endl;//输出789
    myOptional = 456;
    //使用value获取myOptional中的值，如果值不存在，则抛出错误
    cout << myOptional.value() << endl; //输出456
    //值存在，输出变量内的值，值不存在输出789
    cout << myOptional.value_or(789) << endl;//输出456

    auto c = getchar();
}

#include <iostream>
#include <any>
using namespace std;

int main() {
    any myAny1;
    cout << myAny1.has_value() << endl; //输出0
    any myAny2{ 3 };
    //any变量一旦构建就已经明确了类型，不能在用其他类型为其赋值
    //myAny2 = "allen"; error
    //可以使用当前类型为其更改值
    myAny2 = 4;
    //使用any_cast获取myAny2的值
    cout << myAny2.has_value() << " " //输出1
        << any_cast<int>(myAny2) << endl;  //输出 4

    auto c = getchar();
}

int var = 4l; // 正确
4 = var; // 错误
(var + 1) = 4; // 错误

int&& rvalue = 42;  // rvalue 是右值引用

template<typename T>
void print(T&& str) {
    str = "hello liulun";
    std::cout << str << std::endl;
}

//函数对象类型
class MyFunction {
public:
    //重载函数调用运算符
    int operator()(int x, int y) {
        return x + y;
    }
    //函数调用运算符的重载版本
    double operator()(double x, double y) {
        return x * y;
    }
};

int main() {
    MyFunction func; //函数对象
    cout << func(12, 13) << "  " << func(3.2,19.8) << endl; /才使用函数对象
    //执行函数对象上的方法，输出：25  63.36
    return 0;
}

#include <functional> //std::function定义在这个头文件中

//f是一个function类型的对象。
void callFunction(function<int(int, int)> f,int param1,int param2) {
    cout << f(param1,param2) << endl;
}

int main() {
    string str { "等忙完这一阵子，" };
    string str2 {"就可以接着忙下一阵子了。"};
  	// 按引用捕获变量 str
    auto print = [&str](string& param) {
        string str2 { "马克思说：" };
        // 输出： 马克思说：等忙完这一阵子，就可以接着忙下一阵子了。
        cout << str2 << str << param << std::endl;
    };
    print(str2);
		return 0;
}

// 注意此方法的返回值是auto类型的，实际上返回的是一个方法指针
auto getFunction() {
    // 注意：这里匿名函数的参数类型被定义为auto
  	// 其实是一个模板函数，允许开发者向它传递不同类型的参数
    auto print = [](auto param) {
        std::cout << param << std::endl;
    };
    return print;
}

int main() {
    // 得到匿名函数的方法指针
    auto print = getFunction();
    print(123); //输出：123
    print("liulun"); //输出：liulun
		return 0;
}

class ORM {
public:
    ORM* Select(const char* param) {
        cout << param << endl;
        return this; //返回当前对象指针
    }
    ORM* From(const char* param) {
        cout << param << endl;
        return this;
    }
    ORM* Where(const char* param) {
        cout << param << endl;
        return this;
    }
    ORM* OrderBy(const char* param) {
        cout << param << endl;
        return this;
    }
};

int main() {
    ORM* orm {new ORM()};
    orm->Select("userName")->From("user")->Where("id=123")->OrderBy("createTime");
		return 0;
}

//函数重载：整型版本
int getLargestNumber(const vector<int>& vect) {
    int largestNumber{ vect.at(0) };
    for (auto& val : vect)
    {
        if (val > largestNumber) largestNumber = val;
    }
    return largestNumber;
}

//函数重载：浮点数版本
double getLargestNumber(const vector<double>& vect) {
    double largestNumber{ vect.at(0) };
    for (auto& val : vect)
    {
        if (val > largestNumber) largestNumber = val;
    }
    return largestNumber;
}

int main() {
    vector<int> vect1{ 1,2,3,4,5,9,8,7,6,0 };
    vector<double> vect2{ 1.1,2.2,3.3,4.4,9.9,8.8,7.7,6.6 };
    auto result1 = getLargestNumber(vect1);
    auto result2 = getLargestNumber(vect2);
    cout << result1 << endl;  //输出：9
    cout << result2 << endl;  //输出：9.9
    auto c = getchar();
}

// 函数模板
template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int result1 = add(5, 3);        // 实例化为 int 类型
    double result2 = add(2.5, 3.5); // 实例化为 double 类型

    std::cout << "Result 1: " << result1 << std::endl;
    std::cout << "Result 2: " << result2 << std::endl;

    return 0;
}

#include <iostream>
using namespace std;
//模板类：非类型模板参数：WIDTH，以及模板参数的默认值
template <typename T = int,T WIDTH = 123>
class MyType
{
public:
    MyType() = default;
    T getWidth() {
        return WIDTH; //使用模板参数
    }
};

int main() {
    MyType obj; //使用了模板参数的默认值
    cout << obj.getWidth() << endl;  //输出123
    MyType<double,456.1> obj2; //没有使用模板参数的默认值
    cout << obj2.getWidth() << endl;  //输出456.1
    auto c = getchar();
}

#include <iostream>
#include <string>
using namespace std;

//假设这是一个会占用较大堆空间的类型
class Message
{
public:
    Message() : val{"这是一个非常长的字符串"} {
    }
    ~Message() { }
    void SendMessage() {
        cout << val << endl;
    }
    string val;
};

//这个类型负责管理Message对象的释放工作
class MessageRAII {
public:
    MessageRAII() : msgObj{ new Message() } { };
    Message* get() {
        return msgObj;
    }
    ~MessageRAII() {
        delete msgObj;
    }
    Message* msgObj;
};

//入口函数
int main() {
    {
        // 在栈上声明一个代理类型，负责管理目标对象
      	// 代理类型自身会在离开作用域时销毁
        MessageRAII msgRAIIobj;
        msgRAIIobj.get()->SendMessage();
    }
    auto c = getchar();
}

void Send(Message& msg) {
    msg.SendMessage();
}

// Message.h
#pragma once
#include <string>

using namespace std;

class Message {

public:
  	// 构造函数
    Message(int fromUserId, int toUserId, string& messageContent);
    void SendMessage();
    const int MessageId;
    const int ToUserId;
    const int FromUserId;
    const string& MessageContent;
    static inline int MsgContent {0};

private:
    int createMessageId();
};

#include "Message.h"
#include <iostream>
#include <random>

// 构造函数，成员初始化列表
Message::Message(int fromUserId, int toUserId, std::string &messageContent) :
    FromUserId{ fromUserId },
    ToUserId{ toUserId },
    MessageContent{ messageContent },
    MessageId{ createMessageId() } {
    MsgContent += 1;
}

void Message::SendMessage() {
    cout << "From：" << FromUserId << endl
         << "To：" << ToUserId << endl
         << "Message：" << MessageContent << endl
         << "MessageId：" << MessageId << endl;
}

int Message::createMessageId() {
    std::random_device dev;
    return dev();
}

// 实际使用
#include "Message.h"
#include <iostream>
#include <string>

using namespace std;

Message* CreateMessage() {
    string msgContent{"测试 class 嘟嘟。"};
    // 这里 msgContent 传递引用到构造函数，而 msgContent 会在 CreateMessage 函数结束后被回收
    // 所以实际上 msgContent 在 Message 的实例中无法访问
    Message* msg{new Message(12, 34, msgContent)};
    return msg;
}

int main() {
    auto msg {CreateMessage()};
    msg->SendMessage();
    delete msg;
    return 0;
}

//头文件，public节
~Message();  //析构函数的定义
UserInfo* userInfo;

//源码文件：
Message::~Message() { //析构函数的实现
    delete userInfo
}