C++11

列表初始化

先了解C++11的特性：C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。
来看几个例子

struct  point
{
    int a;
    int b;
};

void Test_Initialiszer_list()
{
    int a{100};//不添加等号
    int b = {200};
    int array[5]{0};//没有等号的初始化
    int arr[]{1,2,3,4,5};
    point p{1,2};//这里其C++一种特殊隐式类型转换，给转换成了对应的构造，是多参数的隐式类型转换，相当于识别成了一个特殊的ponit对象。
    return ;
}

那比如要初始化一个数组呢？自定义类型的数组，C++11提供了列表初始化。

//列表初始化
//1.对于所有类型（包括整形等自带的类）都可以列表初始化,还可以取消赋值符号
//2.有一个初始值类，许多默认的参数都是编译器给搞成Initiallizer_lsit
void Test_Initialiszer_list()
{
    auto it = {2022,2,2};//这里实际是C++的Initializer_list,这里就是识别出来，才使得auto没有报错，但是这种Initializer_list只支持一种类型的数据，本质其还是一个类
    vector<int> Nums{1,2,3,4};//这里就是线成了一个Initializer_list来通过这个类，在Vector里面提供接口构造。
    return ;
}

本质是C++对那些数据进行了特殊处理，搞成了一个Initializer_list的类，因此就能够提供初始化，而STL那些容器都提供用Initializer_list来初始化。

左值引用和右值引用

左值：数据得表达式，可以被取地址（这是判断是否是左值得根本区别）。一般不能被修改，但是也有特例，如下。

const int a = 0;

右值：一个临时定义的对象，一般出现在赋值符号右边，其一般不可被修改。
如下面的“10”

int a = 10;

左值引用和右值引用

都是引用，都是对表达式取别名。
左值引用的符号： &
右值引用的符号：&&
有几个规则：
1.左值引用不能引用右值，除非加上const 左值引用。如下面最后个引用
2.右值引用不能引用左值，要引用也要通过move修改左值性质，使其变成右值的性质（注意，没有修改其变量的性质，只是临时给个返回值让右值引用可以引用）
3.右值引用也是引用，可以修改原本的值，因为其一旦引用之后，引用的那个值（如下面的c），其实就是左值的属性了。

void Test_Rvalue_Reference()
{
    int leftVal = 100;
    int && a = 10;
    // int && c = leftVal;这里会报错，原因是不允许右值引用对左值进行引用
    int && c = move(leftVal);//move会返回该值的右值的引用
    c = 200;//打上断点调试发现，本应该是右值引用的c，居然可以修改值
    //事实就是如此，右值引用是可以修改值的,这个时候c，其实就是左值属性了。
    const int & b = 10;
}

完美转发和万能引用

完美转发：完整的保留变量原本的属性，不会使得因为使用右值引用定义的变量属性变成左值。
使用 forward就可以实现完美转发，例子如下。 可以打断点看见调试看见结果。
万能引用：模板加引用就是万能引用。 如下，这个明明是右值，却可以引用左值，这就是万能引用

void func(int &a){
	
}
void func(const int& a)
{

}
void func(int &&a)
{

}
void func(const int&&a)
{

}

//完美转发
template <typename T>
void PerfectRef(T&& x)//这里的引用就万能引用，对左值右值都可以直接引用
{
   int a = 0;
    func(a);
    func(10);
    func(x);//forward可以完美转发对象在传参过程种，对象本身的属性
    func(forward<T>(x));//forward可以完美转发对象在传参过程种，对象本身的属性
    //上面谈过，因为右值引用之后，实际编译器给这个引用的值，就搞成左值的属性了，为了维持这点，用forward就很好
}
int main()
{
    int b = 0;
    PerfectRef(b);
}

右值引用的价值

有了右值引用，就可以设计出移动构造，移动赋值，极大程度的利用将亡值（就是一个临时对象,或者要销毁的值）。

class A{
    public:
    A(int && val = 10)
    :_a(val)
    {
        cout<<"A()"<<endl;
    }
    A(const A& t)
    {
        cout<<"Copy A&()\n";
    }
    A(A&& t)
    {
        cout<<"Copy A&&()\n";
    }
    ~A(){
        cout<<"~A()"<<endl;
    }
    int _a =10;
};

A GetA()
{
    A a;
    return a;
}

void Test_Perfect_Ref()
{
    A a = 1;//经过测试，在g++编译器会做优化，直接把这个局部变量改了作用域和生命周期，使得不需要再调用析构，拷贝构造等函数
    //经过测试，再MSVC下（如VS2022，就不会做这个优化，这是G++编译在做的时候单独处理的
    //这样使得在这个环境下，没办法看见右值引用在构造函数里面，可以省去再开空间得优化，但是可以看见赋值
}

如上述代码，按照正常没有编译器优化的情况，会1先被编译器认识成为一个A对象生成一个对象之后走拷贝构造，生成一个A的a对象。可以说十分消耗资源。
我所使用的g++编译器，优化的十分厉害，直接就修改了变量的生命周期和作用域，（证据是打印GetA里面变量的地址，和外面的地址是一样的。），看不见现象，可以去VS上面调试就能看见效果。

VS2022下运行下面的代码

#include <iostream>
using namespace std;

