//std::initializer_list 是 C++11 引入的一个轻量级模板类，用于支持列表初始化（uniform initialization），
//即使用 { } 初始化对象。它使得初始化语法更加统一，并允许在构造函数或函数中接收任意长度的初始化列表。int main() {// the type of il is an initializer_list auto il = { 10, 20, 30 };cout << typeid(il).name() << endl;//class std::initializer_list<int>return 0;
}

std::initializer_list使用场景：
std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。

int main() {//Date属于多参数构造的类型转换，构造+拷贝构造->优化直接构造//需要和对应构造函数的参数个数匹配Date d1 = { 2025, 07, 24 };//这两种方式的初始化与上面Date初始化并不一样//它们{}中的参数个数可以是任意个数//这里{}中的参数是initializer_listvector<int> v1 = { 1,2,3,4 };vector<int> v2 = { 1,2,3,4,5,6 };list<int> lt = { 10,20,30 };//使用initializer_list赋值v1 = { 10,20,30,40, };initializer_list<int> il2 = { 10,20,30,40 };initializer_list<int>::iterator it2 = il2.begin();while (it2 != il2.end()) {cout << *it2 << " ";++it2;}cout << endl;for (auto e : il2)cout << e << " ";cout << endl;//vector支持initializer_list初始化的实现//vector(const initializer_list<T>&lt) {//	reserve(lt.size());//	for (auto& e : lt) push_back(e);//}return 0;
}

第三章：声明

c++11提供了多种简化声明的方式，尤其是在使用模板时。

3.1 auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

3.2 decltype

关键字decltype将变量的类型声明为表达式指定的类型。

int main() {int i = 1;double d = 2.2;//把类型以字符串形式获取到cout << typeid(i).name() << endl;cout << typeid(d).name() << endl;//typeid(i).name() j;//这是字符串，不能定义类型auto ret = i * d;//vector<auto> v;//错误，auto无法获取类型//用decltype获取ret的类型去实例化vector//decltype可以推导对象的类型。该类型可以用作模板实参，或定义对象vector<decltype(ret)> v;v.push_back(1);v.push_back(1.1);for (auto e : v)cout << e << " ";cout << endl;return 0;
}

3.3 nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

第四章：范围for循环

这个在前面的章节中已经进行了非常详细的讲解。

第五章：智能指针

这个将在智能指针中进行详细的讲解。

第六章：STL中一些变化

<array>、<forward_list>、<unordered_map>、<unordered_set>是C++11中的一些几个新容器，但是实际最有用的是unordered_map和unordered_set。这两个前面已经进行了非常详细的讲解，其他的了解即可。

容器中的一些新方法

比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。

实际上C++11更新后，容器中增加的新方法最后用的插入接口函数的右值引用版本：

但是这些接口到底意义在哪？网上都说他们能提高效率，他们是如何提高效率的？

请看下面的右值引用和移动语义章节的讲解。另外emplace还涉及模板的可变参数，也需要再继续深入学习后面章节的知识。

第七章：右值引用和移动语义

7.1 左值引用和右值引用

什么是左值？什么是左值引用？

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

int main() {// 以下的p、b、c、*p都是左值int* p = new int(0);int b = 1;const int c = 2;// 以下几个是对上面左值的左值引用int*& rp = p;int& rb = b;const int& rc = c;int& pvalue = *p;return 0;
}

什么是右值？什么是右值引用？

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

