C++_C++11的学习

1. 统一的列表初始化

1.1｛｝初始化

        在C++98 中，标准就已经允许使用花括号 {} 对数组或者结构体元素进行统一的列表初始值设定。而到了C++11，标准扩大了用大括号括起的列表 ( 初始化列表 )的使用范围，使其能适用于所有的内置类型和自定义类型，而且使用初始化列表时可用可不用=。

struct Point
{int _x;int _y;
};
class Date
{
public:Date(int year, int month, int day):_year(year), _month(month), _day(day){cout << "Date(int year, int month, int day)" << endl;}
private:int _year;int _month;int _day;
};
int main()
{int x1 = 1;int x2{ 2 };int array1[]{ 1, 2, 3, 4, 5 };int array2[5]{ 0 };Point p{ 1, 2 };// C++11中列表初始化也可以适用于new表达式中int* pa = new int[4] { 0 };//C++98Date d1(2022, 1, 1);//C++11Date d2{ 2022, 1, 2 };Date d3 = { 2022, 1, 3 };return 0;
}

1.2 std::initializer_list

std::initializer_list 一般是作为构造函数的参数， C++11 对 STL 中的不少容器就增加。

std::initializer_list 作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为 operator=

的参数，这样就可以用大括号赋值。

int main()
{vector<int> v = { 1,2,3,4 };list<int> lt = { 1,2 };// 这里{"sort", "排序"}会先初始化构造一个pair对象map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };// 使用大括号对容器赋值v = { 10, 20, 30 };return 0;
}

以vector为例，讲一下initializer_list的使用：
        在C++11中，vector新增了如下的构造函数

	//先构造再拷贝 -> 编译器优化 -> 直接构造vector<int> v1 = { 1,2,3,4,5,6,7,8,9 };//直接构造vector<int> v2{ 1,2,3,4,5,6,7,8,9 };

2. 声明

2.1 auto

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

译期会将 auto 替换为变量实际的类型。

2.1.1 auto的使用细则

1. auto与指针和引用结合起来使用
        用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

2. 在同一行定义多个变量

        当在同一行声明多个变量时，这些变量必须是相同的类型，否则，编译器将会报错，因为编译 器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量 。

2.1.2 auto不能推导的场景

1. auto 不能作为函数的参数

        因为编译器无法对函数参数的实际类型进行推导

2. auto 不能直接用来声明数组

 

2.2 decltype

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

template<class T1, class T2>
void F(T1 t1, T2 t2)
{decltype(t1 * t2) ret;cout << typeid(ret).name() << endl;
}
int main()
{const int x = 1;double y = 2.2;decltype(x * y) ret; // ret的类型是doubledecltype(&x) p;      // p的类型是int*cout << typeid(ret).name() << endl;cout << typeid(p).name() << endl;F(1, 'a');return 0;
}

2.3 nullptr

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

注意：

        1. 在使用 nullptr 表示指针空值时不需要包含头文件，因为 nullptr 是 C++11 作为新关键字 的 。

        2. 在 C++11 中， sizeof(nullptr) 与 sizeof((void*)0) 所占的字节数相同。

3. 基于范围的for循环

3.1 范围for的语法

        对于一个有范围的集合 而言，由程序员来说明循环的范围是多余的,有时候还会容易犯错误。因此C++11 中引入了基于范围的 for 循环。 for 循环后的括号由冒号 “ ： ” 分为两部分：第一部分是范 围内用于迭代的变量，第二部分则表示被迭代的范围 。

int main() {int array[] = { 1, 2, 3, 4, 5 };// 如果要进行修改，就必须要引用for (auto& e : array)e *= 2;// 如果只是访问，可以不用引用for (auto e : array)cout << e << " " << endl;return 0;
}

注意：与普通循环类似，可以用 continue 来结束本次循环，也可以用 break 来跳出整个循环。

3.2 范围for的使用条件

1. for 循环迭代的范围必须是确定的

        对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和 end 的方法， begin 和 end 就是 for 循环迭代的范围。

2. 迭代的对象要实现 ++ 和 == 的操作

        因为对于编译器，编译器范围for的使用最后还是要转化为一般for循环的遍历

int main() {vector<int> v = { 1, 2, 3, 4, 5 };vector<int>::iterator it = v.begin();for (auto e : v)cout << e << " ";cout << endl;for (; it != v.end(); it++)cout << *it << " ";return 0;
}

4. STL中一些变化

4.1 新容器

        在原有容器的基础上新加了如下所标记的容器

 4.2 新方法

1.提供了cbegin和cend方法返回const迭代器等等
        但是实际意义不大，因为begin和end也是可以返回const迭代器的。
2.提供了各容器的initializer_list构造
3.push系列、insert、emplace等函数增加了右值引用的插入版本
4.容器增加了移动构造和移动赋值

总结：C++11引入了右值引用和移动语义，解决了左值引用的一些问题并极大提高了效率

5. 新的类功能

