#include <iostream>
#include <map>
#include <string>
#include <vector>

/**
 * @brief           把字符串前后的字符串给去除
 * @param           s       [in]    要剪切的字符串
 * @param           chars   [in]    要去除什么的字符串
 * @return          std::string& 剪切后的字符串
 * @author          lijiancong(lijiancong@gbcom.com.cn)
 * @note
 */
static std::string& strip(std::string& s, const std::string& chars = " ") {
  s.erase(0, s.find_first_not_of(chars.c_str()));
  s.erase(s.find_last_not_of(chars.c_str()) + 1);
  return s;
}

/**
 * @brief           以特定符号为分隔符，切分字符串并放入vector里
 * @param           s           [in]    原字符串
 * @param           tokens      [out]   剪切后的子字符串
 * @param           delimiters  [in]    分隔符
 * @author          lijiancong(lijiancong@gbcom.com.cn)
 * @note
 */
static void split(const std::string& s, std::vector<std::string>& tokens,
                  const std::string& delimiters = " ") {
  std::string::size_type lastPos = s.find_first_not_of(delimiters, 0);
  std::string::size_type pos = s.find_first_of(delimiters, lastPos);
  while (std::string::npos != pos || std::string::npos != lastPos) {
    tokens.push_back(s.substr(lastPos, pos - lastPos));
    lastPos = s.find_first_not_of(delimiters, pos);
    pos = s.find_first_of(delimiters, lastPos);
  }
}

static void parse(std::string& s, std::map<std::string, std::string>& items) {
  std::vector<std::string> elements;
  s.erase(0, s.find_first_not_of(" {"));
  s.erase(s.find_last_not_of("} ") + 1);
  split(s, elements, ",");
  for (auto& iter : elements) {
    std::vector<std::string> kv;
    split(iter, kv, ":");
    if (kv.size() != 2) continue;
    items[strip(kv[0], " \"")] = strip(kv[1], " \"");
  }
}

int main() {
  std::string data =
      "  {  \"key1\"  :  \"data1\"  ,  \"key2\"  :  \"data2\"    }  ";
  std::map<std::string, std::string> items;
  parse(data, items);

  for (const auto& iter:items){
    std::cout << "key=" << iter.first << ",value=" << iter.second << std::endl;
  }
  system("pause");
}

//
// Rotating file sink based on size
//
template<typename Mutex>
class rotating_file_sink final : public base_sink<Mutex>
{
public:
    rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false);
    static filename_t calc_filename(const filename_t &filename, std::size_t index);
    filename_t filename();

protected:
    void sink_it_(const details::log_msg &msg) override;
    void flush_() override;

private:
    // Rotate files:
    // log.txt -> log.1.txt
    // log.1.txt -> log.2.txt
    // log.2.txt -> log.3.txt
    // log.3.txt -> delete
    void rotate_();

    // delete the target if exists, and rename the src file  to target
    // return true on success, false otherwise.
    bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);

    filename_t base_filename_;          ///< 基础文件名称
    std::size_t max_size_;              ///< 最大单个文件大小
    std::size_t max_files_;             ///< 最大日志文件数量
    std::size_t current_size_;          ///< 当前文件的大小
    details::file_helper file_helper_;  ///< 用于辅助写文件的对象
};

/// @name     rotating_file_sink
/// @brief    构造本对象，
///           1. 打开日志文件
///           2. 获取当前文件大小
///           3. 如果超出了单个文件大小，则重新创建文件并打开
///
/// @param    base_filename   [in]  基础的文件名
/// @param    max_size        [in]  最大单个文件大小
/// @param    max_files       [in]  最大的文件
/// @param    rotate_on_open  [in]  是否在文件打开时rotate
///
/// @date     2020-07-04 21:51:27
rotating_file_sink(std::string base_filename, std::size_t max_size,
                   std::size_t max_files, bool rotate_on_open = false)
    : base_filename_(std::move(base_filename)),
      max_size_(max_size),
      max_files_(max_files) {
  /// 打开当前应该写入的文件，并由file_helper对象来持有这个文件指针
  file_helper_.open(calc_filename(base_filename_, 0));
  /// 该函数时间执行时间很长，在这里只执行一次。
  current_size_ = file_helper_.size();
  /// 假如允许rotate且当前文件大小大于零
  if (rotate_on_open && current_size_ > 0) {
    /// 执行一次rotate
    rotate_();
  }
}

