C++ 11和C++98相比有哪些新特性

简介: 此文是如下博文的翻译: https://herbsutter.com/elements-of-modern-c-style/     C++11标准提供了许多有用的新特性。这篇文章特别针对使C++11和C++98相比看上去像一门新语言的特性,因为: C++11的这些特性改变了书写C++代码的风格和习惯,也改变了设计C++库的方式。

 此文是如下博文的翻译:

https://herbsutter.com/elements-of-modern-c-style/

 

 

C++11标准提供了许多有用的新特性。这篇文章特别针对使C++11和C++98相比看上去像一门新语言的特性,因为:

  • C++11的这些特性改变了书写C++代码的风格和习惯,也改变了设计C++库的方式。例如,你会看到更多的被当作参数和返回值的智能指针,还有按值(by value)返回超大对象的函数。
  • 它们被使用的非常广泛,在大多数代码中你都能看到它们。举个例子,在现代C++中几乎每5行C++代码你就能看到auto关键字。

还有一些其它的非常好的C++11新特性,但先把这篇文章所描述的新特性熟悉起来把,因为这些被广泛使用的特性展示了为什么C++11代码是简洁的,安全的和快速的,就像其它现代主流开发语言一样,并且性能和传统C++一样强大。

1. Auto

在任何可能的时候使用auto。因为有两个原因。第一,非常明显,能够避免重复输入我们已经声明的并且编译器已经认识的类型名称,这是非常方便的。

 1 // C++98
 2 
 3 map<int,string>::iterator i = m.begin();
 4 
 5 double const xlimit = config["xlimit"];
 6 
 7 singleton& s = singleton::instance(); 
 8 
 9 // C++11
10 
11 auto i = begin(m);
12 
13 auto const xlimit = config["xlimit"];
14 
15 auto& s = singleton::instance();

 

第二,当有遇到一个你不知道或者无法用语言表达的类型时,auto就不仅仅是使用方便这么简单了,比如,大多数lambda函数的类型,你不能够容易的将其类型拼写出来甚至根本就不能够写出来。

// C++98

binder2nd< greater > x = bind2nd( greater(), 42 ); 

// C++11

auto x = [](int i) { return i > 42; };

 

注意,使用auto并没有修改代码的语义。代码仍然是静态类型(statically typed),并且每个表达式都干净利落;只是不再强制我们多余的重新声明类型的名称。

一些人开始的时候害怕使用auto,因为给人的感觉像是并没有声明(重新声明)我们想要的类型,这意味着我们可能会突然得到一个不同的类型。如果你想显示的做强制类型转换,这没有问题;声明目标类型就可以了。但是在大部分情况下,使用auto就足够了,由于出现错误而得到另外一个类型的情况很少见,在使用强静态类型(strong static typing)情况下,如果类型出现错误编译器就会告诉你。

2. 智能指针,no delete

