//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;
}