#include <iostream>
#include <string> // 引入 string 头文件

int main () {
    string s1 = "123";
    string s2 = "456";
	string s = s1 + s2; // 支持 + 连接符
    
    string s;
	cin >> s; //读入字符串，遇空格，回车结束
    string s = "xing ma qi";
	char ch[] = s.c_str(); // 实现string向char数组的转换
}

s.push_back()	//在末尾插入
s.push_back('a')	//末尾插入一个字符a
s.insert(pos,element)	//在pos位置插入element
s.insert(s.begin(),'1')	//在第一个位置插入1字符
s.append(str)	//在s字符串结尾添加str字符串
s.append("abc")
erase(iterator p)	//删除字符串中p所指的字符
erase(iterator first, iterator last)	//删除字符串中迭代器区间[first,last)上所有字符
erase(pos, len)	//删除字符串中从索引位置pos开始的len个字符
clear()	//删除字符串中所有字符

s.substr(pos,n)	// 截取从pos索引开始的n个字符

#include <iostream>

// Function to end the recursion of variadic template function
void log() {
    // This can be empty or used to print something that marks the end of output.
}

template<typename T, typename... Args>
void log(T first, Args... args) 
{
    std::cout << first;
    if constexpr (sizeof...(args) > 0)
    {
        std::cout << " , ";
        log(args...);
    }
    else
    {
        std::cout << std::endl; // New line for the last element
    }
}

int main()
{
    // Calling log() functio with 3 arguments
    log(1 , 4.3 , "Hello");

    // Calling log() functio with 4 arguments
    log('a', "test", 78L, 5);

    // Calling log() functio with 2 arguments
    log("sample", "test");

    return 0;
}

void someFunction（） = delete;

// A constructor that might lead to implicit conversions
User(int userId, std::string userName);

// Creating an object with potentially problematic conversions
User obj4(5.5, "Riti");  // double to int
User obj5('a', "Riti");   // char to int

// Deleting constructors to prevent implicit conversions
User(double userId, std::string userName) = delete;
User(char userId, std::string userName) = delete;

class User {
    // ...
    // Delete the new operator to prevent heap allocation
    void* operator new(size_t) = delete;
};

// Error: Use of deleted function 'static void* User::operator new(size_t)'
User* userPtr = new User(1, "Riti");

#include <iostream>
#include <functional> // 包含这个头文件以使用 std::bind
using namespace std;
int add(int first, int second){
    return first + second;
}

int main(){
    auto add_func = std::bind(&add, std::placeholders::_1, std::placeholders::_2);
    cout << "result:" << add_func(1, 3) << endl;
    return 0;
}

[capture](parameters) mutable exception -> return_type {
    // function body
}

int y = 10;
auto lambda = [&y](int x) mutable {
    y = x * y; // 这是有效的，因为 y 是通过引用捕获的，并且 lambda 是 'mutable'
    std::cout << y << std::endl;
};
lambda(5); // 输出 50

#include <iostream>
#include <algorithm>

int main()
{
    int arr[] = {1, 2, 3, 4, 5};
    int discount = 50;

    // 按值捕获
    std::for_each(arr,
                  arr + sizeof(arr) / sizeof(int),
                  [=](int x) mutable {
                        std::cout << x << " ";
                        // 无法在此处修改“discount”，因为它是按值捕获的，除非使用“mutable”。
                        discount = 20;
                  });

    std::cout << std::endl;

    std::cout << "discount Vaue: " << discount << std::endl;
    return 0;
}
/* 输出：
1 2 3 4 5 
discount Vaue: 50
*/

#include <iostream>
#include <vector>
#include <initializer_list>
 
template <class T>
struct S {
    std::vector<T> v;
    S(std::initializer_list<T> l) : v(l) {
         std::cout << "constructed with a " << l.size() << "-element list\n";
    }
    void append(std::initializer_list<T> l) {
        v.insert(v.end(), l.begin(), l.end());
    }
    std::pair<const T*, std::size_t> c_arr() const {
        return {&v[0], v.size()};  // 在 return 语句中复制列表初始化
                                   // 这不使用 std::initializer_list
    }
};
 
template <typename T>
void templated_fn(T) {}
 
int main()
{
    S<int> s = {1, 2, 3, 4, 5}; // 复制初始化
    s.append({6, 7, 8});      // 函数调用中的列表初始化
 
    std::cout << "The vector size is now " << s.c_arr().second << " ints:\n";
 
    for (auto n : s.v)
        std::cout << n << ' ';
    std::cout << '\n';
 
    std::cout << "Range-for over brace-init-list: \n";
 
    for (int x : {-1, -2, -3}) // auto 的规则令此带范围 for 工作
        std::cout << x << ' ';
    std::cout << '\n';
 
    auto al = {10, 11, 12};   // auto 的特殊规则
 
    std::cout << "The list bound to auto has size() = " << al.size() << '\n';
 
//    templated_fn({1, 2, 3}); // 编译错误！“ {1, 2, 3} ”不是表达式，
                             // 它无类型，故 T 无法推导
    templated_fn<std::initializer_list<int>>({1, 2, 3}); // OK
    templated_fn<std::vector<int>>({1, 2, 3});           // 也 OK
}

int a = 1;
int b = 2;
int c = a + b; // a, b, c是左值，但在 "+" 运算时转换为了右值。即左值隐式转化为右值。

int arr[] = {1, 2};
int *p = &arr[0];
*(p+1) = 10; // p+1 为右值，但指针符号 * 将 p+1 转换为左值。

template <typename T>
class my_unique_ptr
{
    T* ptr_;
public:
    // 移动构造函数和移动赋值函数
    my_unique_ptr(my_unique_ptr&& other): ptr_(std::exchange(other.ptr_, nullptr)){}
    my_unique_ptr& operator=(my_unique_ptr&& rhs)
    {
        if (this != &rhs) {
           if (ptr_) {  // 释放当前拥有的指针
               delete ptr_;
           }
           ptr_ = std::exchange(rhs.ptr_, nullptr); // 夺取rhs的指针
        }
    	return *this;
    }
    // 禁止复制构造函数和复制赋值函数
    my_unique_ptr(const my_unique_ptr&) = delete;
    my_unique_ptr& operator=(const my_unique_ptr&) = delete;
}

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void example_function() {
    std::lock_guard<std::mutex> lock(mtx);
    // 互斥区，对共享资源的访问受到保护
    // ...
}  // 锁在此处自动释放

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool condition = false;

void producer() {
    std::lock_guard<std::mutex> lock(mtx);
    condition = true;
    cv.notify_one();
}

void consumer() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return condition; });
    // 条件满足后继续执行
}

int main() {
    std::thread producer_thread(producer);
    std::thread consumer_thread(consumer);

    producer_thread.join();
    consumer_thread.join();

    return 0;
}

#include <iostream>
#include <future>

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

int main() {
    std::promise<int> promise_result;
    std::future<int> future_result = promise_result.get_future();

    std::thread([&](std::promise<int>& p) {
        p.set_value(add(1, 2));
    }, std::ref(promise_result)).detach();

    int result = future_result.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}