总是使用智能指针,不要用原生指针和delete。除非需要实现你自己的底层数据结构(把原生指针很好的封装在类(class boundary)中

如果你知道你是另外一个对象的唯一拥有着,使用unique_ptr来表示唯一的拥有权。一个"new T"表达式能很快的初始化一个拥有 这个智能指针的对象,特别是unique_ptr。典型的例子是指向实现的指针(Pimpl Idiom):

 1 // C++11 Pimpl idiom: header file
 2 class widget {
 3 public:
 4     widget();
 5     // ... (see GotW #100) ...
 6 private:
 7     class impl;
 8     unique_ptr<impl> pimpl;
 9 };
10  
11 // implementation file
12 class widget::impl { /*...*/ };
13  
14 widget::widget() : pimpl{ new impl{ /*...*/ } } { }
15 // ...

 

使用shared_ptr来表示共享所有权(shared ownership)。使用make_shared来创建共享对象更好。

1 // C++98
2 widget* pw = new widget();
3 :::
4 delete pw;
5  
6 // C++11
7 auto pw = make_shared<widget>();

 



使用weak_ptr来打破循环和表示可选性(比如实现一个对象缓存)

 1 // C++11
 2 class gadget;
 3  
 4 class widget {
 5 private:
 6     shared_ptr<gadget> g; // if shared ownership
 7 };
 8  
 9 class gadget {
10 private:
11     weak_ptr<widget> w;
12 };

 


如果你了解到另外一个对象比你的生存周期要长,并且你想观察这个对象,那么使用原生指针(raw pointer)。

1 // C++11
2 class node {
3  vector<unique_ptr<node>> children;
4  node* parent;
5 public:
6  :::
7 };

 

3. Nullptr


用nullptr来表示一个空指针,不要再使用数字0或者宏NULL来表示空指针了,因为这些是模棱两可的,既能表示整形也可表示指针。

1 // C++98
2 int* p = 0;
3  
4 // C++11
5 int* p = nullptr;

 

4. Range for


对一个范围内的元素进行有序访问,基于range的for循环会是更方便的用法。

1 // C++98
2 for( vector<int>::iterator i = v.begin(); i != v.end(); ++i ) {
3     total += *i;
4 }
5  
6 // C++11
7 for( auto d : v ) {
8     total += d;
9 }

 

5. 非成员begin和end


使用非成员函数begin(x)和end(x)(不是x.begin()和x.end()),因为begin(x)和end(x)是可扩展的,能同所有容器类型一块工作——甚至数组也可以——并不是只针对提供了STL风格的x.begin()和x.end()成员函数的容器。
如果你正在使用一个非STL集合类型,这个类型提供迭代器但不是STL风格的x.begin()和x.end(),你可以对他的非成员函数begin()和end()进行重载,这样你就可以使用同STL容器同样的风格进行编码。标准中举了一个例子:数组,并且提供了对象的begin和end函数:

 1 vector<int> v;
 2 int a[100];
 3  
 4 // C++98
 5 sort( v.begin(), v.end() );
 6 sort( &a[0], &a[0] + sizeof(a)/sizeof(a[0]) );
 7  
 8 // C++11
 9 sort( begin(v), end(v) );
10 sort( begin(a), end(a) );

 

6. Lambda函数和算法

Lambda表达式改变了游戏规则,它会时不时的改变你的编码方式,这种方式优雅并且快速。Lambda使现存STL算法实用性提高了百倍。
新增加的C++库的设计都以支持lambad表达式为前提(例如:PPL),甚至有一些库需要通过你编写lambda表达式来它(例如:c++ AMP)。
这里有个例子,找到v中的>X并且<Y的第一个元素。在C++11中,最简单并且干净的代码是使用标准算法。

1 // C++98: write a naked loop (using std::find_if is impractically difficult)
2 vector<int>::iterator i = v.begin(); // because we need to use i later
3 for( ; i != v.end(); ++i ) {
4     if( *i > x && *i < y ) break;
5 }
6  
7 // C++11: use std::find_if
8 auto i = find_if( begin(v), end(v), [=](int i) { return i > x && i < y; } );

 

想使用一个循环或者类似的语言特性(language feature)但实际上在该语言中并不存在,怎么办?将其实现成模板函数(库算法)就可以了,多亏了lambda,使用它就像是用一个语言特性一样的方便,但是更灵活,因为它确实是一个库而不是一个固定的语言特性。

 1 // C#
 2 lock( mut_x ) {
 3     ... use x ...
 4 }
 5  
 6 // C++11 without lambdas: already nice, and more flexible (e.g., can use timeouts, other options)
 7 {
 8     lock_guard<mutex> hold { mut_x };
 9     ... use x ...
10 }
11  
12 // C++11 with lambdas, and a helper algorithm: C# syntax in C++
13 // Algorithm: template<typename T> void lock( T& t, F f ) { lock_guard hold(t); f(); }
14 lock( mut_x, [&]{
15     ... use x ...
16 });

 

熟悉一下lambda吧,你会发现他们很有用,并不只是在c++中,它们已经在几个主流语言中得到支持并且流行开来。

7. Move/&&


把move当作是对拷贝的优化最合适不过了,虽然它也包含其他方面的东西(像完美转发(perfect forwarding))
move语义改变了我们设计API的方式。我们会越来越多的将函数设计成return by value。

 1 // C++98: alternatives to avoid copying
 2 vector<int>* make_big_vector(); // option 1: return by pointer: no copy, but don't forget to delete
 3 :::
 4 vector<int>* result = make_big_vector();
 5  
 6 void make_big_vector( vector<int>& out ); // option 2: pass out by reference: no copy, but caller needs a named object
 7 :::
 8 vector<int> result;
 9 make_big_vector( result );
10  
11 // C++11: move
12 vector<int> make_big_vector(); // usually sufficient for 'callee-allocated out' situations
13 :::
14 auto result = make_big_vector(); // guaranteed not to copy the vector

 

如果你想获得比copy更高效的办法,对你的类型使用move语义吧。

8. 统一的初始化和初始化列表


没有发生变化的:当初始化一个non-POD或者auto的本地变量时,继续使用熟悉的不带额外花括号{}的=语法。

1 // C++98 or C++11
2 int a = 42;        // still fine, as always
3  
4 // C++ 11
5 auto x = begin(v); // no narrowing or non-initialization is possible

 

在其他情况中(特别是随处可见的使用()来构造对象),使用花括号{}会更好。使用花括号{}能避免一些潜在的问题:你不会突然得到一个收缩转换(narrowing conversions)后的值(比如,float转换成int),也不会有偶尔突发的未初始化POD成员变量或者数组的存在,也能避免在c++98中会碰到的奇怪事:你的代码编译没问题,你需要的是变量但实际上你声明了一个函数,这都源于C++声明语法的模糊不清,Scott Meyers的著名说法:“C++最令人苦恼的解析”。通过使用新风格的语法上面解析问题会不复存在。

 1 // C++98
 2 rectangle       w( origin(), extents() );   // oops, declares a function, if origin and extents are types
 3 complex<double> c( 2.71828, 3.14159 );
 4 int             a[] = { 1, 2, 3, 4 };
 5 vector<int>     v;
 6 for( int i = 1; i <= 4; ++i ) v.push_back(i);
 7  
 8 // C++11
 9 rectangle       w   { origin(), extents() };
10 complex<double> c   { 2.71828, 3.14159 };
11 int             a[] { 1, 2, 3, 4 };
12 vector<int>     v   { 1, 2, 3, 4 };

 

新的{}语法在几乎任何地方都能出色的工作。

1 // C++98
2 X::X( /*...*/ ) : mem1(init1), mem2(init2, init3) { /*...*/ }
3  
4 // C++11
5 X::X( /*...*/ ) : mem1{init1}, mem2{init2, init3} { /*...*/ }

 

最后,有时候传递不带(type-named temporary)的函数参数是很方便的:
void draw_rect( rectangle );
 

1 // C++98
2 draw_rect( rectangle( myobj.origin, selection.extents ) );
3  
4 // C++11
5 draw_rect( { myobj.origin, selection.extents } );

 

我不喜欢使用花括号{}的唯一地方是在初始化一个非POD变量的时候,像 auto x= begin(v);使用花括号会使代码不必要的丑陋,因为我知道了它是一个类类型,所以我不必担心收缩转换,并且现代编译器已经对额外的拷贝(或者额外move,如果类型是move-enabled)进行了优化。


 


作者: HarlanC

博客地址: http://www.cnblogs.com/harlanc/
个人博客: http://www.harlancn.me/
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出, 原文链接

如果觉的博主写的可以,收到您的赞会是很大的动力,如果您觉的不好,您可以投反对票,但麻烦您留言写下问题在哪里,这样才能共同进步。谢谢!

目录
相关文章
|
28天前
|
编译器 C++ 开发者
C++一分钟之-C++20新特性:模块化编程
【6月更文挑战第27天】C++20引入模块化编程,缓解`#include`带来的编译时间长和头文件管理难题。模块由接口(`.cppm`)和实现(`.cpp`)组成,使用`import`导入。常见问题包括兼容性、设计不当、暴露私有细节和编译器支持。避免这些问题需分阶段迁移、合理设计、明确接口和关注编译器更新。示例展示了模块定义和使用,提升代码组织和维护性。随着编译器支持加强,模块化将成为C++标准的关键特性。
64 3
|
1月前
|
编译器 C语言 C++
C++一分钟之-C++11新特性:初始化列表
【6月更文挑战第21天】C++11的初始化列表增强语言表现力,简化对象构造,特别是在处理容器和数组时。它允许直接初始化成员变量,提升代码清晰度和性能。使用时要注意无默认构造函数可能导致编译错误,成员初始化顺序应与声明顺序一致,且在重载构造函数时避免歧义。利用编译器警告能帮助避免陷阱。初始化列表是高效编程的关键,但需谨慎使用。
29 2
|
2月前
|
存储 编译器 C语言
从C语言到C++_34(C++11_下)可变参数+ lambda+function+bind+笔试题(下)
从C语言到C++_34(C++11_下)可变参数+ lambda+function+bind+笔试题
42 5
|
13天前
|
存储 安全 编译器
【C++入门 四】学习C++内联函数 | auto关键字 | 基于范围的for循环(C++11) | 指针空值nullptr(C++11)
【C++入门 四】学习C++内联函数 | auto关键字 | 基于范围的for循环(C++11) | 指针空值nullptr(C++11)
|
22天前
|
数据安全/隐私保护 C++
|
29天前
|
安全 JavaScript 前端开发
C++一分钟之-C++17特性:结构化绑定
【6月更文挑战第26天】C++17引入了结构化绑定,简化了从聚合类型如`std::tuple`、`std::array`和自定义结构体中解构数据。它允许直接将复合数据类型的元素绑定到单独变量,提高代码可读性。例如,可以从`std::tuple`中直接解构并绑定到变量,无需`std::get`。结构化绑定适用于处理`std::tuple`、`std::pair`,自定义结构体,甚至在范围for循环中解构容器元素。注意,绑定顺序必须与元素顺序匹配,考虑是否使用`const`和`&`,以及谨慎处理匿名类型。通过实例展示了如何解构嵌套结构体和元组,结构化绑定提升了代码的简洁性和效率。
41 5
|
29天前
|
算法 安全 编译器
【C++航海王:追寻罗杰的编程之路】C++11(四)
【C++航海王:追寻罗杰的编程之路】C++11(四)
21 0
|
29天前
|
存储 安全 程序员
【C++航海王:追寻罗杰的编程之路】C++11(一)
【C++航海王:追寻罗杰的编程之路】C++11(一)
17 0
【C++航海王:追寻罗杰的编程之路】C++11(一)
|
13天前
|
存储 算法 编译器
【C++11】C++11深度解剖(下)
【C++11】C++11深度解剖(下)
14 0
|
13天前
|
存储 安全 程序员
【C++11】C++11深度解剖(上)
【C++11】C++11深度解剖(上)
14 0