C++11 学习笔记

前言：

整体来说C++11并不属于传统的C++，是一支独立特主的支线，完全有着他自己的想法并且发扬光大。so11的优势还是很大的。

列表初始化：

在C98中，{}只能对数组元素等进行初始化，并不能形成一个空间；

在C11中中就可以啦，可以列表初始化，扩大了他的使用范围，用于所有的内置类型和用户自定义类型（可以省略=）

内置类型：

vector<int> v{1,2,3,4,5};

map<int,int> m{{1,1},{2,2},{3,3}};

自定义类型：

class A

{

public:

        A(int x= 0):_x(x){}

private:

        int _x;

};

int main()

{

        A a{1};

        return 0;

}

变量类型推导：

auto的使用前提是对象必须初始化，这里就是补充一个decltype，使用如下

int a = 1, int b =1;

decltype(a+b)c;

这个时候c就是a+b之后的类型，代替了int。

默认成员函数控制：

C11添加了两个新的成员函数，分别是移动构造和移动拷贝构造，在C98中默认成员函数是不可以控制的，在C11中添加了对部分默认成员函数的操作。

显示缺省函数

在C11中自己写是否需要默认构造函数，在声明或定义后加上=default就可以生成无参构造函数（也可以说C11必须自己确定是否需要默认生成，而相对C98比较混乱）

删除默认函数

不是说真正的删除了，而是说不能被调用了，相当于C98里的private，在声明后面加上=delete。

右值引用和move（小重点）

左值引用 右值引用 move

值引用有两个，平时用的引用是左值引用，这里把他拿出来是二者对比好理解右值引用。

先再复习下什么是左值，简单来说就是可以取地址和可以被修改（const修饰也算左值），除此之外全是右值。

平时都是左引左，右引右，但是因为有const和move之后，左也可以引右（const），右也可以引左（move）。

const大家都知道，move最简单来说就是字如其意，和现实一样，把一块资源移动到另一处。

const int& a1 = 10;
const int& a2 = a;

int&& a4 = 10;
int&& a5 = move(a);

那为什么他们之间可以互相引用还要都有呢，当然是有缺点咯，这个就是左值引用。

在函数返回值这里，左值引用出了函数作用域就不存在了，不久就会被销毁，所以这个值也叫将亡值。也就是说使用左值引用时，想要有返回值，就会有一次临时拷贝，增加负担。

而右值引用直接move（移动）资源，少了一次复制，优化了代码。

这里引用雨轩（爵丶迹）这个博主文章C++11特性（详细版）里的一句总结

总结一下：右值引用出来以后，并不是直接使用右值引用去减少拷贝，提高效率。而是支持深拷贝的类，提供移动构造和移动赋值，这时这些类的对象进行传值返回或者是参数为右值时，则可以用移动构造和移动赋值，转移资源，避免深拷贝，提高效率。

————————————————
版权声明：本文为优快云博主「雨轩（爵丶迹）」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/weixin_46873777/article/details/122948389

move的后续

因为有move这个功能后，C++11新增了两个默认成员函数：移动构造函数和移动赋值运算符重载。
如果没有自己实现移动构造（赋值）函数，且没有实现其他的默认成员函数。

那么编译器会默认生成一个移动构造函数，对于内置类型成员会执行逐成员按字节拷贝。

自定义类型成员则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

完美转发

ps：拜读完大佬的文章感觉自己的语言好粗糙，但是我就是觉得，最直白最容易理解的话不才是知识传递的重点吗。

模板函数调用其他函数的时候有个缺点，会把参数变成左值，这个时候通过“万能引用”传参，这个传参就叫完美转发。

void Func(int& x) { cout << "左值引用" << endl; }
void Func(const int& x) { cout << "const 左值引用" << endl; }

void Func(int&& x) { cout << "右值引用" << endl; }
void Func(const int&& x) { cout << "const 右值引用" << endl; }

template<typename T>
void PerfectForward(T&& t)  //万能引用就是俩&&
{
    //Func(t);                           //必须forward转发
    Func(forward<T>(t));
}

int main()
{
    PerfectForward(1);
    return 0;
}

lambda表达式

一种可以把函数写在函数里的方式。

通式是这样的：

[capture-list] (parameters) mutable -> return-type { statement }

[]：捕捉列表，这个可以空着，但必须得带，用于不同形式下捕捉不同变量。

[var]：表示值传递方式捕捉变量var

[=]：表示值传递方式捕获所有父作用域中的变量(包括this)

[&var]：表示引用传递捕捉变量var

[&]：表示引用传递捕捉所有父作用域中的变量(包括this)

可以捕捉很多，用逗号隔开就好，但不能重复，也不能捕捉父作用域外的，块作用域外的捕捉列表也必须是空的

()：参数列表，和正常函数一样，如果不需要参数，可以省略（包括()）。

mutable：lambda表达式会默认自己是const函数，mutable可以写，也可以不写，写了就取消了其const属性并且必须有参数。

->：返回值类型，编译器会自行推导（不写）。

{}：函数体。

lambda表达式之间不能相互赋值，其实底层就是一个类，类中重载了operator（）。

可变参数列表

顾名思义，就是参数列表位置可以变化。

先来一段求大小的代码大家自行体会

template<class ...Args>                                //这里的是...Args
void List(Args... args)                                    //这里的是Args...
{
    cout << sizeof...(args) << endl;                 //这里的是...(args)
}
int main()
{
    List(1, 2, 3);
    List(1, 'a');
    List(1, 'A', string("a"));
    return 0;
}
                                                                    

从...和args的位置可以看到，虽然大差不差，但还是有差异的，使用的时候一定要注意。

//遍历

//结尾函数
void List()
{
    cout << endl;
}

template <class T, class ...Args>
void List(T value, Args... args)
{
    cout << value << " ";
    List(args...);//虽然就一个参数，但还是调用自己，最后没有参数时调用上面的结尾函数
}
 

//初始化

//template <class T>

//int Print(T t)

//{

//        cout << t << " ";

//         return 0;

//}

template<class ...Args>
void List(Args... args)
{
    int arr[ ] = { args... };

    //int arr[] = { Print(args)... };不同类型参数时使用
    cout << endl;
}
int main()

{

        List(1,2,3);

        return 0;

}

暂完结