int main() {double x = 1.1, y = 2.2;// 以下几个都是常见的右值10;x + y;fmin(x, y);// 以下几个都是对右值的右值引用int&& rr1 = 10;double&& rr2 = x + y;double&& rr3 = fmin(x, y);// 这里编译会报错：error C2106: “=”: 左操作数必须为左值//10 = 1;//x + y = 1;//fmin(x, y) = 1;return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

7.2 左值引用与右值引用比较

int main() {//左值引用能否给右值取别名//不能，但const左值引用可以const int& r1 = 10;int i = 0;int j = i;const int& r2 = i + j;//右值引用给右值取别名int&& rr1 = 10;int&& rr2 = i + j;//右值引用能否给左值取别名//不能，但右值引用可以给move(左值)取别名int&& rr3 = move(i);return 0;
}

左值是可以取地址的值(非const可以修改，const不可以修改)。
左值引用可以给左移取别名。
左值引用不能给右值取别名，但const左值引用可以给右值取别名。

右值是不能取地址的值。
右值引用可以给右值取别名。
右值引用不能给左值取别名，但可以给move(左值)取别名。

7.3 右值引用使用场景和意义

左值引用的使用场景：
做参数和做返回值都可以提高效率。

左值引用的短板：
但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：bit::string to_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。

右值引用和移动语义解决上述问题：
在bit::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) { //const左值引用既可以引用左值，也可以引用右值cout << "string(const string& s) -- 拷贝构造 深拷贝" << endl;string tmp(s._str);swap(tmp);}//C++的右值分2类：//1.纯右值：内置类型(纯粹的字面值、临时对象或表达式计算结果，没有持久的内存地址（不能取地址）)//2.将亡值：自定义类型(即将被移动（资源被转移）的对象，通常是“生命周期即将结束”的值。)//         有内存地址（可以取地址），但允许被“掏空”（资源被移动）。//移动构造string(string&& s) {//to_string 中的 ret 是即将销毁的局部变量//编译器将其视为右值（即使它是左值名称，但处于"将亡值"场景）//构造临时对象：需要用一个右值（ret）构造临时对象//移动构造函数内部：新对象（临时对象）刚创建，它的成员是默认值。//参数 s 是 ret 的别名（引用），持有 ret 的真实数据//调用全局的 swap 函数交换每个成员//函数结束后：ret（即移动后的 s）被销毁//临时对象现在持有原 ret 的资源（"1234"），没有发生深拷贝cout << "string(string&& s) -- 移动构造" << endl;swap(s);//this：指向正在构造的临时对象（内存由编译器分配）//临时对象不新开空间}// 赋值重载string& operator=(const string& s) {cout << "string& operator=(string s) -- 赋值重载 深拷贝" << endl;//string tmp(s);//swap(tmp);if (this != &s) {char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);delete[] _str;_str = tmp;_size = s._size;_capacity = s._capacity;}return *this;}string& operator=(string&& s) {//ret 的资源（"1234"）已通过 swap 转移给临时对象。//参数 s：就是刚才那个临时对象（右值引用绑定）。 // this：指向 main 中的str。str和s交换资源。//临时对象s带着str的资源被销毁，并释放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 = nullptr;size_t _size = 0;size_t _capacity = 0; // 不包含最后做标识的\0};bit::string to_string(int x) {bit::string ret;while (x) {int val = x % 10;x /= 10;ret += ('0' + val);}reverse(ret.begin(), ret.end());return ret;//该场景不能使用左值引用返回，ret出了作用域要销毁//也不能使用右值引用返回，右值引用不能引用左值//ret拷贝构造临时对象，在赋值给外面的str，发生两次深拷贝//ret开辟空间存1234，然后拷贝构造给临时对象，临时对象也开辟空间存1234，//出了函数作用域ret销毁并释放空间，当ret赋值给外面的str并走到下一行，s销毁并释放空间//ret 是局部变量（左值），但 return 时会隐式转换为将亡值（xvalue）。//调用string(string && s)，s 就是 ret 转换成的将亡值。//移动构造后，ret 的资源被转移，外部得到新对象。}
}int main() {//无移动构造和移动赋值：//这里有深拷贝发生，to_string函数中要拷贝构造临时对象//再用临时对象赋值给s//有移动构造和移动赋值//整个移动构造和移动复制的过程中只有ret开辟了空间存储资源，临时对象把ret的换走了，//然后main函数中的str再把临时对象的换走了，也就相当于间接换走了ret的资源。bit::string str;	str = bit::to_string(1234);//------------------------------------------------------------------//如果没有移动构造，下面这种写法还是会发生一次深拷贝，相当于ret拷贝构造str。//有了移动构造就是ret和str交换资源bit::string str = bit::to_string(1234);//-------------------------------------------------------------------//下面这里将s1转为右值，虽然不调用拷贝构造(调用移动构造)//但资源交换后，s1变为空了bit::string s1("hello world");bit::string s2 = s1;//这里调用拷贝构造bit::string s3 = move(s1);//-------------------------------------------------------------------//move不会改变s1的属性，只是move的返回值是右值move(s1);bit::string s3 = s1;//调用的是拷贝构造return 0;//右值引用的移动语义主要针对深拷贝，浅拷贝意义不大//左值引用（T&）只能绑定到有名字的、持久化的对象（左值），但无法绑定到：//临时对象（右值）：如函数返回值、表达式结果等。//需要被“移动”而非拷贝的资源：比如动态分配的数组、文件句柄等。//右值引用的核心作用//右值引用（T&& ）直接绑定到临时对象（右值），并允许“窃取”其资源，避免深拷贝。典型场景包括：//函数返回临时对象：如std::vector<int> createVector()。//临时对象赋值或传参：如a = createVector()。//标准库容器的移动语义：如std::vector的移动构造函数。
}

