• 【STL源码剖析】vector类模拟实现 了解底层-走进底层-掌握底层【超详细的注释和解释】

     

    今天博主继续带来STL源码剖析专栏的第二篇博客了！
    今天带来vector的模拟实现！
    其实在很多人学习C++过程中，都是只学习一些STL的使用方式，并不了解底层的实现。博主本人认为，这样的学习这样的技术是不深的。如果我们想要熟悉的掌握一门语言，我认为，底层的实现必不能少！
    但是，想从0开始模拟实现STL的容器，需要我们熟悉C++的语法，特别是类和对象部分的知识！
    博主学习C++到现在，我认为C++类和对象基本语法的学习比任何部分都要重要，而我花在这上面的时间也是最多的！只要搞清楚C++面向对象编程的基本规则，我们才能在STL的世界里游刃有余！
    所以我希望大家在学习STL之前，先将数据结构与算法，C++的类和对象部分内容掌握熟悉！

    前言

    那么这里博主先安利一下一些干货满满的专栏啦！

    手撕数据结构https://blog.csdn.net/yu_cblog/category_11490888.html?spm=1001.2014.3001.5482这里包含了博主很多的数据结构学习上的总结，每一篇都是超级用心编写的，有兴趣的伙伴们都支持一下吧！
    算法专栏https://blog.csdn.net/yu_cblog/category_11464817.html这里是STL源码剖析专栏，这个专栏将会持续更新STL各种容器的模拟实现。

    STL源码剖析https://blog.csdn.net/yu_cblog/category_11983210.html?spm=1001.2014.3001.5482

    实现过程中要注意的一些点

    vector类其实是我们非常常用的一个容器，其底层其实就是一个顺序表。

    博主在带大家实现的过程中，并不会把STL里面每一个成员函数都去模拟实现一次，我们模拟实现容器底层的目的其实是去学习里面实现的思路。

    因此，博主只会将一些重要、常用的成员函数模拟实现给大家。

    另外，除了博主实现的源代码之外，博主还提供一份测试代码，它可以帮助我们检查自己写的代码是否准确。

    在测试代码中遇到的问题和解决思路以及一些细节的处理，博主都在.h和.cpp代码里用注释的形式给大家说明白(注释满满干货不要错过噢)。

    希望大家可以从中学到知识。

    MyVector.h完整源代码

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. namespace yufc {
    7. 	template<class T>
    8. 	class vector {
    9. 	public:
    10. 		typedef T* iterator;//这个要放成共有，不然迭代器外面访问不了 -- 定义迭代器类型是指针类型
    11. 		typedef const T* const_iterator;
    12. 		//vector的迭代器就是原生指针
    13. 		iterator begin() {
    14. 			return _start;
    15. 		}
    16. 		iterator end() {
    17. 			return _finish;
    18. 		}
    19. 		//如果不提供const迭代器 -- 如果传了const的vector是遍历不了的，因为权限不能放大
    20. 		const_iterator begin()const { //不能返回普通迭代器，要返回const迭代器
    21. 			return _start;
    22. 		}
    23. 		const_iterator end()const {
    24. 			return _finish;
    25. 		}
    26. 		vector() :_start(nullptr), _finish(nullptr), _end_of_storage(nullptr) {}
    27. 		~vector() {
    28. 			delete[] _start;
    29. 			_start = _finish = _end_of_storage = nullptr;
    30. 		}
    31. 		//stl的vector还支持使用迭代器区间去构造
    32. 		//为什么需要一个其它类型的迭代器？
    33. 		//因为他要支持用其它容器的迭代器的区间构造
    34. 		template<class InputIterator>
    35. 		vector(InputIterator first, InputIterator last) 
    36. 			:_start(nullptr), _finish(nullptr), _end_of_storage(nullptr)
    37. 		{
    38. 			while (first != last) {
    39. 				//不能直接push_back()，直接push_back()会崩溃 -- 因为没有初始化 -- 野指针
    40. 				push_back(*first);
    41. 				++first;
    42. 			}
    43. 		}
    44. 		vector(size_t n, const T& val = T()) 
    45. 			:_start(nullptr), _finish(nullptr), _end_of_storage(nullptr)
    46. 		{
    47. 			//用n个值去构造
    48. 			reserve(n);
    49. 			for (size_t i = 0; i < n; i++) {
    50. 				push_back(val);
    51. 			}
    52. 		}
    53. 		//传统拷贝构造
    54. #if 0
    55. 		vector(const vector& v) {
    56. 			_start = new T[v.size()];//这里是给size还是capacity呢？STL没有要求
    57. 			//memcpy(_start, v._start, sizeof(T) * v.size());
    58. 			//解决vector>深拷贝的情况,memcpy不能帮助内层的自定义类型完成深拷贝，赋值可以（我们写好了自定义类型的赋值）
    59. 			for (size_t i = 0; i < v.size(); i++) {
    60. 				_start[i] = v._start[i];
    61. 			}
    62. 			_finish = _start + v.size();
    63. 			_end_of_storage = _start + v.size();//因为T[]里面给了size(),所以这里也应该是v.size()
    64. 		}
    65. #endif
    66. 		//写法2
    67. #if 0
    68. 		vector(const vector& v) 
    69. 			:_start(nullptr), _finish(nullptr), _end_of_storage(nullptr)
    70. 		{
    71. 			reserve(v.size());
    72. 			for (const auto& e : v) { //注意：这里拷贝过去一定要引用，不然又要拷贝了
    73. 												//写深拷贝自己还要调深拷贝 -- 肯定是会出问题的
    74. 				push_back(e);
    75. 			}
    76. 			//不需要去调整_finish,因为push_back()已经搞定了
    77. 		}
    78. #endif
    79.  
    80. 		//现代写法拷贝构造 -- 复用迭代器区间构造函数
    81. 		void swap(vector& v) {
    82. 			std::swap(_start, v._start);
    83. 			std::swap(_finish, v._finish);
    84. 			std::swap(_end_of_storage, v._end_of_storage);
    85. 		}
    86. #if 1
    87. 		vector(const vector& v) 
    88. 			:_start(nullptr), _finish(nullptr), _end_of_storage(nullptr)
    89. 		{
    90. 			vectortmp(v.begin(), v.end());
    91. 			swap(tmp);//当然自定义类型自己写的swap更高效 -- 我们自己实现一个
    92. 		}
    93. #endif
    94. 		vector& operator=(vector v) { //v1=v2
    95. 			//v是v2的拷贝，而且是局部的，swap完之后给到v1，v还会自动析构（因为是局部对象）
    96. 			swap(v);
    97. 			return *this;
    98. 		}
    99. 		size_t capacity()const {
    100. 			return _end_of_storage - _start;
    101. 		}
    102. 		size_t size()const {
    103. 			return _finish - _start;
    104. 		}
    105. 		void reserve(size_t n) {
    106. 			if (n > capacity()) {
    107. 				T* tmp = new T[n];
    108. 				size_t sz = size();
    109. 				if (_start) {
    110. 					//memcpy(tmp, _start, sizeof(T) * sz);//拷贝size()个字节过去，先放到tmp里面
    111. 					//同样，解决
    112. 					//vector<自定义类型>的问题
    113. 					for (size_t i = 0; i < sz; i++) {
    114. 						tmp[i] = _start[i];//当T是自定义类型时，调用T类型的operator=
    115. 					}
    116. 					delete[] _start;
    117. 				}
    118. 				_start = tmp;
    119. 				//_finish = _start + size();//这里不要现场去算size()
    120. 				//因为size()是用start减出来的，上面那一行start已经变了
    121. 				//所以在前面我们最好保留一下size先
    122. 				_finish = _start + sz;
    123. 				_end_of_storage = _start + n;
    124. 			}
    125. 		}
    126. 		void resize(size_t n, const T& val = T()) {
    127. 			//1.扩容+初始化
    128. 			//2.初始化
    129. 			//3.删除数据
    130. 			if (n > capacity()) {
    131. 				reserve(n);
    132. 			}
    133. 			if (n > size()) {
    134. 				//初始化填值
    135. 				while (_finish < _start+n) {
    136. 					*_finish = val;
    137. 					++_finish;
    138. 				}
    139. 			}
    140. 			else {
    141. 				_finish = _start + n;
    142. 			}
    143. 		}
    144. 		T& operator[](size_t pos) {
    145. 			assert(pos < size());
    146. 			return _start[pos];
    147. 		}
    148. 		const T& operator[](size_t pos) const {
    149. 			assert(pos < size());
    150. 			return _start[pos];
    151. 		}
    152. 		void push_back(const T& x) {
    153. 			//加了const保证传什么类型都行，因为隐式类型转换临时变量具有常性
    154. 			if (_finish == _end_of_storage) {
    155. 				reserve(capacity() == 0 ? 4 : capacity() * 2);
    156. 			}
    157. 			*_finish = x;
    158. 			++_finish;
    159. 		}
    160. 		void pop_back() {
    161. 			assert(_finish > _start);//为空是不能删的
    162. 			--_finish;
    163. 		}
    164. 		void insert(iterator pos, const T& x) {
    165. 			assert(pos >= _start);
    166. 			assert(pos <= _finish);
    167. 			if (_finish == _end_of_storage) {//扩容
    168. 				//记住pos和start的相对位置
    169. 				size_t len = pos - _start;
    170. 				reserve(capacity() == 0 ? 4 : capacity() * 2);
    171. 				pos = _start + len;//更新pos的位置 -- 解决迭代器失效
    172. 			}
    173. 			//挪动数据
    174. 			iterator end = _finish - 1;
    175. 			while (end >= pos) { // insert要扩容的时候，这个循环就失效了，停不下来了，为什么？
    176. 				*(end + 1) = *end;
    177. 				end--;
    178. 			}
    179. 			//扩容之后，旧空间的数据拷贝到新空间
    180. 			//旧空间已经被释放了 -- pos是指向旧空间的一个数字的位置的
    181. 			//pos成了野指针！ -- 迭代器失效
    182. 			//所以我们要把pos更新一下
    183. 			// -- 修改了内部的pos之后，其实问题还没有根本的解决
    184. 			*pos = x;
    185. 			++_finish;
    186. 		}
    187. 		iterator erase(iterator pos) {
    188. 			assert(pos >= _start);
    189. 			assert(pos < _finish);
    190. 			//挪动覆盖删除
    191. 			iterator begin = pos + 1;
    192. 			while (begin < _finish) {
    193. 				*(begin - 1) = *begin;
    194. 				++begin;
    195. 			}
    196. 			--_finish;
    197. 			//删除了位置的下一个位置 -- 还是pos
    198. 			return pos;
    199. 		}
    200. 		T& front() {
    201. 			assert(size() > 0);
    202. 			return *_start;
    203. 		}
    204. 		T& back() {
    205. 			assert(size() > 0);
    206. 			return *(_finish - 1);
    207. 		}
    208. 	private:
    209. 		iterator _start;//start相当于整个数组的开始位置
    210. 		iterator _finish;//[_start,_finish)
    211. 		iterator _end_of_storage;
    212. 	};
    213. }

     test.cpp测试源文件完整代码

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include"MyVector.h"
    4. #include
    5. #include
    6. using namespace std;
    7.  
    8. void PrintVector(yufc::vector<int>& v) {//在没有写拷贝构造的时候，这里一定要引用的，不然浅拷贝，释放两次会出问题
    9. 	yufc::vector<int>::iterator it = v.begin();
    10. 	while (it != v.end()) {
    11. 		cout << *it << " ";
    12. 		it++;
    13. 	}
    14. 	cout << endl;
    15. }
    16. void PrintVector(const yufc::vector<int>& v) {
    17. 	yufc::vector<int>::const_iterator it = v.begin();
    18. 	while (it != v.end()) {
    19. 		cout << *it << " ";
    20. 		it++;
    21. 	}
    22. 	cout << endl;
    23. }
    24. void test_vector1() {
    25. 	yufc::vector<int>v;
    26. 	v.push_back(1);
    27. 	v.push_back(2);
    28. 	v.push_back(3);
    29. 	v.push_back(4);
    30. 	v.push_back(5);
    31. 	v.push_back(6);
    32. 	for (int i = 0; i < v.size(); i++) {
    33. 		++v[i];
    34. 		cout << v[i] << " ";
    35. 	}
    36. 	cout << endl;
    37. }
    38. void test_vector2() {
    39. 	yufc::vector<int>v;
    40. 	v.push_back(1);
    41. 	v.push_back(2);
    42. 	v.push_back(3);
    43. 	v.push_back(4);
    44. 	v.push_back(5);
    45. 	v.push_back(6);
    46. 	yufc::vector<int>::iterator it = v.begin();
    47. 	while (it != v.end()) {
    48. 		(*it)--;
    49. 		cout << *it << " ";
    50. 		it++;
    51. 	}
    52. 	cout << endl;
    53.  
    54. 	for (auto& e : v) {
    55. 		e++;
    56. 		cout << e << " ";
    57. 	}
    58. 	cout << endl;
    59.  
    60. 	it = v.begin();
    61. 	while (it != v.end()) {
    62. 		cout << *it << " ";
    63. 		it++;
    64. 	}
    65. 	cout << endl;
    66.  
    67. 	PrintVector(v);
    68. }
    69. void test_vector3() {
    70. 	const yufc::vector<int>v;
    71. #if 0 //改不了的
    72. 	v.push_back(1);
    73. 	v.push_back(2);
    74. 	v.push_back(3);
    75. 	v.push_back(4);
    76. 	v.push_back(5);
    77. 	v.push_back(6);
    78. #endif
    79. 	PrintVector(v);
    80. 	//范围for虽然是傻瓜式的替换 -- 但是它也是会调用const迭代器的
    81. }
    82. //迭代器失效问题
    83. void test_vector4() {
    84. 	yufc::vector<int>v;
    85. 	v.push_back(1);
    86. 	v.push_back(2);
    87. 	v.push_back(3);
    88. 	v.push_back(4);
    89. 	//v.push_back(5); // 我们发现  -- 原来4个数据，insert之后要扩容的时候，就出现问题了！
    90. 	//v.push_back(6);
    91. 	yufc::vector<int>::iterator it = v.begin();
    92. 	while (it != v.end()) {
    93. 		cout << *it << " ";
    94. 		it++;
    95. 	}
    96. 	cout << endl;
    97. 	//
    98. 	auto p = find(v.begin(), v.end(), 3);
    99. 	if (p != v.end()) {
    100. 		v.insert(p, 30);
    101.  
    102. 		//在内部初步解决迭代器失效之后，其实问题还是没有根本解决！
    103. 		//因为内部的pos更新不会影响p
    104. 		//所以我们在使用的时候
    105. 		//在p位置插入数据以后，不要访问p，因为p可能失效了
    106. 		//因为我们使用STL的时候，不了解底层的扩容机制，所以以后我们insert之后，不要去访问p位置！ -- 可能会有问题
    107.  
    108. 		//那能否把insert第一个参数改成&行吗？ -- 尽量不要这样做 -- 和库保持一致好
    109. 		//虽然我们看似解决了问题 -- 但是改了可能会引出其它问题 -- 比如，头插，我们想传v.begin();v.insert(v.begin(), 0);
    110. 		//编不过，因为类型不匹配
    111. #if 0
    112. 		cout << *p << endl;
    113. 		v.insert(p, 40);
    114. #endif
    115. 	}
    116. 	PrintVector(v);
    117. }
    118. //erase迭代器会失效吗？
    119. //库里面的erase会失效吗？ -- 不知道
    120. //STL并没有规定什么机制
    121. //有没有一种可能，当size()
    122. //反正用完那个别访问，别动那个p就行了！
    123. void test_vector5() {
    124. 	yufc::vector<int>v;
    125. 	v.push_back(1);
    126. 	v.push_back(2);
    127. 	v.push_back(3);
    128. 	v.push_back(4);
    129. 	auto p = find(v.begin(), v.end(), 3);
    130. 	if (p != v.end()) {
    131. 		v.erase(p);
    132. 	}
    133. 	PrintVector(v);
    134. }
    135. void test_vector6() {
    136. 	yufc::vector<int>v;
    137. #if 0
    138. 	v.push_back(1);
    139. 	v.push_back(2);
    140. 	v.push_back(3);
    141. 	v.push_back(4);
    142. 	v.push_back(5);
    143. #endif
    144. 	//情况1和2
    145. 	//我们发现此时有这个5 -- 程序正常，没有 -- 崩溃
    146. #if 1
    147. 	//情况3
    148. 	v.push_back(1);
    149. 	v.push_back(2);
    150. 	v.push_back(2);
    151. 	v.push_back(3);
    152. 	v.push_back(4);
    153. 	v.push_back(5);
    154. #endif
    155. 	//要求删除所有的偶数
    156. 	auto it = v.begin();
    157. 	//情况3的时候，it会跳过end()，直接继续往后了 -- 崩溃
    158. 	//所以下面这段算法是不正确的！
    159. 	//其实我们看源代码可以发现 -- erase是有返回值的 -- 会更新一下迭代器
    160. 	//STL规定erase返回删除位置下一个位置的迭代器！
    161. 	//vs这个编译器是查的很严格的 -- erase之后不允许去访问！ -- 访问就报错
    162. 	//Linux下就不同
    163. 	while (it != v.end()) {
    164. 		if (*it % 2 == 0) {
    165. 			it = v.erase(it);//我们要返回一个it才行
    166. 		}
    167. 		else {
    168. 			++it;
    169. 		}
    170. 	}
    171. 	PrintVector(v);
    172. }
    173. //总结
    174. //其实迭代器失效，我们在自己做OJ的时候也能体会的，插入或者删除之后，迭代器指向了它不该指向的地方
    175. //在使用vector的迭代器的时候，要多调试！
    176.  
    177. void test_vector7() {
    178. 	//系统默认的拷贝
    179. 	//1.自定义类型 -- 调拷贝构造 -- 默认生成的 -- 浅拷贝
    180. 	//2.内置类型 -- 值拷贝 -- 浅拷贝
    181. 	yufc::vector<int>arr;
    182. 	arr.push_back(1);
    183. 	arr.push_back(2);
    184. 	arr.push_back(3);
    185. 	for (auto i : arr) {
    186. 		cout << i << " ";
    187. 	}
    188. 	cout << endl;
    189. 	yufc::vector<int>arr2 = arr;
    190. 	//调用系统默认的话就是浅拷贝，这样程序肯定会崩溃的 -- 析构了两次
    191. 	//而且如果是浅拷贝，改一边的值另一边也会被改变
    192. 	arr2[0] = 100; //两边都会被改变的 -- 所以我们需要深拷贝！
    193. 	for (auto i : arr) {
    194. 		cout << i << " ";
    195. 	}
    196. 	cout << endl;
    197. 	for (auto i : arr2) {
    198. 		cout << i << " ";
    199. 	}
    200. }
    201. void test_vector8() {
    202. 	string s("hell");
    203. 	yufc::vector<int>vs(s.begin(), s.end());
    204. 	for (auto i : vs) {
    205. 		cout << i << " ";
    206. 	}
    207. 	cout << endl;
    208. 	//赋值
    209. 	yufc::vector<int>v;
    210. 	v.push_back(1);
    211. 	v.push_back(2);
    212. 	v.push_back(3);
    213. 	v.push_back(4);
    214. 	v.push_back(5);
    215. 	v.push_back(1);
    216. 	v.push_back(2);
    217. 	v.push_back(3);
    218. 	v.push_back(4);
    219. 	vs = v;//要实现一个深拷贝
    220. 	//当然，如果f11 -- 这里是先进去拷贝的，因为传参要拷贝
    221. 	//走完拷贝就进去赋值了
    222. 	for (auto i : vs) {
    223. 		cout << i << " ";
    224. 	}
    225. }
    226. //其实内置类型也有构造
    227. void test_type() {
    228. 	int i = 0;
    229. 	int j = int();
    230. 	int k = int(10);
    231. }
    232. void test_vector9() {
    233. 	//vectorv = { 1,2,3,4,5 };
    234. 	vector<int>v(10);
    235. 	yufc::vector<int>v(10, 1);//这样就报错了,如果传了两个参数都是int
    236. 	//这里出问题就是匹配问题，它匹配到不该去的地方去了
    237. 	//为什么 -- 因为迭代器区间构造那个函数，更适合这样传参 -- 所以进到那里去了
    238. 	//解决：
    239. 	//1.传参的时候写(10u,1)表示这个是个usigned int类型
    240. 	//2.把vector(size_t n,const T&val=T())里面的size_t改成int，也可以解决 -- 但是stl官方给的是size_t
    241. 	//3.复制一份，改成int，弄个重载就行 -- stl_3.0是这样解决的
    242. 	for (auto i : v) {
    243. 		cout << i << " ";
    244. 	}
    245. 	cout << endl;
    246. }
    247. void test_vector10() {
    248. 	yufc::vector<int>v;
    249. 	v.resize(10, 1);
    250. 	for (auto e : v) {
    251. 		cout << e << " ";
    252. 	}
    253. 	cout << endl;
    254.  
    255. 	yufc::vector<int>v1;
    256. 	v1.reserve(10);
    257. 	v1.push_back(1);
    258. 	v1.push_back(2);
    259. 	v1.push_back(3);
    260. 	v1.push_back(4);
    261. 	v1.resize(8, 8);
    262. 	for (auto e : v1) {
    263. 		cout << e << " ";
    264. 	}
    265. 	cout << endl;
    266.  
    267. 	v1.resize(20, 20);
    268. 	for (auto e : v1) {
    269. 		cout << e << " ";
    270. 	}
    271. 	cout << endl;
    272.  
    273. 	v1.resize(3);
    274. 	for (auto e : v1) {
    275. 		cout << e << " ";
    276. 	}
    277. 	cout << endl;
    278. }
    279.  
    280.  
    281. //vector到目前为止还有最后一个坑还没有解决
    282. //我们用自己的vector测试一下杨辉三角
    283. class Solution {
    284. public:
    285. 	yufc::vectorint>> generate(int numRows) {
    286. 		yufc::vectorint>> ret(numRows);
    287. 		for (int i = 0; i < numRows; ++i) {
    288. 			ret[i].resize(i + 1);
    289. 			ret[i][0] = ret[i][i] = 1;
    290. 			for (int j = 1; j < i; ++j) {
    291. 				ret[i][j] = ret[i - 1][j] + ret[i - 1][j - 1];
    292. 			}
    293. 		}
    294. 		return ret;
    295. 	}
    296. };
    297. void test_vector11() {
    298. 	Solution().generate(10);
    299. 	//报错 -- 在函数结束的时候崩溃了
    300. 	//修改一下 -- 把函数改成void类型，不return -- 没事了
    301. 	//为什么？
    302. 	//拷贝有问题了 -- 普通的vector深拷贝没问题 -- 这里的深拷贝有问题
    303. 	//里面是浅拷贝，外面是深拷贝
    304. 	// //            //即：我们的vector是深拷贝了 -- 但是里面的自定义类型没有深拷贝！！！！！！！！！！
    305. 	//我们拷贝的时候，外面的空间是深拷贝，但是里面的东西，还是指向以前的地方
    306. 	//传统写法是因为memcpy导致的 -- 我们将memcpy改成一个一个赋值就行了（这样的话自定义类型也可以完成深拷贝（调用自己的deepcopy））
    307. 	//现代写法是因为因为要调用push_back()，而push_back()里面调用reserve(),是reserve()里面的memcpy出问题
    308. }
    309. int main() {
    310. 	//test_vector1();
    311. 	//test_vector2();
    312. 	//test_vector3();
    313. 	//test_vector4();
    314. 	//test_vector5();
    315. 	//test_vector6();
    316. 	//test_vector7();
    317. 	//test_vector8();
    318. 	//test_type();
    319. 	//test_vector9();
    320. 	//test_vector10();
    321. 	test_vector11();
    322. 	return 0;
    323. }
    324.  
    325.  
    326. //我们一定要清晰一个点：
    327. //STL只是一个规范
    328. //这个规范怎么去实现，是没有规定的！
    329. //VS-PJ版   g++ SGI版

    尾声

    看到这里，相信大家对vector类的模拟实现已经有一定的了解了！vector的模拟实现，是我们掌握STL的开始，后面，博主将会给大家带来list,stack等等STL容器的模拟实现，持续关注，订阅专栏，点赞收藏都是我创作的最大动力。

    转载时请注明作者和出处。未经许可，请勿用于商业用途 )
    更多文章请访问我的主页

    @背包https://blog.csdn.net/Yu_Cblog?spm=1000.2115.3001.5343

  • 相关阅读:
    【Flutter 面试题】什么是异步编程 Flutter中如何处理异步操作？
    Leetcode算法入门与数组丨2. LeetCode入门
    中国地表水体、大坝、水库和湖泊数据集
    Java开发快递物流项目
    基于复合优化加速算法研究实际问题
    全国机动车达4.3亿辆 驾驶人达5.2亿人 新能源汽车保有量达1821万辆
    Excel函数2
    什么专业最适合学网络安全？一篇文章告诉你
    商城积分系统的设计方案（上）-- 需求分析
    Redis的常用命令&集群节点管理
  • 原文地址：https://blog.csdn.net/Yu_Cblog/article/details/126930337