C11 列表初始化、左/右值引用、移动语义、可变参数模版

3、右值引用使用场景

在C++编程中，左值引用虽然能在很多场景下有效提升效率，例如作为函数参数传递和作为函数返回值，从而避免不必要的对象拷贝，但仍然存在一定的局限性。当函数返回一个局部变量时，由于局部变量在函数结束后会销毁，此时无法使用左值引用返回，只能采用传值返回。这将导致至少一次拷贝构造（在旧版编译器中可能需要两次拷贝构造），如bit::to_string函数所示。

bit::string to_string(int value)
{bool flag = true;if (value < 0){flag = false;value = 0 - value;}bit::string str;while (value > 0){int x = value % 10;value /= 10;str += ('0' + x);}if (flag == false){str += '-';}std::reverse(str.begin(), str.end());return str;
}

为了解决这个问题，C++11引入了右值引用的概念，配合移动语义，极大地提升了资源管理的效率。右值引用允许我们绑定到即将销毁的临时对象或局部变量上，通过移动构造函数，可以将临时对象的资源转移给新创建的对象，而无需进行深度拷贝。

在bit::string类中，我们添加了移动构造函数和移动赋值运算符，它们接受一个右值引用参数，并通过swap函数巧妙地将参数对象的资源转移到当前对象中。这样一来，当调用bit::to_string函数时，返回的临时字符串对象可以通过移动构造传递给接收变量，避免了深拷贝构造过程，从而显著提升了性能。

namespace bit
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){//cout << "string(char* str)" << endl;_str = new char[_capacity + 1];strcpy(_str, str);}// s1.swap(s2)void swap(string& s){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷贝构造string(const string& s):_str(nullptr){cout << "string(const string& s) -- 深拷贝" << endl;string tmp(s._str);swap(tmp);}// 赋值重载string& operator=(const string& s){cout << "string& operator=(string s) -- 深拷贝" << endl;string tmp(s);swap(tmp);return *this;}// 移动构造string(string&& s):_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 移动语义" << endl;swap(s);}// 移动赋值string& operator=(string&& s){cout << "string& operator=(string&& s) -- 移动语义" << endl;swap(s);return *this;}~string(){delete[] _str;_str = nullptr;}char& operator[](size_t pos){assert(pos < _size);return _str[pos];}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];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] = '\0';}//string operator+=(char ch)string& operator+=(char ch){push_back(ch);return *this;}const char* c_str() const{return _str;}private:char* _str;size_t _size;size_t _capacity; // 不包含最后做标识的\0};
}

// 使用值传递，函数内部会创建字符串对象副本
void func1(bit::string s);
// 使用左值引用传递，避免了对象的拷贝操作
void func2(const bit::string& s);

// 使用值传递，函数内部会创建字符串对象副本
void func1(bit::string s);
// 使用左值引用传递，避免了对象的拷贝操作
void func2(const bit::string& s);

在C++中，右值引用（rvalue reference）设计之初主要是为了能够引用右值，也就是临时对象或即将销毁的对象，以实现高效的资源转移。然而，并非绝对禁止右值引用引用左值；在某些特定场景下，确实可以通过std::move函数将左值“转换”成右值引用以便实现移动语义。

C++11标准库中的std::move函数，位于头文件<memory>中，虽然它的名称可能会令人误解，但它实际上并不会真正执行任何对象的移动操作。std::move的主要功能是将一个左值强制转化为右值引用类型，这样编译器在进行类型推断和匹配时，会优先考虑调用移动构造函数或移动赋值运算符。

template<class _Ty>
typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{// 强制类型转换，使左值看上去像右值一样可移动return static_cast<typename remove_reference<_Ty>::type&&>(_Arg);
}int main()
{bit::string s1("hello world"); // s1 是左值// 这里调用拷贝构造函数，创建s2时复制了s1的资源bit::string s2(s1);// 使用std::move将左值s1转换为右值引用，此时编译器会尝试调用移动构造函数// 将s1的内部资源转移给s3，之后s1可能被置为空或处于无效状态bit::string s3(std::move(s1));// 注意：在此之后不应继续使用s1，因为它可能已不再拥有有效资源return 0;
}

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t)
{Fun(std::forward<T>(t));
}
int main()
{PerfectForward(10);           // 右值int a;PerfectForward(a);            // 左值PerfectForward(std::move(a)); // 右值const int b = 8;PerfectForward(b);      // const 左值PerfectForward(std::move(b)); // const 右值return 0;
}

10、模拟实现list push_back右值引用

完整代码：