STL容器插入接口函数也增加了右值引用版本

int main() {list<bit::string> lt;bit::string s1("hello world");lt.push_back(s1);//左值引用插入，拷贝构造 深拷贝lt.push_back(bit::to_string(1234));//调用2次移动构造。//当bit::to_string(1234)执行完毕后：//它返回一个临时对象（右值）ret。//由于 ret 是一个局部变量，在函数返回时，它会被视为即将销毁的右值。//此时，编译器会优先调用 移动构造函数（string(string && s)）来构造返回值，而不是拷贝构造。//第二次移动构造：push_back 接收临时对象//push_back 接收到 bit::to_string(1234) 返回的临时对象（右值）。//STL 的 list 在插入元素时，会构造一个新的节点来存储该字符串。//由于传入的是 右值，list 内部会调用 string 的 移动构造函数 来构造新节点中的string对象。lt.push_back("11111");//只调用一次移动构造//lt.push_back("11111"); 直接传入 const char*，//只需一次隐式构造 + 一次移动构造，没有额外的返回值传递过程。//右值引用（&& ）不仅优化了函数返回值（如 return 临时对象），//还优化了参数传递（如函数传参或容器插入操作），//特别是对于需要深拷贝的类（如 string、vector 等），//它可以避免不必要的深拷贝，直接“窃取”资源，提高性能。return 0;
}

7.4 右值引用引用左值及其一些更深入的使用场景分析

按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

验证自己实现的list

List Class.h

#pragma oncenamespace bit {template<class T>struct list_node { //节点结构体。T _data;list_node<T>* _next;list_node<T>* _prev;list_node(const T& x = T())//如果T是自定义类型，则x会是该类型的默认构造对象，取决于该类型的默认构造函数如何定义。:_data(x), _next(nullptr), _prev(nullptr) {}//为右值引用提供一个构造函数，不能带缺省参数，否则调用歧义list_node(T&& x):_data(move(x)), _next(nullptr), _prev(nullptr) {}};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* node)//单参数构造函数支持隐式类型转换，也就是说节点指针也可以隐式类型转换为迭代器:_node(node) {}self& operator++() { //前置++_node = _node->_next;return *this;}self& operator--() { //前置--_node = _node->_prev;return *this;}self operator++(int) { //后置++self tmp(*this);_node = _node->_next;return tmp;}self operator--(int) { //后置--self tmp(*this);_node = _node->_prev;return tmp;}Ref operator*() { return _node->_data; }Ptr operator->() { return &_node->_data; }//提供给自定义类型解引用。自定义类型解引用是 指针->形式，所以返回指针//非const和const迭代器中只有上面这两个运算符重载的返回值不同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;const_iterator begin() const { return _head->_next; }//支持隐式类型转换const_iterator end() const { return _head; }//支持隐式类型转换iterator begin() { return _head->_next; }iterator end() { return _head; }void empty_init() {_head = new Node;_head->_next = _head;_head->_prev = _head;_size = 0;}list() { empty_init(); } //构造函数本质是创建一个哨兵位节点//lt2(lt1)list(const list<T>& lt) { //lt是const对象，需要const迭代器empty_init();//创建(lt2的)哨兵位for (auto e : lt)//遍历lt1每个节点赋值给epush_back(e);//lt2尾插每个e节点}//现代写法void swap(list<T>& lt) {std::swap(_head, lt._head);std::swap(_size, lt._size);}list<T>& operator=(list<T> lt) {swap(lt);return *this;}~list() {clear();delete _head;//清除哨兵位_head = nullptr;}void clear() {iterator it = begin();//begin指向哨兵位的下一节点，即有效数据的头节点while (it != end())it = erase(it);}void push_back(const T& x) { insert(end(), x); }//end指向哨兵位，在哨兵位之前插入//void push_back(T&& x) { insert(end(), x); }//右值引用版本void push_back(T&& x) { insert(end(), move(x)); }//右值被右值引用 引用后的属性是左值，这样insert时走的就是左值引用版本//所以move改变x的属性为右值void push_front(const T& x) { insert(begin(), x); }void pop_back() { erase(--end()); }//哨兵位前一节点就是尾结点void pop_front() { erase(begin()); }iterator insert(iterator pos, const T& x) {Node* cur = pos._node;Node* newnode = new Node(x);Node* prev = cur->_prev;//prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;++_size;return iterator(newnode);}iterator insert(iterator pos, T&& x) {Node* cur = pos._node;Node* newnode = new Node(move(x));//右值引用版本//这里和push_back同理，右值被右值引用 引用后的属性是左值//这样走的就是左值引用版本的构造函数，所以move改变x的属性为右值Node* prev = cur->_prev;//prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;++_size;return iterator(newnode);}iterator erase(iterator pos) { //erase后迭代器失效，因为迭代器指向的节点被释放了，所以返回下一个节点的位置Node* cur = pos._node;Node* prev = cur->_prev;Node* next = cur->_next;delete cur;prev->_next = next;next->_prev = prev;--_size;return iterator(next);}size_t size() { return _size; }private:Node* _head;size_t _size;//增加该成员避免每次获取size都要遍历一遍链表};
}