5.1 默认成员函数

原来C++ 类中，有 6 个默认成员函数：

        1. 构造函数

        2. 析构函数

        3. 拷贝构造函数

        4. 拷贝赋值重载

        5. 取地址重载

        6. const 取地址重载

        最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。C++11 新增了两个：移动构造函数和移动赋值运算符重载。

针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

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

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

        3.如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值

5.2 类成员变量初始化

       C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化。

5.3 强制生成默认函数的关键字default

        C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default 关键字显示指定移动构造生成。

5.4 禁止生成默认函数的关键字delete

        如果能想要限制某些默认函数的生成，在C++98 中，是该函数设置成 private ，并且只声明补丁而已，这样只要其他人想要调用就会报错。在C++11 中更简单，只需在该函数声明加上 =delete 即可，该语法指示编译器不生成对应函数的默认版本，称=delete 修饰的函数为删除函数。

5.5 继承和多态中的final与override关键字

1.final: 修饰类时，它表示该类不能被继承
             修饰虚函数时，它表示该虚函数不能在子类中被重写
2.override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

6. 可变参数模板

        C++11的新特性可变参数模板能够让您创建可以接受可变参数的函数模板和类模板，相比 C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数是一个巨大的改进。

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

        我们把带省略号的参数称为“ 参数包” ，它里面包含了 0 到 N （ N>=0 ）个模版参数。我们无法直接获取参数包 args 中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，下面是主要的两种方式：

1. 递归函数方式展开参数包

