统一初始化方法

  1. int arr[3]{1,2,3};
  2. vector<int> iv{1, 2, 3};
  3. map<int, string> mp{{1, "a"}, {2, "b"}};
  4. string str{"Hello World"};
  5. int * p = new int[20]{1,2,3};
  7. struct A {
  8.       int i, j; A(int m, int n):i(m), j(n){ }  
  9. };
  10. A func(int m, int n) { return {m, n}; }
  11. int main() {
  12.      A * pa = new A {3, 7};
  13.     return 0;
  14. }

成员变量默认初始值

  1. class B {
  2. public:
  3.     int m = 1234;
  4.     int n;
  5. };
  7. int main() {
  8.     B b;
  9.     cout << b.m << endl; // 1234
  10.     return 0;
  11. }

auto关键字

  1. auto i = 100;    // i 是 int
  2. auto p = new A(); // p 是 A *
  3. auto k = 34343LL; // k 是 longlong
  5. map<string,int,greater<string> > mp;
  6. for(auto i = mp.begin(); i != mp.end(); ++i)
  7.     cout << i->first << "," << i->second;
  8. // i的类型是： map<string, int, greater<string> >::iterator
  10. class A {};
  11. A operator + (int n, const A & a) {
  12.      return a;   
  13. }
  14. template <class T1, class T2>
  15. auto add(T1 x, T2 y) -> decltype(x+y) {
  16.     return x + y;
  17. }
  19. auto d = add(100, 1.5); // d 是 double d = 101.5
  20. auto k = add(100, A()); // k是A类型

decl关键字

求表达式的类型

  1. int i;
  2. double t;
  3. struct A {double x;};
  4. const A * a = new A();
  6. decltype(a)    x1; // x1 is A *
  7. decltype(i) x2; // x2 is int
  8. decltype(a->x) x3; // x3 is double
  9. decltype((a->x)) x4 // x4 is double &

智能指针shared_ptr

image.png

  1. #include <memory>
  2. #include <iostream>
  3. using namespace std;
  5. struct A
  6. {
  7.     int n;
  8.     A(int v = 0) : n(v) {}
  9.     ~A() { cout << n << " destructor" << endl; }
  10. };
  12. int main()
  13. {
  14.     shared_ptr<A> sp1(new A(2)); // sp1托管A(2)
  15.     shared_ptr<A> sp2(sp1);      // sp2也托管A(2)
  16.     cout << "1) " << sp1->n << "," << sp2->n << endl;
  17.     // 输出 1) 2,2
  19.     shared_ptr<A> sp3;
  20.     A *p = sp1.get();              // p 指向 A(2)
  21.     cout << "2) " << p->n << endl; // 输出 2
  23.     sp3 = sp1;                         // sp3也托管A(2)
  24.     cout << "3) " << (*sp3).n << endl; // 输出2
  25.     sp1.reset();                       // sp1放弃托管A(2)
  27.     if (!sp1)                             //  如果sp1没有托管任何指针
  28.         cout << "4) sp1 is null" << endl; // 输出
  30.     A *q = new A(3);
  31.     sp1.reset(q);                    // sp1托管A(3)
  32.     cout << "5) " << sp1->n << endl; // 输出 3
  33.     shared_ptr<A> sp4(sp1);          // sp4托管A(3)
  34.     shared_ptr<A> sp5;
  35.     // sp5.reset(q); 不妥，会导致程序出错
  36.     sp1.reset(); // sp1放弃托管A(3)
  37.     cout << "before end main" << endl;
  38.     sp4.reset();
  39.     cout << "end main" << endl;
  40.     return 0;    // 程序结束，会delete A(2)
  41. }
  42. /******************** 输出
  43.       1) 2,2
  44.     2) 2
  45.     3) 2
  46.     4) sp1 is null
  47.     5) 3
  48.     before end main
  49.     3 destructor
  50.     end main
  51.     2 destructor
  52.  ***********************/

