详解C++之C++11的牛逼特性

 int array1[] = {1,2,3,4,5}; int array2[] = {0};

 vector v{1,2,3,4,5};

 // 内置类型 int x1 = {10}; int x2{10} // 数组 int arr1[5] {1,2,3,4,5} int arr2[]{1,2,3,4,5}; // 标准容器 vector v{1,2,3} map m{{1,1},{2,2}} // 自定义类型 class Point { int x; int y; } Power p{1,2};

 #include template class Vector{ public: Vecto(initializer_list l) :_capacity(l.size()) ,_size(0){ _array = new T[_capacity]; for(auto e : l) _array[_size++] = 3; } private; T* _array; size_t _capacity; size_t _size; };

 // 不使用auto需要写很长的迭代器的类型 map m; map::iterator it1 = m.begin(); // 使用auto就很简单 auto it2 = m.begin();

 template T1 Add(const T1& a,const T2& b){ return a + b; }

 // 推演表达式作为变量的定义类型 int a = 1,b=2; decltype(a+b) c; cout<

 vector v{1,2,3,4,5}; for(const auto& e : v) cout<

 class Info { public; Info() :_type(0) ,_name('s') {} Info(int type) :_type(type) ,_name('a') {} Info(char a) :_type(0) ,_name(a) {} pirvate; int _type; char _name; };

 class Info { // 目标构造函数 public: Info() :_type(0) ,_a('a') {} // 委派构造函数 Info(int type) :Info() { _type = type; } private; int _type = 0; char _a = 'a'; };

 class A { public: A(int a) :_a(a) {} A() = default; // 显式缺省构造函数 A& operator=(const A& a); // 在类中声明，在类外定义时，让编译器生成默认赋值运算符重载 private: int _a; }; A& A::operator=(const A& a) = default;

 class A { A(int a) :_a(a) {} A(constA&) = delete; // 禁止编译器生成默认的拷贝构造函数 private: int _a; };

 class String { public: String(char* str = '") { if(str == nullptr) _str = ""; _str = new char[strlen(str)+1]; strcpy(_str,str); } String(const String& s) :_str(new char[strlen(c._str)+1]) { strcpy(_str,s._str); } ~String() { if(_str) delete[] _str; } private: char* _str; }; String GetString(char* pStr) { String strTemp(pStr); return strTemp; } int main() { String s1("hello"); String s2(GetString("world")); return 0; }

 String&& GetString(char* pStr) { String strTemp(pStr); return strTemp; } int main() { String s1("hello"); String s2(GetString("world")); return 0; }

 String GetString(char* pStr) { return String(pStr); } int main() { String&& s = GetString("hello"); return 0; }

 int a = 10; int&& a1; // 未初始化，编译失败 int&& a2 = a; // 编译失败，a是一个左值 // 左值是可以改变的值

 Object() Object(const T&) Object(T&&)

 String(const String&&); const String GetString();

 class String { public: String(char* str = "") { if(str == nullptr) str = ""; _str = new char[strlen(str)+1]; strcpy(_str,str); } // 拷贝构造 // String s(左值对象) String(const String& s) :_str(new char[strlen(s._str) + 1]) { strcpy(_str,s_str); } // 移动构造 // String s(将亡值对象) String(String&& s) :_str(nullptr) { swap(_str,s._str); } // 赋值 String& operator=(const String& s) { if(this != &s) { char* tmp = new char[strlen(s._str)+1]; stcpy(tmp,s._str); delete[] _str; _str = tmp; } return *this; } // 移动赋值 String& operator=(String&& s) { swap(_str,s._str); return *this; } ~String() { if(_str) delete[] _str; } // s1 += s2 体现左值引用，传参和传值的位置减少拷贝 String& operator+=(const String& s) { // this->Append(s.c_str()); return *thisl } // s1 + s2 String operator+(const String& s) { String tmp(*this); // tmp.Append(s.c_str()); return tmp; } const char* c_str() { return _str; } private: char* _str; }; int main() { String s1("hello"); // 实例化s1时会调用移动构造 String s2("world"); String ret ret = s1 + s2 // +返回的是临时对象，这里会调用移动构造和移动赋值，减少拷贝 vector v; String str("world"); v.push_back(str); // 这里调用拷贝构造函数 v.push_back(move(str)); // 这里调用移动构造，减少一次拷贝 return 0; }

 void Func(int x) { // ...... } template void PerfectForward(T t) { Fun(t); }

 void Fun(int &x){cout << "lvalue ref" << endl;} void Fun(int &&x){cout << "rvalue ref" << endl;} void Fun(const int &x){cout << "const lvalue ref" << endl;} void Fun(const int &&x){cout << "const rvalue ref" << endl;} template void PerfectForward(T &&t){Fun(std::forward(t));} int main() { PerfectForward(10); // rvalue ref int a; PerfectForward(a); // lvalue ref PerfectForward(std::move(a)); // rvalue ref const int b = 8; PerfectForward(b); // const lvalue ref PerfectForward(std::move(b)); // const rvalue ref return 0; }

 vector v{1,4,3,2,7,6,5}; // 默认按照小于比较，结果是升序 sort(v.begin(),v.end()); // 传入第三个模板参数std::greater(),按照大于比较，默认是降序 sort(v.begin(), v.end(),greater());

 int main() { // 最简单的lambda表达式 []{}; // 省略参数列表和返回值类型,返回值类型有编译器推演为int int a=3,b=4; [=]{return a+3;}; // 省略返回值类型 auto fun1 = [&](int c){b = a + c;}; // 各部分完整的lambda函数 auto fun2 = [=,&b](int c)->int(return += a + c;); // 复制捕捉x int x = 10; auto add_x = [x](int a)mutable{x *= 2; return a + x;}; return 0; }

 a [var]:表示值传递方式捕获变量var b [=]:表示值传递方式捕获所有父作用域中的变量(包括this) c [&var]:表示引用传递变量var d [&]:表示引用传递捕获所有父作用域中的变量(this) e [this]：表示值传递方式捕获当前的this指针

 a 父作用域包含lambda函数的语句块 b 语法上捕获列表可由多个捕获项组成，并以逗号分隔 比如：[=,&a,&b]：以引用传递的方式捕获变量a 和 b，值传递的方式捕获其它所有变量. [&,a,this]；值传递的方式捕获变量a和this，引用方式捕获其它变量。 捕捉列表不允许变量重复传递，否则会导致编译错误。比如：[=,a]以传值的方式捕获了所有变量，又重复捕捉a c 块作用域以外的lambda函数捕捉列表必须为空 e 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错 f lambda表达式之间不能相互赋值，即使看起来类型相同.

 void (*PF)(); int main() { auto f1 = []{cout<<"hello world"<

 typedef bool (*GTF) (int, int); bool greater_func1(int l, int r) { return l > r; } struct greater_func2 { bool operator()(int l, int r) { return l > r; } }; int main() { // 函数指针 GTF f1 = greater_func1; // typedef 定义 // bool (*f1) (int, int) = greater_func1; // 不typedef ,直接原生写法，可读性差 cout<< f1(1,2)<bool{return l > r;}; cout<< f3(1,2)< void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp); return 0; }

 struct Goods { string _name; double _price; double _appraise; }; int main() { Goods gds[] = { { "苹果", 2.1, 10 }, { "相交", 3, 8 }, { "橙子", 2.2, 7 }, { "菠萝", 1.5, 10 } }; sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& g1, const Goods& g2)->bool {return g1._price > g2._price; }); sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& g1, const Goods& g2)->bool {return g1._appraise > g2._appraise; }); return 0; }

 class Rate { public: Rate(double rate) : _rate(rate) {} double operator()(double money, int year) { return money * _rate * year; } private: double _rate; }; int main() { // 函数对象 double rate = 0.49; Rate r1(rate); r1(10000, 2); // 仿函数 auto r2 = [=](double monty, int year)->double{return monty*rate*year; }; r2(10000, 2); return 0; }

 #include #include void fun() { std::cout << "A new thread!" << std::endl; } int main() { std::thread t(fun); t.join(); std::cout << "Main thread!" << std::endl; system("pause"); return 0; }

 // 使用lambda表达式作为线程函数创建线程 int main() { int n1 = 1; int n2 = 2; std::thread t([&](int addNum){n1 += addNum; n2 += addNum; }, 3); t.join(); std::cout << n1 << " " << n2 << std:: endl; system("pause"); return 0; }

 int main() { int n1 = 1; int n2 = 2; std::thread t([&](int addNum){n1 += addNum; n2 += addNum; }, 3); std::cout << "join before,joinable=" << t.joinable() << std::endl; t.join(); std::cout << "join after,joinable=" << t.joinable() << std::endl; system("pause"); return 0; } // 执行结果： join before,joinable=1 join after,joinable=0

 int main() { int n1 = 1; int n2 = 2; std::thread t([&](int addNum){n1 += addNum; n2 += addNum; }, 3); std::cout << "join before,joinable=" << t.joinable() << std::endl; t.detach(); std::cout << "join after,joinable=" << t.joinable() << std::endl; system("pause"); return 0; }

 int sum = 0; void fun(size_t num) { for (size_t i = 0; i 

 int sum = 0; std::mutex m; void fun(size_t num) { for (size_t i = 0; i 

 #include #include #include std::atomic_int sum{ 0 }; void fun(size_t num) { for (size_t i = 0; i