/// @name     rotate_
/// @brief    执行循环日志文件的创建
/// @details
/// Rotate files:
/// log.txt -> log.1.txt
/// log.1.txt -> log.2.txt
/// log.2.txt -> log.3.txt
/// log.3.txt -> delete
///
/// @param    NONE
///
/// @return   NONE
///
/// @date     2020-07-04 21:58:24
inline void rotate_() {
  /// 首先关闭该文件
  file_helper_.close();
  /// 开始查找要创建的下一个日志文件名称
  for (auto i = max_files_; i > 0; --i) {
    /// 拼装出上一个该文件名称
    std::string src = calc_filename(base_filename_, i - 1);
    if (!path_exists(src)) {
      /// 该文件如果不存在则到下一个循环
      continue;
    }
    /// 这里找到要创建的日志名称了日志文件的名称
    std::string target = calc_filename(base_filename_, i);

    /// 把上一个文件改名为当前的文件名
    if (!rename_file_(src, target)) {
      /// 如果失败则在一个短暂的延迟后再次尝试
      sleep_for_millis(100);
      if (!rename_file_(src, target)) {
        /// 关闭并打开这个日志文件，防止它增长超出限制
        file_helper_.reopen(true);
        current_size_ = 0;
        /// 抛出异常
        throw("rotating_file_sink: failed renaming ");
      }
    }
  }
  /// 以追加模式("a")重新打开这个文件
  file_helper_.reopen(true);
}

/// @name   sink_it_
/// @brief  写文件日志的函数，如果写入日志大于最大文件大小则创建下一个文件
///
/// @param  msg [in]  写入的日志信息
///
/// @return
///
/// @date     2020-07-05 09:33:12
void sink_it_(const details::log_msg &msg) override {
  std::string formatted;
  /// 拼装日志信息
  base_sink<Mutex>::formatter_->format(msg, formatted);
  /// 计算这条日志加上原本大小是否超过了最大文件大小
  current_size_ += formatted.size();
  if (current_size_ > max_size_) {
    /// 超过了就创建下一个文件
    rotate_();
    /// 更新为当前文件大小为这个日志信息的大小
    current_size_ = formatted.size();
  }
  /// 如果没有超过最大大小则继续写该文件
  file_helper_.write(formatted);
}

/// @name     flush_
/// @brief    刷新文件
///
/// @param    NONE
///
/// @return   NONE
///
/// @date     2020-07-05 09:36:23
void flush_() override { file_helper_.flush(); }

template <typename T>
Blob<T>::Blob(std::initializer_list<T> il)
try
 : data(std::make_shared<std::vector<T>>(il))
{/** ... */}
catch (const std::bad_alloc &e)
{
    handle_out_of_memory(e);
}

void recoup() noexcept; /** 不会抛出异常 */
void alloc();           /** 可能会抛出异常 */

void recoup() noexcept(true);	/** 不会抛出异常 */
void alloc() noexcept(false);	/** 可能抛出异常 */

noexcept(recoup())	/** 如果recoup不跑出异常则结果为true；否则结果为false */
noexcept(e)	/** 等价于上一句 */

void f() noexcept(noexcept(g()));	// f 和 g的异常说明一致

#include <iostream>
#include <compare>

struct Rational_2 {
    int num;
    int den; // > 0
};

constexpr std::weak_ordering operator<=>(Rational_2 lhs, Rational_2 rhs)
{
    return lhs.num * rhs.den <=> rhs.num * lhs.den;
}

void print(std::weak_ordering value)
{
    if (value == 0)
        std::cout << "equal\n";
    else if (value < 0)
        std::cout << "less\n";
    else
        std::cout << "greater\n";
}

int main()
{
    Rational_2 c{6,5};
    Rational_2 d{8,7};
    print(c <=> d);
    print(std::compare_three_way{}(c,d));
}

#include <iostream>
#include <compare>
struct Basics {
  int i;
  char c;
  float f;
  double d;
  auto operator<=>(const Basics&) const = default;
};

struct Arrays {
  int ai[1];
  char ac[2];
  float af[3];
  double ad[2][2];
  auto operator<=>(const Arrays&) const = default;
};