使用注意事项

  1. #include <iostream>
  2. #include <memory>
  3. using namespace std;
  4. struct A{
  5.      ~A( cout << "~A" << endl;)   
  6. };
  7. int main() {
  8.      A * p = new A();
  9.     shared_ptr<A> ptr(p);
  10.     shared_ptr<A> ptr2;
  11.     ptr2.reset(p); // 并不增加ptr中对p的托管计数
  12.     cout << "end" << endl;
  13.     return 0;
  14. }
  15. /***************** 输出
  16.     end
  17.     ~A
  18.     ~A
  19.     之后程序崩溃,因
  20.     p被delete两次
  21. ******************/

nullptr

  1. #include <memory>
  2. #include <iostream>
  3. using namespace std;
  4. int main() {
  5.      int * p1 = NULL;
  6.     int * p2 = nullptr;
  7.     shared_ptr<double> p3 = nullptr;
  8.     if(p1 == p2)
  9.         cout << "equal 1" << endl;
  10.     if(p3 == nullptr)
  11.         cout << "equal 2" << endl;
  12.     if(p3 == p2); // error 对象类型不同
  13.     if(p3 == NULL)
  14.         cout << "equal 4\n";
  15.     bool b = nullptr; // b = false
  16.     int i = nullptr; // error nullptr不能自动转换为整型
  17. }
  18. /******************* 输出
  19.     equal 1
  20.     equal 2
  21.     equal 4
  22. ********************/

基于范围的for循环

注意 for 中参数类型是否写引用

  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  5. struct A
  6. {
  7.     int n;
  8.     A(int i) : n(i) {}
  9. };
  11. int main()
  12. {
  13.     int ary[]{1, 2, 3, 4, 5};
  14.     for (int &e : ary)
  15.         e *= 10;
  16.     for (int e : ary)
  17.         cout << e << ",";
  18.     cout << endl;
  19.     vector<A> st(ary, ary + 5);
  20.     for (auto &it : st)
  21.         it.n *= 10;
  22.     for (A it : st)
  23.         cout << it.n << ",";
  24.     cout << endl;
  25.     return 0;
  26. }
  27. /******************** 输出    
  28.     10,20,30,40,50,
  29.     100,200,300,400,500,
  30. *********************/

右值引用和move语义

image.png

  1. #include <iostream>
  2. #include <string>
  3. #include <cstring>
  4. using namespace std;
  6. class String
  7. {
  8. public:
  9.     char *str;
  10.     String() : str(new char[1]) { str[0] = 0; }
  11.     String(const char *s)
  12.     {
  13.         str = new char[strlen(s) + 1];
  14.         strcpy(str, s);
  15.     }
  16.     String(const String &s)
  17.     {
  18.         cout << "copy constructor called\n";
  19.         str = new char[strlen(s.str) + 1];
  20.         strcpy(str, s.str);
  21.     }
  22.     String &operator=(const String &s)
  23.     {
  24.         cout << "copy operator= called\n";
  25.         if (str != s.str)
  26.         {
  27.             delete[] str;
  28.             str = new char[strlen(s.str) + 1];
  29.             strcpy(str, s.str);
  30.         }
  31.         return *this;
  32.     }
  33.     // move constructor
  34.     String(String &&s) : str(s.str)
  35.     {
  36.         cout << "move constructor called\n";
  37.         s.str = new char[1];
  38.         s.str[0] = 0;
  39.     }
  40.     // move assignment
  41.     String &operator=(String &&s)
  42.     {
  43.         cout << "move operator= called\n";
  44.         if (str != s.str)
  45.         {
  46.             delete[] str;
  47.             str = s.str;
  48.             s.str = new char[1];
  49.             s.str[0] = 0;
  50.         }
  51.         return *this;
  52.     }
  53.     ~String() { delete[] str; }
  54. };
  56. template <class T>
  57. void MoveSwap(T &a, T &b) // 有意的避免深拷贝
  58. {
  59.     T tmp(move(a)); // std::move(a)为右值，这里会调用 move constructor
  60.     a = move(b);    // move(b)为右值，因此这里会调用 move assignment
  61.     b = move(tmp);  // move(tmp)为右值，因此这里会调用 move assignment
  62. }
  64. int main()
  65. {
  66.     // String &r = String("this"); // error
  67.     String s;
  68.     s = String("ok"); // String("ok")是右值
  69.     cout << "******" << endl;
  70.     String &&r = String("this");
  71.     cout << r.str << endl;
  72.     String s1 = "hello", s2 = "world";
  73.     MoveSwap(s1, s2);
  74.     cout << s2.str << endl;
  76.     return 0;
  77. }
  78. /**************** 输出
  79.     move operator= called
  80.     ******
  81.     this
  82.     move constructor called
  83.     move operator= called
  84.     move operator= called
  85.     hello    
  86. *****************/

