std::ref

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

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