struct Bases : Basics, Arrays {
  auto operator<=>(const Bases&) const = default;
};

int main() {
  constexpr Bases a = { { 0, 'c', 1.f, 1. },
                        { { 1 }, { 'a', 'b' }, { 1.f, 2.f, 3.f }, { { 1., 2. }, { 3., 4. } } } };
  constexpr Bases b = { { 0, 'c', 1.f, 1. },
                        { { 1 }, { 'a', 'b' }, { 1.f, 2.f, 3.f }, { { 1., 2. }, { 3., 4. } } } };
  static_assert(a == b);
  static_assert(!(a != b));
  static_assert(!(a < b));
  static_assert(a <= b);
  static_assert(!(a > b));
  static_assert(a >= b);
}

// 一个定义std::set<struct>的例子
#include <set>
#include <iostream>

struct ORDERING_EXAMPLE
{
    int x;
    int y;
    int z;

    /// 重载遵循严格弱序的运算符<
    bool operator < (const ORDERING_EXAMPLE& OtherStruct) const
    {
        if (this->x < OtherStruct.x)
            return true;
        if (OtherStruct.x < this->x)
            return false;

        // x == x则比较y
        if (this->y < OtherStruct.y)
            return true;
        if (OtherStruct.y < this->y)
            return false;

        // y == y则比较z
        if (this->z < OtherStruct.z)
            return true;

        return false;
    }
};

int main()
{
    std::set<ORDERING_EXAMPLE> setOrderingExample;

    ORDERING_EXAMPLE stOrderingExample0 = { 0, 0, 0 };
    ORDERING_EXAMPLE stOrderingExample1 = { 0, 1, 2 };
    ORDERING_EXAMPLE stOrderingExample2 = { 0, 1, 3 };
    ORDERING_EXAMPLE stOrderingExample3 = { 0, 1, 3 };

    setOrderingExample.insert(stOrderingExample0);
    setOrderingExample.insert(stOrderingExample1);
    setOrderingExample.insert(stOrderingExample2);
    setOrderingExample.insert(stOrderingExample3);

    return 0;
}

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
  std::vector<int> temp(5, 1);
  std::vector<std::vector<int>> vec(5, temp);
  std::sort(vec.begin(), vec.end(),
            [](const std::vector<int> &l, const std::vector<int> &r) {
              if (l.size() == r.size()) {
                for (size_t i = 0; i < l.size(); ++i) {
                  if (l.at(i) == r.at(i)) {
                    continue;
                  } else {
                    return l.at(i) < r.at(i);
                  }
                }
                return true;  /// 这里会崩溃，改为false则不会而不会崩溃(遵循严格弱序)
              } else {
                return l.size() < r.size();
              }
            });
}

class key
{
public:
    int x;
    int y;

    bool operator<(const key& stOther)
    {
        if (x < stOther.x)
        {
            return true;
        }
        else if (x > stOther.x)
        {
            return false;
        }
        else if (y < stOther.y)
        {
            return true;
        }
        else if (y > stOther.y)
        {
            return false;
        }
        else
        {
            return false;
        }
    }
};

class key
{
public:
    int x;
    std::string y;

    bool operator<(const key& stOther)
    {
        if (x < stOther.x)
        {
            return true;
        }
        else if (x > stOther.x)
        {
            return false;
        }
        else if (y < stOther.y)
        {
            return true;
        }
        else if (y > stOther.y)
        {
            return false;
        }
        else
        {
            return false;
        }
    }
};

/// 判断两入参相乘是否溢出，溢出返回true，否则返回false
bool is_multi_overflow(int x, int y) {
  if (x > 0 && y > 0) {
    /// 同为正号
      return x > INT_MAX/y;
  } else if (x < 0 && y < 0) {
    /// 同为负号
    if (y == INT_MIN && x <= -1) {
      return true;
    }
    return x < INT_MIN/-y;
  } else if (x > 0 && y<0 || (x < 0 && y > 0)) {
    /// 异号的情况稍等补上
    return false;
  } else {
    return false;
  }
}

#include <cassert>
#include <iostream>
#include <numeric>

