10 C++11

1、类型推导

1.1 auto关键字

• C++98中，auto表示栈变量，通常省略不写

void foo(void){int i;auto int j;//表示在栈里分配的
}

• C++11中，给auto赋予新的语义，表示自动类型推导
  • 既根据对变量进行初始化时所使用的数据的类型，由编译器自动推导出所定义变量的实际类型

auto i=0; -> int j=10;
auto j=i; -> int j=i;

1.2 auto类型推断本质

·按照定义独立对象并根据初始化数据的类型进行推导。
注意：无法自动推断const,只能自己在auto的上下文显示指明。但是有两种情况是除外的：
1：如果给出的初始化数据类型为常量指针，则可以自动推导出const
2：auto与引用的联合联用
- 按照定义独立对象并根据初始化数据的类型进行推导，所以不可能推导出引用
- 除非auto的上下文指明按照引用推导若指明按引用推导并且目标带有常属性，则可以自动推导const

/*类型推导  
linux 默认是c98标准的，如果需要编译的话需要添加 -std=c++11 
类型推导绝对不是类型照抄
*/
int main(){int a = 10;auto c = a;cout << "c的类型" << typeid(c).name() << endl;// typeid无法获取到对象的常属性c++;// 允许更改，说明不被const修饰cout <<"&c:"<< &c <<"&a:"<< &a << endl;const int b = 20;auto d = b;cout << "d的类型" << typeid(d).name() << endl;cout << "&d:" << &d<< "&b:" << &b << endl;d++;// 允许更改，说明不带constconst auto e = b;// 自己在auto上添加constcout << "e的类型" << typeid(e).name() << endl;cout << "&e:" << &e << "&d:" << &d << endl;// e++;// 不允许更改，说明带constauto f = &b;// 如果初始化数据的类型为常指针，则可以自动推导出constcout << "f的类型为：" << typeid(f).name() << endl;// *f = 888; // *f不允许更改f = NULL; // f是可以更改，说明推导出来的类型是 const int *return 0;
}
/*类型推导和引用的联合使用*/
int main(){int a = 10;const int b = 10;auto & d = a;cout << "d的类型" << typeid(d).name() << endl; cout << "&d:" << &d << "&a:" << &a << endl; // 地址相同，说明是别名d++;auto&e = b; // 这里指明了e是引用推导，并且b带有常属性，则可以自动推导出constcout << "e的类型" << typeid(e).name() << endl;cout << "&e:" << &e << "&b:" << &b << endl;// // 地址相同，说明是别名//e++; // 出错，说明不能更改 那么e的类型为const int &return 0;
}

• auto关键字的使用限制
  • 1：函数形参类型无法推导(C++14标准支持)。
  • 2：类的成员变量无法推导。

void foo(auto v){}

2、类型计算

2.1 类型计算分类

c语言：sizeof-计算类型的大小
C++语言：typeid-可以获取类型的信息字符串
C++11:decltype-获取参数表达式的类型
注意事项：类型推导和类型计算都是由编译器确定，并不是运行期确定

/*类型计算*/
int main(){const int a = 10;auto  b = a; // 类型推导cout << "b的类型" << typeid(b).name() << endl; cout << "&b:" << &b << "&a:" << &a << endl; b++;// 允许更改，所以推导出来的类型是intdecltype(a)c = 100;// 类型计算 初始值可以设置和a不一样cout << "c的类型" << typeid(c).name() << endl;cout << "&c:" << &c << "&a:" << &a << endl;// // 地址不相同相同// c++; // 出错，说明不能更改 那么c的类型为const int return 0;
}

• 类型推导和类型计算的比较
  1：类型计算比类型推导在类型的确定上更加精准
  2：类型计算比类型推导在初值的确定上更加灵活

2.2 类型计算的四种规则

• 1:如果给decltype传递的为标识符表达式，decltype取该标识符的类型作为最终计算出的类型

int main(){int a = 10;// 如果给decltype传递的为标识符表达式，decltype取该标识符的类型作为最终计算出的类型decltype(a)b = a;// 类型计算cout << "b的类型" << typeid(b).name() << endl;cout << "&b:" << &b << "&a:" << &a << endl;// // 地址不相同b++; // 能更改说明b的类型为 int return 0;
}

• 2：如果给decltype传递的为函数表达式，decltype取该函数的返回值类型作为最终计算出的类型

float foo(){cout << "函数被调用" << endl;return 3.14;
}
int main(){int a = 10;// 如果给decltype传递的为函数表达式，decltype取该函数的返回值类型作为最终计算出的类型decltype(foo())b = a;// 并不会去实际调用foo()函数，类型计算是编译器确定的，不是运行时cout << "b的类型" << typeid(b).name() << endl;cout << "&b:" << &b << "&a:" << &a << endl;// // 地址不相同b++; // 能更改说明b的类型为 float return 0;
}

