C++11

  • auto和decltype
  • 右值引用
  • 列表初始化
    C++14
    C++17
    C++20
    持续更新…


auto和decltype


类型推导:C++11引用auto和decltype关键字,使用它们可以在编译期就推导出变量或者表达式的类型。


auto


推导规则:

  • 通过=右边的类型推导出变量的类型:​​auto a = 10; // 10是int型,可以自动推导出a是int​

推导限制:

  • auto的使用必须马上初始化,否则无法推导出类型:​​auto e; // error,使用auto必须马上初始化,否则无法推导类型​
  • auto在一行定义多个变量时,各个变量的推导不能产生二义性,否则编译失败:​​auto d = 0, f = 1.0; // error,0和1.0类型不同,对于编译器有二义性,没法推导​
  • auto不能用作函数参数:​​void func(auto *value*) {} // error,auto不能用作函数参数​
  • 在类中auto不能用作非静态成员变量:

class A
{
auto a = 1; // error,在类中auto不能用作非静态成员变量
static auto b = 1; // error,这里与auto无关,正常static int b = 1也不可以
static const auto c = 1; // ok
};

  • auto不能定义数组,可以定义指针:​​auto c[10] = a; // error,auto不能定义数组,可以定义指针​
  • auto无法推导出模板参数:

vector<int> d;
vector<auto> f = d; // error,auto无法推导出模板参数

  • 在不声明为引用或指针时,auto会忽略等号右边的引用类型和const 和volatile限定
  • 在声明为引用或者指针时,auto会保留等号右边的引用和const 和volatile属性

int i = 0;
auto *a = &i; // a是int*
auto &b = i; // b是int&
auto c = b; // c是int,忽略了引用

const auto d = i; // d是const int
auto e = d; // e是int

const auto &f = e; // f是const int&
auto &g = f; // g是const int&


decltype


推导规则:

decltype则用于推导表达式类型,这里只用于编译器分析表达式的类型,表达式实际不会进行运算。

对于decltype(exp)有

  • exp是表达式,decltype(exp)和exp类型相同
  • exp是函数调用,decltype(exp)和函数返回值类型相同
  • 其它情况,若exp是左值,decltype(exp)是exp类型的左值引用
  • decltype会保留表达式的引用和const 和volatile属性

int a = 0, b = 0;
decltype(a + b) c = 0; // c是int,因为(a+b)返回一个右值
decltype(a += b) d = c;// d是int&,因为(a+=b)返回一个左值

d = 20;
cout << "c " << c << endl; // 输出c 20


auto和decltype配合使用


返回值后置类型语法就是为了解决函数返回值类型依赖于参数但却难以确定返回值类型的问题

template<typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
return t + u;
}


右值引用


C++11引用


左值&右值


概念1

  • 左值:可以放到等号左边的东西叫左值。
  • 右值:不可以放到等号左边的东西就叫右值。

概念2

  • 左值:可以取地址并且有名字的东西就是左值。
  • 右值:不能取地址的没有名字的东西就是右值。

int a = b + c; // a是左值,有变量名,可以取地址,也可以放到等号左边, 表达式b+c的返回值是右值,没有名字且不能取地址,&(b+c)不能通过编译,而且也不能放到等号左边。
int a = 4; // a是左值,4作为普通字面量是右值

左值一般有:

  • 函数名和变量名
  • 返回左值引用的函数调用
  • 前置自增自减表达式++i、–i
  • 赋值表达式或赋值运算符连接的表达式(a=b, a += b等)
  • 解引用表达式*p
  • 字符串字面值"abcd"


纯右值&将亡值


纯右值和将亡值都属于右值。

纯右值

运算表达式产生的临时变量、不和对象关联的原始字面量、非引用返回的临时变量、lambda表达式等都是纯右值。

举例:

  • 除字符串字面值外的字面值
  • 返回非引用类型的函数调用
  • 后置自增自减表达式i++、i–
  • 算术表达式(a+b, a*b, a&&b, a==b等)
  • 取地址表达式等(&a)

将亡值

将亡值是指C++11新增的和右值引用相关的表达式,通常指将要被移动的对象、T&&函数的返回值、std::move函数的返回值、转换为T&&类型转换函数的返回值,将亡值可以理解为即将要销毁的值,通过“盗取”其它变量内存空间方式获取的值,在确保其它变量不再被使用或者即将被销毁时,可以避免内存空间的释放和分配,延长变量值的生命周期,常用来完成移动构造或者移动赋值的特殊任务。

