掀起C++11的神秘面纱

【 6月21日外电头条】C++之父Bjame Stroustrup最近说C++11就像一个新语言，的确，C++11核心已经发生了巨大的变化，它现在支持Lambda表达式，对象类型自动推断，统一的初始化语法，委托构造函数，deleted和defaulted函数声明nullptr，以及最重要的右值引用。

创新互联建站是一家集网站建设,平凉企业网站建设,平凉品牌网站建设,网站定制,平凉网站建设报价,网络营销,网络优化,平凉网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

[]里是函数调用的参数列表，表示一个Lambda表达式的开始，让我们来看一个Lambda例子：

假设你想计算某个字符串包含多少个大写字母，使用for_each()遍历一个char数组，下面的Lambda表达式确定每个字母是否是大写字母，每当它发现一个大写字母，Lambda表达式给Uppercase加1，Uppercase是定义在Lambda表达式外的一个变量：

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

这是因为，如果你定义的函数主体被放置在另一个函数调用内部，[&Uppercase]中的“&”记号意味着Lambda主体获得一个Uppercase的引用，以便它能修改，如果没有这个特殊记号，Uppercase将通过值传递，C++11 Lambda表达式也包括成员函数构造器。

自动类型推断和decltype

在C++03中，在声明对象时，你必须指定对象的类型，然而，在许多情况下，对象的声明包括在初始化代码中，C++11利用了这个优势，允许你声明对象时不指定类型：

 
 
 
    
  
  
  
  1. auto x=0; //x has type int because 0 is int 
    2. 
  
  
  
  2. auto c='a'; //char 
    3. 
  
  
  
  3. auto d=0.5; //double 
    4. 
  
  
  
  4. auto national_debt=14400000000000LL;//long long
    5.

相反，你可以声明下面这样的迭代器：

 
 
 
    
  
  
  
  1. void fucn(const vector &vi) 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. vector::const_iterator ci=vi.begin(); 
    4. 
  
  
  
  4. } 
    5.

关键字auto不是什么新生事物，我们早已认识，它实际上可以追溯到前ANSI C时代，但是，C++11改变了它的含义，auto不再指定自动存储类型对象，相反，它声明的对象类型是根据初始化代码推断而来的，C++11删除了auto关键字的旧有含义以避免混淆，C++11提供了一个类似的机制捕捉对象或表达式的类型，新的操作符decltype需要一个表达式，并返回它的类型。

 
 
 
    
  
  
  
  1. const vector vi; 
    2. 
  
  
  
  2. typedef decltype (vi.begin()) CIT; 
    3. 
  
  
  
  3. CIT another_const_iterator; 
    4.

统一初始化语法

C++至少有4个不同的初始化符号，有些存在重叠，括号初始化语法如下：

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

在某些情况下，你也可以使用“=”符号进行初始化：

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

对于POD聚合，你还可以使用大括号：

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

***，构造函数使用成员进行初始化：

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

显然，这么多种初始化方法会引起混乱，对新手来说就更痛苦了，更糟糕的是，在C++03中，你不能初始化POD数组成员，POD数组使用new[]分配，C++11使用统一的大括号符号清理了这一混乱局面。

 
 
 
    
  
  
  
  1. class C 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3. int a; 
    4. 
  
  
  
  4. int b; 
    5. 
  
  
  
  5. public: 
    6. 
  
  
  
  6.  C(int i, int j); 
    7. 
  
  
  
  7. }; 
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9. C c {0,0}; //C++11 only. Equivalent to: C c(0,0); 
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11. int* a = new int[3] { 1, 2, 0 }; /C++11 only 
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13. class X { 
    14. 
  
  
  
  14.   int a[4]; 
    15. 
  
  
  
  15. public: 
    16. 
  
  
  
  16.   X() : a{1,2,3,4} {} //C++11, member array initializer 
    17. 
  
  
  
  17. };
    18.

关于容器，你可以和一长串的push_back()调用说再见了，在C++11中，你可以直观地初始化容器：

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

类似地，C++11支持类似的数据成员类内初始化：

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

#p#

Deleted和Defaulted函数

一个表单中的函数：

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

被称为一个defaulted函数，“=default;”告诉编译器为函数生成默认的实现。Defaulted函数有两个好处：比手工实现更高效，让程序员摆脱了手工定义这些函数的苦差事。

与defaulted函数相反的是deleted函数：

 
 
 
    
  
  
  
  1. int func()=delete;
    2.

Deleted函数对防止对象复制很有用，回想一下C++自动为类声明一个副本构造函数和一个赋值操作符，要禁用复制，声明这两个特殊的成员函数=delete即可：

 
 
 
    
  
  
  
  1. struct NoCopy 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     NoCopy & operator =( const NoCopy & ) = delete; 
    4. 
  
  
  
  4.     NoCopy ( const NoCopy & ) = delete; 
    5. 
  
  
  
  5. }; 
    6. 
  
  
  
  6. NoCopy a; 
    7. 
  
  
  
  7. NoCopy b(a); //compilation error, copy ctor is deleted 
    8.

