C++0X中值得关注的几大变化
注:作者 Danny Kalev 曾是 C++ 标准委员会成员。
C++之父Bjame Stroustrup最近说C++11就像一个新语言,的确,C++11核心已经发生了巨大的变化,它现在支持Lambda表达式,对象类型自动推断,统一的初始化语法,委托构造函数,deleted和defaulted函数声明nullptr,以及最重要的右值引用。
【编辑推荐】
C++0x FAQ中文版(http://imcc.blogbus.com/logs/106046323.html)
C++11标准库也使用新的算法,新的容器类,原子操作,类型特征,正则表达式,新的智能指针,async()函数和多线程库进行了改造。
C++11的新内核和库特性完整列表请移步这里(http://www2.research.att.com/~bs/C++0xFAQ.html)。 C++标准在1998年获得通过后,有两位委员会委员预言,下一代C++标准将“肯定”包括内置的垃圾回收器(GC),但可能不会支持多线程,因为定义一个可移植的线程模型涉及到的技术太复杂了,13年后,新的C++标准C++11也接近完成,你猜怎么着?让那两位委员没想到的是,本次更新还是没有包括GC,但却包括了一个先进的线程库。
在这篇文章中,我将介绍C++11标准中发生的最大变化,以及为什么应该引起注意,正如你将看到的,线程库不是唯一的变化,新标准采纳了数十位专家的意见,使C++变得更有意义。正如Rogers Cadenhead指出的那样,它们就像迪斯科、宠物石和长胸毛的奥运游泳选手一样不可思议。
Lambda 表达式
Lambda 表达式的形式是这样的:
01.[capture](parameters)->return-type {body}
来看个计数某个字符序列中有几个大写字母的例子:
01.int main()
02.{
03. char s[]="Hello World!";
04. int Uppercase = 0; //modified by the lambda
05. for_each(s, s+sizeof(s), [&Uppercase] (char c) {
06. if (isupper(c))
07. Uppercase++;
08. });
09. cout<< Uppercase<<" uppercase letters in: "<< s<<endl;
10.}
其中 [&Uppercase] 中的 & 的意义是 lambda 函数体要获取一个 Uppercase 引用,以便能够改变它的值,如果没有 &,那就 Uppercase 将以传值的形式传递过去。
自动类型推导和 decltype
在 C++03 中,声明对象的同时必须指明其类型,其实大多数情况下,声明对象的同时也会包括一个初始值,C++11 在这种情况下就能够让你声明对象时不再指定类型了:
01.auto x=0; //0 是 int 类型,所以 x 也是 int 类型
02.auto c='a'; //char
03.auto d=0.5; //double
04.auto national_debt=14400000000000LL;//long long
这个特性在对象的类型很大很长的时候很有用,如:
01.void func(const vector<int> &vi)
02.{
03. vector<int>::const_iterator ci=vi.begin();
04.}
那个迭代器可以声明为:
01.auto ci=vi.begin();
C++11 也提供了从对象或表达式中“俘获”类型的机制,新的操作符 decltype 可以从一个表达式中“俘获”其结果的类型并“返回”:
01.const vector<int> vi;
02.typedef decltype (vi.begin()) CIT;
03.CIT another_const_iterator;
统一的初始化语法
C++ 最少有 4 种不同的初始化形式,如括号内初始化,见:
01.std::string s("hello");
02.int m=int(); //default initialization
还有等号形式的:
01.std::string s="hello";
02.int x=5;
对于 POD 集合,又可以用大括号:
01.int arr[4]={0,1,2,3};
02.struct tm today={0};
最后还有构造函数的成员初始化:
01.struct S {
02. int x;
03. S(): x(0) {} };
这么多初始化形式,不仅菜鸟会搞得很头大,高手也吃不消。更惨的是 C++03 中居然不能初始化 POD 数组的类成员,也不能在使用 new[] 的时候初始 POD 数组,操蛋啊!C++11 就用大括号一统天下了:
01.class C
02.{
03.int a;
04.int b;
05.public:
06. C(int i, int j);
07.};
08.C c {0,0}; //C++11 only. 相当于 C c(0,0);
09.int* a = new int[3] { 1, 2, 0 }; /C++11 only
10.class X {
11. int a[4];
12.public:
13. X() : a{1,2,3,4} {} //C++11, 初始化数组成员
14.};
还有一大好事就是对于容器来说,终于可以摆脱 push_back() 调用了,C++11中可以直观地初始化容器了:
01.// C++11 container initializer
02.vector vs<string>={ "first", "second", "third"};
03.map singers =
04. { {"Lady Gaga", "+1 (212) 555-7890"},
05. {"Beyonce Knowles", "+1 (212) 555-0987"}};
而类中的数据成员初始化也得到了支持:
01.class C
02.{
03. int a=7; //C++11 only
04.public:
05. C();
06.};
deleted 函数和 defaulted 函数
像以下形式的函数:
01.struct A
02.{
03. A()=default; //C++11
04. virtual ~A()=default; //C++11
05.};
叫做 defaulted 函数,=default; 指示编译器生成该函数的默认实现。这有两个好处:一是让程序员轻松了,少敲键盘,二是有更好的性能。
与 defaulted 函数相对的就是 deleted 函数:
01.int func()=delete;
这货有一大用途就是实现 noncopyabe 防止对象拷贝,要想禁止拷贝,用 =deleted 声明一下两个关键的成员函数就可以了:
01.struct NoCopy
02.{
03. NoCopy & operator =( const NoCopy & ) = delete;
04. NoCopy ( const NoCopy & ) = delete;
05.};
06.NoCopy a;
07.NoCopy b(a); //编译错误,拷贝构造函数是 deleted 函数
nullptr
nullptr 是一个新的 C++ 关键字,它是空指针常量,它是用来替代高风险的 NULL 宏和 0 字面量的。nullptr 是强类型的:
01.void f(int); //#1
02.void f(char *);//#2
03.//C++03
04.f(0); //调用的是哪个 f?
05.//C++11
06.f(nullptr) //毫无疑问,调用的是 #2
所有跟指针有关的地方都可以用 nullptr,包括函数指针和成员指针:
01.const char *pc=str.c_str(); //data pointers
02.if (pc!=nullptr)
03. cout<<pc<<endl;
04.int (A::*pmf)()=nullptr; //指向成员函数的指针
05.void (*pmf)()=nullptr; //指向函数的指针
委托构造函数
C++11 中构造函数可以调用同一个类的另一个构造函数:
01.class M //C++11 delegating constructors
02.{
03. int x, y;
04. char *p;
05.public:
06. M(int v) : x(v), y(0), p(new char [MAX]) {} //#1 target
07. M(): M(0) {cout<<"delegating ctor"<<end;} //#2 delegating
#2 就是所谓的委托构造函数,调用了真正的构造函数 #1。
右值引用
在 C++03 中的引用类型是只绑定左值的,C++11 引用一个新的引用类型叫右值引用类型,它是绑定到右值的,如临时对象或字面量。
增加右值引用的主要原因是为了实现 move 语义。与传统的拷贝不同,move 的意思是目标对象“窃取”原对象的资源,并将源置于“空”状态。当拷贝一个对象时,其实代价昂贵且无必要,move 操作就可以替代它。如在 string 交换的时候,使用 move 意义就有巨大的性能提升,如原方案是这样的:
01.void naiveswap(string &a, string & b)
02.{
03. string temp = a;
04. a=b;
05. b=temp;
06.}
这种方案很傻很天真,很慢,因为需要申请内存,然后拷贝字符,而 move 就只需要交换两个数据成员,无须申请、释放内存和拷贝字符数组:
01.void moveswapstr(string& empty, string & filled)
02.{
03.//pseudo code, but you get the idea
04. size_t sz=empty.size();
05. const char *p= empty.data();
06.//move filled's resources to empty
07. empty.setsize(filled.size());
08. empty.setdata(filled.data());
09.//filled becomes empty
10. filled.setsize(sz);
11. filled.setdata(p);
12.}
要实现支持 move 的类,需要声明 move 构造函数和 move 赋值操作符,如下:
01.class Movable
02.{
03.Movable (Movable&&); //move constructor
04.Movable&& operator=(Movable&&); //move assignment operator
05.};
C++11 的标准库广泛使用 move 语义,很多算法和容器都已经使用 move 语义优化过了。
C++11 的标准库
除 TR1 包含的新容器(unordered_set, unordered_map, unordered_multiset, 和unordered_multimap),还有一些新的库,如正则表达式,tuple,函数对象封装器等。下面介绍一些 C++11 的标准库新特性:
线程库
从程序员的角度来看,C++11 最重要的特性就是并发了。C++11 提供了 thread 类,也提供了 promise 和 future 用以并发环境中的同步,用 async() 函数模板执行并发任务,和 thread_local 存储声明为特定线程独占的数据,这里(http://www.devx.com/SpecialReports/Article/38883)有一个简单的
C++11 线程库教程(英文)。
新的智能指针类
C++98 定义的唯一的智能指针类 auto_ptr 已经被弃用,C++11 引入了新的智能针对类 shared_ptr 和 unique_ptr。它们都是标准库的其它组件兼容,可以安全地把智能指针存入标准容器,也可以安全地用标准算法“倒腾”它们。
新的算法
主要是 all_of()、any_of() 和 none_of(),下面是例子:
01.#include <algorithm>
02.//C++11 code
03.//are all of the elements positive?
04.all_of(first, first+n, ispositive()); //false
05.//is there at least one positive element?
06.any_of(first, first+n, ispositive());//true
07.// are none of the elements positive?
08.none_of(first, first+n, ispositive()); //false
还有一个新的 copy_n:
01.#include <algorithm>
02.int source[5]={0,12,34,50,80};
03.int target[5];
04.//从 source 拷贝 5 个元素到 target
05.copy_n(source,5,target);
iota() 算法可以用来创建递增序列,它先把初值赋值给 *first,然后用前置 ++ 操作符增长初值并赋值到给下一个迭代器指向的元素,如下:
01.#include <numeric>
02.int a[5]={0};
03.char c[3]={0};
04.iota(a, a+5, 10); //changes a to {10,11,12,13,14}
05.iota(c, c+3, 'a'); //{'a','b','c'}
是的,C++11 仍然缺少一些很有用的库如 XML API,socket,GUI、反射——以及自动垃圾收集。然而现有特性已经让 C++ 更安全、高效(是的,效率更高了,可以参见 Google 的 基准测试结果http://www.itproportal.com/2011/06/07/googles-rates-c-most-complex-highest-performing-language/)以及更加易于学习和使用。
如果觉得 C++ 变化太大了,不必惊恐,花点时间来学习就好了。可能在你融会贯通新特性以后,你会同意 Stroustrup 的观点:C++11 是一门新的语言——一个更好的 C++。