class A {
xxx;
};
A a;
auto c = std::move(a); // c是将亡值
auto d = static_cast<A&&>(a); // d是将亡值


左值引用&右值引用


左值引用就是对左值进行引用的类型;

右值引用就是对右值进行引用的类型;

他们都是引用,都是对象的一个别名并不拥有所绑定对象的堆存,所以都必须立即初始化

type &name = exp; // 左值引用
type &&name = exp; // 右值引用

左值引用

int a = 5;
int &b = a; // b是左值引用
b = 4;
int &c = 10; // error,10无法取地址,无法进行引用,非常量引用的初始值必须为左值
const int &d = 10; // ok,因为是常引用,引用常量数字,这个常量数字会存储在内存中,可以取地址

// 对于左值引用,等号右边的值必须可以取地址,如果不能取地址,则会编译失败,或者可以使用const引用形式,但这样就只能通过引用来读取输出,不能修改数组,因为是常量引用。

右值引用

// 如果使用右值引用,那表达式等号右边的值需要时右值,可以使用std::move函数强制把左值转换为右值。
int a = 4;
int &&b = a; // error, a是左值,无法将右值引用绑定到左值
int &&c = std::move(a); // ok


深拷贝&浅拷贝


区别

  • 在未定义显示拷贝构造函数的情况下,系统会调用默认的拷贝函数——即浅拷贝,它能够完成成员的一一复制。当数据成员中没有指针时,浅拷贝是可行的;但当数据成员中有指针时,如果采用简单的浅拷贝,则两类中的两个指针将指向同一个地址,当对象快结束时,会调用两次析构函数,而导致指针悬挂现象,所以,此时,必须采用深拷贝。
  • 深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据,从而也就解决了指针悬挂的问题。简而言之,当数据成员中有指针时,必须要用深拷贝




// 浅拷贝
class A {
public:
A(int size) : size_(size) {
data_ = new int[size];
}
A(){}
A(const A& a) {
size_ = a.size_;
data_ = a.data_;
cout << "copy " << endl;
}
~A() {
delete[] data_;
}
int *data_;
int size_;
};
int main() {
A a(10);
A b = a;
cout << "b " << b.data_ << endl;
cout << "a " << a.data_ << endl;
return 0;
}

/*
输出:
b 0x6b61a0
a 0x6b61a0
*/
// 深拷贝
class A {
public:
A(int size) : size_(size) {
data_ = new int[size];
}
A(){}
A(const A& a) {
size_ = a.size_;
data_ = new int[size_]; // 深拷贝
cout << "copy " << endl;
}
~A() {
delete[] data_;
}
int *data_;
int size_;
};
int main() {
A a(10);
A b = a;
cout << "b " << b.data_ << endl;
cout << "a " << a.data_ << endl;
return 0;
}

/*
输出:
copy
b 0x976b80
a 0x976b10
*/

深拷贝就是再拷贝对象时,如果被拷贝对象内部还有指针引用指向其它资源,自己需要重新开辟一块新内存存储资源,而不是简单的赋值。


移动语义


转移所有权,之前的拷贝是对于别人的资源,自己重新分配一块内存存储复制过来的资源,而对于移动语义,类似于转让或者资源窃取的意思,对于那块资源,转为自己所拥有,别人不再拥有也不会再使用,通过C++11新增的移动语义可以省去很多拷贝负担,怎么利用移动语义呢,是通过移动构造函数

class A {
public:
A(int size) : size_(size) {
data_ = new int[size];
}
A(){}
A(const A& a) {
size_ = a.size_;
data_ = new int[size_];
cout << "copy " << endl;
}
A(A&& a) {
this->data_ = a.data_;
a.data_ = nullptr;
cout << "move " << endl;
}
~A() {
if (data_ != nullptr) {
delete[] data_;
}
}
int *data_;
int size_;
};
int main() {
A a(10);
A b = a;
A c = std::move(a); // 调用移动构造函数
return 0;
}

/*
输出:
copy
move
*/

如果不使用std::move(),会有很大的拷贝代价,使用移动语义可以避免很多无用的拷贝,提供程序性能,C++所有的STL都实现了移动语义,方便我们使用。