/// 判断两入参相乘是否溢出，溢出返回true，否则返回false
bool is_multi_overflow(int x, int y) {
  if (x > 0 && y > 0) {
    /// 同为正号
      return x > INT_MAX/y;
  } else if (x < 0 && y < 0) {
    /// 同为负号
    if (y == INT_MIN && x <= -1) {
      return true;
    }
    return x < INT_MIN/-y;
  } else if (x > 0 && y<0 || (x < 0 && y > 0)) {
    /// 异号的情况稍等补上
    return false;
  } else {
    return false;
  }
}

int main() {
  int x = 0;
  int y = 0;
  int max_num = std::numeric_limits<int>::max();
  int min_num = std::numeric_limits<int>::min();

  /// case 1 #1
  x = 7;
  y = 1 + max_num / x;
  assert(is_multi_overflow(x, y));
  x = max_num - 1;
  y = 1 + max_num / x;
  assert(is_multi_overflow(x, y));

  /// case 1 #2
  x = 7;
  y = max_num / x;
  assert(!is_multi_overflow(x, y));
  x = max_num - 1;
  y = max_num / x;
  assert(!is_multi_overflow(x, y));

  /// case 2 #1
  x = -7;
  y = -1 + min_num / -x;
  assert(is_multi_overflow(x, y));
  x = min_num + 1;
  y = -1 + min_num / -x;
  assert(is_multi_overflow(x, y));

  /// case 2 #2
  x = -7;
  y = min_num / -x;
  assert(!is_multi_overflow(x, y));
  x = min_num + 1;
  y = min_num / -x;
  assert(!is_multi_overflow(x, y));
}

#include <cassert>
#include <iostream>
#include <numeric>

/// 判断两入参相乘是否溢出，溢出返回true，否则返回false
template <typename T1, typename T2>
bool is_multi_overflow(T1 x, T2 y) {
  static_assert(std::is_same<T1, T2>::value,
                "is_multi_overflow need same type!");
  static_assert(std::is_integral<T1>::value,
                " is_multi_overflow need integral type!");
  int num_max = std::numeric_limits<T1>::max();
  int num_min = std::numeric_limits<T1>::min();
  if (x == 0 || y == 0 || x == 1 || y == 1) {
    return false;
  }
  if (x == -1) {
    return y == num_min;
  } else if (y == -1) {
    return x == num_min;
  }

  if (x > 0 && y > 0) {
    /// 同为正号
    return x > num_max / y;
  } else if (x < 0 && y < 0) {
    /// 同为负号
    if (y == num_min && x <= -1) {
      return true;
    }
    return x < num_min / -y;
  } else if (x > 0 && y < 0 || (x < 0 && y > 0)) {
    /// 异号的情况
    if (x > y) {
      std::swap(x, y);
    }
    return x < num_min / y;
  } else {
    return false;
  }
}

int main() {
  int x = 0;
  int y = 0;
  int max_num = std::numeric_limits<int>::max();
  int min_num = std::numeric_limits<int>::min();

  /// case 1 #1
  x = 7;
  y = 1 + max_num / x;
  assert(is_multi_overflow(x, y));
  x = max_num - 1;
  y = 1 + max_num / x;
  assert(is_multi_overflow(x, y));

  /// case 1 #2
  x = 7;
  y = max_num / x;
  assert(!is_multi_overflow(x, y));
  x = max_num - 1;
  y = max_num / x;
  assert(!is_multi_overflow(x, y));

  /// case 2 #1
  x = -7;
  y = -1 + min_num / -x;
  assert(is_multi_overflow(x, y));
  x = min_num + 1;
  y = -1 + min_num / -x;
  assert(is_multi_overflow(x, y));

  /// case 2 #2
  x = -7;
  y = min_num / -x;
  assert(!is_multi_overflow(x, y));
  x = min_num + 1;
  y = min_num / -x;
  assert(!is_multi_overflow(x, y));

  /// case 3
  x = 0;
  y = max_num;
  assert(!is_multi_overflow(x, y));
  x = min_num;
  y = 0;
  assert(!is_multi_overflow(x, y));
  x = 0;
  y = 0;
  assert(!is_multi_overflow(x, y));

  /// case 4
  x = 1;
  y = max_num;
  assert(!is_multi_overflow(x, y));
  x = INT_MIN;
  y = 1;
  assert(!is_multi_overflow(x, y));

  /// case 5
  x = -1;
  y = max_num;
  assert(!is_multi_overflow(x, y));
  x = -1;
  y = min_num;
  assert(is_multi_overflow(x, y));

  /// case 6
  x = 2;
  y = min_num / 2;
  assert(!is_multi_overflow(x, y));
  assert(!is_multi_overflow(y, x));
  x = 2;
  y = -1 + min_num / 2;
  assert(is_multi_overflow(x, y));
  assert(is_multi_overflow(y, x));
}

