C++11

auto
auto不能作为函数的参数,后续C++20 可以了
auto 不能作用于类的非静态成员变量
auto 关键字不能定义数组
auto 不能作用于模板参数

std::less<int> ()用法

auto lessFun = std::less<int>(); //是struct 对象，重载了()作为比较函数
    bool bRes = lessFun(1, 8);
    int foo[]={10,20,5,15,25};
    std::sort (foo, foo+5, std::less<int>());  // 5 10 15 20 25
    for(int i = 0; i< 5; i++)
    {
        std::cout << "value:"<<foo[i]<<std::endl;
    }

//bind1st 把 x 作为 fn 的第一个参数，bind2nd 把 x 作为 fn 的第二个参数
  //这里把10作为less()的第二个参数，11是第一个参数 
  auto is_large_ten = std::bind2nd(std::less<int>(), 10);
  bool bRes = is_large_ten(11);

std::thread

#include <thread>
#include <exception>
#include <mutex>
#include <random>


void ReqTestFun(int i) 
{
  cout << "will mutex" << endl;

  //std::mutex myMutex; 
  //try 
  //{
  //  myMutex.lock();
  //}
  //catch(std::exception& e)
  //{
  //  cout << "catch" << endl;
  //} 
  //myMutex.unlock();
  
  CHttpRequest httpRequest("http://127.0.0.1:8080/spaces");
  string strResData;
  char szMsg[1024] = { '\0' };
  sprintf_s(szMsg, "{\"age\" : \"%d\"}", i);
  httpRequest.PostData(szMsg, strResData);
  
};

int main()
{
  InitHttp();
  for (int i = 0; i < 50; i++)
  {
    std::thread thReqTest(ReqTestFun, i);
    thReqTest.join(); //不join的话，会有异常
  }
  
  //ReqTestFun(5);
  char chIn;
  cin >> chIn;
}

单例模式线程安全

在c++11中，static静态类对象在执行构造函数进行初始化的过程是线程安全的

g++ hello.cpp -o hello -std=c++11 -lpthread
 

#include <thread>
#include <exception>
#include <mutex>
#include <random>
#include <iostream>
#include <windows.h>
using namespace std;


void ReqTestFun(int i)
{
  cout <<i <<  " will mutex" << endl;
  Sleep(3000000);
  cout << i << " end mutex" << endl;

  //std::mutex myMutex; 
  //try 
  //{
  //  myMutex.lock();
  //}
  //catch(std::exception& e)
  //{
  //  cout << "catch" << endl;
  //} 
  //myMutex.unlock();



};

int main()
{
  
  for (int i = 0; i < 50; i++)
  {
    std::thread thReqTest(ReqTestFun, i);
    thReqTest.detach(); //不join的话，会有异常
  }

  //ReqTestFun(5);
  char chIn;
  cin >> chIn;
}

std::move

并不能进行深拷贝， 原对象不再被使用，如果对其使用会造成不可预知的后果。

智能指针（不要混合使用普通指针和智能指针）

unique_ptr

void Unique_Test()
{
  unique_ptr<Device> upDev(new Device);
  upDev->m_strName = "xiaoming";
  upDev->InitDevice();
  unique_ptr<Device> upOther = move(upDev); //upDev会被置空empty
  upOther->m_strName = "xiaozhang";

  //Device* pDev = upDev.release(); //不会释放原来对象, 对象自己手动释放了，否则内存泄漏
  //upDev.reset(); //会释放原来对象
  //Device* pDev = upDev.get();
  //pDev->m_strName = "xiaozhang";
}

lambda表达式

mutable：默认情况下，lambda函数总是一个const函数，捕捉的传值参数具有常性，mutable可以取消常性。使用mutable修饰符时，参数列表不能省略，即使参数为空

void TestLambda() {
  //最简单的lambda,没有参数,()和 -> 返回值,mutable都可以省略
  auto fun0 = [] {
    cout << "测试" << endl;
  };
  fun0();
  int x = 100;
  int y = 50;

  auto fun1 = [&x, y] ()  -> int {
    x += 1;
    return 0;

  };
  fun1();

  auto fun2 = [x, y]() mutable -> int {
    x += 1; //必须加mutable
    return 0;

  };
  fun2();

}