移动语义仅针对于那些实现了移动构造函数的类的对象,对于那种基本类型int、float等没有任何优化作用,还是会拷贝,因为它们实现没有对应的移动构造函数。


完美转发


一个接受任意实参的函数模板,并转发到其它函数,目标函数会收到与转发函数完全相同的实参,转发函数实参是左值那目标函数实参也是左值,转发函数实参是右值那目标函数实参也是右值。使用std::forward()实现完美转发。

void PrintV(int &t) {
cout << "lvalue" << endl;
}

void PrintV(int &&t) {
cout << "rvalue" << endl;
}

template<typename T>
void Test(T &&t) {
PrintV(t);
PrintV(std::forward<T>(t));

PrintV(std::move(t));
}

int main() {
Test(1); // lvalue rvalue rvalue
int a = 1;
Test(a); // lvalue lvalue rvalue
Test(std::forward<int>(a)); // lvalue rvalue rvalue
Test(std::forward<int&>(a)); // lvalue lvalue rvalue
Test(std::forward<int&&>(a)); // lvalue rvalue rvalue
return 0;
}

  • Test(1):1是右值,模板中T &&t这种为万能引用,右值1传到Test函数中变成了右值引用,但是调用PrintV()时候,t变成了左值,因为它变成了一个拥有名字的变量,所以打印lvalue,而PrintV(std::forward(t))时候,会进行完美转发,按照原来的类型转发,所以打印rvalue,PrintV(std::move(t))毫无疑问会打印rvalue。
  • Test(a):a是左值,模板中T &&这种为万能引用,左值a传到Test函数中变成了左值引用,所以有代码中打印。
  • Test(std::forward(a)):转发为左值还是右值,依赖于T,T是左值那就转发为左值,T是右值那就转发为右值。


返回值优化


返回值优化(RVO)是一种C++编译优化技术,当函数需要返回一个对象实例时候,就会创建一个临时对象并通过复制构造函数将目标对象复制到临时对象,这里有复制构造函数和析构函数会被多余的调用到,有代价,而通过返回值优化,C++标准允许省略调用这些复制构造函数。

那什么时候编译器会进行返回值优化呢?

  • return的值类型与函数的返回值类型相同
  • return的是一个局部对象

std::vector<int> return_vector(void) {
std::vector<int> tmp {1,2,3,4,5};
return tmp;
}

std::vector<int> rval_ref = return_vector();

触发RVO,不拷贝也不移动,不生成临时对象。


列表初始化


在变量名后面加上初始化列表来进行对象的初始化。

struct A {
public:
A(int) {}
private:
A(const A&) {}
};
int main() {
A a(123);
A b = 123; // error
A c = { 123 };
A d{123}; // c++11

int e = {123};
int f{123}; // c++11

return 0;
}

列表初始化也可以用在函数的返回值上

std::vector<int> func() {   
return {};
}

首先说下聚合类型可以进行直接列表初始化,这里需要了解什么是聚合类型

  1. 类型是一个普通数组,如int[5],char[],double[]等
  2. 类型是一个类,且满足以下条件:
  • 没有用户声明的构造函数
  • 没有用户提供的构造函数(允许显示预置或弃置的构造函数)
  • 没有私有或保护的非静态数据成员
  • 没有基类
  • 没有虚函数
  • 没有{}和=直接初始化的非静态数据成员
  • 没有默认成员初始化器

// 类A不是聚合类型,无法进行列表初始化,必须以自定义的构造函数来构造对象。
struct A {
int a;
int b;
int c;
A(int, int){}
};
int main() {
A a{1, 2, 3};// error,A有自定义的构造函数,不能列表初始化
}
struct A {
int a;
int b;
virtual void func() {} // 含有虚函数,不是聚合类
};

struct Base {};
struct B : public Base { // 有基类,不是聚合类
int a;
int b;
};

struct C {
int a;
int b = 10; // 有等号初始化,不是聚合类
};

struct D {
int a;
int b;
private:
int c; // 含有私有的非静态数据成员,不是聚合类
};

struct E {
int a;
int b;
E() : a(0), b(0) {} // 含有默认成员初始化器,不是聚合类
};

对于一个聚合类型,使用列表初始化相当于对其中的每个元素分别赋值;对于非聚合类型,需要先自定义一个对应的构造函数,此时列表初始化将调用相应的构造函数。