2011年12月5日Tiobe发布了2011年12月的编程语言排行榜。新一期排行榜Objective-C持续给力跃居第五位,而上一期关注的
谷歌Dart语言也上升到第68名,但PHP由第四位跌到第6名。从2001年Tiobe编程语言排行榜开始发布至今,C++几乎一直占据着第三名。

        C++11中值得关注的几大变化       

        分类:           
C++2011-06-23 18:0554832人阅读评论(103)收藏;)举报

赖勇浩( 声明:本文源自 Danny Kalev 在 2011 年 6
月 21 日发表的《The Biggest Changes in C++11(and Why You Should
Care)》一文,几乎所有内容都搬了过来,但不是全文照译,有困惑之处,请参详原文(http://www.softwarequalityconnection.com/2011/06/the-biggest-changes-in-c11-and-why-you-should-care/)。
注:作者 Danny Kalev 曾是 C++ 标准委员会成员。

虽然Perl, Visual Basic
和PHP曾经也排到第3名,但和C++相比,他们就显得弱爆了,因为他们最多只能保持几个月而已。然而相比C++,微软的编程语言C#却更被看好,甚至有
人认为C#势必会取代C++,C++是垃圾语言。因为微软的大力推广,使用C#的人越来越多,而老将C++却正在被人遗忘。不甘寂寞,2011年C++再
次亮剑,13年来第一个重大修订版,C++11横空出世!

Lambda 表达式

Lambda 表达式的形式是这样的:

[cpp] view
plaincopyprint?

  1. [capture](parameters)->return-type
    {body} 

[capture](parameters)->return-type {body}

来看个计数某个字符序列中有几个大写字母的例子:

[cpp] view
plaincopyprint?

  1. int main() 
  2.    char s[]=”Hello World!”; 
  3.    int Uppercase = 0; //modified by the lambda 
  4.    for_each(s, s+sizeof(s),
    [&Uppercase] (char c) { 
  5.     if (isupper(c)) 
  6.      Uppercase++; 
  7.     }); 
  8. cout<< Uppercase<<” uppercase
    letters in: “<< s<<endl; 

int main() { char s[]=”Hello World!”; int Uppercase = 0; //modified by
the lambda for_each(s, s+sizeof(s), [&Uppercase] (char c) { if
(isupper(c)) Uppercase++; }); cout<< Uppercase<<” uppercase
letters in: “<< s<<endl; }

其中 [&Uppercase] 中的 & 的意义是 lambda 函数体要获取一个 Uppercase
引用,以便能够改变它的值,如果没有 &,那就 Uppercase
将以传值的形式传递过去。

 

下面是前20名的编程语言排行

自动类型推导和 decltype

在 C++03
中,声明对象的同时必须指明其类型,其实大多数情况下,声明对象的同时也会包括一个初始值,C++11
在这种情况下就能够让你声明对象时不再指定类型了:

[c-sharp] view
plaincopyprint?

  1. auto x=0; //0 是 int 类型,所以 x 也是 int
    类型 
  2. auto c=’a’; //char 
  3. auto d=0.5; //double 
  4. auto national_debt=14400000000000LL;//long
    long 

auto x=0; //0 是 int 类型,所以 x 也是 int 类型 auto c=’a’; //char auto
d=0.5; //double auto national_debt=14400000000000LL;//long long

这个特性在对象的类型很大很长的时候很有用,如:

[cpp] view
plaincopyprint?

  1. void func(const vector<int> &vi) 
  2.   vector<int>::const_iterator
    ci=vi.begin(); 

void func(const vector<int> &vi) {
vector<int>::const_iterator ci=vi.begin(); }

那个迭代器可以声明为:

[cpp] view
plaincopyprint?

  1. auto ci=vi.begin(); 

auto ci=vi.begin();

C++11 也提供了从对象或表达式中“俘获”类型的机制,新的操作符 decltype
可以从一个表达式中“俘获”其结果的类型并“返回”:

[c-sharp] view
plaincopyprint?

  1. const vector<int> vi; 
  2. typedef decltype (vi.begin()) CIT; 
  3. CIT another_const_iterator; 

const vector<int> vi; typedef decltype (vi.begin()) CIT; CIT
another_const_iterator;

 

澳门新葡亰 1 

统一的初始化语法

C++ 最少有 4 种不同的初始化形式,如括号内初始化,见:

[cpp] view
plaincopyprint?

  1. std::string s(“hello”); 
  2. int m=int(); //default
    initialization 

std::string s(“hello”); int m=int(); //default initialization

还有等号形式的:

[cpp] view
plaincopyprint?

  1. std::string s=”hello”; 
  2. int x=5; 

std::string s=”hello”; int x=5;

对于 POD 集合,又可以用大括号:

[cpp] view
plaincopyprint?

  1. int arr[4]={0,1,2,3}; 
  2. structtm
    today={0}; 

int arr[4]={0,1,2,3}; struct tm today={0};

最后还有构造函数的成员初始化:

[cpp] view
plaincopyprint?

  1. struct S { 
  2. int x; 
  3. S(): x(0) {} }; 

struct S { int x; S(): x(0) {} };

这么多初始化形式,不仅菜鸟会搞得很头大,高手也吃不消。更惨的是 C++03
中居然不能初始化 POD 数组的类成员,也不能在使用 new[] 的时候初始 POD
数组,操蛋啊!C++11 就用大括号一统天下了:

[cpp] view
plaincopyprint?

  1. class C 
  2. int a; 
  3. int b; 
  4. public: 
  5. C(int i, int j); 
  6. }; 
  7. C c {0,0}; //C++11 only. 相当于 C
    c(0,0); 
  8. int* a = newint[3] {
    1, 2, 0 }; /C++11 only 
  9. class X { 
  10.   int a[4]; 
  11. public: 
  12.   X() : a{1,2,3,4} {} //C++11,
    初始化数组成员 
  13. }; 

class C { int a; int b; public: C(int i, int j); }; C c {0,0}; //C++11
only. 相当于 C c(0,0); int* a = new int[3] { 1, 2, 0 }; /C++11 only
class X { int a[4]; public: X() : a{1,2,3,4} {} //C++11,
初始化数组成员 };

还有一大好事就是对于容器来说,终于可以摆脱 push_back()
调用了,C++11中可以直观地初始化容器了:

[cpp] view
plaincopyprint?

  1. // C++11 container initializer 
  2. vector vs<string>={ “first”, “second”, “third”}; 
  3. map singers = 
  4.   { {“Lady Gaga”, “+1 (212) 555-7890”}, 
  5.     {“Beyonce Knowles”, “+1 (212) 555-0987”}}; 

// C++11 container initializer vector vs<string>={ “first”,
“second”, “third”}; map singers = { {“Lady Gaga”, “+1 (212) 555-7890”},
{“Beyonce Knowles”, “+1 (212) 555-0987”}};

