现代 C++ 使用教程

std::ref

std::variant<double, bool, std::string> var;   //替代union

if(std::holds_alternative<double>(var))

if(0 == var.index())

struct {
    void operator()(int) { std::cout << "int!\n"; }
    void operator()(std::string const&) { std::cout << "string!\n"; }
} visitor;

std::visit(visitor, var);

template<typename T>
auto print_type_info(const T& t) {
    if constexpr (std::is_integral<T>::value) {
        return t + 1;
    } else {
        return t + 0.001;
    }
}

template<typename T = int, typename U = int>
auto add(T x, U y) -> decltype(x+y) {
    return x+y;
}

// sizeof... 不定参数个数
template<typename... Ts>
void magic(Ts... args) {
    std::cout << sizeof...(args) << std::endl;
}

// 1. recursive parameter unpack
template<typename T0>
void printf1(T0 value) {
    std::cout << value << std::endl;
}

template<typename T, typename... Ts>
void printf1(T value, Ts... args) {
    std::cout << value << std::endl;
    printf1(args...);
}

template<typename T, typename... Ts>
auto printf3(T value, Ts... args) {
    std::cout << value << std::endl;
    (void) std::initializer_list<T>{([&args] {
        std::cout << args << std::endl;
    }(), value)...};
}

template<typename ... T>
auto sum(T ... t) {
    return (t + ...);
}

static std::mutex mtx;
std::lock_guard<std::mutex> lock(mtx);

// pack a lambda expression that returns 7 into a std::packaged_task
std::packaged_task<int()> task([](){return 7;});
// get the future of task
std::future<int> result = task.get_future();    // run task in a thread
std::thread(std::move(task)).detach();
std::cout << "waiting...";
result.wait(); // block until future has arrived

// 限制参数是否满足指定用法
template<typename T>
concept bool Stringable = requires(T a){
    {a.to_string()} -> string;
};

void print(Stringable a){
    std::cout << a.to_string() << std::endl;
}

struct Person {
    double height, weight;
    Person(double a, double b) : height(a), weight(b) {}
    string to_string(){
        return "weight: "+ std::to_string(weight) + ", height: "+ std::to_string(height);
    }
};
Person p(57, 170.0);
print(p); // uses concept Stringable

std::vector<int> datas{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto             sum = std::reduce(datas.begin(), datas.end());

std::recursive_mutex 解决死锁
atomic 自带线程锁 fetch_add is +=, store is =, load is read, exchange读取并写入，compare_exchange_strong读取，比较是否相等，相等则写入

std::recursive_mutex 替换std::mutex解决同一线程死锁

GitHub - parallel101/course: 高性能并行编程与优化 - 课件

双笙子佯谬的个人空间-双笙子佯谬个人主页-哔哩哔哩视频

---

创作不易，小小的支持一下吧！