Test.cpp

int main() {bit::list<bit::string> lt;bit::string s1("hello world");//拷贝构造 深拷贝lt.push_back(s1);//拷贝构造 深拷贝lt.push_back(bit::to_string(1234));//具体发生过程：拷贝构造 深拷贝 -> 移动构造 ->拷贝构造 深拷贝//bit::to_string(1234)返回值是右值，所以传给了push_back的右值引用版本，//但是右值被右值引用 引用后的属性是左值。//因为如果不这样，移动构造和移动赋值里的临时对象就无法修改，也就无法实现交换。//即右值不能被直接修改，但右值被右值引用后需要被修改。lt.push_back("11111");return 0;
}

7.5 完美转发

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; }
template<typename T>
void PerfectForward(T&& t) {//Fun(t);//都退化为左值//Fun(move(t));//这种方式会导致全部变成右值引用或const 右值引用//如果期望实参的属性与形参一致，使用完美转发Fun(forward<T>(t));
}//完美转发不能再非模板使用，因为只有在模板中&&才代表万能引用，
//这里是右值引用，不能传左值
void PerfectForward(int&& t) {Fun(forward<int>(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 右值//虽然上面传的值有左值和右值，但调用后全部变成左值引用或const 左值引用//无论参数是以什么引用形式传入的（左值引用或右值引用），在函数内部使用时，这个参数名本身都是一个左值//也就是说，即使你传入的是一个右值引用，在函数内部使用这个参数名时，它仍然是一个左值//原因：C++不自动将具名变量(任何有名字的变量或参数)当作右值的核心原因：避免意外的资源窃取导致后续代码出错。return 0;
}

​
#pragma oncenamespace bit {template<class T>struct list_node { //节点结构体。T _data;list_node<T>* _next;list_node<T>* _prev;list_node(const T& x = T())//如果T是自定义类型，则x会是该类型的默认构造对象，取决于该类型的默认构造函数如何定义。:_data(x), _next(nullptr), _prev(nullptr) {}//为右值引用提供一个构造函数，不能带缺省参数，否则调用歧义list_node(T&& x)//:_data(move(x)), _next(nullptr), _prev(nullptr) {:_data(forward<T>(x)), _next(nullptr), _prev(nullptr) {}};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* node)//单参数构造函数支持隐式类型转换，也就是说节点指针也可以隐式类型转换为迭代器:_node(node) {}self& operator++() { //前置++_node = _node->_next;return *this;}self& operator--() { //前置--_node = _node->_prev;return *this;}self operator++(int) { //后置++self tmp(*this);_node = _node->_next;return tmp;}self operator--(int) { //后置--self tmp(*this);_node = _node->_prev;return tmp;}Ref operator*() { return _node->_data; }Ptr operator->() { return &_node->_data; }//提供给自定义类型解引用。自定义类型解引用是 指针->形式，所以返回指针//非const和const迭代器中只有上面这两个运算符重载的返回值不同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;const_iterator begin() const { return _head->_next; }//支持隐式类型转换const_iterator end() const { return _head; }//支持隐式类型转换iterator begin() { return _head->_next; }iterator end() { return _head; }void empty_init() {_head = new Node;_head->_next = _head;_head->_prev = _head;_size = 0;}list() { empty_init(); } //构造函数本质是创建一个哨兵位节点//lt2(lt1)list(const list<T>& lt) { //lt是const对象，需要const迭代器empty_init();//创建(lt2的)哨兵位for (auto e : lt)//遍历lt1每个节点赋值给epush_back(e);//lt2尾插每个e节点}//现代写法void swap(list<T>& lt) {std::swap(_head, lt._head);std::swap(_size, lt._size);}list<T>& operator=(list<T> lt) {swap(lt);return *this;}~list() {clear();delete _head;//清除哨兵位_head = nullptr;}void clear() {iterator it = begin();//begin指向哨兵位的下一节点，即有效数据的头节点while (it != end())it = erase(it);}void push_back(const T& x) { insert(end(), x); }//end指向哨兵位，在哨兵位之前插入//void push_back(T&& x) { insert(end(), x); }//右值引用版本//void push_back(T&& x) { insert(end(), move(x)); }////右值被右值引用 引用后的属性是左值，这样insert时走的就是左值引用版本////所以move改变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()); }iterator insert(iterator pos, const T& x) {Node* cur = pos._node;Node* newnode = new Node(x);Node* prev = cur->_prev;//prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;++_size;return iterator(newnode);}iterator insert(iterator pos, T&& x) {Node* cur = pos._node;//Node* newnode = new Node(move(x));//右值引用版本//这里和push_back同理，右值被右值引用 引用后的属性是左值//这样走的就是左值引用版本的构造函数，所以move改变x的属性为右值Node* newnode = new Node(forward<T>(x));Node* prev = cur->_prev;//prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;++_size;return iterator(newnode);}iterator erase(iterator pos) { //erase后迭代器失效，因为迭代器指向的节点被释放了，所以返回下一个节点的位置Node* cur = pos._node;Node* prev = cur->_prev;Node* next = cur->_next;delete cur;prev->_next = next;next->_prev = prev;--_size;return iterator(next);}size_t size() { return _size; }private:Node* _head;size_t _size;//增加该成员避免每次获取size都要遍历一遍链表};
}​

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& operator=(const Person& p) {//	if (this != &p) {//		_name = p._name;//		_age = p._age;//	}//	return *this;//}//~Person() {}
private:bit::string _name;int _age;
};
int main() {//屏蔽Person(const Person& p)、Person& operator=(const Person& p)、~Person()Person s1;Person s2 = s1;//调用默认的拷贝构造 string(const string& s)Person s3 = std::move(s1);//调用默认的移动构造 string(string&& s)return 0;
}

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;int _age;
};