image.png

可移动但不可复制的对象

  1. struct A {
  2.      A(const A & a) = delete;
  3.     A(const A && a) {cout << "move" << endl;}
  4.     A() {};
  5. };
  6. A b;
  7. A func() {
  8.      A a;
  9.     return a;
  10. }
  11. void func2(A a) {}
  13. int main() {
  14.     A a1;
  15.     A a2(a1); // compile error
  16.     func2(a1); // compile error
  17.     func();
  18.     return 0;
  19. }

无序容器（哈希表）

跟 map 的完全一样，只是底层使用的哈希表实现

  1. #include <iostream>
  2. #include <unordered_map>
  3. #include <string>
  4. using namespace std;
  6. int main()
  7. {
  8.     unordered_map<string, int> turingWinner; // 图灵奖获奖名单
  9.     turingWinner.insert(make_pair("Dijkstra", 1972));
  10.     turingWinner.insert(make_pair("Scott", 1976));
  11.     turingWinner.insert(make_pair("Wilkes", 1967));
  12.     turingWinner.insert(make_pair("Hamming", 1968));
  13.     turingWinner["Ritchie"] = 1983;
  15.     string name;
  16.     cin >> name;
  17.     unordered_map<string, int>::iterator p = turingWinner.find(name);
  18.     if (p != turingWinner.end())
  19.         cout << p->second;
  20.     else
  21.         cout << "Not found.\n";
  23.     return 0;
  24. }

正则表达式

  1. #include <iostream>
  2. #include <regex>
  3. using namespace std;
  5. int main()
  6. {
  7.     regex reg("b.?p.*k");
  8.     cout << regex_match("bopggk", reg) << endl;   // 输出1，表示匹配成功
  9.     cout << regex_match("boopgggk", reg) << endl; // 输出0，表示匹配失败
  10.     cout << regex_match("b pk", reg) << endl;     // 输出1，表示匹配成功
  11.     regex reg2("\\d{3}([a-zA-z]+).(\\d{2}|N/A)\\s\\1");
  12.     string correct = "123Hello N/A Hello";
  13.     string incorrect = "123Hello 12 hello";
  14.     cout << regex_match(correct, reg2);   // 输出1，匹配成功
  15.     cout << regex_match(incorrect, reg2); // 输出0 匹配失败
  16.     return 0;
  17. }

lambda表达式

image.png

  1. #include <iostream>
  2. using namespace std;
  4. int main()
  5. {
  6.     int x = 100, y = 200, z = 300;
  7.     cout << [](double a, double b) { return a + b; }(1.2, 2.5) << endl;
  8.     auto ff = [=, &y, &z](int n) {
  9.         cout << x << endl;
  10.         y++;
  11.         z++;
  12.         return n * n;
  13.     };
  14.     cout << ff(15) << endl;
  15.     cout << y << "," << z << endl;
  17.     return 0;
  18. }
  19. /****************** 输出
  20.     3.7
  21.     100
  22.     225
  23.     201,301
  24. *******************/
  1. #include <iostream>
  2. #include <algorithm>
  3. using namespace std;
  5. int main()
  6. {
  7.     int a[4] = {4, 2, 11, 33};
  8.     sort(a, a + 4, [](int x, int y) -> bool { return x % 10 < y % 10; });
  9.     for_each(a, a + 4, [](int x) { cout << x << " "; });
  11.     return 0;
  12. }
  13. /************ 输出
  14.     11 2 33 4
  15. *************/
  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4. using namespace std;
  6. int main()
  7. {
  8.     vector<int> a{1, 2, 3, 4};
  9.     int total = 0;
  10.     for_each(a.begin(), a.end(), [&](int &x) { total += x; x *= 2; });
  11.     cout << total << endl; // 输出 10
  12.     for_each(a.begin(), a.end(), [](int x) { cout << x << " "; });
  14.     return 0;
  15. }
  16. /************** 输出
  17.     10
  18.     2 4 6 8
  19. ***************/

image.png