c++新特性 语言运行期强化

目录

1.Lamabad

1.1基础语法

1.1.1值捕获

1.1.2引用捕获

1.1.3. 隐式捕获

1.1.4表达式捕获

2.函数对象包装器

2.1.1std::function的来历

2.1.2std::function的作用

2.2std::bind和std::palceholder

3 右值引用

3.1 右值引用的来历

3.2左值、右值的纯右值、将亡值、右值

3.3右值引用和左值引用

3.4移动语义

3.5完美转发

---

1.Lamabad

Lambda 表达式是现代 C++ 中最重要的特性之一，而 Lambda 表达式，实际上就是提供了一个类

似匿名函数的特性，而匿名函数则是在需要一个函数，但是又不想费力去命名一个函数的情况下去使用 的。这样的场景其实有很多很多，所以匿名函数几乎是现代编程语言的标配。

1.1基础语法

Lambda 表达式的基本语法如下：

[ 捕获列表 ]( 参数列表 ) mutable( 可选 ) 异常属性 -> 返回类型 {

// 函数体

}

上面的语法规则除了 [ 捕获列表 ] 内的东西外，其他部分都很好理解， 只是一般函数的函数名被略

去，返回值使用了一个 -> 的形式进行

所谓捕获列表 ，其实可以理解为参数的一种类型 ， lambda 表达式内部函数体在默认情况下是不能够 使用函数体外部的变量的 ，这时候捕获列表可以起到传递外部数据的作用。根据传递的行为，捕获列表 也分为以下几种：

1.1.1值捕获

与参数传值类似， 值捕获的前提是变量可以拷贝 ，

不同之处则在于， 被捕获的变量在 lambda 表达式被创建时拷贝，而非调用时才拷贝

void lamada_value_capture(){
int value=1;
auto copy_value=[value]{
return value;
}
value=100;
auto stored_value = copy_value();
std::cout << "stored_value = " << stored_value << std::endl;

// 这时, stored_value == 1, 而 value == 100.
// 因为 copy_value 在创建时就保存了一份 value 的拷贝
}

1.1.2引用捕获

与引用传参类似，引用捕获保存的是引用，值会发生变化

oid lamada_value_capture(){
int value=1;
auto copy_value=[&value]{
return value;
}
value=100;
auto stored_value = copy_value();
std::cout << "stored_value = " << stored_value << std::endl;
// 这时, stored_value == 100, value == 100.
// 因为 copy_value 保存的是引用

}

1.1.3. 隐式捕获

手动书写捕获列表有时候是非常复杂的， 这种机械性的工作可以交给编译器来处理 ，这时候可以在

捕获列表中写一个 & 或 = 向编译器声明采用引用捕获或者值捕获 .

总结一下，捕获提供了 lambda 表达式对外部值进行使用的功能，捕获列表的最常用的四种形式可

以是

• [] 空捕获列表

• [name1, name2, . . . ] 捕获一系列变量

• [&] 引用捕获 , 让编译器自行推导捕获列表

• [=] 值捕获 , 让编译器执行推导引用列表

1.1.4表达式捕获

上面提到的值捕获、 引用捕获都是已经在外层作用域声明的变量，因此这些捕获方式捕获的均为左

值，而不能捕获右值。

C++14 给与了我们方便，允许捕获的成员用任意的表达式进行初始化，这就允许了右值的捕获，被 声明的捕获变量类型会根据表达式进行判断， 判断方式与使用 auto 本质上是相同的