#include <optional>

template <typename T1, typename T2>
std::optional<T1> multiplies_s(const T1 x, const T2 y) noexcept {
  static_assert(std::is_same<T1, T2>::value, "Multiplies_s need same type!");
  static_assert(std::is_integral<T1>::value,
                "Multiplies_s need integral type!");
  if (is_multi_overflow(x, y)) return {};
  return x * y;
}

int main()
{
  int x = 5;
  int y = 5;
  int result = multiplies_s(x, y).value_or(0);
}

#include <iostream>

struct Base
{
     Base() { std::cout << "Base Construct!" << std::endl; }
     /// 该析构函数为错误示例，严禁这样写.
     ~Base() { std::cout << "Base Deconstruct!" << std::endl; }
};

struct Derived : public Base
{
    Derived()   { std::cout << "Derived Construct!" << std::endl; }
    ~Derived() { std::cout << "Derived Deconstruct!" << std::endl; }
};

int main()
{
    {
        /** 使用基类指针指向派生类实例 */
        Base* BasePtr = new Derived;
        delete BasePtr;
    }
    system("pause");
}

#include <iostream>

struct Base
{
     Base() { std::cout << "Base Construct!" << std::endl; }
     /** 正确写法： 加上关键字virtual， 后面函数体可写可不写，或者直接使用=default都行。 */
     virtual ~Base() { std::cout << "Base Deconstruct!" << std::endl; }
};

struct Derived : public Base
{
    Derived()   { std::cout << "Derived Construct!" << std::endl; }
    ~Derived() { std::cout << "Derived Deconstruct!" << std::endl; }
    /// 或者 virtual ~Derived() override {}
};

int main()
{
    {
        /** 使用基类指针指向派生类实例 */
        Base* BasePtr = new Derived;
        delete BasePtr;
    }
    system("pause");
}

class ThreadPool {
 public:
  ThreadPool(size_t);
  /// 任务入列
  template <class F, class... Args>
  auto enqueue(F&& f, Args&&... args)
      -> std::future<typename std::invoke_result<F(Args...)>::type>;
  ~ThreadPool();

 private:
  /// 所有的工作线程
  std::vector<std::thread> workers;
  /// 任务队列
  std::queue<std::function<void()> > tasks;

  /// 用于同步的互斥锁和条件变量
  std::mutex queue_mutex;
  std::condition_variable condition;
  bool stop;  ///< 用于判断所有线程是否需要结束
};

/// @name     ThreadPool
/// @brief    用于创建若干个线程，并规定消费者函数
///
/// @param    threads   [in]    要创建的线程数量
///
/// @return   NONE
///
/// @date     2020-06-27 16:17:50
/// @warning  线程安全
inline ThreadPool::ThreadPool(size_t threads) : stop(false) {
  for (size_t i = 0; i < threads; ++i)
    workers.emplace_back([this] {
      for (;;) {
        std::function<void()> task;

        {
          /// 获取同步锁
          std::unique_lock<std::mutex> lock(this->queue_mutex);
          /// 阻塞等待获取任务，直到任务队列不为空
          this->condition.wait(
              lock, [this] { return this->stop || !this->tasks.empty(); });
          /// 如果stop标志位为true，且任务列表都执行完毕后，该线程退出
          if (this->stop && this->tasks.empty()) return;
          /// 从任务队列中拿出来一个任务
          task = std::move(this->tasks.front());
          this->tasks.pop();
        }  ///< 这里释放锁

        /// 执行该任务函数
        task();
      }
    });
}

inline ThreadPool::~ThreadPool() {
  {
    std::unique_lock<std::mutex> lock(queue_mutex);
    stop = true;
  }
  /// 在stop位, 置为true后通知所有线程执行一次，然后等待所有线程处理完任务后join()
  condition.notify_all();
  for (std::thread& worker : workers) worker.join();
}