#pragma once
#include<assert.h>namespace bit
{template<class T>struct list_node{list_node<T>* _next;list_node<T>* _prev;T _data;list_node(const T& x = T()):_next(nullptr), _prev(nullptr), _data(x){}list_node(T&& x = T()):_next(nullptr), _prev(nullptr), _data(forward<T>(x)){}};// 1、迭代器要么就是原生指针// 2、迭代器要么就是自定义类型对原生指针的封装，模拟指针的行为template<class T, class Ref, class Ptr>struct __list_iterator{typedef list_node<T> node;typedef __list_iterator<T, Ref, Ptr> self;node* _node;__list_iterator(node* n):_node(n){}Ref operator*(){return _node->_data;}Ptr operator->(){return &_node->_data;}self& operator++(){_node = _node->_next;return *this;}self operator++(int){self tmp(*this);_node = _node->_next;return tmp;}self& operator--(){_node = _node->_prev;return *this;}self operator--(int){self tmp(*this);_node = _node->_prev;return tmp;}bool operator!=(const self& s){return _node != s._node;}bool operator==(const self& s){return _node == s._node;}};template<class T>class list{typedef list_node<T> node;public:typedef __list_iterator<T, T&, T*> iterator;typedef __list_iterator<T, const T&, const T*> const_iterator;iterator begin(){return iterator(_head->_next);}const_iterator begin() const{return const_iterator(_head->_next);}iterator end(){return iterator(_head);}const_iterator end() const{return const_iterator(_head);}void empty_init(){_head = new node(T());_head->_next = _head;_head->_prev = _head;}list(){empty_init();}template <class Iterator>list(Iterator first, Iterator last){empty_init();while (first != last){push_back(*first);++first;}}void swap(list<T>& tmp){std::swap(_head, tmp._head);}list(const list<T>& lt){empty_init();list<T> tmp(lt.begin(), lt.end());swap(tmp);}// lt1 = lt3list<T>& operator=(list<T> lt){swap(lt);return *this;}~list(){clear();delete _head;_head = nullptr;}void clear(){iterator it = begin();while (it != end()){//it = erase(it);erase(it++);}}void push_back(const T& x){insert(end(), x);}void push_back(T&& x){insert(end(), forward<T>(x));}void push_front(const T& x){insert(begin(), x);}void pop_back(){erase(--end());}void pop_front(){erase(begin());}void insert(iterator pos, const T& x){node* cur = pos._node;node* prev = cur->_prev;node* new_node = new node(x);prev->_next = new_node;new_node->_prev = prev;new_node->_next = cur;cur->_prev = new_node;}void insert(iterator pos, T&& x){node* cur = pos._node;node* prev = cur->_prev;node* new_node = new node(forward<T>(x));prev->_next = new_node;new_node->_prev = prev;new_node->_next = cur;cur->_prev = new_node;}iterator erase(iterator pos){assert(pos != end());node* prev = pos._node->_prev;node* next = pos._node->_next;prev->_next = next;next->_prev = prev;delete pos._node;return iterator(next);}private:node* _head;};
}

关键讲解：

template<class T>
class list
{
private:struct list_node{list_node(T&& x): _data(forward<T>(x)){}T _data;// ... 其他成员和构造函数省略};public:void push_back(T&& x){insert(end(), forward<T>(x));}private:void insert(iterator pos, T&& x){list_node* new_node = new list_node(forward<T>(x));// ... 实现节点插入逻辑，如更新前后节点的指针}// ... 其他成员函数和数据成员省略
};

在上述代码中，list容器模板类实现了对元素的push_back操作，包括接受左值引用和右值引用两种版本。针对右值引用，主要关注void push_back(T&& x)函数：

void push_back(T&& x)
{insert(end(), forward<T>(x));
}

• 在这个版本中，push_back接受一个右值引用参数T&& x，这意味着它可以高效地处理临时对象或将要被移动的对象。这里的forward<T>(x)调用是为了完美转发参数x，保持其原有的左值或右值属性。

接着，它调用了通用的插入函数insert(iterator pos, T&& x)，这里pos是尾部迭代器end()。在插入函数内部：

void insert(iterator pos, T&& x)
{...node* new_node = new node(forward<T>(x));...
}

• 创建了一个新的list_node对象new_node，并使用forward<T>(x)将参数x传递给list_node的移动构造函数，这样就能有效地将x的数据移动到新节点中，而不是进行拷贝，从而节省了资源，特别是当T类型的对象较大或构造/拷贝成本较高时。

list容器的push_back(T&& x)通过完美转发和移动构造机制，实现了对右值引用参数的高效插入操作，避免了不必要的数据拷贝。

四、新的类功能

1、默认成员函数

在C++标准库中，类的默认成员函数扮演着重要的角色。原先在C++98/03版本中，类默认提供的六个关键成员函数包括：

1. 默认构造函数
2. 析构函数
3. 拷贝构造函数
4. 赋值运算符重载（拷贝赋值操作）
5. 取址运算符重载（一般不需要显式定义，由编译器自动生成）
6. 常量成员的取址运算符重载（同样通常由编译器自动生成，与普通取址运算符一致）

其中，前四个函数对于对象的生命周期管理和资源复制至关重要。

随着C++11标准的引入，为了优化资源管理，特别是对于包含动态内存或其他不可复制资源的类，新增了两个默认成员函数：

1. 移动构造函数
2. 移动赋值运算符重载

关于移动构造函数和移动赋值运算符的特性及注意事项：

• 如果开发者没有手动定义移动构造函数，并且也没有定义析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个，编译器会自动生成一个默认的移动构造函数。对于内置类型的数据成员，该函数按照字节逐个进行移动（类似于浅拷贝）；而对于自定义类型的数据成员，若该类型自身实现了移动构造函数，则调用其移动构造函数来转移资源，否则退化为调用拷贝构造函数。

• 同样地，若未定义移动赋值运算符，同时其他相关函数（析构函数、拷贝构造函数或拷贝赋值运算符）也均未定义时，编译器将生成一个默认的移动赋值运算符。在此情况下，内置类型数据成员的处理方式与移动构造函数相同，自定义类型数据成员则视其是否实现了移动赋值运算符而决定采用移动赋值还是拷贝赋值。

• 当程序员提供了类的移动构造函数或移动赋值运算符时，编译器将不再自动生成对应的拷贝构造函数或拷贝赋值运算符。这意味着在实现高效资源迁移的同时，需要确保类的行为依然满足预期，特别是在涉及深拷贝和资源所有权转移的情况下。

class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}
private:bit::string _name;int _age;
};
int main()
{
// 使用默认构造函数创建s1，其_name成员为空字符串，_age为0Person s1; // 对s1进行深拷贝构造s2，调用_string(const string&)构造函数，
//输出："string(const string& s) -- 深拷贝"Person s2 = s1;// 对s1进行移动构造s3，调用_string(string&&)构造函数，
//输出："string(string&& s) -- 移动语义"，此时s1._name已经被移动，不再是有效的字符串Person s3 = std::move(s1); // 对s2进行移动赋值给s4，调用string& operator=(string&&)，
//输出："string& operator=(string&& s) -- 移动语义"，此时s2._name也被移动，不再是有效字符串Person s4;s4 = std::move(s2); 	                        return 0;
}

