C++11 右值引用与移动语义、可变参数模板及包装器详解 | 极客日志

C++算法

C++11 右值引用与移动语义、可变参数模板及包装器详解

综述由AI生成系统讲解 C++11 核心特性，涵盖列表初始化、右值引用与移动语义、完美转发、可变参数模板、Lambda 表达式及函数包装器。详细阐述了左值与右值的区别、移动构造与赋值如何优化资源拷贝、万能引用与 forward 机制的工作原理、变参模板的实例化过程及 emplace 接口的高效性。此外，还介绍了 Lambda 的捕获规则、底层原理及其在算法排序中的应用，以及 function 和 bind 包装器在统一可调用对象类型和参数适配方面的用法。

松间照月发布于 2026/3/29更新于 2026/5/3027 浏览

一、列表初始化

1. C++98 传统的{ }

C++98 中，数组和结构体可以用 { } 进行初始化：

struct Point {
    int _x;
    int _y;
};
int main() {
    int array1[] = {1,2,3,4,5};
    int array2[5] = {0}; 
    Point p = {1,2};
    return 0;
}

2. C++11 中的{ }

C++11 以后想一初始化方式，试图实现一切对象皆可用 { } 初始化，{ } 初始化也叫做 列表初始化。
内置类型支持，自定义类型也支持（自定义类型本质是类型转换，中间会产生临时对象，最后编译器优化了以后变成直接构造）
{ } 初始化的过程中，可以省略掉 =
C++11 列表初始化的本意是想实现⼀个统一的初始化方式，其次他在有些场景下带来的不少便利，如容器 push/inset 多参数构造的对象时，{ } 初始化会很方便

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

struct Point {
    int _x;
    int _y;
};

class Date {
public:
    Date(int year = 1, int month = 1, int day = ) : _year(year), _month(month), _day(day) {
        cout <<  << endl;
    }
    ( Date &d) : _year(d._year), _month(d._month), _day(d._day) {
        cout <<  << endl;
    }
:
     _year;
     _month;
     _day;
};

{
    
     a1[] = {,,,,};
     a2[] = {}; 
    Point p = {,};
    
    
     x1 = {};
    
    
    
    
    Date d1 = {,,};
    
     Date &d2 = {,,};
    
    Date d3 = {}; 
    Date d4 = ;
    
    Point p1{,};
     x2{}; 
    Date d5{,,};
     Date &d6{,,};
    
    
    vector<Date> v;
    Date d7 = {,,};
    v.(d7);
    v.((,,));
    
    v.({,,});
     ;
}

(1) std::initializer_list<int> il = {10, 20, 30};
(2) auto il = {10, 20, 30}; // the type of il is an initializer_list 
// 这两种写法的效果是一模一样的，使用 auto 能自动推导出 il 为 initializer_list 类型

// 1.STL 中的容器的构造函数 都增加了⼀个 initializer_list 版本
vector(initializer_list<value_type> il);
list(initializer_list<value_type> il);
map(initializer_list<value_type> il, const key_compare &comp = key_compare());
// ...
// 2.容器的赋值函数 也支持 initializer_list 版本
vector &operator=(initializer_list<value_type> il);
map &operator=(initializer_list<value_type> il);
// ...

template<class T>
class vector {
public:
    typedef T *iterator;
    // 模拟实现 vector 类中构造函数的 initializer_list 版本
    vector(initializer_list<T> il) {
        for(auto e : il)
            push_back(e);
    }
    // ...
private:
    iterator _start = nullptr;
    iterator _finish = nullptr;
    iterator _endofstorage = nullptr;
};