• 3：如果给decltype传递的为其他表达式，并且表达式的结果为左值，则取该左值引用的类型作为最终计算出的类型

int main(){int a = 10;// 如果给decltype传递的为其他表达式，并且表达式的结果为左值，则取该左值引用的类型作为最终计算出的类型decltype(++a)b = a;cout << "b的类型" << typeid(b).name() << endl;cout << "&b:" << &b << "&a:" << &a << endl;// // 地址相同b++; //允许更改 说明b的类型为int &return 0;
}

• 4:如果给decltype传递的为其他表达式，并且表达式的结果为右值，则取该右值本身的类型作为最终计算出的类型

int main(){int a = 10;// 如果给decltype传递的为其他表达式，并且表达式的结果为右值，则取该右值本身的类型作为最终计算出的类型decltype(a++)b = a;cout << "b的类型" << typeid(b).name() << endl;cout << "&b:" << &b << "&a:" << &a << endl;// // 地址不相同b++; //允许更改 说明b的类型为int return 0;
}

2.3 返回值类型计算

• 返回值类型后置

auto foo(int x, double y)->decltype(x+y){// 返回值类型后置，通过decltype计算得出return  x + y;
}
int main(){auto f = foo(1, 3.1);// 类型推导cout << typeid(f).name() << endl; // double类型return 0;
}

3、列表初始化

基本类型，类类型，结构/联合/枚举类型等等的单个对象或对象数组，都可以采用形式完全统一的列表初始化语法
进行对象的初始化

• 书写形式：类型 对象 {初值表};
  -int a{123);
  -new double {1.23);
  -string c{“123”};
  -struct Student {d,“张飞”,20,{1997,10,10}};
  -float e[]{1.1,2.2,3.3};

struct BD{int m_year;int m_month;int m_day;
};
struct myStudent{string m_name;int m_age;BD m_body;
};
class Human{
public:Human(int age = 0, const char* name = "无名") :m_age(age), m_name(name){}int m_age;string m_name;
};
int main(){int a = { 123 }; // int a=123cout << "a=" << a << endl;double* pa = new double{ 3.14 };// double *pa = new double(3.14);double *pb{ new double{ 3.14 } };cout << "*pa=" << *pa << " *pb=" << *pb << endl;int b[]{1, 2, 3};//int b[] = { 1, 2, 3 };for (int i = 0; i < 3; i++){ cout << b[i] << ' '; }int *parr{ new int[3]{4, 5, 6} };for (int i = 0; i < 3; i++){ cout << parr[i] << ' '; }delete[]parr;myStudent s{ "zs", 22, { 1997, 5, 7 } }; // myStudent s = { "zs", 22, { 1997, 5, 7 } };cout << s.m_name << s.m_age << s.m_body.m_year << s.m_body.m_month << s.m_body.m_day << endl;Human h{ 20, "赵云" };//Human h (20, "赵云" )cout << h.m_age << h.m_name << endl;return 0;
}

• 小括号操作符函数

class AA{
public:int operator()(int x, int y){return x + y;}
};
int main(){AA a;cout << a(100, 200) << endl;;// a.operator()(100,200)
}

4、Lambda表达式

4.1 前置知识

在C++中函数的作用域中可以有类型，也可以有表达式

• 针对于函数内部定义了类型，编译器先编译函数内部的类型，然后在编译函数体本身的代码