class Person {
public:Person(const char* name = "", int age = 0):_name(name), _age(age) {}Person(const Person& p) = delete;
private:bit::string _name;int _age;
};

下面就是一个基本可变参数的函数模板

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来一一获取参数包的值。

void _ShowList() { cout << endl; }template <class T, class ...Args>
void _ShowList(const T& val, Args... args) {cout << val << " ";_ShowList(args...);
}template <class ...Args>
void ShowList(Args... args) {_ShowList(args...);
}
//ShowList把参数包args传给了_ShowList，然后_ShowList解析参数包第一个参数，并打印1。
//然后递归调用解析参数包第二个参数，以此类推，打印完123后，继续解析，发现里面是0个参数，
//就不匹配void _ShowList(const T& val, Args... args)  而是更匹配void _ShowList()，最后打印一个换行结束。
int main() {ShowList(1);ShowList(1, 2);ShowList(1, 2, 3);ShowList(1, 2.2, 'x', 3.3);return 0;
}

//方式一
template <class T>
void PrintArg(T t) {cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args) {//PrintArg(args)是展开参数包的，逗号表达式是为了顺序执行且返回最后一个值，//就是展开参数包后再返回0。因为0才能去初始化数组，参数包的返回值(void)不能初始化数组。int arr[] = { (PrintArg(args), 0)... };cout << endl;
}//方式二
template <class T>
int PrintArg(T t) {cout << t << " ";return 0;
}
//展开函数
template <class ...Args>
void ShowList(Args... args) {//数组开多大空间取决于参数包有几个参数//有几个参数PrintArg就会调用几次int arr[] = { PrintArg(args) };cout << endl;
}int main() {ShowList(1);ShowList(1, 'A');ShowList(1, 'A', std::string("sort"));return 0;
}

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) { //const左值引用既可以引用左值，也可以引用右值cout << "string(const string& s) -- 拷贝构造 深拷贝" << endl;string tmp(s._str);swap(tmp);}//移动构造string(string&& s) {cout << "string(string&& s) -- 移动构造" << endl;swap(s);//this：指向正在构造的临时对象（内存由编译器分配）//临时对象不新开空间}// 赋值重载string& operator=(const string& s) {cout << "string& operator=(string s) -- 赋值重载 深拷贝" << endl;//string tmp(s);//swap(tmp);if (this != &s) {char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);delete[] _str;_str = tmp;_size = s._size;_capacity = s._capacity;}return *this;}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 = nullptr;size_t _size = 0;size_t _capacity = 0; // 不包含最后做标识的\0};
}int main() {std::list<bit::string> lt;//该场景下，push_back 和 emplace_back没区别bit::string s1("111");lt.push_back(s1);//拷贝构造 深拷贝lt.push_back(move(s1));//移动构造//void emplace_back (Args&&... args);bit::string s2("111");lt.emplace_back(s2);//拷贝构造 深拷贝lt.emplace_back(move(s2));//移动构造//插入匿名对象lt.push_back("xxx");//调用构造 和 移动构造lt.emplace_back("xxx");//调用构造//push_back 的声明是 void push_back(const T& val) 或 void push_back(T&& val)。//"xxx" 是 const char* 类型，需要先构造一个临时 bit::string 对象。//然后调用 push_back(T&& val)（临时对象是右值，触发移动构造）。//emplace_back 的声明是 template <class... Args> void emplace_back(Args&&... args)。//它直接将参数包 Args... 转发到 bit::string 的构造函数：//对于 emplace_back("xxx")，Args 推导为 const char* 。//直接在 list 的节点内存中调用 bit::string("xxx")，省去临时对象和移动操作。return 0;
}

