c++11详解

一、c++11简介

c++11的上一个标准版本是c++03，由于c++标准协会是一个非盈利的组织，c++03的下一个版本拖延到了2011年才确定下来，c++11带来了很多新的语法，修复了约600个缺陷。

二、列表初始化

c++11的列表初始化不在局限于数组和结构体元素，现在列表初始化可用于所有内置类型和自定义类型

int arr[]={1,2,3,4,5};
struct stu
{
	int x;
	int y;
}
stu s={1,2};
//以上c98适用的列表初始化
class stu
{
    public:
    	stu(int _x,int _y)
        	:x(_x)
        	,y(_y)
    		{}
    private:
    	int x;
    	int y;
}
stu s1{1,2};
stu s1={1,2};
//这里的列初始化会调用构造函数初始化

std::initializer_list就是列表auto li={1,2,3,4},这个东西一般做构造函数的参数和operator=的参数，内置容器中很多都实现了std::initializer_list做参数的构造函数，在vector中模拟一个std::initializer_list做参数的构造函数

 vector(initializer_list<T> l)
     {
         _start = new T[l.size()];
         _finish = _start + l.size();
         _endofstorage = _start + l.size();
         iterator vit = _start;
         typename initializer_list<T>::iterator lit = l.begin();
         while (lit != l.end())
         {
             *vit++ = *lit++;
         }
         //for (auto e : l)
         //   *vit++ = e;
     }

三、声明

aotu是c++98中是一个可以自动推导显示初始化了 的值的类型的关键字，但是不能作为函数参数类型声明。
**decltype **可以将变量的类型声明为表达式指定的类型

int a=10;
int b=20;
decltype(a*b) c;//变量c的类型被声明成了(a*b)的指定类型int

nullptr由于NULL被定义成0，NULL能表达成指针常量又能表达成指针常量，nullptr只能表示成空指针

四、右值引用和移动语义

传统的引用只能给左值引用，就是给左值取别名，可以取地址可以被赋值的就是左值

int a=0;
int*b=&a;
const c=2;//abc都是左值

右值一般是字面常量，表达式返回值，临时变量，右值可以出现在等号的右边不能出现在等号的左边

10;
a+b;
func(a,b);//这几个都是常见的右值

int &&ra=10;//对右值取引用
int &&rb=(a+b);
int &&rb=func(a,b);

在对右值取引用之后是可以进行修改的

int &&ra=10;//对右值取引用
int &&rb=(a+b);
int &&rc=func(a,b);

//下面的操作都是允许的
ra=20;
rb=50;
rc=100;
//不想被修改就在前面加上const就行了

右值引用只能引用右值，不能引用左值，但是可以引用move之后的左值

int a=0;
//int ra&&=a;//这样会报错
int ra&&=move(a);//这样就行了

我们都知道使用左值引用做函数参数和返回值都能提高程序的效率，但是也存在一些场景不能使用左值引用

string func()
{
    string s;
    return s;
}
string s1=func();//这里会调用拷贝构造，一次深拷贝，因为const左值引用也能匹配右值
//如果返回值是一个局部变量就不能使用传引用返回

我们加上移动构造（虽然string本来就有）

string(string&& s)
 :_str(nullptr)
 ,_size(0)
 ,_capacity(0)
{
     swap(s);//直接把临时变量据为己有
}
int main()
{
     string ret2 = bit::to_string(-1234);//这个情况会找最匹配的
     return 0;
}

减少了开辟空间和拷贝数据提高了效率
还有移动赋值，同理

string& operator=(string&& s)
{
    cout << "string& operator=(string&& s) -- 移动语义" << endl;
    swap(s);
    return *this;
}
int main()
{
     bit::string ret1;
     ret1 = bit::to_string(1234);
     return 0;
}

五、完美转发

当我们在模板中使用&&时这个参数既能就收左值也能接收右值

template<typename T>
void PerfectForward(T&& t)
{
 	Fun(t);
}

这个时候我们想把t的属性（左值还是右值）匹配到合适的函数中的时候就需要用到完美转发

template<typename T>
void PerfectForward(T&& t)
{
 	Fun(std::forward<T>(t));
}

这个时候重载的func无论接收参数是左值还是右值都能被匹配到合适的函数中

六、类的新功能

强制生成默认函数的关键字default，字面意思因为一些原因没有自动生成默认函数，你可以在这个函数声明后面加上default，这样系统就会强制生成了

Person(Person&& p) = default;//强制生成移动构造

禁止生成默认函数的关键字delete，一样的道理

七、可变参数模板

template <class ...Args>
void ShowList(Args... args)
{}

args…里面包含了0个及以上的模板，我们无法直接获取里面的每个参数
我们可以使用一些方式来展开参数包
递归展开

// / 递归终止函数
template <class T>
void ShowList(const T& t)//当参数包中参数使用完毕之后，传参就剩下T，就会调用终止函数
{
 cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
 cout << value <<" ";
 ShowList(args...);
}

八、lambda表达式

简单来说就是一个匿名函数
我们在调用sort的时候想使元素按照我们的心意排序，这个时候就需要添加第三个参数

struct ComparePriceGreater
{
     bool operator()(const Goods& gl, const Goods& gr)
     {
         return gl._price > gr._price;	
     }
};
int main()
{
     vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
   	 sort(v.begin(), v.end(), ComparePriceGreater());
}

这种方式有那么一点麻烦

int main()
{
     vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
     sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._price < g2._price; });
}

完整的lambda表达式书写方式是 [捕捉列表] (参数列表) mutable -> 返回值类型{ 函数体 }
捕捉列表特殊字符使用

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

其中lambda函数总是一个const函数，mutable可以取消其常量 性。使用该修饰符时，参数列表不可省略(即使参数为空)。函数体内除了参数以外还能使用捕捉列表内的所有变量
每个lambda表达式都是不一样的无名函数，想直接调用可以使用auto关键字

auto fun2 = [=, &b](int c)->int{return b += a+ c; }; 
cout<<fun2(10)<<endl;

九、 function包装器

包装器的存在是为了解决需要实例化多份功能类似的问题，可以使用函数、仿函数、lambda表达式来创建