int a;
void foo(int b){int c;class A{public:void bar(int d){a = 0;// 能访问// b = 0; // 不能访问// c = 0; // 不能访问d = 0;// 能访问}};
}

4.2 Lambda表达式

• 语法规则：

[捕获表]（参数表）选项->返回类型
{函数体
}

• 使用

int main(void){int a = 10, b = 20;auto c =[](int x, int y)->int{return x > y ? x : y; };// 编译器 (1) 生成一个类  (2) 类内定义一个小括号操作符函数 (3) 返回这个类的匿名对象cout<<c(a,b)<<endl;return 0;
}

• 本质
  lambda表达式本质其实是一个类并且最终返回值为这个类的对象,因此对lambda表达式的调用就是该对象的函数操作符的调用
  

解释：编译器在编译到Lambda表达式时，编译器会生成一个类Z4XXX的类，类中定义一个小括号操作函数，函数体里面填充Lambda的函数体内容，函数的返回值类型为Lambda中定义的返回类型。
其中

• 可以没有返回值类型，将根据return推断

int main(void){int a = 10, b = 20;auto c = [](int x, int y){return x + y; };// 当没有返回值类型时，中间的箭头可以省略cout << c(a, b) << endl;return 0;
}

• 如果连return也没有，则返回值为void

int main(void){int a = 10, b = 20;[](int x, int y){cout<< x + y<<endl; }(a,b);// 如果连return也没有，则返回值为voidreturn 0;
}

• 参数为void可以省略不写的

int main(void){int a = 10, b = 20;[]{cout << "12345" << endl; }();// 如果没有形参，返回值类型也为void那么小括号和中间的剪头都可以省略return 0;
}

4.3 捕获表

• []-不捕获任何外部变量
• [variable]-捕获外部变量的值
• [&variable]-按引用捕获,外部变量的别名
• [this]-捕获this指针，访问外部对象的成员

int a = 10;
class Y{
public:Y(int m_e) :e(m_e){};void foo(int c = 30){cout << "---" << endl;// []-不捕获外部变量的值[](int d = 40){cout << "a=" << a << endl;cout << "b=" << b << endl;// cout << "c=" << c << endl; // 错误cout << "d=" << d << endl;// cout << "e=" << e << endl; // 错误}();cout << "--------------[c]--------" << endl;// [variable]-捕获外部变量只读[c](int d = 0){cout << "c=" << c << endl; }();cout << "--------[&c]---------" << endl;// [&variable]-按引用捕获,外部变量的别名[&c]{c++; cout << "c=" << c << endl; }();cout << c << endl;// [this]-捕获this指针，访问外部对象的成员cout << "--------[this]---------" << endl;[this]{cout << "e=" << e << endl; }();}
private:static int b;int e;
};
int Y::b = 10;int main(){Y y(4);y.foo();return 0;
}

• [=]-按值捕获所有的外部变量，也包括this
• [&]-按引用捕获所有的外部变量，也包括his
• [=,&variable]-按值捕获所有的外部变量包括this,但是指定的外部变量按引用捕获。
• [&,=variable]-按引用捕获所有的外部变量，也包括this,但是指定的外部变量按值捕获。

5、右值引用

5.1 概念

左值引用是别名，右值引用就是真名
左值：可以“取”地址的值就是左值，左值通常具名
右值：不可“取”地址的值就是右值，右值通常匿名
左值细分为非常左值和常左值
- 非常左值：有名字、可以取地址、没有常属性
- 常左值：有名字、可以取地址、有常属性
右值细分为纯右值和将亡值
- 纯右值：有一块无名内存，里面存放了基本类型的数据
- 将亡值：有一块无名内存，里面存放了类类型的数据

5.2 左值引用和右值引用

• 左值引用只能引用左值，不能引用右值
• 右值引用只能引用右值，不能引用左值
• 常左值引用，既能引用左值，也能引用右值
• 常右值引用，完全可以被常左值引用替代

/*左值引用和右值引用的差别*/
int main(){// 左值引用只能引用左值，不能引用右值int a=1, c=2;int & ra = a;// int & rb = a + c; // 错误 左值引用不能引用右值int &&rb = a + c;// 使用右值引用// int &&rc = a;// 错误 右值引用只能引用右值，不能引用左值cout << rb << endl;const int & _l = a; // 引用左值const int & _r = a + c; // 引用右值// 常左值引用会丧失修改目标的权限// _l = 9;// 错误// 右值引用不会丧失修改目标的权限rb = 90;cout << rb << endl;
}

6、移动语义

• 方法：
  资源的转移 代替 资源的重建
• 作用：
  保证功能正确的情况下，做到性能提升

//深拷贝构造函数 资源的重建String(const String & that) :m_psz(new char[strlen(that.m_psz) + 1]){cout << "深拷贝构造 资源的重建" << endl;strcpy(m_psz, that.m_psz); // 没有复制地址，复制了数据(深拷贝)
}
// 深拷贝构造函数 资源的转移 
String(String && that):m_psz(that.m_psz){that.m_psz = NULL;cout << "资源转移" << endl;
}
// 深拷贝赋值函数 资源的重建String& operator=(/*String* this*/const String & that){cout<<"深拷贝赋值函数 资源的重建"<<endl;if (this == &that){}// 防止出现用户自己给自己赋值else{delete[] this->m_psz;// 编译器会先定义一个m_psz，并初始>化为空串，所以需要先释放内存this->m_psz = new char[strlen(that.m_psz) + 1];// 申请新资源strcpy(m_psz, that.m_psz); // 拷贝新内容}return *this;// 返回自引用
}// 拷贝赋值函数 资源的转移
String& operator=(String&& that){cout<<"拷贝赋值函数 资源的转移"<<endl;delete this->m_psz;this->m_psz=that.m_psz;that.m_psz=NULL;return *this;
}
//在linux下 命令行输入：g++ abc.cpp -std=c++11 -fno-elide-constructors
int main(){ String s1=String("hello"); // 深拷贝构造函数 资源的转移String s2=s1;// 拷贝构造函数 资源的重建s2=s1;// 拷贝赋值函数 资源的重建s2=String("hello");// 拷贝赋值函数 资源的转移
}