侯捷C++ 2.0 新特性

关键字

nullptr and std::nullptr_t

侯捷C++ 2.0 新特性_第1张图片

auto

侯捷C++ 2.0 新特性_第2张图片

一致性初始化:Uniform Initialization

11之前,初始化方法包括:小括号、大括号、赋值号,这让人困惑。基于这个原因,给他来个统一,即,任何初始化都能够使用大括号来实现。实现的方法使用另外一个新特性:初始化列表。下一个特性介绍。

// 11之前
Rect r1 = {3, 7, 30};
Rect r2(3, 7, 20);
int ia[6] = {27, 89, 20};

// 11之后
int values[] {1, 2, 3};
vector v {1, 2, 3};
complex c {4.0, 3.0};

初始化列表:Initializer Lists

ERROR:narrowing    不允许窄化的转换 

前面的一致性初始化中的大括号会形成一个初始化列表。具体实现代码如下:

侯捷C++ 2.0 新特性_第3张图片

explicit

struct complex{
	int real, imag;
	// explicit
	complex(int re, int im = 0) : real(re), imag(im){}
	complex operator+(const complex& x){
		return complex((real + x.real), (imag + x.imag));
	}
}

11之前,用于一个参数的构造函数。有上面的代码,那么在执行complex c1(12, 5); complex c2 = c1 + 5;的时候,构造函数不用explicit修饰,则会把5变成一个复数类,但是如果用explicit修饰了,这两句代码就会报错。也就是,让编译器知道,用户希望只在显式调用构造函数的时候才会调用,其他时候不允许调用。

11之后,explicit可用在接受一个以上参数的构造函数。突破了一个参数的限制,阻止任意多个参数的构造函数的隐式调用。

class p {

public:
	p(int a, int b){
		cout << "p(int a, int b)" << endl;
	}

	explicit p(int a, int b, int c){
		cout << "expilict p(int a, int b, int c)" << endl;
	}
}

p p1(1, 2); //p(int a, int b)
p p2 = {1, 2, 3}; // 报错,因为initializer想要去调用用explicit修饰的构造函数,被编译器阻止

=default, =delete


如果自行定义了一个构造函数,那么编译器就不会给你一个默认的构造函数;

如果你强行加一个 =default,就可以重新获得并使用编译器给出的默认构造函数。

=default只可以用于构造函数,=delete可用于任何函数,给编译器说明禁止使用这个函数。

侯捷C++ 2.0 新特性_第4张图片

模板别名:Alias Template

别以为它只是让一个类换个名字,方便书写,它后面会引发一个大事情。

比如下面这个例子:

template 
using Vec = std::vector>;

Vec coll; 
is equivalent to
std::vector> coll;

那我们可以用#define或是typedef来达到同样的效果吗?

#define Vec template std::vector>;
Vec coll; //------> template std::vector>; //这不是我们想要的

//如果使用typedef,因为typedef是不能够接受参数的,最多写成下面这样
typedef std::vector> Vec;

所以,using的优势就是能够指定参数。

那这样做,只是为了减少代码量吗?如果有一个场景,需要以一个类型作为参数,而不是以一个类的对象作为参数呢?比如说下面这种情况:

Container是一种类型,所以上面的语句就会报错,找不到Container定义。有一种解决方案是牺牲方法的通用性,将Container和T进行组合变成一个参数传入,这种实现方法也不赖。那有没有更优雅的实现方案呢?程序员嘛,都是讲究优雅的!

所以要进行下面的思考:有没有模板语法,能够在一个模板类中接受一个模板参数,在模板类中取出这个模板参数呢?有!模板模板参数!

模板模板参数

侯捷C++ 2.0 新特性_第5张图片

template class Container>
class XCIs{
private:
	Container c;
public:
	XCIs(){
		for(long i = 0; i < size; ++i)
			c.insert(c.end(), T());
		...(上图中的实现)
	}
}

上述就是模板模板参数的使用。在引入模板模板参数之后,就可以这么使用:XCIs c1;完成我们的任务。但是!这一句又会报错,因为vector模板容器需要两个模板参数(类型和分配器)!这,不就需要using了吗? 

类型别名:Type Alias

类似于typedef,不过是借助using来实现:

typedef void(*func)(int, int); // 函数指针
				|
				|
				v
using func = void(*)(int, int);

和typedef的唯一区别是using多了一个模板别名(带参数)的功能。

using的所有用法

  1. using namespace std; //打开一个命名空间
    using std::count; //打开一个命名空间的一个组件
  2. using Base::_M_Prime; //打开一个类的一个成员
  3. 模板别名、类型别名

noexcept

保证一个函数不会抛出异常:

void foo() noexcept;
void foo() noexcept(predicate); // 在条件predicate为真时,不抛出异常

异常一定要被处理,如果一个函数声明为noexcept就会把异常交给上一层调用。

你最好是告诉C++(特别是vector):你的移动构造函数和移动赋值构造函数是noexcept的。因为vector要增长空间,增长空间有构造函数调用过程,如果不显示声明移动构造时noexcept的,编译器不敢调用!

final