#include<iostream>
#include<utility>
int main()
{
auto importance=std::make_unique<int>(1);
auto add=[[v1 = 1, v2 = std::move(important)](int x,int y)->int{
return x+y+v1+(*v2);

}
std::cout << add(3,4) << std::endl;
}

1.2.泛型Lambda

上一节中我们提到了 auto 关键字不能够用在参数表里，这是因为这样的写法会与模板的功能产生

冲突。但是 Lambda 表达式并不是普通函数，所以 Lambda 表达式并不能够模板化。这就为我们造成了 一定程度上的麻烦：参数表不能够泛化，必须明确参数表类型。 幸运的是，这种麻烦只存在于 C++11 中， 从 C++14 开始，Lambda 函数的形式参数可以使用 auto

关键字来产生意义上的泛型：

auto add=[](auto x,auto y)
{
return x+y
}
add(1,2);
add(1.2,3.2);

2.函数对象包装器

这部分内容虽然属于标准库的一部分，但是从本质上来看，它却增强了 C++ 语言运行时的能力，这 部分内容也相当重要，所以放到这里来进行介绍:

2.1.1std::function的来历

 

Lambda 表达式的本质是一个和函数对象类型相似的类类型（称为闭包类型）的对象（称为闭包对

象），当 Lambda 表达式的捕获列表为空时，闭包对象还能够转换为函数指针值进行传递

#include<iostream>

using foo=void(int);

void function(foo f)//定义在参数列表中的函数类型 foo 被视为退化后的函数指针类型 foo*
{
  foo(1);// 通过函数指针调用函数
}
int main()
{
auto f=[](int value)
{
std::cout << value << std::endl;
} 
function(f);// 传递闭包对象，隐式转换为 foo* 类型的函数指针值
f(1);// lambda 表达式调用
}

上面的代码给出了两种不同的调用形式:

一种是将 Lambda 作为函数类型传递进行调用

而另一种 则是直接调用 Lambda 表达式

在 C++11 中，统一了这些概念，将能够被调用的对象的类型，统一称 之为可调用类型。而这种类型，便是通过 std::function 引入的。

2.1.2std::function的作用

C++11 std::function 是一种通用、多态的函数封装，它的实例可以对任何可以调用的目标实体进

行存储、复制和调用操作，它也是对 C++ 中现有的可调用实体的一种类型安全的包裹（相对来说，函数 指针的调用不是类型安全的），换句话说，就是函数的容器。当我们有了函数的容器之后便能够更加方便 的将函数、函数指针作为对象进行处理。

#include<functional>
#include <iostream>

int foo(int para)
{
return para;
}
int main()
{
//std::function包装了一个返回值为 int, 参数为 int 的函数
std::function<int(int)> fun=foo;
int importance=10;
std::function<int(int)> func2=[&](int value)->int
{
return 1+value+importance;
}
std::cout << func(10) << std::endl;
std::cout << func2(10) << std::endl;

}

2.2std::bind和std::palceholder

std::bind 则是用来绑定函数调用的参数的， 它解决的需求是我们有时候可能并不一定能够一次

性获得调用某个函数的全部参数 ，通过这个函数，我们可以将部分调用参数提前绑定到函数身上成为一 个新的对象，然后在参数齐全后，完成调用。例如

#include <iostream>
#include <functional>
using namespace std;
  
int TestFunc(int a, char c, float f)
{
    cout << a << endl;
    cout << c << endl;
    cout << f << endl;
  
    return a;
}
  
int main()
{
    auto bindFunc1 = bind(TestFunc, std::placeholders::_1, 'A', 100.1);
    bindFunc1(10); //等于TestFunc(10,'A', 100.1)
  
    cout << "=================================\n";
  
    auto bindFunc2 = bind(TestFunc, std::placeholders::_2, std::placeholders::_1, 100.1);
    bindFunc2('B', 10); //等于TestFunc(10,'B', 100.1)
  
    cout << "=================================\n";
  
    auto bindFunc3 = bind(TestFunc, std::placeholders::_2, std::placeholders::_3, std::placeholders::_1);
    bindFunc3(100.1, 30, 'C'); //等于TestFunc(30,'C', 100.1)
  
    return 0;
}

3 右值引用

3.1 右值引用的来历

右值引用是 C++11 引入的与 Lambda 表达式齐名的重要特性之一。它的引入解决了 C++ 中大

量的历史遗留问题 ，消除了诸如 std::vector、std::string 之类的额外开销 ，也才使得函数对象容器 std::function 成为了可能

3.2左值、右值的纯右值、将亡值、右值

左值 (lvalue, left value) ，顾名思义就是 赋值符号左边的值 。准确来说，左值是表达式（不一定是

赋值表达式）后 依然存在的持久对象 。

右值 (rvalue, right value) ，右边的值，是指表达式结束后就 不再存在的临时对象

纯右值 (prvalue, pure rvalue) ，纯粹的右值，要么是纯粹的字面量，例如 10 , true ；要么是求值

结果相当于字面量或匿名临时对象，例如 1+2 。非引用返回的临时变量、运算表达式产生的临时变量、原 始字面量、Lambda 表达式都属于纯右值

需要注意的是， 字符串字面量只有在类中才是右值，当其位于普通函数中是左值

class Foo {
const char*&& right = "this is a rvalue"; // 此处字符串字面量为右值
public:
void bar() {
right = "still rvalue"; // 此处字符串字面量为右值
}
};
int main() {
const char* const &left = "this is an lvalue"; // 此处字符串字面量为左值
}

将亡值 (xvalue, expiring value) ，是 C++11 为了引入右值引用而提出的概念（因此在传统 C++

中，纯右值和右值是同一个概念），也就是即将被销毁、却能够被移动的值。

std::vector<int> foo() {
std::vector<int> temp = {1, 2, 3, 4};
return temp;
}
std::vector<int> v = foo();

在这样的代码中，就传统的理解而言，函数 foo 的返回值 temp 在内部创建然后被赋值给 v ，然而 v 获得这个对象时， 会将整个 temp 拷贝一份，然后把 temp 销毁，如果这个 temp 非常大，这将造成大量 额外的开销（这也就是传统 C++ 一直被诟病的问题） 。在最后一行中， v 是左值、 foo() 返回的值就是右值（也是纯右值）

3.3右值引用和左值引用

要拿到一个将亡值，就需要用到右值引用： T && ，其中 T 是类型。右值引用的声明让这个临时值的 生命周期得以延长、只要变量还活着，那么将亡值将继续存活。

C++11 提供了 std::move 这个方法将左值参数无条件的转换为右值，有了它我们就能够方便的获

得一个右值临时对象，例如：

#include <iostream>
#include <string>
void reference(std::string& str) {
std::cout << " 左值" << std::endl;
}
void reference(std::string&& str) {
std::cout << " 右值" << std::endl;
}
int main()
{
std::string lv1 = "string,"; // lv1 是一个左值
// std::string&& r1 = lv1; // 非法, 右值引用不能引用左值
std::string&& rv1 = std::move(lv1); // 合法, std::move 可以将左值转移为右值
std::cout << rv1 << std::endl; // string,
const std::string& lv2 = lv1 + lv1; // 合法, 常量左值引用能够延长临时变量的生命周期
// lv2 += "Test"; // 非法, 常量引用无法被修改
std::cout << lv2 << std::endl; // string,string
std::string&& rv2 = lv1 + lv2; // 合法, 右值引用延长临时对象生命周期
rv2 += "Test"; // 合法, 非常量引用能够修改临时变量
std::cout << rv2 << std::endl; // string,string,string,Test
reference(rv2); // 输出左值
return 0; }

3.4移动语义

传统 C++ 通过拷贝构造函数和赋值操作符为类对象设计了拷贝 / 复制的概念，但为了实现对资源的

移动操作，调用者必须使用先复制、再析构的方式，否则就需要自己实现移动对象的接口。试想，搬家的 时候是把家里的东西直接搬到新家去，而不是将所有东西复制一份（重买）再放到新家、再把原来的东 西全部扔掉（销毁），这是非常反人类的一件事情。 传统的 C++ 没有区分『移动』和『拷贝』的概念，造成了大量的数据拷贝，浪费时间和空间。右值

引用的出现恰好就解决了这两个概念的混淆问题，例如：

#include<iostream>
class A
{
    public:
    int* pointer;
    A():pointer(new int(1))
    {
      std::cout<<" 构造"<<pointer<<std::endl;
    }
    A(A&a):pointer(new int(*a.pointer))
    {
        std::cout << " 拷贝" << pointer << std::endl;
    }
    A(A&& a):pointer(a.pointer) {
       a.pointer = nullptr;
       std::cout << " 移动" << pointer << std::endl;
    }
    ~A()
    {
        std::cout << " 析构" << pointer << std::endl;
        delete pointer;
    }
};
A return_rvalue(bool test)
{
    A a,b;
    if(test )return a;
    else return b; 
    //static_cast<A>(b);

}
int main()
{
    A obj = return_rvalue(false);
   std::cout << "obj:" << std::endl;
   std::cout << obj.pointer << std::endl;
   std::cout << *obj.pointer << std::endl;
   return 0;  
}

代码结果：

构造0x603010//a
构造0x603030//b
移动0x603030//b
析构0//b
析构0x603010//a
obj:
0x603030//b
1
 析构0x603030

分析：

1. 首先会在 return_rvalue 内部构造两个 A 对象，于是获得两个构造函数的输出；

2. 函数返回后，产生一个将亡值，被 A 的移动构造（ A(A&&) ）引用，从而延长生命周期，并将这个右值中的指针拿到，保存到了 obj 中，而 将亡值的指针被设置为 nullptr ，防止了这块内存区域被销毁

3.5完美转发

前面我们提到了，一个声明的右值引用其实是一个左值。这就为我们进行参数转发（传递）造成了

问题：

#include<iostream>
void reference(int& v) {
std::cout << " 左值" << std::endl;
}
void reference(int&& v) {
std::cout << " 右值" << std::endl;
}
template <typename T>
void pass(T&& v) {
std::cout << " 普通传参:";
reference(v); // 始终调用 reference(int&)
}
int main() {
std::cout << " 传递右值:" << std::endl;
pass(1); // 1 是右值, 但输出是左值
std::cout << " 传递左值:" << std::endl;
int l = 1;
pass(l); // l 是左值, 输出左值
return 0; }

传递右值:
普通传参: 左值
传递左值:
普通传参: 左值

分析：对于 pass(1) 来说，虽然传递的是右值，但由于 v 是一个引用，所以同时也是左值。因此

reference(v) 会调用 reference(int&) ，输出『左值』。而对于 pass(l) 而言， l 是一个左值，为什么

会成功传递给 pass(T&&) 呢？

这是基于 引用坍缩规则 的：在传统 C++ 中，我们不能够对一个引用类型继续进行引用，但 C++ 由

于右值引用的出现而放宽了这一做法，从而产生了引用坍缩规则，允许我们对引用进行引用，既能左引 用，又能右引用。但是却遵循如下规则：

函数形式参数	实参	推导
T&	左引用	T&
T&	右引用	T&
T&&	左引用	T&
T&&	右引用	T& &

总结 两者都右才是右

完美转发就是基于上述规律产生的。所谓完美转发，就是为了让我们在传递参数的时候，保持原来

的参数类型（左引用保持左引用，右引用保持右引用）。为了解决这个问题，我们应该使用 std::forward 来进行参数的转发（传递）：

#include<iostream>

void reference(int& v) {
std::cout << " 左值" << std::endl;
}
void reference(int&& v) {
std::cout << " 右值" << std::endl;
}
template <typename T>
void pass(T&& v) {
std::cout << " 普通传参:";
reference(v); // 始终调用 reference(int&)
std::cout << " std::move 传参: ";
reference(std::move(v));
std::cout << " std::forward 传参: ";
reference(std::forward<T>(v));
std::cout << "static_cast<T&&> 传参: ";
reference(static_cast<T&&>(v));
}
int main() {
std::cout << " 传递右值:" << std::endl;
pass(1); // 1 是右值, 但输出是左值(临时变量)
std::cout << " 传递左值:" << std::endl;
int l = 1;
pass(l); // l 是左值, 输出左值
return 0; }

结果：

传递右值:
普通传参: 左值
std::move 传参:  右值
std::forward 传参:  右值
static_cast<T&&> 传参:  右值
传递左值:
普通传参: 左值
std::move 传参:  右值
std::forward 传参:  左值
static_cast<T&&> 传参:  左值