#include <iostream>
using namespace std;
int main() {
    initializer_list<int> mylist;
    mylist = {10,20,30};
    // 这⾥ begin 和 end 返回的值是 initializer_list 对象中存的两个指针
    // 这两个指针的值跟 i 的地址跟接近，说明 initializer_list 对象创建的数组 存在栈上
    int i = 0;
    cout << mylist.begin() << endl;
    cout << mylist.end() << endl;
    cout << &i << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <map>
using namespace std;
int main() {
    // 1. STL 容器支持 initializer_list 版本的构造函数
    // {} 列表中可以有任意多个值
    // 这两个写法语义上还是有差别的：
    // 第⼀个 v1：{1, 2, 3, 4, 5} 直接构造 v1，
    // 第二个 v2：{1, 2, 3, 4, 5} 构造临时对象 + 临时对象拷贝构造 v2; 编译器优化后，变为直接构造
    // 第三个 v3 跟 v2 写法的语义一致（{} 初始化的过程中，可以省略掉 =）
    vector<int>v1({1,2,3,4,5});
    vector<int> v2 = {1,2,3,4,5};
    vector<int> v3{1,2,3,4,5};
    // 这里 v4 引用的是 {1, 2, 3, 4, 5} 构造的临时对象（临时对象具有常属性，所以必须用 const 引用）
    const vector<int>&v4 = {1,2,3,4,5};
    // 这里是 pair 对象的{}初始化 和 map 的 initializer_list 构造结合到⼀起用了
    // {"sort", "排序"} 和 {"string", "字符串"} 构造两个 pair<string, string> 对象
    // 两个 pair<string, string> 对象 构造 map 类临时对象 + 临时对象拷贝构造 dict; 编译器优化后，变为直接构造
    map<string, string> dict = {{"sort","排序"},{"string","字符串"}};
    // 2. STL 容器支持 initializer_list 版本的赋值重载
    v1 = {10,20,30,40,50};
    dict = {{"one","第一"},{"two","第二"}};
    return 0;
}

（1）直接构造 vector<int>v1({1,2,3,4,5});
（2）构造 vector<int> 类的 临时对象 + 临时对象拷贝构造 v2; 编译器优化后，变为直接构造
vector<int> v2{1,2,3,4,5};
// 省略了等号=，实际是：vector<int> v2 = {1, 2, 3, 4, 5};

#include <iostream>
using namespace std;
int add(int x, int y) {
    int z = x + y;
    return z;
}
int main() {
    // 1.左值：可以取地址
    // 以下的 p、b、c、*p、s、s[0] 就是常见的左值
    int*p = new int(0);
    int b = 1;
    const int c = b;
    *p = 10;
    string s("111111"); 
    s[0]='x'; 
    cout << &c << endl;
    cout << (void*)&s[0] << endl;
    double x = 1.1, y = 2.2;
    // 2.右值：不能取地址
    // 以下几个 10、x + y、add(x, y)、string("11111") 都是常见的右值
    10;
    x + y;
    // 产生运算的表达式结果存储在临时对象
    add(x, y);
    // 值返回（除指针类型或引用类型返回外，都是值返回）的函数，它的返回值存储在临时对象
    string("11111");
    // 匿名对象属于右值
    // 右值取地址会直接报错
    // cout << &10 << endl;
    // cout << &(x+y) << endl;
    // cout << &(add(x, y)) << endl;
    // cout << &string("11111") << endl;
    return 0;
}

#include <string>
using namespace std;
int add(int x, int y) {
    int z = x + y;
    return z;
}
int main() {
    // 左值：可以取地址
    // 以下的 p、b、c、*p、s、s[0] 就是常见的左值
    int*p = new int(0);
    int b = 1;
    const int c = b;
    *p = 10;
    string s("111111"); 
    s[0]='x';
    // 1.左值引用给左值取别名
    int&r1 = b;
    int*&r2 = p;
    int&r3 =*p;
    string &r4 = s;
    char&r5 = s[0];
    // 2.右值引⽤给右值取别名
    int&&rr1 = 10;
    double&&rr2 = x + y;
    double&&rr3 = add(x, y);
    string &&rr4 = string("11111");
    // 3.左值引用不能直接引用右值，但是 const 左值引用可以引用右值
    const int&rx1 = 10;
    const double&rx2 = x + y;
    const double&rx3 = add(x, y);
    const string &rx4 = string("11111");
    // 4.右值引用不能直接引用左值，但是右值引用可以引用 move(左值)
    int&&rrx1 = move(b);
    int*&&rrx2 = move(p);
    int&&rrx3 = move(*p);
    int&&rrx4 = (int&&)*p;
    string &&rrx5 = move(s);
    string &&rrx6 = (string &&)s;
    return 0;
}

string s("111111");
// s 是左值
// 右值引用不能直接引用左值，但是右值引用可以引用 move(左值)
// move(左值)：其实就相当于将 左值 强制转换成 右值引用类型
// 以下两种写法效果等同
string &&rrx5 = move(s);
string &&rrx6 = (string &&)s;

using namespace std;
int main() {
    int b = 1;
    // 左值引用给左值取别名
    int&r1 = b;
    int&pr1 = r1;
    // 右值引用给右值取别名
    int&&rr1 = 10;
    // 这里要注意的是，rr1 的属性是左值，所以不能再被右值引用绑定，除非 move⼀下（或强制类型转换成 右值引用类型）
    // 错误写法：
    // int &&prr1 = rr1;（会报错）
    int&&prr1 = move(rr1);
    int&&prr2 = (int&&)rr1;
    return 0;
}

int&&rr1 = 10;
// 错误写法：
// int &&prr1 = rr1;（会报错）
int&&prr1 = move(rr1);
int&&prr2 = (int&&)rr1;

#include <iostream>
#include <string>
using namespace std;
int main() {
    string s1 = "Test";
    // operator+() 的返回值是 string 类型的临时对象
    const string &r2 = s1 + s1;
    // const 的左值引用延长 临时对象的生命存期
    // r2 += "Test"; // 但不能通过到 const 的引用修改
    std::string &&r3 = s1 + s1;
    // 右值引用延长 临时对象的生命存期
    cout << r3 << endl; 
    r3 += "Test";
    // 能通过到⾮ const 的引用修改
    cout << r3 << endl;
    return 0;
}

#include <iostream>
using namespace std;
void f(int&x) {
    std::cout << "左值引用重载 f(int&)" << endl;
}
void f(const int&x) {
    std::cout << "到 const 的左值引用重载 f(const int&)" << endl;
}
int main() {
    int i = 1;
    const int ci = 2;
    f(i); // 调用 f(int&)
    f(ci); // 调用 f(const int&)
    f(3); // 调用 f(const int&)
    f(move(i)); // 调用 f(const int&)
    // 右值引用变量在用于表达式时是左值
    int&&x = 1;
    f(x); // 调用 f(int& x)
    f(move(x)); // 调用 f(const int&)
    return 0;
}

#include <iostream>
using namespace std;
void f(int&x) {
    std::cout << "左值引用重载 f(int&)" << endl;
}
void f(const int&x) {
    std::cout << "到 const 的左值引用重载 f(const int&)" << endl;
}
void f(int&&x) {
    std::cout << "右值引用重载 f(int&&)" << endl;
}
int main() {
    int i = 1;
    const int ci = 2;
    f(i); // 调用 f(int&)
    f(ci); // 调用 f(const int&)
    f(3); // 调用 f(int&&); 如果没有 f(int&&) 重载，则会调用 f(const int&)
    f(move(i)); // 调用 f(int&&)
    // 右值引用变量在用于表达式时是左值
    int&&x = 1;
    f(x); // 调用 f(int& x)
    f(move(x)); // 调用 f(int&& x)
    return 0;
}

#include <algorithm>
#include <vector>
#include <string>
using namespace std;
string addStrings(string num1, string num2) {
    string str;
    int end1 = num1.size()-1, end2 = num2.size()-1;
    int next = 0;
    while(end1 >=0|| end2 >=0){
        int val1 = end1 >=0? num1[end1--]-'0':0;
        int val2 = end2 >=0? num2[end2--]-'0':0;
        int ret = val1 + val2 + next; 
        next = ret /10; 
        ret = ret %10; 
        str +=('0'+ ret);
    }
    if(next ==1) str +='1';
    reverse(str.begin(), str.end());
    return str;
}
// 这里的传值返回拷贝代价就太⼤了
vector<vector<int>>generate(int numRows) {
    vector<vector<int>>vv(numRows);
    for(int i = 0; i < numRows;++i){ 
        vv[i].resize(i +1,1);
    }
    for(int i = 2; i < numRows;++i){
        for(int j = 1; j < i;++j){ 
            vv[i][j]= vv[i -1][j]+ vv[i -1][j -1];
        }
    }
    return vv;
}

#include <iostream>
#include <string.h>
#include <algorithm>
#include <assert.h>
using namespace std;

class my_string {
public:
    typedef char* iterator;
    typedef const char* const_iterator;
    iterator begin(){return _str;} 
    iterator end(){return _str + _size;}
    const_iterator begin()const{return _str;} 
    const_iterator end()const{return _str + _size;}
    // 构造函数
    my_string(const char*str =""):_size(strlen(str)),_capacity(_size){ 
        cout <<"string(char* str)-构造"<< endl; 
        _str =new char[_capacity +1];
        strcpy(_str, str);
    }
    void swap(my_string &s){ 
        std::swap(_str, s._str); 
        std::swap(_size, s._size); 
        std::swap(_capacity, s._capacity); 
    }
    // 拷贝构造
    my_string(const my_string &s){ 
        cout <<"string(const string& s) -- 拷贝构造"<< endl; 
        reserve(s._capacity);
        for(auto ch : s){push_back(ch);}
    }
    // 移动构造
    my_string(my_string &&s){ 
        cout <<"string(string&& s) -- 移动构造"<< endl; 
        swap(s);
    }
    // 拷贝赋值
    my_string &operator=(const my_string &s){ 
        cout <<"string& operator=(const string& s) -- 拷⻉赋值"<< endl;
        if(this!=&s){ 
            _str[0]='�'; 
            _size =0;
            reserve(s._capacity);
            for(auto ch : s){push_back(ch);}
        }
        return*this;
    }
    // 移动赋值
    my_string &operator=(my_string &&s){ 
        cout <<"string& operator=(string&& s) -- 移动赋值"<< endl;
        swap(s);
        return*this;
    }
    ~my_string(){ 
        cout <<"~string() -- 析构"<< endl; 
        delete[] _str; 
        _str =nullptr;
    }
    void reserve(size_t n){
        if(n > _capacity){
            char*tmp =new char[n +1];
            if(_str){strcpy(tmp, _str);delete[] _str;}
            _str = tmp; 
            _capacity = n;
        }
    }
    void push_back(char ch){
        if(_size >= _capacity){ 
            size_t newcapacity = _capacity ==0?4: _capacity *2;
            reserve(newcapacity);
        }
        _str[_size]= ch;
        ++_size; 
        _str[_size]='�';
    }
    char&operator[](size_t pos){
        assert(pos < _size);
        return _str[pos];
    }
    my_string &operator+=(char ch){push_back(ch);return*this;}
    size_t size()const{return _size;}
private:
    char*_str =nullptr; 
    size_t _size =0; 
    size_t _capacity =0;
};

#include"my_string.hpp"
my_string addStrings(my_string num1, my_string num2){
    my_string str;
    int end1 = num1.size()-1, end2 = num2.size()-1;
    int next = 0;
    while(end1 >=0|| end2 >=0){
        int val1 = end1 >=0? num1[end1--]-'0':0;
        int val2 = end2 >=0? num2[end2--]-'0':0;
        int ret = val1 + val2 + next; 
        next = ret /10; 
        ret = ret %10; 
        str +=('0'+ ret);
    }
    if(next ==1) str +='1';
    reverse(str.begin(), str.end());
    return str;
}

// my_list 类（链表）中 每个节点的类型
template<class T>
struct ListNode {
    ListNode<T>*_next;
    ListNode<T>*_prev;
    T _data;
    ListNode(const T &data =T()):_next(nullptr),_prev(nullptr),_data(data)// 关键语句{}
    ListNode(T &&data):_next(nullptr),_prev(nullptr),_data(move(data))// 关键语句
    {}
};

// 简化版 list 类迭代器的实现
template<class T,class Ref,class Ptr>
struct ListIterator {
    typedef ListNode<T> Node;
    typedef ListIterator<T, Ref, Ptr> Self;
    Node *_node;
    ListIterator(Node *node):_node(node){}
    Self &operator++(){ 
        _node = _node->_next;
        return*this;
    }
    Self &operator--(){ 
        _node = _node->_pre;
        return*this;
    }
    Ref operator*(){return _node->_data;}
    // list 迭代器的很多接口实现省略
};

// 实现简化版的 list 类
template<class T>
class my_list {
    typedef ListNode<T> Node;
    void empty_init(){ 
        _head =new Node(); 
        _head->_next = _head; 
        _head->_prev = _head;
    }
public:
    my_list(){empty_init();}
    typedef ListIterator<T, T &, T *> iterator;
    typedef ListIterator<T,const T &,const T *> const_iterator;
    iterator begin(){return iterator(_head->_next);}
    iterator end(){return iterator(_head);}
    void push_back(const T &x){insert(end(), x);// 关键语句}
    void push_back(T &&x){insert(end(),move(x));// 关键语句}
    iterator insert(iterator pos,const T &x){ 
        Node *cur = pos._node; 
        Node *newnode =new Node(x);// 关键语句 
        Node *prev = cur->_prev; 
        prev->_next = newnode; 
        newnode->_prev = prev; 
        newnode->_next = cur; 
        cur->_prev = newnode;
        return iterator(newnode);
    }
    iterator insert(iterator pos, T &&x){ 
        Node *cur = pos._node; 
        Node *newnode =new Node(move(x));// 关键语句 
        Node *prev = cur->_prev; 
        prev->_next = newnode; 
        newnode->_prev = prev; 
        newnode->_next = cur; 
        cur->_prev = newnode;
        return iterator(newnode);
    }
private: 
    Node *_head;
};

typedef int& lref;
typedef int&& rref;
int main() {
    int n = 0;
    lref &r1 = n;// int& &(左值引用 + 左值引用)，折叠成：int&(左值引用)
    // 所以 r1 的类型是 int&
    lref &&r2 = n;// int& &&(左值引用 + 右值引用)，折叠成：int&(左值引用)
    // 所以 r2 的类型是 int&
    rref &r3 = n;// int&& &(右值引用 + 左值引用)，折叠成：int&(左值引用)
    // 所以 r3 的类型是 int&
    rref &&r4 = 1;// int&& &&(右值引用 + 右值引用)，折叠成：int&&(右值引用)
    // 所以 r4 的类型是 int&&
    return 0;
}

// 由于引用折叠限定，f1 实例化以后总是⼀个左值引用
template<class T>
void f1(T &x){}
// 由于引用折叠限定，f2 实例化后可以是左值引用，也可以是右值引用
template<class T>
void f2(T &&x){}
int main() {
    int n = 0;
    // 没有折叠->实例化为 void f1(int& x)
    f1<int>(n);
    f1<int>(0);// 报错
    // 折叠->实例化为 void f1(int& x)
    f1<int&>(n);
    f1<int&>(0);// 报错
    // 折叠->实例化为 void f1(int& x)
    f1<int&&>(n);
    f1<int&&>(0);// 报错
    // 折叠->实例化为 void f1(const int& x)
    f1<const int&>(n);
    f1<const int&>(0);// 折叠->实例化为 void f1(const int& x)
    f1<const int&&>(n);
    f1<const int&&>(0);
    // 没有折叠->实例化为 void f2(int&& x)
    f2<int>(n);// 报错
    f2<int>(0);
    // 折叠->实例化为 void f2(int& x)
    f2<int&>(n);
    f2<int&>(0);// 报错
    // 折叠->实例化为 void f2(int&& x)
    f2<int&&>(n);
    f2<int&&>(0);
    return 0;
}

#include <iostream>
using namespace std;
template<class T>
void Function(T &&t){
    int a = 0;
    T x = a;
    // x++;
    cout << &a << endl;
    cout << &x << endl;
}
int main() {
    // 10 是右值，推导出 T 为 int，模板实例化为 void Function(int&& t)
    Function(10); // 右值
    /////////////////////////////////////////////////////////////////////
    int a;
    // a 是左值，推导出 T 为 int&，引用折叠，模板实例化为 void Function(int& t)
    Function(a); // 左值
    // move(a) 是右值，推导出 T 为 int，模板实例化为 void Function(int&& t)
    Function(move(a)); // 右值
    /////////////////////////////////////////////////////////////////////
    const int b = 8;
    // b 是左值，推导出 T 为 const int&，引用折叠，模板实例化为 void Function(const int&t)
    // 此时 Function 内部，x++ 语句会导致报错
    Function(b); // const 左值
    // move(b) 右值，推导出 T 为 const int，模板实例化为 void Function(const int&&t)
    // 此时 Function 内部，x++ 语句会导致报错
    Function(move(b)); // const 右值
    return 0;
}

#include <iostream>
using namespace std;
template<typename T>
void wrapper(T &&arg){
    // ...
}
template<>
void wrapper<int&>(int&arg){ 
    cout <<"左值引用版本"<< endl;
}
template<>
void wrapper<int>(int&&arg){ 
    cout <<"右值引用版本"<< endl;
}
template<typename T>
void function(T &&arg){
    wrapper(arg);
    // int &arg：左值引用类型的 arg 的属性是左值，走左值引用版本的 wrapper
    // int &&arg：右值引用类型的 arg 的属性是左值，走左值引用版本的 wrapper
}
int main() {
    int x = 10;
    function(x); // 传入左值 → T 推导为 int&
    function(20); // 传入右值 → T 推导为 int
    return 0;
}

#include <iostream>
using namespace std;
template<typename T>
void wrapper(T &&arg){
    // ...
}
template<>
void wrapper<int&>(int&arg){ 
    cout <<"左值引用版本"<< endl;
}
template<>
void wrapper<int>(int&&arg){ 
    cout <<"右值引用版本"<< endl;
}
template<typename T>
void function(T &&arg){
    wrapper(forward<T>(arg));
    // int &arg：左值引用类型的 arg 的属性是左值，
    // forward<int &>(arg) 对 arg 不做额外处理。
    // int &&arg：右值引用类型的 arg 的属性是左值，
    // forward<int>(arg) 对 arg 进行 move 处理，恢复 arg 的右值属性。
}
int main() {
    int x = 10;
    function(x); // 传入左值 → T 推导为 int&
    function(20); // 传入右值 → T 推导为 int
    return 0;
}

（1）template<class...Args>
void Func(Args... args){}
// 值传递版本的参数包
（1）template<class...Args>
void Func(Args&... args){}
// 左值引用版本的参数包
（1）template<class...Args>
void Func(Args&&... args){}
// 万能引用版本的参数包

#include <iostream>
using namespace std;
template<class... Args>
void Print(Args &&...args){ 
    cout << sizeof...(args) << endl;
}
int main() {
    double x = 2.2;
    Print(); // 包里有 0 个参数
    Print(1); // 包里有 1 个参数
    Print(1,string("xxxxx")); // 包里有 2 个参数
    Print(1.1,string("xxxxx"), x); // 包里有 3 个参数
    return 0;
}

// 原理：编译器在底层会结合引用折叠规则实例化出以下四个函数
// void Print(); 
// void Print(int&& arg1); 
// void Print(int&& arg1, string&& arg2); 
// void Print(double&& arg1, string&& arg2, double& arg3); 
// 更本质去看，如果没有可变参数模板，我们得实现出多个函数模板才能支持
// 这里的功能，有了可变参数模板，用户进⼀步被解放，可变参数模板是在类型泛化基础
// 上叠加参数数量的变化，让我们泛型编程更加灵活。
void Print();
template <class T1> void Print(T1&& arg1);
template <class T1, class T2> void Print(T1&& arg1, T2&& arg2);
template <class T1, class T2, class T3> void Print(T1&& arg1, T2&& arg2, T3&& arg3);

#include <iostream>
using namespace std;
void ShowList(){
    // 编译器时递归的终止条件，参数包是 0 个时，直接匹配这个函数
    cout << endl;
}
template<class T,class... Args>
void ShowList(T x, Args... args){ 
    cout << x <<" ";
    // args 是 N 个参数的参数包
    // 调用 ShowList，参数包的第一个传给 x，剩下 N-1 传给第二个参数包
    ShowList(args...);
}
// 编译时递归推导解析参数
template<class... Args>
void Print(Args... args){
    ShowList(args...);
}
int main() {
    Print(1,string("xxxxx"),2.2);
    return 0;
}

#include <iostream>
using namespace std;
template<class T>
const T &GetArg(const T &x){ 
    cout << x <<" ";
    return x;
}
template<class... Args>
void Arguments(Args... args){}
template<class... Args>
void Print(Args... args){
    // 注意 GetArg 函数必须返回 获得到的对象，这样才能组成参数包给 Arguments
    Arguments(GetArg(args)...);
}
// 本质可以理解为编译器编译时，包的扩展模式
// 将上面的函数模板扩展实例化为下面的函数：
// void Print(int x, string y, double z)
// {
//     Arguments(GetArg(x), GetArg(y), GetArg(z));
// }
int main() {
    Print(1,string("xxxxx"),2.2);
    return 0;
}

template<class... Args>
void emplace_back(Args&&... args);
template<class... Args>
iterator emplace(const_iterator position, Args&&... args);

// my_list 类（链表）中 每个节点的类型
template<class T>
struct ListNode {
    ListNode<T>*_next;
    ListNode<T>*_prev;
    T _data;
    ListNode(const T &data =T()):_next(nullptr),_prev(nullptr),_data(data){}
    ListNode(T &&data):_next(nullptr),_prev(nullptr),_data(move(data)){}
    template<class... Args>
    // emplace_back 接口把参数包不断往下传递，ListNode(Args&&... args)
    // 最终在结点的构造中直接去匹配容器存储的数据类型 T 的构造
    :_next(nullptr),_prev(nullptr),_data(std::forward<Args>(args)...){}
};

// 简化版 list 类迭代器的实现
template<class T,class Ref,class Ptr>
struct ListIterator {
    typedef ListNode<T> Node;
    typedef ListIterator<T, Ref, Ptr> Self;
    Node *_node;
    ListIterator(Node *node):_node(node){}
    Self &operator++(){ 
        _node = _node->_next;
        return*this;
    }
    Self &operator--(){ 
        _node = _node->_pre;
        return*this;
    }
    Ref operator*(){return _node->_data;}
    // list 迭代器的很多接口实现省略
};

// 实现简化版的 list 类
template<class T>
class my_list {
    typedef ListNode<T> Node;
    void empty_init(){ 
        _head =new Node(); 
        _head->_next = _head; 
        _head->_prev = _head;
    }
public:
    my_list(){empty_init();}
    typedef ListIterator<T, T &, T *> iterator;
    typedef ListIterator<T,const T &,const T *> const_iterator;
    iterator begin(){return iterator(_head->_next);}
    iterator end(){return iterator(_head);}
    void push_back(const T &x)// push_back 接口
    {insert(end(), x);}
    void push_back(T &&x){insert(end(),move(x));}
    iterator insert(iterator pos,const T &x){ 
        Node *cur = pos._node; 
        Node *newnode =new Node(x); 
        Node *prev = cur->_prev; 
        prev->_next = newnode; 
        newnode->_prev = prev; 
        newnode->_next = cur; 
        cur->_prev = newnode;
        return iterator(newnode);
    }
    iterator insert(iterator pos, T &&x){ 
        Node *cur = pos._node; 
        Node *newnode =new Node(move(x)); 
        Node *prev = cur->_prev; 
        prev->_next = newnode; 
        newnode->_prev = prev; 
        newnode->_next = cur; 
        cur->_prev = newnode;
        return iterator(newnode);
    }
    template<class... Args>
    // 新增 emplace_back 接口
    void emplace_back(Args &&...args){
        insert(end(), std::forward<Args>(args)...);
        // emplace_back 接口把参数包不断往下传递
    }
    template<class... Args>
    iterator insert(iterator pos, Args &&...args){ 
        Node *cur = pos._node; 
        Node *newnode =new Node(std::forward<Args>(args)...); 
        Node *prev = cur->_prev; 
        prev->_next = newnode; 
        newnode->_prev = prev; 
        newnode->_next = cur; 
        cur->_prev = newnode;
        return iterator(newnode);
    }
private: 
    Node *_head;
};

#include"my_list.h"
#include <string>
using namespace std;
int main() {
    my_list<string> lt;
    string s1("111111111111");
    // 传左值，跟 push_back⼀样，⾛拷贝构造
    lt.emplace_back(s1);
    // 传右值，跟 push_back⼀样，⾛移动构造
    lt.emplace_back(move(s1));
    // 直接把构造 string 参数包往下传，直接⽤ string 参数包构造 string
    // 这里达到的效果是 push_back 做不到的
    lt.emplace_back("111111111111");
    return 0;
}

#include"my_list.h"
#include <string>
using namespace std;
int main() {
    my_list<pair<string,int>> lt1;
    // 跟 push_back⼀样
    // 构造 pair + 拷⻉/移动构造 pair 到 list 的节点中 data 上
    pair<string,int>kv("苹果",1);
    lt1.emplace_back(kv);
    // 跟 push_back⼀样
    lt1.emplace_back(move(kv));
    // 直接把构造 pair 参数包往下传，直接⽤ pair 参数包构造 pair
    // 这⾥达到的效果是 push_back 做不到的
    lt1.emplace_back("苹果",1);
    return 0;
}

#include <string>
using namespace std;
class Person {
public:
    Person(const char*name ="",int age =0):_name(name),_age(age){}
    Person(const Person &p):_name(p._name),_age(p._age){}
    Person(Person &&p)=default; // 使用 default 关键字 显式指定 编译器生成默认的移动构造
private: 
    string _name;
    int _age;
};

#include <string>
using namespace std;
class Person {
public:
    Person(const char*name ="",int age =0):_name(name),_age(age){}
    Person(const Person& p)=delete;
private: 
    string _name;
    int _age;
};

#include <iostream>
using namespace std;
int main() {
    // ⼀个简单的 lambda 表达式
    // lambda 表达式 就是一个对象
    auto add1 =[](int x,int y)->int{return x + y;}; 
    cout << add1(1,2) << endl;
    // 1、捕捉列表为空也不能省略
    // 2、参数为空可以省略
    // 3、返回值可以省略，可以通过返回值类型自动推导
    // 4、函数体不能省略
    auto func1 =[]{ cout <<"hello bit"<< endl;return 0;};
    func1();
    int a = 0, b = 1; 
    cout << a <<":"<< b << endl;
    auto swap1 =[](int&x,int&y){int tmp = x; x = y; y = tmp;};
    swap1(a, b); 
    cout << a <<":"<< b << endl;
    return 0;
}

#include <iostream>
using namespace std;
int main() {
    int a = 0, b = 0, c = 0, d = 0;
    auto func1 =[a, b,&c,&d]{
        // 值捕捉的变量默认被 const 修饰，不能修改;
        // 引用捕捉的变量可以修改
        // a++;
        // b++;
        c++; 
        d++;
    };
    func1(); // 执行 lambda 对象
    cout << a <<'|'<< b <<'|'<< c <<'|'<< d << endl;
    return 0;
}

#include <iostream>
using namespace std;
int main() {
    int a = 0, b = 0, c = 0, d = 0;
    auto func1 =[a, b,&c,&d]()mutable{ 
        a++; 
        b++; 
        c++; 
        d++;
    };
    func1(); // 执行 lambda 对象
    cout << a <<'|'<< b <<'|'<< c <<'|'<< d << endl;
    return 0;
}

#include <iostream>
using namespace std;
int main() {
    int a = 0, b = 0, c = 0, d = 0;
    // 隐式值捕捉
    auto func1 =[=]()mutable{ 
        a++; 
        b++; 
        c++; 
        d++;
    };
    func1(); // 执行 lambda 对象
    cout << a <<'|'<< b <<'|'<< c <<'|'<< d << endl;
    // 隐式引用捕捉
    auto func2 =[&]{ 
        a++; 
        b++; 
        c++; 
        d++;
    };
    func2(); // 执行 lambda 对象
    cout << a <<'|'<< b <<'|'<< c <<'|'<< d << endl;
    return 0;
}

#include <iostream>
using namespace std;
int main() {
    int a = 0, b = 0, c = 0, d = 0;
    // 隐式值捕捉 + 显示引用捕捉
    auto func1 =[=,&c,&d]()mutable{ 
        a++; 
        b++; 
        c++; 
        d++;
    };
    func1(); // 执行 lambda 对象
    cout << a <<'|'<< b <<'|'<< c <<'|'<< d << endl;
    // 隐式引用捕捉 + 显示值捕捉
    auto func2 =[&, c, d]()mutable{ 
        a++; 
        b++; 
        c++; 
        d++;
    };
    func2(); // 执行 lambda 对象
    cout << a <<'|'<< b <<'|'<< c <<'|'<< d << endl;
    return 0;
}

#include <iostream>
using namespace std;
int m = 0; // 全局变量
int main() {
    static int n = 0; // 静态局部变量
    auto func1 =[]{ 
        m++; 
        n++;
    };
    func1(); // 执行 lambda 对象
    cout << m <<'|'<< n << endl;
    return 0;
}

变量类型	捕获方式	内部修改是否影响外部	能否被捕获
非静态局部变量	值捕获 [x]	不影响（副本）	能
非静态局部变量	引用捕获 [&x]	影响	能
静态局部变量	不捕获	影响	禁止
全局变量	不捕获	影响	禁止

#include <iostream>
using namespace std;
class Rate {
public:
    Rate(int a,int b,int&c,int&d):_a(a),_b(b),_pc(c),_pd(d){}
    int operator()(int ret)const{ 
        _pc++; 
        _pd++; 
        ret = _a + _b + _pc + _pd;
        return ret;
    }
private:
    int _a;
    int _b;
    int&_pc;
    int&_pd;
};
int main() {
    int a = 0, b = 0, c = 0, d = 0;
    int ret = 0;
    // lambda
    auto function_1 =[a, b,&c,&d](int ret){ 
        c++; 
        d++; 
        ret = a + b + c + d;
        return ret;
    };
    cout << function_1(ret) << endl;
    cout << a <<'|'<< b <<'|'<< c <<'|'<< d << endl;
    // 匿名对象
    auto function_2 = Rate(a,b,c,d);
    cout << function_2(ret) << endl;
    cout << a <<'|'<< b <<'|'<< c <<'|'<< d << endl;
    return 0;
}

#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
struct Goods {
    string _name; // 名字
    double _price; // 价格
    int _evaluate; // 评价
    Goods(const char*str,double price,int evaluate):_name(str),_price(price),_evaluate(evaluate){}
};
// 仿函数类
struct ComparePriceLess {
    bool operator()(const Goods &gl,const Goods &gr){
        return gl._price < gr._price;
    }
};
struct ComparePriceGreater {
    bool operator()(const Goods &gl,const Goods &gr){
        return gl._price > gr._price;
    }
};
// 函数
bool CompEvaluateLess(const Goods &gl,const Goods &gr){
    return gl._evaluate < gr._evaluate;
}
bool CompEvaluateGreater(const Goods &gl,const Goods &gr){
    return gl._evaluate > gr._evaluate;
}
int main() {
    vector<Goods> v ={{"苹果",2.1,5},{"香蕉",3,4},{"橙子",2.2,3},{"菠萝",1.5,4}};
    // 类似这样的场景，我们实现仿函数对象 或者 函数指针支持商品中不同项的比较时，
    // 还得实现对应的仿函数类 以及 函数，相对还是比较麻烦的
    sort(v.begin(), v.end(),ComparePriceLess());
    sort(v.begin(), v.end(),ComparePriceGreater());
    sort(v.begin(), v.end(), CompEvaluateLess);
    sort(v.begin(), v.end(), CompEvaluateGreater);
    // 那么这里直接使用 lambda 表达式就很方便好用了（不需要提前定义含仿函数类 或 函数）
    // 虽然 lambda 表达式的底层 就是 仿函数类，但它的仿函数类是编译器编译时自动生成的，
    // 不需要用户费心，所以 lambda 表达式使用起来非常爽（用户使用时，不用管底层实现）
    sort(v.begin(), v.end(),[](const Goods &g1,const Goods &g2){
        return g1._price < g2._price;
    });
    sort(v.begin(), v.end(),[](const Goods &g1,const Goods &g2){
        return g1._price > g2._price;
    });
    sort(v.begin(), v.end(),[](const Goods &g1,const Goods &g2){
        return g1._evaluate < g2._evaluate;
    });
    sort(v.begin(), v.end(),[](const Goods &g1,const Goods &g2){
        return g1._evaluate > g2._evaluate;
    });
    return 0;
}

template<class T>
class function; // undefined
template<class Ret,class... Args>
class function<Ret(Args...)>;

#include <iostream>
#include <functional>
using namespace std;
// 函数
int f(int a,int b){return a + b;}
// 仿函数类
struct Functor {
    int operator()(int a,int b){return a + b;}
};
// 普通类
class Plus {
public:
    static int plusi(int a,int b)// 静态成员函数
    {return a + b;}
    double plusd(double a,double b)// 普通成员函数
    {return a + b;}
};
int main() {
    // 包装各种可调用对象
    function<int(int,int)> f1 = f;
    function<int(int,int)> f2 = Functor();
    function<int(int,int)> f3 =[](int a,int b){return a + b;};
    cout << f1(1,1) << endl;
    cout << f2(1,1) << endl;
    cout << f3(1,1) << endl;
    // 包装静态成员函数
    // 成员函数要指定类域并且前面加 & 才能获取地址
    function<int(int,int)> f4 =&Plus::plusi;
    cout << f4(1,1) << endl;
    // 包装普通成员函数
    // 普通成员函数还有⼀个隐含的 this 指针参数，所以绑定时还得在第一个参数 传对象的指针过去
    function<double(Plus *,double,double)> f5 =&Plus::plusd;
    Plus pd;
    cout << f5(&pd,1.1,1.1) << endl;
    return 0;
}

class Solution {
public:
    int evalRPN(vector<string>&tokens){
        stack<int> st;
        for(auto&str : tokens){
            if(str=="+"|| str=="-"|| str=="*"|| str=="/"){
                int right = st.top(); 
                st.pop();
                int left = st.top(); 
                st.pop();
                switch(str[0]){
                    case'+': st.push(left + right);break;
                    case'-': st.push(left - right);break;
                    case'*': st.push(left * right);break;
                    case'/': st.push(left / right);break;
                }
            }else{
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

class Solution {
public:
    int evalRPN(vector<string>&tokens){
        stack<int> st;
        // function 作为 map 的映射可调用对象的类型
        map<string, function<int(int,int)>> opFuncMap ={{"+",[](int x,int y){return x + y;}},
                                                        {"-",[](int x,int y){return x - y;}},
                                                        {"*",[](int x,int y){return x * y;}},
                                                        {"/",[](int x,int y){return x / y;}}};
        for(auto&str : tokens){
            if(opFuncMap.count(str))// 操作符
            {
                int right = st.top(); 
                st.pop();
                int left = st.top(); 
                st.pop();
                int ret = opFuncMap[str](left, right);
                st.push(ret);
            }else{
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

template<class Fn,class... Args>
bind(Fn&& fn, Args&&... args);
template<class Ret,class Fn,class... Args>
bind(Fn&& fn, Args&&... args);

#include <iostream>
#include <functional>
using namespace std;
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int sub(int a,int b,int c){return(a - b - c)*10;}
int main() {
    auto sub0 =bind(sub, _1, _2, _3); 
    cout << sub0(10,5,1) << endl; // （10 - 5 -1）*10
    // bind 本质返回的⼀个仿函数对象
    // _1代表第⼀个实参
    // _2代表第二个实参
    // _3代表第三个实参
    // 调整参数顺序（不常用）
    auto sub1 =bind(sub, _2, _1, _3); 
    cout << sub1(10,5,1) << endl; // （5 - 10 -1）*10
    auto sub2 =bind(sub, _3, _2, _1); 
    cout << sub2(10,5,1) << endl; // （1 - 5 -10）*10
    return 0;
}

#include <iostream>
#include <functional>
using namespace std;
using placeholders::_1;
using placeholders::_2;
int sub(int a,int b,int c){return(a - b - c)*10;}
class Plus {
public:
    double plusd(double a,double b){return a + b;}
};
int main() {
    // 分别绑死第 1、2、3 个参数
    auto sub1 =bind(sub,100, _1, _2); 
    cout << sub1(5,1) << endl; // （100 - 5 - 1） * 10
    auto sub2 =bind(sub, _1,100, _2); 
    cout << sub2(5,1) << endl; // （5 - 100 - 1） * 10
    auto sub3 =bind(sub, _1, _2,100); 
    cout << sub3(5,1) << endl; // （5 - 1 - 100） * 10
    cout <<"---------------------------"<< endl;
    // 同时绑死 2 个参数
    auto sub4 =bind(sub,100,10, _1); 
    cout << sub4(5) << endl; // （100 - 10 - 5） * 10
    auto sub5 =bind(sub, _1,100,10); 
    cout << sub5(5) << endl; // （5 - 100 - 10） * 10
    cout <<"---------------------------"<< endl;
    function<double(Plus *,double,double)> f1 =&Plus::plusd;
    Plus pd;
    cout << f1(&pd,1.1,1.1) << endl;
    // 将成员函数的第一个参数进行绑死，就不需要每次都传递了
    function<double(double,double)> f2 =bind(&Plus::plusd,&pd, _1, _2);
    cout << f2(1.1,1.1) << endl;
    return 0;
}

#include <iostream>
#include <functional>
using namespace std;
using placeholders::_1;
int main() {
    // 计算复利的 lambda
    auto func =[](double rate,double money,int year)->double{
        double ret = money;
        for(int i =0; i < year; i++){
            ret += ret * rate;
        }
        return ret - money;
    };
    // 绑死⼀些参数，实现出支持不同年华利率，不同金额和不同年份计算出复利的结算利息
    function<double(double)> func1 =bind(func,0.015, _1,3);
    function<double(double)> func2 =bind(func,0.02, _1,5);
    function<double(double)> func3 =bind(func,0.025, _1,10);
    function<double(double)> func4 =bind(func,0.035, _1,30);
    cout << func1(1000000.0) << endl;
    cout << func2(1000000.0) << endl;
    cout << func3(1000000.0) << endl;
    cout << func4(1000000.0) << endl;
    return 0;
}

C++11 右值引用与移动语义、可变参数模板及包装器详解

一、列表初始化

1. C++98 传统的{ }

2. C++11 中的{ }

3. C++11 中的 std::initializer_list

二、右值引用

1. 左值和右值

2. 左值引用和右值引用（讨论 右值引用变量 的属性）

3. 引用延长生命周期

4. 左值和右值的参数匹配

三、移动语义

1. 左值引用的使用场景 及其 局限性（有些场景必须 传值返回）

2. 移动构造 和 移动赋值（移动构造 与 拷贝构造 的对比）

3. 右值引用 和 移动语义 解决传值返回问题

3.1 右值对象构造场景

3.2 右值对象赋值场景

4. 右值引用 和 移动语义在传参中的提效（STL 容器的 push 和 insert 系列接口 增加右值引用版本）

四、左值引用 和 右值引用的补充知识

1. 类型分类（了解即可）

2. 引用折叠

2.1 引用折叠的介绍 和 规则（typedef 中的类型操作 构成引用的引用 的场景）

2.2 函数模板 构成引用的引用 的场景（实现 万能引用）

3. 完美转发（搭配 万能引用 使用）

五、可变参数模板

1. 基本语法及原理

2. 包扩展

3. emplace 系列接口（emplace 系列接口 比 insert 和 push 系列接口高效）

六、新的类功能

1. 默认的移动构造和移动赋值（先看 三.2）

2. default 和 delete

3. final 与 override

七、lambda

1. lambda 表达式语法

2. 捕捉列表

3. lambda 的原理

4. lambda 的使用场景

八、包装器

1. function

2. bind

九、智能指针

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

2. 左值引用和右值引用（讨论右值引用变量的属性）

1. 左值引用的使用场景及其局限性（有些场景必须传值返回）

2. 移动构造和移动赋值（移动构造与拷贝构造的对比）

3. 右值引用和移动语义解决传值返回问题

4. 右值引用和移动语义在传参中的提效（STL 容器的 push 和 insert 系列接口增加右值引用版本）

四、左值引用和右值引用的补充知识

2.1 引用折叠的介绍和规则（typedef 中的类型操作构成引用的引用的场景）

2.2 函数模板构成引用的引用的场景（实现万能引用）

3. 完美转发（搭配万能引用使用）

3. emplace 系列接口（emplace 系列接口比 insert 和 push 系列接口高效）

1. 默认的移动构造和移动赋值（先看三.2）