nullptr

C++终于有一个关键字指定一个空指针常量了，nullptr取代了有错误倾向的null和文字0，这两个被用来作为空指针替代品已经有很多年的历史了，nullptr是一个强类型：

 
 
 
    
  
  
  
  1. void f(int); //#1 
    2. 
  
  
  
  2. void f(char *);//#2 
    3. 
  
  
  
  3. //C++03 
    4. 
  
  
  
  4. f(0); //which f is called? 
    5. 
  
  
  
  5. //C++11 
    6. 
  
  
  
  6. f(nullptr) //unambiguous, calls #2 
    7.

nullptr适用于所有指针类别，包括函数指针和成员指针：

 
 
 
    
  
  
  
  1. const char *pc=str.c_str(); //data pointers 
    2. 
  
  
  
  2. if (pc!=nullptr) 
    3. 
  
  
  
  3.   cout<
  
  
  
  4. int (A::*pmf)()=nullptr; //pointer to member function 
    5. 
  
  
  
  5. void (*pmf)()=nullptr; //pointer to function 
    6.

委托构造函数

在C++11中，构造函数可以调用相同类中的其它构造函数：

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

构造函数#2，委托构造函数，调用目标构造函数#1。

右值引用

C++03中的引用类型只能绑定左值，C++11引入了一种新型引用类型，叫做右值引用，右值引用可以绑定左值，例如，临时对象和字面量。增加右值引用的主要原因是move(移动)语义，它和传统的复制不一样，移动意味着目标对象偷窃了源对象的资源，留下一个状态为“空”的资源，在某些情况下，复制一个对象代价既高又没有必要，可以用一个移动操作代替，如果你想评估移动带来的性能收益，可以考虑字符串交换，一个幼稚的实现如下：

 
 
 
    
  
  
  
  1. void naiveswap(string &a, string & b) 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.  string temp = a; 
    4. 
  
  
  
  4.  a=b; 
    5. 
  
  
  
  5.  b=temp; 
    6. 
  
  
  
  6. } 
    7.

像这样写代价是很高的，复制字符串必须分配原始内存，将字符从源位置复制到目标位置，相反，移动字符串仅仅是交换两个数据成员，不用分配内存，复制char数组和删除内存：

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

如果你实现的类支持移动，你可以像下面这样声明一个移动构造函数和一个移动赋值操作符：

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

#p#

C++11标准库广泛使用了移动语义，许多算法和容器现在都为移动做了优化。

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中更简单的多线程”。

新的智能指针类

C++98只定义了一个智能指针类auto_ptr，它现在已经被废弃了，C++11引入了新的智能指针类shared_ptr和最近添加的unique_ptr，两者都兼容其它标准库组件，因此你可以在标准容器内安全保存这些智能指针，并使用标准算法操作它们。

新的算法

C++11标准库定义了新的算法模仿all_of()，any_of()和none_of()操作，下面列出适用于ispositive()到(first, first+n)范围，且使用all_of(), any_of() and none_of() 检查范围的属性的谓词：

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

一种新型copy_n算法也可用了，使用copy_n()函数，复制一个包含5个元素的数组到另一个数组的代码如下：

 
 
 
    
  
  
  
  1. #include 
    2. 
  
  
  
  2. int source[5]={0,12,34,50,80}; 
    3. 
  
  
  
  3. int target[5]; 
    4. 
  
  
  
  4. //copy 5 elements from source to target 
    5. 
  
  
  
  5. copy_n(source,5,target); 
    6.

算法iota()创建了一个值顺序递增的范围，好像分配一个初始值给*first，然后使用前缀++使值递增，在下面的代码中，iota()分配连续值{10,11,12,13,14}给数组arr，并将{‘a’,’b’,’c’}分配给char数组c。

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

C++11仍然缺乏一些有用的库，如XML API，套接字，GUI，反射以及前面提到的一个合适的自动垃圾回收器，但C++11的确也带来了许多新特性，让C++变得更加安全，高效，易学易用。

如果C++11的变化对你来说太大的话，也不要惊慌，多花些时间逐渐消化这一切，当你完全吸收了C++11的变化后，你可能就会同意Stroustrup的说法：C++11感觉就像一个新语言，一个更好的新语言。

原文出处：http://www.softwarequalityconnection.com/2011/06/the-biggest-changes-in-c11-and-why-you-should-care/

原文名：The Biggest Changes in C++11

网站栏目：掀起C++11的神秘面纱
标题来源：http://www.shufengxianlan.com/qtweb/news36/276186.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制开发知识

同城分类信息

软文平台　　 　成都网站制作　　 　江油网站建设　　 　重庆网站建设　　 　德阳做网站　　 　网站设计　　 　乐山网站建设　　 　成都做网站　　 　成都网站托管　　 　成都定制网页设计　　 　微信小程序　　 　成都网络营销公司　　 　梓潼网站建设　　 　wap网站制作　　 　香港空间腾讯云　　 　中建建业环保　　 　光华村机房　　 　广安网站制作公司　　 　全网整合营销推广　　 　眉山网站建设