string(const string& s) -- 深拷贝
string(string&& s) -- 移动语义
string& operator=(string&& s) -- 移动语义

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;private:bit::string _name; // 假定bit::string是一种支持移动语义的字符串类型int _age;
};int main()
{Person s1;Person s2 = s1; // 使用拷贝构造函数
// 使用移动构造函数，由于已经显式声明为default，所以会调用默认实现Person s3 = std::move(s1);return 0;
}

class Person
{
public:// 默认构造函数，带有默认参数Person(const char* name = "", int age = 0): _name(name), _age(age){}// 显式删除拷贝构造函数Person(const Person& p) = delete;private:bit::string _name; // 假定bit::string为一种支持移动语义的字符串类型int _age;
};int main()
{Person s1;// 下面这一行尝试使用拷贝构造函数，但由于拷贝构造函数已被删除，所以会导致编译错误// Person s2 = s1;// 移动构造函数未受影响，但如果未显示声明为default或delete，由于拷贝构造函数已自定义，// 编译器也不会生成默认的移动构造函数（除非它能确保安全有效）return 0;
}

template <class... Args>
void emplace_back(Args&&... args);

#include <iostream>
#include <list>
#include <utility>// 假设存在一个自定义的bit::string类，这里为了演示只声明不实现
class bit::string {
public:bit::string(const char* str); // 从C风格字符串构造// 其他拷贝构造、移动构造等成员...
};int main() {// 示例一：使用std::pair<int, char>std::list<std::pair<int, char>> simple_list;// 使用emplace_back直接构造pair元素simple_list.emplace_back(10, 'a');simple_list.emplace_back(20, 'b');simple_list.emplace_back(std::make_pair(30, 'c')); // 虽然也可以用，但实际上并不需要make_pairsimple_list.push_back(std::make_pair(40, 'd')); // 这里创建了一个临时pair对象simple_list.push_back({50, 'e'}); // C++11及以后可以直接列表初始化// 输出列表内容for (const auto& e : simple_list) {std::cout << e.first << ":" << e.second << std::endl;}// 示例二：使用std::pair<int, bit::string>std::list<std::pair<int, bit::string>> complex_list;// 使用emplace_back直接构造包含bit::string的pair元素，避免了临时对象的创建complex_list.emplace_back(10, "sort"); complex_list.emplace_back(std::make_pair(20, "sort")); // 同样，这里使用make_pair可以优化// 使用push_back时，会先创建一个临时的pair对象，然后移动到列表中complex_list.push_back(std::make_pair(30, "sort")); complex_list.push_back({40, "sort"}); // 注意：此处假设bit::string支持移动构造，否则push_back可能涉及拷贝构造// 实际输出部分省略，因为bit::string未实现，无法直接输出return 0;
}

// Args 是一个模板参数包，而 args 是与之对应的函数实际参数包
// 定义一个参数包 Args... args，它可以收纳从0到任意个数的模板参数。
template <class ...Args>
void ShowList(Args... args)
{// 在此处，args 参数包内可以包含不同类型的任意数量参数// 使用可变参数模板时，直接访问 args 的各个元素并不直接支持索引操作如 args[i]// 而是需要采用参数包展开技术来分别处理每个参数// （此处留空是因为展开的具体实现依赖于具体应用场景）
}