C++STL---Vector、List所要掌握的基本知识

绪论​
拼着一切代价，奔你的前程。 ——巴尔扎克；本章主要围绕vector和list的使用，以及容器底层迭代器失效问题，同时会有对原码的分析和模拟实现其底层类函数。​​​​话不多说安全带系好，发车啦（建议电脑观看）。

附：红色，部分为重点部分；蓝颜色为需要记忆的部分（不是死记硬背哈，多敲）；黑色加粗或者其余颜色为次重点；黑色为描述需要

---

1.Vector

——————————————

Vector就像一个动态的数组也就是顺序表（有些时候可以想象成常规数组），也就是在写好的类中进行一定的函数操作，其中函数操作也就是上面所写。

---

1.1构造函数

//初始化vector的方法
vector<int> v;//缺省
vector<int> v1(10,0);//初始化0个10
vector<int> v2(v1.begin(),v1.end());//迭代器从begin到end初始化
vector<int> v3(v2);//拷贝构造
1
2
3
4
5

---

1.2析构函数

在使用中不用去管因为其会自动执行释放构造函数所申请的空间

---

1.3迭代器类函数

知识点：

1.3.1begin（）、end（）、rbegin（）、rend（）

此处begin、end和string中的差不多用来指向结构中的数据，begin指向vector的首元素（类似于数组的首元素）、end指向的是数组最后一个元素的下一个位置，相反的rbegin指向的是数组的最后一个元素，而rend指向的是第一个元素的前一个位置
其中可以发现begin指向vector内的数据，而end则不会指向vector内

练习使用：

	vector<int> v(10, 1);
	v.push_back(2);
	vector<int>::iterator it = v.begin();//指向vector首元素的1
	while (it != v.end())
	{
		cout << *it << ' ';
		it++;
	}
	//正向打印出所有元素：1 1 1 1 1 1 1 1 1 1 2 类似于指针
	cout << endl;
	vector<int>::reverse_iterator rit = v.rbegin();
	while (rit != v.rend())
	{
		cout << *rit << ' ';
		rit++;//注意此处仍然是++而不是--
	}
	//反向的打印出所有元素：2 1 1 1 1 1 1 1 1 1 1  类似于指针
	
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

附：cbegin、cend、crbeing、crend 是针对于const类型的，用法一样就不展开讲了。

1.4容量类函数

知识点：

1.4.1size（）

函数原型：size_type size() const;
功能：查看vector中有几个元素。

vector<int> v(10,1);
v.size();//返回10
1
2

1.4.2capacity（）

函数原型：size_type capacity() const;
功能：查看vector的capacity。

vector<int> v(10,1);
v.capacity();//在VS2019IDE环境下每次扩容1.5倍 1 ~ 2 ~ 3 ~ 6 ~ 9 ~ 13 ....
1
2

1.4.3reserve（）

函数原型：void reserve (size_type n);
功能：设置vector的capacity，可提前把capacity设置好避免不断动态扩容的消耗

1.4.4resize（）

函数原型：void resize (size_type n, value_type val = value_type());
改变vector的size（size决定了vector容器中的元素个数）

一般来说capacity申请扩展后都不会轻易的缩回

1.4.5empty（）

函数原型：bool empty() const;
功能：查看vector内是否有数据，若返回true表示size == 0，否则放回false；

1.4.6shrink_to_fit（）

函数原型：void shrink_to_fit();
功能：把capacity缩小到size大小（这条函数不一定执行最终是否执行还得看编译器他是无约束力的（non-binding））

1.5元素访问类函数

知识点：

1.5.1operator[]

功能：像数组一样来访问vector中的元素
如：第一个元素v[0] …

1.5.2at（）

功能:访问vector中的元素，但一般来说更多的用operator[]
如：v.at(0);访问第一个元素

1.5.3front（）、back()

front的功能：找到vector中第一个元素并返回
如：vector v(10,1); v.fornt();//指向向首元素1
back的功能：同理就是找到vector的最后一个元素
如： vector v(10,1); v.back();//指向向最后一个元素1

---

写到这我觉得没必要再写了（有点浪费时间），对于这些函数可以自行查资料，里面有解释以及函数原型！c++官网，下面我将只写函数的用处，但仍然会把一些细节给写出来！

---

1.6修改类函数