int main() {std::list<pair<bit::string, int>> lt;lt.push_back(make_pair("1111", 1));//构造 + 移动构造lt.emplace_back("2222", 2);//构造//行为	    push_back	                emplace_back//构造时机	先构造临时对象，再放入容器	直接在容器内构造//参数处理	必须构造完整对象传入	        接受参数包，延迟构造//效率	    可能有额外拷贝 / 移动	        更高效，避免临时对象return 0;
}

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; }
};int main() {vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };//sort无法直接排序，需要自定义仿函数(即比较规则)sort(v.begin(), v.end(), ComparePriceLess());sort(v.begin(), v.end(), ComparePriceGreater());return 0;
}

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; }
};int main() {vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {return g1._price < g2._price; });sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate > g2._evaluate; });return 0;
}

int main() {auto f1 = [](int x)->int {cout << x << endl; return 0; };f1(1);cout << typeid(f1).name() << endl;//class <lambda_620c015845ff2142109bf3f80a50cb0a>//每个lambda都是一个类，f1就是一个类对象//f1对象可以调用operator()，所以lambda本质是仿函数//省略返回类型，编译器自动推导auto f2 = [](int x) {cout << x << endl; return 0; };f2(2);cout << typeid(f2).name() << endl;//class <lambda_5d21ffa5b2bbbd0b5a72ac1266224191>ComparePriceGreater f3;cout << typeid(f3).name() << endl;//struct ComparePriceGreaterreturn 0;
}

int main() {//使用lambda交换两个元素int x = 0, y = 1;cout << x << " " << y << endl;auto f1 = [](int& r1, int& r2) {int tmp = r1;r1 = r2;r2 = tmp;};f1(x, y);cout << x << " " << y << endl;cout << x << " " << y << endl;//[]可以捕获参数作为该类的成员变量，也就是仿函数的参数// ()中的参数默认是const修饰//所以加mutable可以取消其常量性//不需要参数传递()可以省略，但使用mutable参数列表不可省略//auto f2 = [x, y] () mutable { //交换失败，因为这是传值捕获//auto f2 = [&x, &y] () mutable { //修改为传引用捕获//mutable 的作用是允许 lambda 表达式修改 按值捕获的变量。//mutable 不影响引用捕获，因为 mutable 控制的是 lambda 对象本身的状态，//而引用捕获只是别名，修改的是外部变量。auto f2 = [&x, &y] { //可以省略() mutableint tmp = x;x = y;y = tmp;};f2();cout << x << " " << y << endl;return 0;
}

