C++11新特性总结 (二)

1. 范围for语句

C++11 引入了一种更为简单的for语句，这种for语句能够很方便的遍历容器或其余序列的全部元素

vector<int> vec = {1,2,3,4,5,6};
for(int x: vec)
{
    cout<<x<<endl;
}

2. 尾置返回类型

要想引入尾置类型，咱们还得从复杂的类型声明提及。若是咱们须要定义一个含有10个int元素的数组，通常是这样的：

int arr[10] = {0};

若是要定义指向这个数组的指针呢：

int (*p_arr)[10] = &arr; //注意：int *p_arr[10] 表示一个数组，有10个元素，元素类型是int*

若是要定义一个函数，这个函数接受一个char类型的参数，并返回一个指向10个int类型数组的指针呢：

int (*func(char x))[10];

这样的声明是否是看的头都大了，其实咱们能够简化一点，通常状况下咱们可使用别名进行简化，好比：

typedef int ARR[10] ; // 定义一个类型 ARR这是一个数组类型，含有10个int类型的元素
using ARR = int[10] ; // 同上

再定义如上的函数：

ARR * func(char x) ; // 函数返回的类型是 ARR* 也就是指向具备10个int元素数组的指针

固然在C++11中咱们能够用以前讲到过的另一个关键字decltype：

decltype(arr) * func(char x) ; // decltype(arr)表达式会得到arr的类型

最后就轮到咱们本节要说的C++11的另一个特性，尾置返回类型，任何函数均可以使用尾置返回类型，这种形式对于返回类型比较复杂的函数最有效，好比上面的函数可使用以下方式：

auto func(char x) -> int(*) [10]; 

这种形式将函数的返回类型写在函数声明的最后面，而且在函数形参列表后面加上 -> 符号，而后紧接着是函数须要返回的类型，因为函数的返回类型被放在了形参列表以后，因此在函数名前面使用一个 auto替代。

3. =default 生成默认构造函数

在C++的类中，若是咱们没有定义构造函数，编译器会为咱们合成默认的无参构造函数，若是咱们定义了构造函数，则编译器就不生成默认构造函数了，可是若是咱们定义构造函数同时也但愿编译器生成默认构造函数呢? C++11中能够经过在构造函数的声明中直接  =default的方式要求编译器生成构造函数。

class ClassName{
	public:
		ClassName(int x);
		ClassName()=default; // 显示要求编译器生成构造函数
};

4. 类对象成员的类内初始化

class ClassName
{
        public:
                int x = 10; //C++11 以前是不容许的
};

5. lambda表达式与bind函数

lambda表达式是一个能够被调用的代码单元，至关于一个内联函数，有参数和返回值以及函数体。可是跟函数不一样的是，lambda表达式能够定义在函数的内部，一个完整的lambda表达式具备以下形式：

[捕获列表](参数列表) mutable -> 返回类型 {函数体}

int x = 10;
int y = 20;
auto f = [x,&y](int a ,int b){++y;return a+b+x+y;};
cout<<f(1,2)<<endl; //34
cout<<y<<endl;      //21

lambda能够省略参数列表(若是没有参数的话)，能够省略返回类型，可是不能省略捕获部分与函数体部分，即便捕获列表为空,也要有一个空的[]，lambda有两种捕获，一种是值捕获，一种是引用捕获。若是是值捕获那么lambda中得到的是捕获的变量的副本，若是是引用捕获则得到的是引用，能够在lambda内部修改引用的变量的值，如上x是值捕获，y是引用捕获，lambda中默认是值捕获，若是变量前面添加&则是引用捕获，另外lambda中还有两种形式的引用捕获，例如[=]表示值捕获全部可见的变量，而[&]则表示引用捕获全部可见变量。若是但愿值捕获全部可见变量，可是又有个别变量采用引用捕获呢，[=,&x]表示值捕获全部可见变量，同时引用捕获x。而[&,x]则表示引用捕获全部可见变量，x采用值捕获的方式。

有关bind函数，在不少地方咱们可使用函数替换lambda表达式，毕竟若是不少地方须要用到同一个lambda表达式，并且这个lambda表达式比较长的话，将其定义成函数应该是最好的。对于没有捕获列表的lambda表达式咱们能够直接使用函数替代，例如：

void main()
{
	auto f=[](int x,int y){return x+y};
	f();
}

咱们能够用下面的方式替代：

int f(int x,int y)
{
   return x+y;
}

void main()
{
	f();
}

与上面的lambda是等价的，可是对于有捕获列表的lambda表达式应该怎么处理呢，例如：

void main()
{
	int x = 10;
	int y = 20;
	auto f = [x,&y](int a ,int b){return a+b+x+y;}; //一个值捕获，一个引用捕获
	f(33,44);
}

若是转换成函数的形式：

int x = 10;
int y = 20;
int f(int a,int b)
{
  return a+bx+y;
}

void main()
{
	f(33,44);
}

这是一种可行的方法，可是总不能把全部的捕获变量定义成全局变量吧。如今的关键问题是lambda的捕获表达式中的内容转换成函数不可行，C++11提供了bind函数来完成这样的操做。

#include <functional> //bind()
#include <iostream>
using namespace std;
using namespace std::placeholders; // _1,_2所在的命名空间
int f(int x,int y,int a,int b)
{
  return a+b+x+y;
}