而类中的数据成员初始化也得到了支持:

[cpp] view
plaincopyprint?

  1. class C 
  2. int a=7; //C++11 only 
  3. public: 
  4. C(); 
  5. }; 

class C { int a=7; //C++11 only public: C(); };

 

掀起C++ 11的神秘面纱

deleted 函数和 defaulted 函数

像以下形式的函数:

[cpp] view
plaincopyprint?

  1. struct A 
  2. A()=default; //C++11 
  3. virtual ~A()=default; //C++11 
  4. }; 

struct A { A()=default; //C++11 virtual ~A()=default; //C++11 };

叫做 defaulted 函数,=default;
指示编译器生成该函数的默认实现。这有两个好处:一是让程序员轻松了,少敲键盘,二是有更好的性能。
与 defaulted 函数相对的就是 deleted 函数:

[cpp] view
plaincopyprint?

  1. int func()=delete; 

int func()=delete;

这货有一大用途就是实现 noncopyabe 防止对象拷贝,要想禁止拷贝,用
=deleted 声明一下两个关键的成员函数就可以了:

[cpp] view
plaincopyprint?

  1. struct NoCopy 
  2.     NoCopy & operator =( const NoCopy &
    ) = delete; 
  3.     NoCopy ( const NoCopy & ) = delete; 
  4. }; 
  5. NoCopy a; 
  6. NoCopy b(a); //编译错误,拷贝构造函数是
    deleted 函数 

struct NoCopy { NoCopy & operator =( const NoCopy & ) = delete; NoCopy (
const NoCopy & ) = delete; }; NoCopy a; NoCopy b(a);
//编译错误,拷贝构造函数是 deleted 函数

 