class AA {
public:void func() {//捕获列表 [] 只能捕获 当前作用域内的局部变量 或 this 指针（对于成员函数），//而不能直接捕获 类的成员变量（如 _a1 和 _a2）。//在 AA::func() 内部，_a1 和 _a2 是 类的成员变量，而不是 局部变量。//C++ 的 lambda 捕获机制 只能捕获当前作用域内可见的变量（如局部变量、函数参数、全局变量等），//而成员变量必须通过 this 指针访问。//auto f1 = [_a1, _a2] {//不可行//auto f1 = [this] {auto f1 = [=] {cout << _a1 << endl;cout << _a2 << endl;};f1();}
private:int _a1;int _a2;
};int main() {int x = 0, y = 1, z = 2;auto f1 = [=, &z] {z++;cout << x << endl;cout << y << endl;cout << z << endl;};f1();//捕获列表[]：用于 让 lambda 访问外部变量（相当于给 lambda 类添加了成员变量）。//参数列表()：用于 在调用 lambda 时传入临时参数（相当于函数参数）。//它们互相独立，捕获变量后仍然可以（或需要）参数列表，取决于你的需求。return 0;
}

template<class F, class T>
T useF(F f, T x) {static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x);
}
double f(double i) { return i / 2; }
struct Functor {double operator()(double d) { return d / 3; }
};int main() {// 函数名cout << useF(f, 11.11) << endl;// 函数对象cout << useF(Functor(), 11.11) << endl;// lamber表达式cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;return 0;
}

std::function在头文件<functional>// 类模板原型如下
template <class T> function;     // undefinedtemplate <class Ret, class... Args>
class function<Ret(Args...)>;模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

void swap_func(int& r1, int& r2) {int tmp = r1;r1 = r2;r2 = tmp;
}struct Swap {void operator()(int& r1, int& r2) {int tmp = r1;r1 = r2;r2 = tmp;}
};// 包装函数名(函数指针)\函数、函数对象、lamber表达式
int main() {int x = 0, y = 1;cout << x << " " << y << endl;auto swaplambda = [](int& r1, int& r2) {int tmp = r1;r1 = r2;r2 = tmp;};//function<void(int&, int&)> f1(swap_func);function<void(int&, int&)> f1 = swap_func;f1(x, y);cout << x << " " << y << endl;function<void(int&, int&)> f2 = Swap();f2(x, y);cout << x << " " << y << endl;function<void(int&, int&)> f3 = swaplambda;f3(x, y);cout << x << " " << y << endl;map<string, function<void(int&, int&)>> cmdOP = { {"函数指针",swap_func},{"仿函数",Swap()}, {"lambda",swaplambda} };cmdOP["函数指针"](x, y);cout << x << " " << y << endl;cmdOP["仿函数"](x, y);cout << x << " " << y << endl;cmdOP["lambda"](x, y);cout << x << " " << y << endl;return 0;
}

// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2) 
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);

int Sub(int a, int b) { return a - b; }int main() {function<int(int, int)> f1 = Sub;cout << f1(10, 5) << endl;//5//调整参数的顺序function<int(int, int)> f2 = bind(Sub, placeholders::_2, placeholders::_1);cout << f2(10, 5) << endl;//-5//调整参数的个数，有些参数可以bind时写死。20固定是第一个function<int(int)> f3 = bind(Sub, 20, placeholders::_1);cout << f3(5) << endl;//15return 0;
}

int f(int a, int b) { return a + b; }struct Functor {
public: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 = &Plus::plusi;cout << f1(1, 2) << endl;////成员函数参数中还有this指针，所以不匹配//function<double(double, double)> f2 = &Plus::plusd;function<double(Plus*, double, double)> f2 = &Plus::plusd;Plus ps;cout << f2(&ps, 1.1, 2.2) << endl;//cout << f2(&Plus(), 1.1, 2.2) << endl;//不可以传匿名对象(是右值)，左值才能取地址//特殊处理，相当于用对象调函数function<double(Plus, double, double)> f3 = &Plus::plusd;cout << f3(Plus(), 1.1, 2.2) << endl;//使用bind绑定第一个参数function<double(double, double)> f4 = bind(&Plus::plusd, Plus(), placeholders::_1, placeholders::_2);cout << f4(1.1, 2.2) << endl;return 0;
}