/// @name     enqueue
/// @brief    用于添加任务函数到任务队列中
///
/// @param    f     [in]    任务函数
/// @param    args  [in]    任务函数的入参列表
///
/// @return   取决于任务函数的返回值
///
/// @date     2020-06-27 16:06:30
/// @warning  线程安全
template <class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args)
    -> std::future<typename std::invoke_result<F(Args...)>::type> {
  using return_type = typename std::invoke_result<F(Args...)>::type;

  /// 这里封装一个异步的线程并执行刚刚传入的函数，这个函数通过bind改类型为void()
  auto task = std::make_shared<std::packaged_task<return_type()> >(
      std::bind(std::forward<F>(f), std::forward<Args>(args)...));
  /// 创建一个这个函数的未来的值， 这个未来值不获取就不会进行计算
  std::future<return_type> res = task->get_future();
  {
    std::unique_lock<std::mutex> lock(queue_mutex);

    /// 假如说没有让这个线程停止则继续，否则抛出异常阻止线程池结束后在入列
    if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
    /// 这个封装好的函数放入任务列表中
    tasks.emplace([task]() { (*task)(); });
  }
  /// 通知一个阻塞中的线程，任务队列中有任务了
  condition.notify_one();
  return res;
}

#include <future>
#include <iostream>
#include <string>

bool is_prime(int x)
{
    for (int i = 2; i < x; i++)
    {
        if (x % i == 0)
            return false;
    }
    return true;
}

int main()
{
    /** is_prime(700020007)这个函数调用隐藏于主线程，异步执行 */
    std::future<bool> fut = std::async(is_prime, 700020007);
    std::cout << "please wait";
    std::chrono::milliseconds span(100);
    /** 这个异步调用函数等待100ms，如果没有计算完就继续等待 */
    while (fut.wait_for(span) != std::future_status::ready)
        std::cout << ".";
    std::cout << std::endl;

    /** 计算完毕后，获取函数返回值 */
    std::cout << "final result: " << std::boolalpha << fut.get() << std::endl;

    system("pause");
    return 0;
}

#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <future>

using namespace std::chrono;

std::string fetchDataFromDB(std::string recvData)
{
    //确保函数要5秒才能执行完成
    std::this_thread::sleep_for(seconds(5));

    //处理创建数据库连接、获取数据等事情
    return "DB_" + recvData;
}

std::string fetchDataFromFile(std::string recvData)
{
    //确保函数要5秒才能执行完成
    std::this_thread::sleep_for(seconds(5));

    //处理获取文件数据
    return "File_" + recvData;
}

int main()
{
    //获取开始时间
    system_clock::time_point start = system_clock::now();

    /** 使用std::launch::async，来指定其异步执行 */
    std::future<std::string> resultFromDB = std::async(std::launch::async,
                                                    fetchDataFromDB, "Data");

    //从文件获取数据
    std::string fileData = fetchDataFromFile("Data");

    //从DB获取数据
    //数据在future<std::string>对象中可获取之前，将一直阻塞
    std::string dbData = resultFromDB.get();

    //获取结束时间
    auto end = system_clock::now();

    auto diff = duration_cast<std::chrono::seconds>(end - start).count();
    std::cout << "Total Time taken= " << diff << "Seconds" << std::endl;

    //组装数据
    std::string data = dbData + " :: " + fileData;

    //输出组装的数据
    std::cout << "Data = " << data << std::endl;

    return 0;
}

#include <iostream>       // std::cout
#include <functional>     // std::ref
#include <thread>         // std::thread
#include <future>         // std::promise, std::future

void print_int (std::future<int>& fut)
{
    std::cout << "Enter print_int: " << std::endl;
    int x = fut.get();  ///< 在这里会等待外部std::promise变量set_value进来，否则会一致阻塞在这里
    std::cout << "value: " << x << '\n';
}

int main ()
{
    std::promise<int> prom;                      // 创建一个std::promise变量

    std::future<int> fut = prom.get_future();    // 创建一个std::future变量

    std::thread th1 (print_int, std::ref(fut));  // 创建一个线程执行函数print_int

    std::this_thread::sleep_for(std::chrono::seconds(3));
    prom.set_value (10);                         // 传值进入线程th1

    th1.join();
    system("pause");
    return 0;
}