逐个使用C++11新特性

C++11

auto & decltype

auto：根据变量初始值来推导变量类型，并用右值初始化变量。

 int main()
 {
     map<string, vector<string>> family;
     family.insert(pair<string, vector<string>>("陈", {"澄", "尘"}));
     family.insert(pair<string, vector<string>>("朱", {"珠", "茱"}));
     for(const auto &mp : family)
     {
         cout << mp.first << endl;
         for(const auto &str : mp.second)
             cout << str << "  ";
         cout << endl;
     }
     return ;
 }

decltype：从表达式推导出类型，并将变量定义为该类型，但不用表达式的值初始化该变量。

这里要注意下：decltype(i)--是i的类型，而decltype((i))就是引用了。就像上面例子中的x 就是int &x;

右值引用

新标准在拷贝构造函数、拷贝赋值运算符和析构函数之外，还增加了移动构造函数和移动赋值运算符，而这二位就需要右值引用的支持。

1. 延长将亡值的生命。

     //右值引用
     int a = ;
     int &b = a;
     int &&bb = ;//右值引用只能绑定将亡值
     //int &&bb = a;//错，a是左值（持久值）
     a = std::move(bb);//右值引用移动

     cout << "引用：" << b << endl;
     cout << "右值引用：" << bb << endl;
     cout << "移动： " << a << endl;  
　　　　

　　&&bb = 999;//错，类似左值引用，不可二次赋值
　　&b = 888;//错

我们居然输出了89，要知道，右值只是临时量，用完就扔的。

2. 用于移动(构造)函数

 #include <iostream>
 #include <vector>
 #include <algorithm>
 using namespace std;

 class test
 {
 public:
     test();
     ~test();
　　　　void push(const int& i);
     void push(int&& i)
     {
         bar = std::move(i);//std::move(右值引用)实现移动
     }
 private:
     int bar;
 };

 int main()
 {
     int a = ;
     test t;
     t.push();
     //t.push(a);错误无法将右值绑定到左值

     return ;
 }

范围for循环

统计字符

     string str = "No pain, no gain! Everyone need to struggle for himself.";
     decltype(str.length()) count = , count1 =;
     for (auto i : str)
         if (ispunct(i))
             ++count;
         else
             ++count1;
     cout << "字符串长度：" << str.size() << endl;
     cout << "标点字符的个数：" << count << endl;
     cout << "其他字符的个数：" << count1 << endl;

改写字符

 #include <iostream>
 #include <string>
 using namespace std;

 int main()
 {
     string str("No pain, no gain! Everyone need to struggle for himself.");
     cout << str << endl;

     for (auto &c : str)
         c = toupper(c);//小写换大写

     cout << str << endl;;
     return ;
 }

去除字符

//去除标点 1 
#include <iostream>
 #include <string>
 using namespace std;

 int main()
 {
     string input, res = "";
     while (cin >> input)
     {
         for (auto c : input)
             if (!ispunct(c))
                 res += c;
         cout << res << endl;
         res = "";
     }
 }

智能指针

std::unique_ptr

std::weak_ptr & std::shared_ptr

lambda表达式·λ

先看它怎么用

例1

     //惯用法
     //[捕获外部变量](参数列表)->返回类型{ 函数体（别忘记";"）}
     auto str = "I want you!";
     auto f = [](string str)->int { return str.size(); };
     cout << f(str) << endl;

     int m = ;
     //捕获参数---值捕获
     auto getValue = [m] {cout << m << endl; };
     getValue();
     //捕获参数---引用捕获
     auto getValue1 = [&m] {cout << m << endl; };
     getValue1();

     //捕获参数---隐式值捕获
     auto getValue2 = [=] {cout << m << endl; };
     getValue2();

     //捕获参数---隐式引用捕获
     auto getValue3 = [&] {
         cout << m << endl;
         cout << "修改：" << ++m << endl;
     };
     getValue3();

     int num[] = { , , , ,  };
     sort(num, num + , [](const int a, const int b) ->bool {return a > b; });

     for (auto i : num)
         cout << i << " ";    

例子补充：

 int main()
 {
     //lambda表达式
     //1.标准写法[捕获函数内局部变量列表] (传入参数列表) ->return type {function body;} ;
     auto fc = []()->int {
         return ;
     };
     cout << "1.标准写法\n" << fc() << endl;

     //2.带传参数
     auto f = [](int a, int b) {
         return a + b;
     };
     cout << "2.带传参数\n" << f(, ) << endl;

     //3.捕获变量值
     int param = ;
     auto ff = [param](int b){
         return param + b;
     };
     cout << "3.捕获变量值\n" << ff() << endl;

     //4.捕获变量引用
     int param2 = ;
     auto ff2 = [&param2](int b){
         param2 += ;
         return param2 + b;
     };
     cout <<  "4.捕获变量引用\n" <<ff2() << endl;
     cout << param2 << endl;

     //4.当作算法函数谓词,例修改sort排序降序
     vector<int> vec = {, , , , , };
     sort(vec.begin(), vec.end(), [](int a, int b){ return a > b;});
     for(auto i : vec)
         cout << i << "  ";

     //隐式引用捕获：即默认局部变量都是引用类型，可以在λ体内修改，也可以在参数捕获列表中指定某些参数只是值捕获，否则全部默认引用捕获
     string str = "lambda";
     string str2 = " is good candy!";
     auto addStr = [&]{
         str = "lambda really";
         return str + str2;
     };
     cout << addStr() << "  " << str << endl;
     return ;
 }

它的优势在哪里？又或者说为什么要用它呢？

再看一个例子

例2

 　　 //多线程
     for (int i = ; i < ; ++i)
     {
         std::thread t([i] { cout << i << endl; });//<thread>
         t.detach();
     }

从上面的多个例子看来，我们可以很方便的实现“函数内的函数定义和使用”，即函数嵌套【例1】，这样一来就不用再在外部定义函数，然后才能使用【例2】。甚至，它连函数名都可以不要，就像上面的sort函数中的用法一样。极大的简化了我们的代码，可读性也增强了许多，不用再回到定义处推敲了。