♠️ 3. 声明

c++11提供了多种简化声明的方式，尤其是在使用模板时。

♥️ 3.1 auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

int main()
{int i = 10;auto p = &i;auto pf = strcpy;//输出p、pf的类型cout << typeid(p).name() << endl;cout << typeid(pf).name() << endl;map dict = { {"sort", "排序"}, {"insert", "插入"} };//map::iterator it = dict.begin();auto it = dict.begin();return 0;
}

♥️ 3.2 decltype

关键字decltype将变量的类型声明为表达式指定的类型

// decltype的一些使用使用场景
template
void F(T1 t1, T2 t2)
{decltype(t1 * t2) ret = t1 * t2;vector v;v.push_back(ret);cout << typeid(ret).name() << endl;
}int main()
{int i = 10;auto p = &i;auto pf = strcpy;decltype(pf) pf1;    //char * (__cdecl*)(char *,char const *)vector v;cout << typeid(p).name() << endl;cout << typeid(pf).name() << endl;return 0;
}

注意：decltype与auto的差别：auto必须要求显式初始化，而decltype没要求

♥️ 3.3 nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

♠️ 4. STL中一些变化

新容器

用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered_map和
unordered_set。其他的大家了解一下即可。

容器中的一些新方法

如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。
比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。

♠️ 5. final 和 override

final

• final修饰类的时候，表示该类不能被继承

class A final //表示该类是最后一个类
{
private:int _year;
};
class B : public A //无法继承
{};

• final修饰虚函数时，这个虚函数不能被重写

class A 
{
public:virtual void fun() final//修饰虚函数{cout << "this is A" << endl;}
private:int _year;
};
class B : public A
{
public:virtual void fun()//父类虚函数用final修饰，表示最后一个虚函数，无法重写{cout << "this is B" << endl;}
};

override

• 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

class A 
{
public:virtual void fun(){cout << "this is A" << endl;}
private:int _year;
};
class B : public A
{
public:virtual void fun() override{cout << "this is B" << endl;}
};

♠️ 6. 右值引用和移动语义

♥️ 6.1 左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，无论左值引用还是右值引用，都是给对象取别名。

• 左值引用

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main()
{// 以下的p、b、c、*p都是左值int* p = new int(0);int b = 1;const int c = 2;//	可以取地址cout << &p << endl;cout << &b << endl;cout << &c << endl;cout << &(*p) << endl;b = c;// 以下几个是对上面左值的左值引用int*& rp = p;int& rb = b;const int& rc = c;int& pvalue = *p;return 0;
}

• 右值引用

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

int main()
{double x = 1.1, y = 2.2;// 以下几个都是常见的右值10; x + y;fmin(x, y);// 以下几个都是对右值的右值引用int&& rr1 = 10;double&& rr2 = x + y;double&& rr3 = fmin(x, y);//	// 不能取地址//	cout << &10 << endl;//	cout << &(x+y) << endl;//	cout << &fmin(x, y) << endl;// 这里编译会报错：error C2106: “=”: 左操作数必须为左值//10 = 1; //x + y = 1;//fmin(x, y) = 1;return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用

int main()
{double x = 1.1, y = 2.2;int&& rr1 = 10;const double&& rr2 = x + y;rr1 = 20;int& rr = rr1;//rr2 = 5.5;  // 报错return 0;
}

注意：左值引用可以连续左值引用，而右值引用是不可以连续右值引用的（右值引用后该变量为左值，不能使用右值引用了）

♥️ 6.2 左值引用和右值引用比较

左值引用总结：

1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值

int main()
{// 左值引用只能引用左值，不能引用右值。int a = 10;int& ra1 = a;// ra为a的别名//int& ra2 = 10;// 编译失败，因为10是右值// const左值引用既可引用左值，也可引用右值。const int& ra3 = 10;const int& ra4 = a;return 0;
}

右值引用总结：

1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以move以后的左值。

int main()
{// 右值引用只能右值，不能引用左值int&& r1 = 10;// error C2440: “初始化”: 无法从“int”转换为“int &&”// message : 无法将左值绑定到右值引用int a = 10;//int&& r2 = a;  //报错 右值引用只能右值，不能引用左值// 右值引用可以引用move以后的左值int&& r3 = move(a);return 0;
}

♥️ 6.3 右值引用使用场景和意义

右值引用可以补齐左值引用的短板

namespace lc
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){//cout << "string(char* str)" << endl;_str = new char[_capacity + 1];strcpy(_str, str);}// s1.swap(s2)void swap(string& s){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷贝构造string(const string& s):_str(nullptr){cout << "string(const string& s) -- 深拷贝" << endl;string tmp(s._str);swap(tmp);}// 移动构造string(string&& s):_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 移动拷贝" << endl;//this->swap(s);swap(s);}// 赋值重载string& operator=(const string& s){cout << "string& operator=(string s) -- 深拷贝" << endl;string tmp(s);swap(tmp);return *this;}~string(){delete[] _str;_str = nullptr;}char& operator[](size_t pos){assert(pos < _size);return _str[pos];}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}void push_back(char ch){if (_size >= _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}_str[_size] = ch;++_size;_str[_size] = '\0';}//string operator+=(char ch)string& operator+=(char ch){push_back(ch);return *this;}const char* c_str() const{return _str;}private:char* _str;size_t _size;size_t _capacity; // 不包含最后做标识的\0};
}

