一. 零碎新功能
- 新类型:
long long 和 unsigned long long,支持64位(或更宽)的整型。
char16_t 和 char32_t,支持16位和32位的字符表示。
- 列表初始化可以用于new表达式中:
int *ar=new int[4] {2,4,6,7};
Stump s2{5,43.4}; //构造函数为:Stump(int r,double w): roots(r),weight(w){} - 初始化列表禁止缩窄:如double到char的自动转换是禁止的。但允许转换为更宽的类型,例如int到double的转换。
- initializer_list是一个C++11提供的新类型,定义在<initializer_list>头文件中。
- 有了initializer_list之后,对于STL的container的初始化就方便多了,比如以前初始化一个vector需要这样:
有了initializer_list后,就可以直接像初始化数组一样:int a[] = {0, 1, 2, 3}; std::vector<int> vec(a, a+sizeof(a)); //或 std::vector v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4);
并且,C++11允许构造函数和其他函数把初始化列表当做参数:std::vector v = { 1, 2, 3, 4 };
#include <iostream> #include <vector> class MyNumber { public: MyNumber(const std::initializer_list<int> &v) { for (auto itm : v) { mVec.push_back(itm); } } void print() { for (auto itm : mVec) { std::cout << itm << " "; } } private: std::vector<int> mVec; }; int main() { MyNumber m = { 1, 2, 3, 4 }; m.print(); // 1 2 3 4 return 0; }
- nullptr:
不会指向有效数据的指针,以前C++源代码中用0表示这种指针,但内部表示可能不同。这使得0既可以表示指针常量,又可以表示整型常量。
C++11中的新增关键字nullptr,是指针类型,不能转换为整型类型。但仍允许用0来表示空指针,如nullptr==0是true。
- C++11摒弃了auto_ptr,新增了:unique_ptr、shared_ptr、weak_ptr三种智能指针。详细看:C++中智能指针和野指针
- 基于范围的for循环:
一般情况下在C++下遍历一个容器的方法是这样的:
std::vector<int> array = {1, 2, 3, 4, 5}; for(auto it=array.begin(), it !=array.end(); ++it) { std::cout << *it << "\t"; } //或 void do_cout(int n) { std::cout << n << "\t"; } std::for_each(array.begin(), array.end(), do_cout);
现在,C++11中有了基于范围的for循环,那么之前我们写的遍历容器的方法就可以写成这样:
for(int item : array) { cout << item << "\t"; }
二. Lambda表达式
- 或许,Lambda 表达式算得上是 C++ 11 新增特性中最激动人心的一个。简而言之,Lambda 表达式就是用于创建匿名函数的。
- 为什么说 lambda 表达式如此激动人心呢?举一个例子。标准 C++ 库中有一个常用算法的库,其中提供了很多算法函数,比如 sort() 和 find()。这些函数通常需要提供一个“谓词函数 predicate function”。所谓谓词函数,就是进行一个操作用的临时函数。比如 find() 需要一个谓词,用于查找元素满足的条件;能够满足谓词函数的元素才会被查找出来。这样的谓词函数,使用临时的匿名函数,既可以减少函数数量,又会让代码变得清晰易读。
1. 声明Lambda表达式
Lambda表达式完整的声明格式如下:
[capture list] (params list) mutable exception-> return type { function body }
各项具体含义如下
①capture list:捕获外部变量列表
②params list:形参列表
③mutable指示符:用来说用是否可以修改捕获的变量
④exception:异常设定
⑤return type:返回类型
⑥function body:函数体
此外,我们还可以省略其中的某些成分来声明“不完整”的Lambda表达式,常见的有以下几种:
序号 | 格式 |
---|---|
1 | [capture list] (params list) -> return type {function body} |
2 | [capture list] (params list) {function body} |
3 | [capture list] {function body} |
其中:
- 格式1声明了const类型的表达式,这种类型的表达式不能修改捕获列表中的值。
- 格式2省略了返回值类型,但编译器可以根据以下规则推断出Lambda表达式的返回类型: (1):如果function body中存在return语句,则该Lambda表达式的返回类型由return语句的返回类型确定; (2):如果function body中没有return语句,则返回值为void类型。
- 格式3中省略了参数列表,类似普通函数中的无参函数。
2. 一个例子
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool cmp(int a, int b)
{
return a < b;
}
int main()
{
vector<int> myvec{ 3, 2, 5, 7, 3, 2 };
vector<int> lbvec(myvec);
sort(myvec.begin(), myvec.end(), cmp); // 旧式做法
cout << "predicate function:" << endl;
for (int it : myvec)
cout << it << ' ';
cout << endl;
sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; }); // Lambda表达式
cout << "lambda expression:" << endl;
for (int it : lbvec)
cout << it << ' ';
}
3. 捕获外部变量
Lambda表达式可以使用其可见范围内的外部变量,但必须明确声明(明确声明哪些外部变量可以被该Lambda表达式使用)。那么,在哪里指定这些外部变量呢?Lambda表达式通过在最前面的方括号[]来明确指明其内部可以访问的外部变量,这一过程也称过Lambda表达式“捕获”了外部变量。
#include <iostream>
using namespace std;
int main()
{
int a = 123;
auto f = [a] { cout << a << endl; };
f(); // 输出:123
//或通过“函数体”后面的‘()’传入参数
auto x = [](int a){cout << a << endl;}(123);
}
上面这个例子先声明了一个整型变量a,然后再创建Lambda表达式,该表达式“捕获”了a变量,这样在Lambda表达式函数体中就可以获得该变量的值。
类似参数传递方式(值传递、引入传递、指针传递),在Lambda表达式中,外部变量的捕获方式也有值捕获、引用捕获、隐式捕获。
①值捕获
值捕获和参数传递中的值传递类似,被捕获的变量的值在Lambda表达式创建时通过值拷贝的方式传入,因此随后对该变量的修改不会影响影响Lambda表达式中的值。
这里需要注意的是,如果以传值方式捕获外部变量,则在Lambda表达式函数体中不能修改该外部变量的值。
示例如下:
int main()
{
int a = 123;
auto f = [a] { cout << a << endl; };
a = 321;
f(); // 输出:123
}
②引用捕获
使用引用捕获一个外部变量,只需要在捕获列表变量前面加上一个引用说明符&。如下:
int main()
{
int a = 123;
auto f = [&a] { cout << a << endl; };
a = 321;
f(); // 输出:321
}
③隐式捕获
上面的值捕获和引用捕获都需要我们在捕获列表中显示列出Lambda表达式中使用的外部变量。除此之外,我们还可以让编译器根据函数体中的代码来推断需要捕获哪些变量,这种方式称之为隐式捕获。隐式捕获有两种方式,分别是[=]和[&]。[=]表示以值捕获的方式捕获外部变量,[&]表示以引用捕获的方式捕获外部变量。
隐式值捕获示例:
int main()
{
int a = 123;
auto f = [=] { cout << a << endl; }; // 值捕获
f(); // 输出:123
}
隐式引用捕获示例:
int main()
{
int a = 123;
auto f = [&] { cout << a << endl; }; // 引用捕获
a = 321;
f(); // 输出:321
}