C++标准在1998年获得通过后,有两位委员会委员预言,下一代C++标准将“肯定”包括内置的垃圾回收器(GC),但可能不会支持多线程,因为定义一
个可移植的线程模型涉及到的技术太复杂了,13年后,新的C++标准C++11也接近完成,你猜怎么着?让那两位委员没想到的是,本次更新还是没有包括
GC,但却包括了一个先进的线程库。C++之父Bjame
Stroustrup说C++11就像一个新语言,
的确,C++11核心已经发生了巨大的变化,它现在支持Lambda表达式,对象类型自动推断,统一的初始化语法,委托构造函数,deleted和defaulted函数声明nullptr,以及最重要的右值引用。

nullptr

nullptr 是一个新的 C++ 关键字,它是空指针常量,它是用来替代高风险的 NULL
宏和 0 字面量的。nullptr 是强类型的:

[cpp]澳门新葡亰, view
plaincopyprint?

  1. void f(int); //#1 
  2. void f(char *);//#2 
  3. //C++03 
  4. f(0); //调用的是哪个 f? 
  5. //C++11 
  6. f(nullptr) //毫无疑问,调用的是 #2 

void f(int); //#1 void f(char *);//#2 //C++03 f(0); //调用的是哪个 f?
//C++11 f(nullptr) //毫无疑问,调用的是 #2

所有跟指针有关的地方都可以用 nullptr,包括函数指针和成员指针:

[cpp] view
plaincopyprint?

  1. constchar *pc=str.c_str(); //data pointers 
  2. if (pc!=nullptr) 
  3.   cout<<pc<<endl; 
  4. int (A::*pmf)()=nullptr; //指向成员函数的指针 
  5. void (*pmf)()=nullptr; //指向函数的指针 

const char *pc=str.c_str(); //data pointers if (pc!=nullptr)
cout<<pc<<endl; int (A::*pmf)()=nullptr;
//指向成员函数的指针 void (*pmf)()=nullptr; //指向函数的指针

 

C++11中值得关注的几大变化

委托构造函数

C++11 中构造函数可以调用同一个类的另一个构造函数:

[cpp] view
plaincopyprint?

  1. class M //C++11
    delegating constructors 
  2. int x, y; 
  3. char *p; 
  4. public: 
  5. M(int v) : x(v), y(0),  p(newchar
    [MAX])  {} //#1 target 
  6. M(): M(0) {cout<<“delegating
    ctor”<<end;} //#2
    delegating 

class M //C++11 delegating constructors { int x, y; char *p; public:
M(int v) : x(v), y(0), p(new char [MAX]) {} //#1 target M(): M(0)
{cout<<“delegating ctor”<<end;} //#2 delegating

#2 就是所谓的委托构造函数,调用了真正的构造函数 #1。

 

◆ Lambda表达式

右值引用

在 C++03 中的引用类型是只绑定左值的,C++11
引用一个新的引用类型叫右值引用类型,它是绑定到右值的,如临时对象或字面量。
增加右值引用的主要原因是为了实现 move 语义。与传统的拷贝不同,move
的意思是目标对象“窃取”原对象的资源,并将源置于“空”状态。当拷贝一个对象时,其实代价昂贵且无必要,move
操作就可以替代它。如在 string 交换的时候,使用 move
意义就有巨大的性能提升,如原方案是这样的:

[cpp] view
plaincopyprint?

  1. void naiveswap(string &a, string & b) 
  2. string temp = a; 
  3. a=b; 
  4. b=temp; 

void naiveswap(string &a, string & b) { string temp = a; a=b; b=temp; }

这种方案很傻很天真,很慢,因为需要申请内存,然后拷贝字符,而 move
就只需要交换两个数据成员,无须申请、释放内存和拷贝字符数组:

[cpp] view
plaincopyprint?

  1. void moveswapstr(string& empty, string
    & filled) 
  2. //pseudo code, but you get the idea 
  3. size_t sz=empty.size(); 
  4. constchar *p= empty.data(); 
  5. //move filled’s resources to empty 
  6. empty.setsize(filled.size()); 
  7. empty.setdata(filled.data()); 
  8. //filled becomes empty 
  9. filled.setsize(sz); 
  10. filled.setdata(p); 

void moveswapstr(string& empty, string & filled) { //pseudo code, but
you get the idea size_t sz=empty.size(); const char *p= empty.data();
//move filled’s resources to empty empty.setsize(filled.size());
empty.setdata(filled.data()); //filled becomes empty filled.setsize(sz);
filled.setdata(p); }

要实现支持 move 的类,需要声明 move 构造函数和 move 赋值操作符,如下:

[cpp] view
plaincopyprint?

  1. class Movable 
  2. Movable (Movable&&); //move
    constructor 
  3. Movable&& operator=(Movable&&); //move
    assignment operator 
  4. }; 

