struct Cars {
  int carnum;
  int price;
  string name;
};
struct cmp {
  bool operator()(Cars& c1, Cars& c2) {
    return c1.price < c2.price;
  }
};
bool cmp2(const Cars& c1, const Cars& c2) {
  return c1.price < c2.price;
}
int main() {
  auto fun = [] {};   //这个是最为简单的lambda表达式啥都不干
  fun();          //调用, 使用方式像极了无参仿函数调用
  auto add = [](double a, double b)->double { return a + b; };
  cout << add(2.7, 3.7) << endl;
  //然后是常用方式:  代替 仿函数使用
  Cars cars[] = { 
    {100, 150000, "长城"}
  , {55, 20000, "宝马摩托"}
  , {455, 1000, "小电瓶"}
  , {1000, 500, "自行车"}};
  //形式1:
  sort(cars, cars + sizeof(cars) / sizeof(Cars)
    , [](Cars& c1, Cars& c2)->bool {return c1.price < c2.price; });
  //形式2:
  sort(cars, cars + sizeof(cars) / sizeof(Cars), cmp());  //传入匿名可调用对象
  //形式3:
  sort(cars, cars + sizeof(cars) / sizeof(Cars), cmp2); //传入函数指针
  return 0;
}

struct Cars {
  int carnum;
  int price;
  string name;
  bool operator<(Cars& c) const {
    return price < c.price;
  }
};
int main() {
  Cars cars[] = {
    {100, 150000, "长城"}
  , {55, 20000, "宝马摩托"}
  , {455, 1000, "小电瓶"}
  , {1000, 500, "自行车"} };
  sort(cars, cars + sizeof(cars) / sizeof(Cars));
  return 0;
}

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(int i=0;i<tokens.size();i++){
            if(tokens[i]=="+"||tokens[i]=="-"||tokens[i]=="*"||tokens[i]=="/"){
                int rhs=st.top();
                st.pop();
                int lhs=st.top();
                st.pop();
                switch(tokens[i][0]){
                    case '+':st.push(lhs+rhs);break;
                    case '-':st.push(lhs-rhs);break;
                    case '*':st.push(lhs*rhs);break;
                    case '/':st.push(lhs/rhs);break;
                }
                continue;
            }
            st.push(stoi(tokens[i]));         
        }
        //然后就是最后的结果了
        return st.top();
    }
};

class Solution {
    //使用包装器进行复用???  如何利用包装器??
    //需要的是 function 和  对应的 op 对应起来...
    //如何对应 使用的就是map 对应  map<string, function<int(int, int) > > opmap
    //逆波兰表达式:  左 右 op
    //遇到 op 的时候 说明前面的就是 l + r
    //每一个运算结果需要重新入栈
public:
    int evalRPN(vector<string>& tokens) {
        stack<int > numst;
        map<string, function<int(int, int) > > opmap = {
            {"+", [](int a, int b)->int{ return a + b;}} ,
            {"-", [](int a, int b)->int{ return a - b;}} ,
            {"*", [](int a, int b)->int{ return a * b;}} ,
            {"/", [](int a, int b)->int{ return a / b;}} 
        };
        for (auto& e : tokens) {
            if (e == "+" || e == "-" || e == "*" || e == "/") {
                int r = numst.top(); numst.pop();
                int l = numst.top(); numst.pop();       //先提取的是r 后 l
                numst.push(opmap[e](l, r));
            } else {
                numst.push(stoi(e));
            }
        }
        return numst.top();
    }
};

int main() {
  size_t n = 100;
  thread t1([n]{
    for (size_t i = 0; i < n; i += 2) {
      cout << i << endl;
    }
  });
  cout << t1.get_id() << endl;    //线程id  
  thread t2([n]{
    for (size_t i = 1; i < n; i += 2) {
      cout << i << endl;
    }
  });
  cout << t2.get_id() << endl;    //线程id  
  t1.join();
  t2.join();      //主线程阻塞等待子线程的死亡
  while (1);      //等待他们结束
  return 0;
}

void TFun() {
  cout << "函数指针" << endl;
}
struct TF {
  void operator()() {
    cout << "函数对象" << endl;
  }
};
int main() {
  thread t1(TFun);    //传入函数指针
  TF tf;
  thread t2(tf);      //可调用对象(仿函数)
  thread t3([]() {cout << "Lambda" << endl; });
  t1.join();
  t2.join();
  t3.join();              //join 主线程挂起等待三个线程结束返回
  return 0;
}

// RAII
namespace tyj
{
  template<class Lock>
  class lock_guard
  {
  public:
    lock_guard(Lock& lock)
      :_lock(lock)
    {
      _lock.lock();
      cout << "加锁" << endl;
    }
    /*void lock()
    {
    _lock.lock();
    }
    void unlock()
    {
    _lock.unlock();
    }*/
        //对于lock_guard是没有上述操作的, 它仅仅只是做垃圾回收
        //出作用域自动回收锁, 调用析构解锁
    ~lock_guard()
    {
      _lock.unlock();
      cout << "解锁" << endl;
    }
    lock_guard(const lock_guard<Lock>& lock) = delete;
  private:
    Lock& _lock;
  };
}

int main() {
  mutex mtx;    //定义锁 为后面的完成要求做准备
  bool flag = 1;//flag = 1 打印偶数  flag = 0 打印奇数 配合 condion_variable使用
  condition_variable _cond; //定义条件变量为后序相互耦合关联式打印埋伏笔
  thread t1([&](){
    unique_lock<mutex> _lock(mtx);
    int i = 0;
    while (i < 100) {
      while (!flag) _cond.wait(_lock);//不满足flag 一直等
      //说明满足了
      cout << "i: " << i << endl;
      flag = 0;      //修改让t2去打印
      _cond.notify_one();//唤醒t2打印奇数了
      i += 2;
    }
  });
  thread t2([&](){
    unique_lock<mutex> _lock(mtx);
    int j = 1;
    while (j < 100) {
      while (flag) _cond.wait(_lock);//满足flag 说明这个时候在打印偶数
      //说明满足了
      cout << "j: " << j << endl;
      flag = 1;      //修改让t2去打印
      _cond.notify_one();//唤醒t2打印奇数了
      j += 2;
    }
  });
  t1.join();
  t2. join();
  return 0;
}