// 每次递归都会获取并显示1个参数直至全部参数获取完就结束
template <class T>
void ShowList(const T& t)
{cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{cout << value << " ";ShowList(args...);
}
int main()
{ShowList(1);ShowList(1, 'A');ShowList(1, 'A', std::string("sort"));return 0;
}

2. 逗号表达式展开参数包

        PrintArg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式：
        函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。同时，逗号表达式的前面部分会执行PrintArg函数打印参数，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

template <class T>
void PrintArg(T t)
{cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{int arr[] = { (PrintArg(args), 0)... };cout << endl;
}
int main()
{ShowList(1);ShowList(1, 'A');ShowList(1, 'A', std::string("sort"));return 0;
}

3. STL容器中的empalce相关接口函数

std::vector::emplace_back
template <class... Args>  void emplace_back (Args&&... args);std::list::emplace_back
template <class... Args>  void emplace_back (Args&&... args);

        STL中的容器大多都实现了可参数列表式的empalce式的接口函数，它和insert、push式的函数比较如下：
1. 插入类型是单个值，两个没什么区别
2. 直接给插入对象参数时，empalce系列对于深拷贝的类对象，减少一次移动构造，对于浅拷贝的类对象，减少一次拷贝构造

7. lambda表达式

7.1 书写格式

lambda 表达式书写格式： [capture-list] (parameters) mutable -> return-type { statement }

lambda 表达式各部分说明：

1.[capture-list] : 捕捉列表 ，该列表总是出现在 lambda 函数的开始位置， 编译器根据 [] 来 判断接下来的代码是否为 lambda 函数 ， 捕捉列表能够捕捉上下文中的变量供 lambda 函数使用 。 （必写）

2.(parameters) ：参数列表。与 普通函数的参数列表一致 ，如果不需要参数传递，则可以连同() 一起省略。

3.mutable ：默认情况下， lambda 函数总是一个 const 函数， mutable 可以取消其常量性。使用该修饰符时，参数列表不可省略( 即使参数为空 ) 。

4.returntype：返回值类型。用 追踪返回类型形式声明函数的返回值类型 ，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推 导 。

5.{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量. （必写）

注意：

        在lambda 函数定义中， 参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以 空 。因此 C++11 中 最简单的 lambda 函数为： []{} ; 该 lambda函数不能做任何事情。 表达式实际上可以理解为无名函数，在语法层没有类型，该函数无法直接调 用，如果想要直接调用，可借助 auto 将其赋值给一个变量，或者用decltype推导表达式的类型，lambda对象禁止了默认构造。

void Test()
{auto f = [] {cout << "hello world" << endl; };f();
}class Date
{
public:Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){cout << "Date(int year, int month, int day)" << endl;}Date(const Date& d):_year(d._year), _month(d._month), _day(d._day){cout << "Date(const Date& d)" << endl;}
private:int _year = 1;int _month = 1;int _day = 1;
};int main()
{auto DateLess = [](const Date* p1, const Date* p2){return p1 < p2;//偷懒直接比指针};cout << typeid(DateLess).name() << endl;// lambda对象支持拷贝构造auto copy(DateLess);// lambda对象禁掉默认构造// decltype(DateLess) xx;//运行报错//为了下面的代码运行通过，还得有比较对象DateLess，因为lambda对象不会默认构造priority_queue<Date*, vector<Date*>, decltype(DateLess)> p1(DateLess);return 0;
}

7.2 函数对象与lambda表达式

        函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator() 运算符的类对象。

class Rate
{
public:Rate(double rate) : _rate(rate){}double operator()(double money, int year){return money * _rate * year;}
private:double _rate;
};int main()
{double rate = 0.49;Rate r1(rate);r1(10000, 2);auto r2 = [=](double monty, int year)->double {return monty * rate * year;};r2(10000, 2);auto f1 = [] {cout << "hello world" << endl; };auto f2 = [] {cout << "hello world" << endl; };f1();f2();return 0;
}

通过查看汇编代码可以知道，编译器对于lambda表达式的处理最终还是转换成对仿函数的处理，而且还可以知道，编译器对这个转换后的仿函数的地址对于相同的lambda表达式是不同的，这就解释了为什么lambda表达式间是不支持赋值的，即使看上去类型相同。

8. 包装器

8.1 function包装器

//std::function在头文件<functional>
// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;模板参数说明：
Ret : 被调用函数的返回类型
Args…：被调用函数的形参

        function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器，是对可调用对象的再封装，统一类型，可调用对象有函数指针/函数名、仿函数、lambda表达式等。   
         对于编译器而言，下面的代码模useF板会实例化3份：

template<class F, class T>
T useF(F f, T x)
{static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x);
}double f(double i)
{return i / 2;
}struct Functor
{double operator()(double d){return d / 3;}
};int main()
{// 函数名cout << useF(f, 11.11) << endl;// 函数对象cout << useF(Functor(), 11.11) << endl;// lamber表达式cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;return 0;
}

 

         而如果使用function进行封装后得到的可调用类型是一样的，实例化就只有1份，function的使用无疑减小了模板实例化的开销：

int main()
{// 函数指针function<double(double)> fc1 = f;fc1(11.11);cout << useF(fc1, 11.11) << endl;// 函数对象function<double(double)> fc2 = Functor();fc2(11.11);cout << useF(fc2, 11.11) << endl;// lambda表达式function<double(double)> fc3 = [](double d)->double { return d / 4; };fc3(11.11);cout << useF(fc3, 11.11) << endl;return 0;
}

        除了上述的可调用对象，function还能对类的（静态）成员函数进行封装：

int f(int a, int b)
{return a + b;
}class Plus
{
public:static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return a + b;}
};int main()
{// 普通函数function<int(int, int)> fc1 = f;cout << fc1(1, 1) << endl;// 静态成员函数function<int(int, int)> fc2 = &Plus::plusi;cout << fc2(1, 1) << endl;// 非静态成员函数// 非静态成员函数需要对象的指针或者对象去进行调用// 因为非静态成员函数还有一个隐式参数：this/*Plus plus;function<double(Plus*, double, double)> fc3 = &Plus::plusd;cout << fc3(&plus, 1, 1) << endl;*/function<double(Plus, double, double)> fc3 = &Plus::plusd;cout << fc3(Plus(), 1, 1) << endl;return 0;
}

8.2 bind

template <class Fn, class... Args>/* unspecified */ bind (Fn&& fn, Args&&... args);template <class Ret, class Fn, class... Args>/* unspecified */ bind (Fn&& fn, Args&&... args);

        std::bind函数定义在头文件中， 是一个函数模板，它就像一个函数包装器 ( 适配器 ) ， 接受一个可 调用对象 ，生成一个新的可调用对象来 “ 适应 ” 原对象的参数列表。

        调用bind 的一般形式： auto newCallable = bind(callable,arg_list); 其中，newCallable 本身是一个可调用对象， arg_list 是一个逗号分隔的参数列表，对应给定的callable的参数。 当我们调用 newCallable 时， newCallable 会调用 callable, 并传给它 arg_list 中 的参数 。

        arg_list中的参数可能包含形如 _n 的名字，其中 n 是一个整数，这些参数是 “ 占位符 ” ，表示

newCallable 的参数，它们占据了传递给 newCallable 的参数的 “ 位置 ” 。数值 n 表示生成的可调用对象中参数的位置：_1 为 newCallable 的第一个参数， _2 为第二个参数，以此类推。 它的功能如下：

1. 调整参数顺序（意义不大）

int Sub(int a, int b)
{return a - b;
}class Plus
{
public:static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return a - b;}
};int main()
{// 调整参数顺序，意义不大int x = 10, y = 20;cout << Sub(x, y) << endl;auto f1 = bind(Sub, placeholders::_2, placeholders::_1);cout << f1(x, y) << endl;function<double(Plus, double, double)> fc3 = &Plus::plusd;cout << fc3(Plus(), 1, 1) << endl;return 0;
}

2. 调整参数个数（意义大）

int main()
{// 调整参数的个数// 某些参数绑死function<double(double, double)> fc4 = bind(&Plus::plusd, Plus(), placeholders::_1, placeholders::_2);cout << fc4(2, 3) << endl;function<double(double)> fc5 = bind(&Plus::plusd, Plus(), placeholders::_1, 20);cout << fc5(2) << endl;return 0;
}