class Movable { Movable (Movable&&); //move constructor Movable&&
operator=(Movable&&); //move assignment operator };

C++11 的标准库广泛使用 move 语义,很多算法和容器都已经使用 move
语义优化过了。

 

◆自动类型推断和decltype

C++11 的标准库

除 TR1 包含的新容器(unordered_set, unordered_map,
unordered_multiset,
和unordered_multimap),还有一些新的库,如正则表达式,tuple,函数对象封装器等。下面介绍一些
C++11 的标准库新特性:

◆统一初始化语法

线程库

从程序员的角度来看,C++11 最重要的特性就是并发了。C++11 提供了 thread
类,也提供了 promise 和 future 用以并发环境中的同步,用 async()
函数模板执行并发任务,和 thread_local
存储声明为特定线程独占的数据,这里(
C++11 线程库教程(英文)。


Deleted和Defaulted函数

新的智能指针类

C++98 定义的唯一的智能指针类 auto_ptr 已经被弃用,C++11
引入了新的智能针对类 shared_ptr 和
unique_ptr。它们都是标准库的其它组件兼容,可以安全地把智能指针存入标准容器,也可以安全地用标准算法“倒腾”它们。

◆ nullptr

新的算法

主要是 all_of()、any_of() 和 none_of(),下面是例子:

[cpp] view
plaincopyprint?

  1. #include <algorithm> 
  2. //C++11 code 
  3. //are all of the elements positive? 
  4. all_of(first, first+n, ispositive()); //false 
  5. //is there at least one positive
    element? 
  6. any_of(first, first+n, ispositive());//true 
  7. // are none of the elements positive? 
  8. none_of(first, first+n, ispositive()); //false 

#include <algorithm> //C++11 code //are all of the elements
positive? all_of(first, first+n, ispositive()); //false //is there at
least one positive element? any_of(first, first+n, ispositive());//true
// are none of the elements positive? none_of(first, first+n,
ispositive()); //false

还有一个新的 copy_n:

[cpp] view
plaincopyprint?

  1. #include <algorithm> 
  2. int source[5]={0,12,34,50,80}; 
  3. int target[5]; 
  4. //从 source 拷贝 5 个元素到 target 
  5. copy_n(source,5,target); 

#include <algorithm> int source[5]={0,12,34,50,80}; int
target[5]; //从 source 拷贝 5 个元素到 target
copy_n(source,5,target);

iota() 算法可以用来创建递增序列,它先把初值赋值给 *first,然后用前置 ++
操作符增长初值并赋值到给下一个迭代器指向的元素,如下:

[cpp] view
plaincopyprint?

  1. #include <numeric> 
  2. int a[5]={0}; 
  3. char c[3]={0}; 
  4. iota(a, a+5, 10); //changes a to
    {10,11,12,13,14} 
  5. iota(c, c+3, ‘a’); //{‘a’,’b’,’c’} 

#include <numeric> int a[5]={0}; char c[3]={0}; iota(a, a+5,
10); //changes a to {10,11,12,13,14} iota(c, c+3, ‘a’); //{‘a’,’b’,’c’}

是的,C++11 仍然缺少一些很有用的库如 XML
API,socket,GUI、反射——以及自动垃圾收集。然而现有特性已经让 C++
更安全、高效(是的,效率更高了,可以参见 Google 的
基准测试结果
如果觉得 C++
变化太大了,不必惊恐,花点时间来学习就好了。可能在你融会贯通新特性以后,你会同意
Stroustrup 的观点:C++11 是一门新的语言——一个更好的 C++。

◆ 委托构造函数

◆ 右值引用

C++11标准库

C++于2003年以库技术报告1(TR1)的形式经历了重大改版,TR1包括新的容器类
(unordered_set,unordered_map,unordered_multiset和unordered_multimap)和多个支撑
正则表达式、元组和函数对象封装器等的新库。随着C++11标准获得通过,TR1和自它首次发布以来新增的库被正式纳入标准的C++标准,下面是
C++11标准库的一些特性:

线程库

站在程序员的角度来看,C++11最重要的新功能毫无疑问是并行操作,C++11拥有一个代表执行线程的线程类,在并行环境中用于同步,async()函
数模板启动并行任务,为线程独特的数据声明thread_local存储类型。如果你想找C++11线程库的快速教程,请阅读Anthony
William的“C++0x中更简单的多线程”。

新的智能指针类

网站地图xml地图