【C/C++ 13】C++11高效特性
目录
一、初始化列表
二、auto
三、decltype
四、可变参数列表
五、lambda表达式
C++11在C++98的基础上增添了许多特性，但是同时也使得C++程序的开发变得复杂繁琐，让众多开发者苦不堪言，于是我们需要从C++11新增舔的特性中选择一些能够提高开发效率的东西进行学习和应用。
一、初始化列表
在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定，比如：
struct Point
{
int _x;
int _y;
};
int main()
{
int array1[] = { 1, 2, 3, 4, 5 };
int array2[5] = { 0 };
Point p = { 1, 2 };
return 0;
}C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自
定义的类型，使用初始化列表时，可添加等号(=)，也可不添加，但是这样一来，C++代码就有些显得花里胡哨了，为了和C++98更兼容，建议在对列表进行初始化时都加上等号。
但是C++11的初始化列表在new表达式中非常方便，我们只在new表达式中使用C++11初始化列表即可。
#include
using namespace std;
int main()
{
int* arr1 = new int[3]{ 0 };
int* arr2 = new int[3]{ 1, 2, 3 };
for (int i = 0; i < 3; ++i)
cout << arr1[i] << ' ';
// 0 0 0
cout << endl;
for (int i = 0; i < 3; ++i)
cout << arr2[i] << ' ';
// 1 2 3
return 0;
} #include
using namespace std;
int main()
{
auto il = { 10, 20, 30 };
cout << typeid(il).name() << endl;
// class std::initializer_list
return 0;
}
// std::initializer_list
// This type is used to access the values in a C++ initialization list,
// which is a list of elements of type const T.
// std::initializer_list一般是作为构造函数的参数。
// C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。
// 也可以作为operator = 的参数，这样就可以用大括号赋值。
#include
#include
using namespace std;
int main()
{
// 初始化列表对STL容器初始化构造
vector arr = { 1, 2, 3 };
for (int i = 0; i < arr.size(); ++i)
cout << arr[i] << ' ';
// 1 2 3
return 0;
}
二、auto
C++11中 auto 用于实现自动类型推断，常应用于迭代器和范围for循环中。
#include
#include 三、decltype
关键字decltype将变量的类型声明为表达式指定的类型。
#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
template
void F(T1 x, T2 y)
{
decltype(x * y) ret;
cout << typeid(ret).name() << endl;
}
int main()
{
const int x = 1;
double y = 2.5;
decltype(x * y) ret;
decltype(&x) p;
cout << typeid(ret).name() << endl; // double
cout << typeid(p).name() << endl; // int const *
F(1, 'a'); // int
return 0;
} 四、可变参数列表
C++11的可变参数模板能够创建可以接受可变参数的函数模板和类模板，相比于C++98类模板只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template
void ShowList(Args... args)
{}
/*
上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，
它里面包含了0到N（N >= 0）个模版参数。我们无法直接获取参数包args中的每个参数的，
只能通过展开参数包的方式来获取参数包中的每个参数，
这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。
由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来一一获取参数包的值。
*/ #define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
// 递归方式展开参数包
template
void ShowList(const T& value)
{
cout << value << endl;
}
template
void ShowList(T value, Args... args)
{
cout << value << " ";
ShowList(args...);
}
int main()
{
ShowList(1);
ShowList(1, 'a');
ShowList(1, 'a', string("test"));
return 0;
}
#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
// 逗号表达式展开参数包
template
void PrintArgs(T t)
{
cout << t << ' ';
}
template
void ShowList(Args... args)
{
int arr[] = { (PrintArgs(args), 0)... };
cout << endl;
}
int main()
{
ShowList(1);
ShowList(1, 'a');
ShowList(1, 'a', string("test"));
return 0;
}
/*
这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的，
PrintArg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。
这种就地展开参数包的方式实现的关键是逗号表达式，我们知道逗号表达式会按顺序执行逗号前面的表达式。
expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，
先执行PrintArg(args)，再得到逗号表达式的结果0。
同时还通过初始化列表来初始化一个变长数组，
{(PrintArg(args), 0)...}将会展开成((PrintArg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )
最终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。
于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分PrintArg(args)打印出参数，
也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。
*/
五、lambda
C++11的 lambda 表达式，实际上是一个匿名函数，熟练使用 lambda 表达式，可以极大地提升编程效率。
// lambda表达式语法
[capture-list](parameters)mutable->return-type{statement}
// [capture-list]：捕捉列表，捕捉上下文中的变量供lambda使用
// (parameters)：参数列表
// mutable：取消lambda函数的默认常性，使用该修饰符时参数列表不可省略
// ->return-type：返回值类型，可省略由编译器推导
// {statement}：函数体，除了可以使用参数列表的变量，还可以使用捕捉到的变量在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。
#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
int main()
{
// 最简单的lambda表达式
auto func1 = [] {};
func1();
// 省略参数列表，返回值由编译器推导
int a = 3, b = 4;
auto func2 = [=] {cout << a + b << endl; };
func2();
auto func3 = [&](int c) {b = c + a; };
func3(10);
cout << "b = " << b << endl;
cout << [=, &b](int c)->int {return b += a + c; }(10) << endl;
auto func4 = [b](int a)mutable {b %= 10; return b + a; };
cout << func4(5) << endl;
return 0;
}
/*
捕获列表说明：
1. [var]：表示值传递方式捕捉变量var
2. [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
3. [&var]：表示引用传递捕捉变量var
4. [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
5. [this]：表示值传递方式捕捉当前的this指针
注意：
1. 父作用域指包含lambda函数的语句块
2. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割
3. 捕捉列表不允许变量重复传递，否则就会导致编译错误
4. lambda表达式之间不能相互赋值
*/ 从原理上看，编译器对于lambda表示式的实现方式，就是将其作为仿函数实现的，而仿函数的实现原理就是对 operator() 进行重载。也就是说，如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。
从代码编写角度来说，使用lambda表达式效率更高。
#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
class Salary
{
public:
Salary(int money)
: _money(money)
{}
int operator()(int month)
{
return _money * month;
}
private:
int _money;
};
int main()
{
int money = 3000;
int month = 5;
Salary a(money);
cout << a(month) << endl;
auto func = [=] {return money * month; };
cout << func() << endl;
} 六、包装器
function 包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
#define _CRT_SECURE_NO_WARNINGS 1
#include
using namespace std;
template
T UseF(F f, T t)
{
static int count = 0;
cout << "count: " << ++count << endl;
cout << "count: " << &count << endl;
return f(t);
}
double func(double x)
{
return x / 2;
}
struct Func
{
double operator()(double x)
{
return x / 3;
}
};
int main()
{
// 函数名
cout << UseF(func, 11.11) << endl;
// 函数对象
cout << UseF(Func(), 11.11) << endl;
// lambda表达式
cout << UseF([](double x) {return x / 4; }, 11.11) << endl;
return 0;
}
// 由运行结果可见，UseF函数模板实例化了三份。
// 每出现一种新的函数定义，通过UseF调用就会使UseF实例化一个新的对象，这会导致效率低下。
// 包装器的出现就是为了解决这个问题。
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
using namespace std;
// 通过包装器提高模板函数的效率
template
T UseF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double func(double x)
{
return x / 2;
}
struct Func
{
double operator()(double x)
{
return x / 3;
}
};
class Plus
{
public:
static int plusi(int a)
{
return a + 1;
}
double plusd(double a)
{
return a + 1;
}
};
int main()
{
// 函数名
std::function f1 = func;
cout << UseF(f1, 11.11) << endl;
// 函数对象
std::function f2 = Func();
cout << UseF(f2, 11.11) << endl;
// lambda表达式
std::function f3 = [](double x) {return x / 4; };
cout << UseF(f3, 11.11) << endl;
// 类的成员函数
std::function f4 = &Plus::plusd;
cout << f4(Plus(), 11.11) << endl;
return 0;
}
std::bind 是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。
可以将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为第二个参数，以此类推。
#define _CRT_SECURE_NO_WARNINGS 1
// 使用举例
#include
#include
int Plus(int a, int b)
{
return a + b;
}
class Sub
{
public:
int sub(int a, int b)
{
return a - b;
}
};
int main()
{
//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
std::function func1 = std::bind(Plus, std::placeholders::_1,
std::placeholders::_2);
//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
//func2的类型为 function 与func1类型一样
//表示绑定函数 plus 的第一，二为： 1， 2
auto func2 = std::bind(Plus, 1, 2);
std::cout << func1(1, 2) << std::endl;
std::cout << func2() << std::endl;
Sub s;
// 绑定成员函数
std::function func3 = std::bind(&Sub::sub, s,
std::placeholders::_1, std::placeholders::_2);
// 参数调换顺序
std::function func4 = std::bind(&Sub::sub, s,
std::placeholders::_2, std::placeholders::_1);
std::cout << func3(1, 2) << std::endl;
std::cout << func4(1, 2) << std::endl;
return 0;
}