void main()
{
  int x = 10;
  int y = 20;

  auto f_wrap = bind(f,x,y,_1,_2);
  cout<<f_wrap(33,44)<<endl; // _1,_2是占位符,表示调用f_wrap的时候_1是第一个参数,_2是第二个参数。最终会被替换成调用  f(10,20,33,44)
}

若是引用类型的捕获怎么作呢，看下面的例子，用lambda是这样的：

#include <iostream>
#include <functional>
using namespace std;
using namespace std::placeholders;
void main()
{
  int x = 10;
  ostream &o = cout;
  auto f =[&o](int a){o<<a<<endl;}; // 注意这里的输出对象是用的引用捕获
  f(x);
}

使用bind是这样的：

#include <iostream>
#include <functional>
using namespace std;
using namespace std::placeholders;
void f(ostream &o,int x)
{
  o<<x<<endl;
}
int main()
{
  int x = 10;
  auto f_wrap = bind(f,ref(cout),_1); //将变量的引用传递到bind中是个问题，为此C++11提供了ref()函数用于得到引用
  f_wrap(x);
  return 0 ;
}

6. 智能指针share_ptr,unique_ptr

C++11中引入了几种智能指针，智能指针可以自动释放所指向的对象，其中shared_ptr容许多个指针指向同一个对象，unique_ptr则独占所指向的对象，咱们主要说明shared_ptr的使用。经过使用make_shared<type>()函数产生智能指针对象。

shared_ptr<int> p = make_shared<int>(40); // p指向一个值为40的int对象
shared_ptr<string> p2 = make_shared<string>(10,'c'); //指向值为'cccccccccc'的string对象

make_shared<type>()函数中传递的值要与对应的type的构造函数相匹配，实际上应该就是直接调用的对应type的构造函数。

咱们可使用new初始化的指针来初始化智能指针：

share_ptr<int> p (new int(40));
p.get(); // 使用share_ptr<type>的get()函数来得到其关联的原始指针。

shared_ptr对象在离开其做用域(例如一个函数体)，会自动释放其关联的指针指向的动态内存，就像局部变量那样。另外多个shared_ptr能够指向一个对象，当最后一个shared_ptr对象销毁的时候才会销毁其关联的那个对象的动态内存。这里使用了引用记数。

7. 右值引用与move调用,移动构造函数

为了支持移动操做，C++11中使用了一种称为右值引用的类型。移动操做是什么呢，通常状况下咱们将一个对象赋值给另外一个对象的时候会调用对象到拷贝构造函数或者拷贝赋值运算符。而移动构造函数和移动赋值运算符则用来将数据从一个对象移动到另外一个对象。在不少状况下对象拷贝以后须要被销毁，此时使用移动操做会大幅提升性能。右值引用被使用以后，其关联的对象会被销毁。右值引用使用两个&&表示，例如 int && 表示右值引用，而int &则是左值。经过C++11标准库提供的函数 std::move()能够获得某一对象的右值引用。

TestClass::TestClass(TestClass &&t) noexcept //移动构造函数不该该抛出任何异常
:x(t.x),y(t.y),z(t.z),p(t.p)
{
  t.p=nullptr; // 实现移动操做以后须要保证被移动的对象的析构是安全的，因此源对象的指针成员置为空，随后t的析构函数将会被自动调用，t被销毁。
}

8. function

C++11中提供了名为function的标准库类型，定义在头文件<functional>中，该类型用来存储一个可调用的对象，统一了全部能够像函数同样调用的调用形式，例如：

#include <functional>
#include <iostream>
using namespace std;

int add(int x,int y)
{
	return x+y;
}

class Add
{
	public:
		int operator()(int x,int y)
		{
			return x+y;
		}
};

void main()
{
  //function模版的参数是函数调用形式,包括返回类型,以及参数列表个数和类型
	function<int(int,int)> f1 = add;  //函数指针
	function<int(int,int)> f2 = Add(); // 可调用类对象
	function<int(int,int)> f3 = [](int x,int y){return x+y;}; //lambda表达式
	
	cout<<f1(10,20)<<" "<<f2(30,40)<<" "<<f3(50,60)<<endl;
}

9. 其余新增类型(array,forward_list,bitset,regex)

实际上C++11中除了一些语法特性新增以外，还增长了一些新的库。例如array至关于咱们传统使用的定长数组，支持随机访问，不能添加删除元素，不能够像vector同样增加，使用array比传统数组更加安全。

forward_list是C++11中增长的单向链表

regex则是C++11中新增的正则表达式库

10. 总结

C++11中增长了一些库，库自己的使用不作过多介绍，能够参考C++标准库/STL源码剖析，这都是用单独的大部头书籍讲解的，有些特性和库是我感受比较惊艳的，例如：

auto 定义：可让编译器自动推算定义的变量类型，而不须要写长长的一串类型，特别是在含有迭代器的类型上。
decltype ：能够根据已知的变量来定义一个跟该变量同样的类型。
lambda：我的认为这是C++11中增长的最惊艳的特性之一，对应的还有bind()函数，其实这些内容是从Boost中来的。
智能指针：shared_ptr 虽然在之前的C++中有相似auto_ptr的智能指针，可是auto_ptr有一些缺陷并不算很好用。
function类型：标准库的function类型定义了一种可调用对象，该类型统一了全部能够看成函数同样调用的调用形式，例如lambda，函数指针，重载了函数调用运算符()的类对象等，该特性也是参考了Boost库。
regex库：C++11中总算有了方便的regex可使用了。

 

C++11新特性总结 (一)

 

若是您以为这篇文章对您有帮助，须要您的【赞】，让更多的人也能看见哦