附：对于容器中我们若想在指定位置插入的话其实他并没有find函数来找到所对应的任意位置，对此在c++库中的算法库中其实有一个通用的find（）查找函数
函数原型为：
template
InputIterator find (InputIterator first, InputIterator last, const T& val);
用法如下：
vector v;//在其中存储着1 2 3 4 5 6 7 find(v.begin(),v.end(),3);//传进迭代器区间，在其中找3，最后返回对应迭代器
这样就能找到容器中的数据并且进行一定的操作。

---

---

对于vector来说，还有个比较重要的点：

vector迭代器失效问题

在vector使用中可能会出现两种迭代器失效的情况：

1. 当插入数据后的迭代器失效问题：因为在插入数据的情况下，有可能会发生异地扩容,当发生异地时就会导致原本迭代器所指向的位置为一个野指针也就是所说的迭代器失效，所以我们要注意的是迭代器在插入数据后要给迭代器重新赋值，并且在模拟实现插入函数中我们可能会扩容此处也要记得防止迭代器失效而记录迭代器位置，并作出一定的改变。

        iterator insert(iterator pos, const T& x)
        {
            assert(pos <= _finish);
            assert(pos >= _start);

            if (_finish == _endofstorage)
            {
                size_t n = pos - _start;//记录相对位置防止迭代器在扩容后失效
                reserve(capacity() == 0 ? 4 : capacity() * 2);
                pos = _start + n;
            }
            iterator it = _finish;
            while (it > pos) 
            {
                *it = *(it - 1);
                it--;
            }
            *it = x;
            _finish++;

            return _start;
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2. 当删除数据时我们要注意的是，他可能也会有迭代器失效的问题，因为在VS2019IDE下规定当一个迭代器所指向的位置被删除后，该迭代器就已经失效了，我们不能再次的去使用若使用就会报错，而在CentOs7 g++下迭代器会指向物理下的下一个位置（如：1234 删除2后3覆盖了2的位置迭代器就会指向4），此处解决的方法为：更新迭代器让它接收erase的返回值，在c++中规定了erase删除后返回迭代器指向被删除数据的下一个位置，这样才能正确的删除数据， 如：it = erase(it)//删除后需要接收返回的迭代器。

vector深浅拷贝问题

当有异地扩容的时候，我们需要去将数据进行拷贝，此处如果是内置类型的话直接进行拷贝然后释放就行了，而对于像string类这种有深浅拷贝问题的就需要注意，我们若用memcpy直接进行的拷贝就会出深浅拷贝问题，对此我们在reserve扩容函数中就需要注意改变写法具体如下。

        void reserve(size_t n)
        {
            if (n  > capacity())
            {
                T* tmp = new T[n];
                size_t sz = size();
                if (_start) 
                {
                    //memcpy(tmp, _start, sz * sizeof(T)); 此处对于自定义类型来说是一个浅拷贝了
 
                    for(size_t i = 0; i < size();i++)
                    {
                        tmp[i] = _start[i];//逐个元素的进行赋值操作就能避免
                    }
                    delete[] _start;
                }
                _start = tmp;
                _finish = _start + sz;//这里不用size()因为这样会导致为nullptr , 
                _endofstorage = _start + n;
            }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

vector反向迭代器的实现

对于vector反向迭代器来说，我们不能像正向一样的直接用一个指针指向start，他们需要从后往前来走（也就表示当reverse_iterartor ++ 时并不是往前走的而是往后的），这样我们就需要重新分装一个反向迭代器的类，并且对操作符++、–重载改变其原理。对此在一个类中我们还需要去实现一些其他的操作符，具体如下：

    template<class iterator>
    class reverse_iterator
    {
        typedef reverse_iterator<iterator> Self;

        reverse_iterator(iterator t)
            :it(t)
        {}
        Self& operator++()
        {
            it--;
            return *this;
        }
        Self operator++(int)
        {
            Self tmp (it);
            it--;
            return tmp;
        }
        Self& operator--()
        {
            it++;
            return *this;
        }
        Self operator--(int)
        {
            reverse_iterator tmp = it;
            it++;
            return tmp;
        }

        Self& operator*()
        {
            reverse_iterator tmp = it;
            return *(--tmp);
        }

  

        bool operator!=(const Self& t)
        {
            return it != t.it;
        }

        bool operator==(const Self& t)
        {
            return it == t.it;
        }

    private:
        iterator it;
    };
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

模拟实现Vector：

#pragma once
#include
#include
#include

using namespace std;

namespace bit
{
    template<class T>
    class vector
    {
    public:
        // Vector的迭代器是一个原生指针
        typedef T* iterator;

        typedef const T* const_iterator;

        typedef reverse_iterator<iterator> reverse_iterator;


        reverse_iterator rbegin()
        {
            return reverse_iterator(end());
        }

        reverse_iterator rend()
        {
            return  reverse_iterator(begin());
        }

        iterator begin() 
        {
            return _start;
        }

        iterator end() 
        {
            return _finish;
        }

        const_iterator cbegin() const
        {
            return _start;
        }

        const_iterator cend() const
        {
            return _finish;
        }

        // construct and destroy
        // 
        //对于直接的构造不做如何处理
        vector()
        {}

        vector(size_t n, const T& value = T())
        {
            reserve(n);
            while (n--) {
                push_back(value);
            }
        }

        vector(int n, const T& value = T())
        {
            reserve(n);
            while (n--) {
                push_back(value);
            }
        }

        template<class InputIterator>
        vector(InputIterator first, InputIterator last)
        {
            assert(first && last);
            while(first != last)
            {
                push_back(*first);
                first++;
            }
        }
        //现代写法：
        vector(const vector<T>& v)
        {
            vector<T> tmp(v.cbegin(),v.cend());

            swap(tmp);
        }
        //传统写法：
        //vector(const vector& v)
        //{
        //    //开辟一个空间
        //    reserve(v.capacity());
        //    //把数据放进去
        //    for (auto& e : v)
        //    {
        //        push_back(e);
        //    }
        //}

        vector<T>& operator=(vector<T> v)
        {
            swap(v);
            return *this;
        }
        //void operator++(int)
        //{
        //    swap(v);
        //    return *this;
        //}

        ~vector()
        {
            delete[] _start;
            _start = _finish = _endofstorage = nullptr;
        }

         capacity

        size_t size() const
        {
            return _finish - _start;
        }

        size_t capacity() const
        {
            return _endofstorage - _start;
        }

        void reserve(size_t n)
        {
            if (n  > capacity())
            {
                T* tmp = new T[n];
                size_t sz = size();
                if (_start) 
                {
                    //memcpy(tmp, _start, sz * sizeof(T)); 此处对于自定义类型来说是一个浅拷贝了
 
                    for(size_t i = 0; i < size();i++)
                    {
                        tmp[i] = _start[i];
                    }
                    delete[] _start;
                }
                _start = tmp;
                _finish = _start + sz;//这里不用size()因为这样会导致为nullptr , 
                _endofstorage = _start + n;
            }
        }

        void resize(size_t n, const T& value = T())
        {
            if (n < capacity())
            {
                _finish = _start + n;
            }
            else {
                reserve(n);
                while (_finish < _start + n)
                {
                    *_finish = value;
                    ++_finish;
                }
            }
        }



        /access///

        T& operator[](size_t pos)
        {
            assert(pos < size());

            return _start[pos];
        }

        const T& operator[](size_t pos)const
        {
            assert(pos < size());

            return _start[pos];
        }



        /modify/

        void push_back(const T& x)
        {
   /*         if (_finish == _endofstorage)
            {
                int cp = capacity() == 0 ? 4 : capacity() * 2;
                reserve(cp);
            }
            *_finish = x;
            _finish++;*/
            insert(end(), x);
        }

        void pop_back()
        {
            _finish--;
        }

        void swap(vector<T>& v)
        {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_endofstorage, v._endofstorage);
        }

        iterator insert(iterator pos, const T& x)
        {
            assert(pos <= _finish);
            assert(pos >= _start);

            if (_finish == _endofstorage)
            {
                size_t n = pos - _start;//防止迭代器在扩容后失效
                reserve(capacity() == 0 ? 4 : capacity() * 2);
                pos = _start + n;
            }
            iterator it = _finish;
            while (it > pos) 
            {
                *it = *(it - 1);
                it--;
            }
            *it = x;
            _finish++;

  
            return _start;
        }

        iterator erase(iterator pos)
        {
            assert(pos < _finish);
            assert(pos >= _start);

            iterator it = pos + 1;
            while (it < _finish)
            {
                *(it - 1) = *it;
                it++;
            }
            
            _finish--;
            return pos;
        }
  

    private:
        //给他们初始值是为了预防
        iterator _start = nullptr; // 指向数据块的开始

        iterator _finish = nullptr; // 指向有效数据的尾

        iterator _endofstorage = nullptr; // 指向存储容量的尾

    };

    template<class iterator>
    class reverse_iterator
    {
        typedef reverse_iterator<iterator> Self;

        reverse_iterator(iterator t)
            :it(t)
        {}
        Self& operator++()
        {
            it--;
            return *this;
        }
        Self operator++(int)
        {
            Self tmp (it);
            it--;
            return tmp;
        }
        Self& operator--()
        {
            it++;
            return *this;
        }
        Self operator--(int)
        {
            reverse_iterator tmp = it;
            it++;
            return tmp;
        }

        Self& operator*()
        {
            reverse_iterator tmp = it;
            return *(--tmp);
        }

        bool operator!=(const Self& t)
        {
            return it != t.it;
        }

        bool operator==(const Self& t)
        {
            return it == t.it;
        }

    private:
        iterator it;
    };

}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320

---

2.List

在STL的list其实就是数据结构中的带头双向循环列表（若不清楚的建议看看数据机构基础之链表）

同样的在list中也不会去详细的简述函数（这些都是熟能生巧的多去查文档），会在后面写道一些细节内容以及函数的功能

2.1构造函数、析构函数

析构函数不用自己调用，其内部主要包括把所借的内存归还给操作系统操作

2.2迭代器类函数

2.3容量类函数

2.4元素访问类函数

2.5修改类函数

2.5.1list 删除操作时的迭代器失效问题：

list在插入数据时并不会迭代器失效，而在删除时因为当前位置的迭代器所指向的地址空间已经被释放，而形成了迭代器失效。
所以为避免这种情况删除的实现会返回一个迭代器（也就是被删除数据的下一个位置）并且我们需要用接收这个迭代器才能解决失效问题（例：iterator it = l.erase(l.begin())）
通过上面的分析我们能知道当list删除数据后其原本的迭代器会指向被删除的数据的下一个数据，并且返回该位置！对此来实现list的删除：

       iterator erase(iterator pos)
        {
            Node* cur = pos._Node;
            Node* prev = cur->_Prev;
            Node* next = cur->_Next;//一开始记录删除数据的下一个位置

            prev->_Next = next;
            next->_Prev = prev;

            _size--;
            return iterator(next);//返回next
        }
1
2
3
4
5
6
7
8
9
10
11
12

2.6操作类函数

2.7list的实现

#pragma once

#include
using namespace std;


namespace bite
{
    // List的节点类
    template<class T>
    struct ListNode
    {
        ListNode(const T& val = T())
            :_val(val)
            ,_Prev(nullptr)
            ,_Next(nullptr)
        {}

        ListNode<T>* _Prev;
        ListNode<T>* _Next;
        T _val;
    };

    //List的迭代器类
    template<class T, class Ref, class Ptr>
    struct ListIterator
    {
        typedef ListNode<T> Node;
        typedef ListIterator<T, Ref, Ptr> Self;
    public:
        ListIterator(Node* node = nullptr) 
            :_Node(node)
        {}

        //ListIterator(const Self& l);

        T& operator*()
        {
            return _Node->_val;
        }

        Ptr operator->()
        {
            return &_Node->_val;
        }

        Self& operator++()
        {
            _Node = _Node->_Next;
            return *this;
        }
      //后置
        Self operator++(int)
        {
            Self tmp(*this);//拷贝构造
            //其中self是类型、*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& l)
        {
            return _Node != l._Node;
        }

        bool operator==(const Self& l)
        {
            return _Node == l._Node;
        }

        Node* _Node;
    };

    template<class T, class Ref, class Ptr>
    struct RIterator
    {
        typedef ListNode<T> Node;
        typedef RIterator<T, Ref, Ptr> Self;
    public:
          RIterator(Node* node = nullptr)
            :_Node(node)
          {}

        //ListIterator(const Self& l);

        T& operator*()
        {
            return _Node->_val;
        }

        Ptr operator->()
        {
            return &_Node->_val;
        }

        Self& operator++()
        {
            _Node = _Node->_Prev;
            return *this;
        }
        //后置
        Self operator++(int)
        {
            Self tmp(*this);//拷贝构造
            //其中self是类型、*this是一个具体的对象
            _Node = _Node->_Prev;
            return tmp;
        }

        //前置
        Self& operator--()
        {
            _Node = _Node->_Next;
            return *this;
        }

        //后置需要一个类型来占位
        Self& operator--(int)
        {
            Self tmp(*this);
            _Node = _Node->_Next;
            return tmp;
        }

        bool operator!=(const Self& l)
        {
            return _Node != l._Node;
        }

        bool operator==(const Self& l)
        {
            return _Node == l._Node;
        }

        Node* _Node;
    };

    //list类
    template<class T>
    class list
    {
    public:
        typedef ListNode<T> Node;

        typedef ListIterator<T, T&, T*> iterator;//将


        typedef ListIterator<T, const T&, const T&> const_iterator;
    
        typedef RIterator<T, T&, T*> reverse_iterator;//将

    public:
        ///
        // List的构造

        void empty_init()
        {
            _Head = new Node;//头节点
            _Head->_Next = _Head;
            _Head->_Prev = _Head;
        }


        list()
        {
            empty_init();
        }

        list(int n, const T& value = T())
        {
            for(int i = 0; i<n;i++)
            {
                push_back(value);
            }
        }

        template <class Iterator>
        list(Iterator first, Iterator last)
        {
            Iterator it = first;
            while (it != last)
            {
                push_back(*it);
                ++it;
            }
        }

        void swap(list<T>& l)
        {
            std::swap(_Head, l._Head);
            std::swap(_size, l._size);
        }

        list(const list<T>& l)
        {
            empty_init();
            for (auto nd : l)
            {
                push_back(nd);
            }
        }

        list<T>& operator=(list<T> l)
        {
            swap(l);

            return *this;
        }

        ~list()
        {
            clear();//将申请的空间返还
            delete _Head;
            _Head = nullptr;
        }

        ///
        // List Iterator
        iterator begin()
        {
            //return iterator(_Head->_Next);
            return _Head->_Next;

        }
        iterator end()
        {
            //return iterator(_Head);
            return _Head;
        }

        const_iterator begin()const
        {
            return _Head->_Next;
        }

        const_iterator end()const
        {
            return _Head;
        }
        
        reverse_iterator rbegin()
        {
            return reverse_iterator(_Head->_Prev);
        }

        reverse_iterator rend()
        {
            return reverse_iterator(_Head);
        }

        // List Capacity
        size_t size()const
        {
            return _size;
        }

        bool empty()const
        {
            return _size == 0;
        }

         List Access
        T& front()
        {
            return _Head->_Next->_val;
        }

        const T& front()const
        {
            return _Head->_Next->_val;
        }
        //
        T& back()
        {
            return _Head->_Prev->_val;
        }
        //
        const T& back()const
        {
            return _Head->_Prev->_val;
        }
        
        // List Modify
        void push_back(const T& val)
        { 
            //Node* tail = _Head->_Prev;
            //Node* newnode = new Node(val);

            //tail->_Next = newnode;
            //newnode->_Prev = tail;

            //_Head->_Prev = newnode;
            //newnode->_Next = _Head;

            //_size++;
            insert(end(), val); 
        }


        void pop_back() 
        {
 /*           Node* tail = _Head->_Prev;

            tail->_Prev->_Next = _Head;
            _Head->_Prev = tail->_Prev;

            delete tail;

            _size--;*/
            erase(--end()); 
        }

        void push_front(const T& val) 
        { 
            //Node* head = _Head->_Next;
            //Node* newnode = new Node(val);

            //head->_Prev = newnode;
            //newnode->_Next = head;

            //_Head->_Next = newnode;
            //head->_Prev = _Head;

            //_size++;
            insert(begin(), val); 
        }

        void pop_front()
        { 
   /*         Node* head = _Head->_Next;

            head->_Next->_Prev = _Head;
            _Head->_Next = head->_Next;
            delete head;
            _size--;*/
            erase(begin());
        }
         在pos位置前插入值为val的节点
        iterator insert(iterator pos, const T& val)
        {
            Node* cur = pos._Node;
            Node* newnode = new Node(val);
            Node* prev = cur->_Prev;

            prev->_Next = newnode;
            newnode->_Prev = prev;

            newnode->_Next = cur;
            cur->_Prev = newnode;
            
            _size++;
            return iterator(newnode);
        }
         删除pos位置的节点，返回该节点的下一个位置
        iterator erase(iterator pos)
        {
            Node* cur = pos._Node;
            Node* prev = cur->_Prev;
            Node* next = cur->_Next;

            prev->_Next = next;
            next->_Prev = prev;

            _size--;
            return iterator(next);
        }
        void clear()
        {
            iterator it = begin();
            while(it != end())
            {
                it = erase(it);
            }
            //for(auto it : )
            _size = 0;
        }
    private:
        Node* _Head;
        size_t _size;
    };
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396

本章完。预知后事如何，暂听下回分解。

如果有任何问题欢迎讨论哈！

如果觉得这篇文章对你有所帮助的话点点赞吧！

持续更新大量C++细致内容，早关注不迷路。

​