class A {
public:
    A()
    {
        cout << "A()" << endl;
    }
    A(A&& a)
    {
        cout << "A(A&&a)" << endl;
        swap(a);
    }

    void swap(A& a)
    {
        cout << "swap" << endl;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
};

A GetA()
{
    A a;
    cout << &a << endl;
    return a;
}
int main()
{
    //vs2022里面，当你写了移动构造函数，用其他临时对象构造当前对象时，会直接修改生命周期和作用域，省去重复调构造拷贝构造，也省去调用多余得析构函数
    //但是如果没有写移动构造，就会重新构造，但是依然连续的构造，拷贝构造会省掉多的构造。
    A a = GetA();
    cout << &a << endl;
    return 0;
}

比如说下面代码，逐步调试就可以明白，移动构造与普通构造的不同，只需要直接转走右值引用里面的东西（右值引用之后性质是左值，上述讲过），不需要再次创建，可以说省了很大的力气。

class I{
    public:
    I()
    {

    }
    I(I&& a)
    {
        //转移走a的资源就好
        cout<<"I &&\n";
    }
    I(const I& a)
    {
        //拷贝资源
        cout<<"const I& a\n";
    }
    I operator =(I&& a)
    {
        cout<<"I &&\n";
        return *this;
    }
    I operator =(const I& a)
    {
        cout<<"const I& a\n";
        return *this;
    }
    int a = 0;
    int*p = &a;
};

class V{
    public:
    int count = 0;
    I arr[10];
    void push(I && a)
    {
        arr[count++] = forward<I>(a);//用一个完美转发
    }
    void push(const I& a)
    {
        arr[count++] = a;
    }
};
int main()
{
    V v;
    I tmp;
    v.push(I());
    v.push(tmp);
    return 0;
}

上面定义比较轻量，不足以显出移动构造的优势，倘若你想如果是vector里面的string呢？是不是优势就会很大。这就是移动构造的价值。

C++11里新增的类的默认成员

移动构造函数和移动赋值运算符重载：
如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

可变模板参数

C++11提供了一种可变模板参数。就是说，你穿了任意个数，任意种类的类都可以使用的模板。

template <class ...Args>
void Args_Test(Args... args)
{
	cout<<"Args_Test"<<endl;
}

可变模板参数的展开
一般来说，不可能一直让他随便个数都拿着用。
如下是展开可变模板参数的方法，利用 … 代表可变数量的意思，用数组也可以展开。

// 递归终止函数
//利用选择最匹配版本的原理，当可变模板参数大于两个时，就可以
template <class T,class K>
void ShowList(const T& t,const K& a)
{ 
    cout << t << "   "<< a << ' '<<endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
    cout << value <<" ";
    ShowList(args...);
}
void Args_Test_Recursion()
{
    ShowList(1,'a');
    ShowList(1, 'A', 2, 'b', 3, 'c');
    ShowList(1, 'A', std::string("sort"));
    return ;
}


//
template <class T>
void PrintArg(const T& t)
{
 cout << t << " "<<"  "<<endl;
}
template <class ...Args>
void Args_Test_Iteration(Args... args)
{
    //展开函数,依次展开,相当于只对Print不断依次展开，后面的...其实就是代表不定个数
    int arr[] = { (PrintArg(args), 0)... };
    cout << endl;
}

上面介绍了移动构造和赋值，对效率的提升，利用可变参数模板可以做到这一点。
就是一直传递可变参数包，直至底层才构造。

template <class T,class K>
void GetAddr(const T& a,K&& b)
{
    cout<<"const T& "<<a<<endl<<"K&& "<<b<<endl;
}
template <class T>
void GetAddr(T& a)
{
    cout<<"const T& "<<a<<endl;
}

template <class K>
void GetAddr(K&& b)
{
    cout<<"K&& "<<b<<endl;
}

template <class K,class T>
void construct_pair(const K& k,const T& t)
{
    pair<K,T>kv(k,t);
}

//模板加右值引用，就是万能引用，可以引用左值或者右值
template <class ...Args>
void Pass(Args&& ...args)
{
    construct_pair(forward<Args>(args)...);
    GetAddr(forward<Args>(args)...);//这里值得注意的是，由于本质使用的是右值引用，使用之后，其实就是左值展开了，也就是说，传过去的值实际上左值引用时更适配的
    //所以想要保持其本真的属性，需要加上完美转发
    cout<<"Perfect Ref Pass"<<endl;
}

template <class ...Args>
void Pass1(Args&& ...args)
{
    Pass(forward<Args>(args)...);
}

void Test_Template()
{
    //解开注释 调试一下，可以发现可变参数列表也可以对应的万能引用和完美转发，传递多层的效果
    int a = 0;
    // Pass(a);
    // Pass(1);
    //Pass(a,1);
    Pass1(a,'1');
    return ;
}

用这种方法，也能发到不构造多余的对象出来，从而节省时间空间。且性能上比移动构造和移动赋值更加的优秀。

decltype

decltype,识别类型，并指定成对应的类型

void Test_Decltype()
{
    const int x=1;
    double y = 2.2;
    decltype(x+y) ret;//这里的ret，处理之后，就识别成double行
    decltype(&ret) p;//由上，这里识别成double形指针
    std::cout<<typeid(ret).name()<<endl;
    std::cout<<typeid(p).name()<<endl;
    return ;
}