♥️ 6.4 左值引用使用场景

void func1(bit::string s)
{}void func2(const bit::string& s)
{}int main()
{bit::string s1("hello world");// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值func1(s1);func2(s1);// string operator+=(char ch) 传值返回存在深拷贝// string& operator+=(char ch) 传左值引用没有拷贝提高了效率s1 += '!';return 0;
}

♥️ 6.4 左值引用短板

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：bit::string to_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

♥️ 6.5 右值引用和移动语义解决上述问题

移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人（将亡值）的资源来构造自己。

注意：出了作用域，如果返回对象不在了，不能使用引用返回(左值引用和右值引用都不可以)

namespace byih
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){//cout << "string(char* str)" << endl;_str = new char[_capacity + 1];strcpy(_str, str);}// s1.swap(s2)void swap(string& s){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷贝构造string(const string& s):_str(nullptr), _size(0), _capacity(0){cout << "string(const string& s) -- 深拷贝" << endl;string tmp(s._str);swap(tmp);}// 移动构造string(string&& s):_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 移动拷贝" << endl;//this->swap(s);swap(s);}// 拷贝赋值string& operator=(const string& s){cout << "string& operator=(const string& s) -- 深拷贝" << endl;string tmp(s);swap(tmp);return *this;}// 移动赋值string& operator=(string&& s){cout << "string& operator=(string&& s) -- 移动赋值" << endl;swap(s);return *this;}~string(){delete[] _str;_str = nullptr;}char& operator[](size_t pos){assert(pos < _size);return _str[pos];}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}void push_back(char ch){if (_size >= _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}_str[_size] = ch;++_size;_str[_size] = '\0';}//string operator+=(char ch)string& operator+=(char ch){push_back(ch);return *this;}const char* c_str() const{return _str;}void clear(){_str[0] = '\0';_size = 0;}private:char* _str;size_t _size;size_t _capacity; // 不包含最后做标识的\0};string to_string(int val){string str;while (val){int i = val % 10;str += ('0' + i);val /= 10;}reverse(str.begin(), str.end());return str;}
}

右值是将亡值而将亡值不一定是右值

注意：

按照语法，右值引用只能引用右值，但右值引用也能引用左值。因为：有些场景下，可能 真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move 函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性， 它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。
使用move函数时，要注意该对象的资源（所开空间），该对象的资源会根据移动赋值、移动拷贝来决定，建议使用完move函数之后不要再使用该对象了

♥️ 6.6 STL容器插入接口函数也增加了右值引用版本

void push_back (value_type&& val);
int main()
{list lt;bit::string s1("1111");// 这里调用的是拷贝构造lt.push_back(s1);// 下面调用都是移动构造lt.push_back("2222");lt.push_back(std::move(s1));return 0;
}运行结果：
// string(const string& s) -- 深拷贝
// string(string&& s) -- 移动语义
// string(string&& s) -- 移动语义