修饰类,表示被修饰的类不能够继承;
修饰虚函数,表示虚函数不能被重写。

侯捷C++ 2.0 新特性_第6张图片

decltype

主要是为泛型编程而设计,以解决泛型编程中,由于有些类型由模板参数决定,而难以(甚至不可能)表示之的问题。有点类似typeof。

// C++11
map coll;
decltype(coll)::value_type elem;

// C++11之前
map coll;
map::value_type elem;

应用:

  1. 用于声明返回类型
// 希望如此
templat
decltype(x+y) add(T1 x, T2 y);

// 这么实现
templat
auto add(T1 x, T2 y) -> decltype(x+y); //和lambdas表达式相似

 拿来表示一个函数类型

侯捷C++ 2.0 新特性_第7张图片

元编程

lambdas表达式


C++11引入lambdas表达式,允许定义一个匿名函数,这个匿名函数时inline的。可以定义在一些状态或者表达式中。下图中的auto就是一个functor的匿名类。lambdas无默认构造函数(所以在容器中指定sort方法的时候,需要调用该容器对应的lambda构造函数)。
侯捷C++ 2.0 新特性_第8张图片

不加 mutable 不能改变数字

[]开头的就是lambdas表达式,叫做introducer,用于捕获lambdas表达式外的变量用到具体方法内,可以指定传值方法。如果是=,则方法内可以以值传递的方式捕获lambdas外的所有变量

()放函数参数

mutable关系到[]中的内容是否可被改写,用在传值上(写上mutable说明[]中的值可以在{}中进行修改),可选

throwSpec指定是否抛出异常,可选

retType指定返回类型,可选

{}中放具体的方法实现

定义出来的是一个对象,需要()来调用

lambdas表达式妙用:

vector vec {1,30,69,20,40,195,124};
int x = 20;
int y = 100;
vec.erase(
	remove_if(vec.begin(), vec.end(), [x, y](int n){return x , n && n < y;}),
	vec.end()	
); // 之前需要使用仿函数适配器才能完成这个任务

可变参数:Variadic Templates

初级语法

允许一个函数的参数可以是任意类型,任意个数。

函数在执行的时候,会将参数包解析为一个参数和剩余参数组成的参数包两个部分。

需要一个空函数用于处理在参数包解析到不包含参数的情况。

侯捷C++ 2.0 新特性_第9张图片

void printX(){

}

template 
void printX(const T& firstArg, const Types&... args){
	cout << firstArg << endl;
	printX(args...);
}

// 可以这么调用
print(7.5, "hello", biset<16>(337), 42);

// 想知道参数包中有几个参数,可以用sizeof...(args)
cout << sizeof...(args) << endl;

STL中HashCode、Tuple的实现就使用了Variadic Template:

图中1,2两个函数的关系就像模板的泛化与特化的关系,第2个函数是特化版本,在1函数中虽然从理论上讲可以递归调用自己,但是调用2函数更加匹配。

更深入的了解(例子)

变化的是:参数个数,参数类型。

例子:printf

例子:maximun

例子:tuple(头尾处理方式不同)

例子:tuple(递归继承)

例子:tuple(递归复合)

右值引用

对容器的效率有大幅度改善,避免不必要的copy(当拷贝的来源端是一个右值,则接受端可以去偷(steal)这个右值的资源)而不执行separate allocation。perfect forward

左值:可以出现在operator=左侧
右值:只能出现在operator=右侧

临时对象是一个右值。拷贝构造是个深拷贝。

为什么放在标准库这一块谈呢?因为它和标准库密切相关。

侯捷C++ 2.0 新特性_第10张图片

int foo(){return 5;}

int x = foo();
int *p = &foo(); //不行!不能够取右值地址
foo() = 7; //不行

侯捷C++ 2.0 新特性_第11张图片

当右值出现于operator=的右侧时,我们认为其对资源进行搬移而非拷贝是可以的,合理的,那么:

  1. 必须要有语法让我们在调用端告诉编译器,这里是个右值(move)
  2. 必须有语法让我们在被调用端写出一个专门处理右值的move assignment函数(移动构造)

进行移动构造的时候,把新指针指向旧指针指向的地方,旧指针的指向会被取消掉,旧指针不能够再使用!所以,右值和移动构造配合得很好,因为右值以后也不会再使用了啊!如果本来是一个左值,可以把这个左值传入move函数作为参数,就是显式调用移动构造函数(move把左值变成了右值)。

写一个移动构造、移动赋值构造的例子:

MyString(MyString&& str) noexcept
	: _data(str._data), len(str._len){
	str._len = 0;
	str._data = NULL; //为什么不直接delete?因为要把工作交给析构函数
}

MyString& operator=(MyString&& str) noexcept{
	if(this != &str){
		_len = str._len;
		_data = str._data;
		str._len = 0;
		str._dtat = NULL;
	}
	return *this;
}

 不完美的交付:

C++11 枚举类

C++11枚举类——enum class-CSDN博客

参考文章:侯捷C++八部曲笔记(四、C++2.0新特性)_2.0/3+1c++-CSDN博客

你可能感兴趣的:(C++,c++)