• 【C++】vector的模拟实现【完整版】

    目录

    一、vector的默认成员函数 

    1、vector类的大体结构 

      2、无参构造函数

     3、拷贝构造函数

      4、Swap(operator=需要用)

     5、赋值重载operator=

     6、析构函数 

    二、vector的三种遍历方式

     1、size和capacity(大小和容量)

    2、 operator[]遍历 

     3、迭代器iterator遍历和范围for

    三、vector相关的增容和删除

     1、reserve (指定容量)

    2、resize（指定大小） 

     3、push_back(尾插)

     4、pop_back(尾删)

    5、insert 

    6、erase 

    四、完整代码 

    vector.h: 

    test.cpp:

    一、vector的默认成员函数 

    1、vector类的大体结构 

    vector的成员变量本质是由三个T类型（模板）的指针变量组成的，T是因为用了模板，因为vector具体存储什么类型的需要指定

    1. namespace mz
    2. {
    3. using std::cout;
    4. using std::endl;
    5. using std::string;
    6.  
    7. 	template<class T>
    8. 	class vector
    9. 	{
    10. 	public:
    11. 		typedef T* iterator;
    12. 		typedef const T* const_iterator;
    13.     private:
    14. 	    iterator _start;
    15. 	    iterator _finish;
    16. 	    iterator _endofstorage;
    17.     }
    18. }

     ①、为什么要在新的命名空间中模拟实现vector？

    防止与库里面的vector冲突，因为我们要自己模拟实现一个

    ②、iterator为什么要用两个版本（const和非const）？

    因为迭代器遍历时我们要有只读和又能读又能写的状态，所以要有个const版本的

      2、无参构造函数

    1. vector()
    2. 	:_start(nullptr)
    3. 	,_finish(nullptr)
    4. 	,_endofstorage(nullptr)
    5. {}

     3、拷贝构造函数

    注：此函数最好放最后面看，因为其内部调用了下文才讲的成员函数

    ①、正常版本

    首先我们不自己实现，就是浅拷贝，会出现问题，故需我们自己实现深拷贝，v2(v1),即只要让v2拷贝一份新的数据即可（使v2和v1不是指向同一份数据）

    ②、现代版本

    v2(v1)，先让v2 reserve和v1一样的容量大小，防止频繁增容降低效率，再把v1中的每个数据尾插到v2中即可

    问题：为什么要const auto&e？

    其是一种用于迭代容器元素的引用方式。它表示在循环过程中，我们用一个常量引用来访问容器中的元素。好处是不会对容器进行修改，并不会产生拷贝操作，可提高代码的效率。

    在用范围for循环时，如果我们只是想读取容器中的元素而不对其进行修改，可以使用const auto&来声明循环变量。例如，当我们遍历一个vector或者数组时，可以使用const auto&来避免对容器进行修改操作。

    例如，当我们遍历一个数组时，如果使用const auto&来声明循环变量，则不能修改数组中的元素。例如，对于以下代码：

    int arr = {0, 1, 2, 3, 4};
    for (const auto& a : arr) {
    a = 1; // 错误，不能修改
    cout << a << “\t”;
    }

    由于使用了const auto&声明循环变量a，所以对a进行修改会导致编译错误。

    1. //v2(v1) 正常版本的实现
    2. /*vector(const vector& v)
    3. {
    4. 	_start = new T[v.capacity()];
    5. 	_finish = _start;
    6. 	_endofstorage = _start + v.capacity();
    8. 	for (size_t i = 0; i < v.size(); ++i)
    9. 	{
    10. 		*_finish = v[i];
    11. 		++_finish;
    12. 	}
    13. }*/
    14.  
    15. //v2(v1) 现代版本的实现(更推荐)
    16. vector(const vector& v)
    17. 	:_start(nullptr)
    18. 	, _finish(nullptr)
    19. 	, _endofstorage(nullptr)
    20. {
    21. 	reserve(v.capacity());
    22.  
    23. 	for (const auto& e : v)
    24. 		push_back(e);
    25. }

      4、Swap(operator=需要用)

    为什么需要自己提供swap，而不调用库里提供的？

    因为库里面提供的对于自定义类型代价极大，因为需要深拷贝，但对于内置类型用库函数里面的还好，所以应该自己写一个成员函数swap

    1. void swap(vector& v)
    2. {
    3. 	//调用全局的swap，交换指针,其为内置类型，无需深拷贝
    4. 	//代价相比于直接调用库里面函数交换比较小
    5. 	std::swap(_start, v._start);
    6. 	std::swap(_finish, v._finish);
    7. 	std::swap(_endofstorage, v._endofstorage);
    8. }

     5、赋值重载operator=

    ①、正常版本

    先要避免自己给自己赋值，先要用tmp拷贝空间，再释放旧空间，再使_start指向一份自己新开辟的新空间，再把需要赋值的数据拷过去即可（为什么要用tmp？因为new动态开辟可能会出错，若先释放旧空间，再直接用_start开辟空间且开辟失败，_str也被销毁了，赔礼夫人又折兵）

    ②、现代版本（更推荐）

    v是v3的临时拷贝，然后v会与v1交换，出了函数v就被销毁了，不用我们自己再销毁了，省力

    1. //v1 = v3 正常版本的实现
    2. /*vector& operator=(const vector& v)
    3. {
    4. 	if (this != &v)
    5. 	{
    6. 		delete[] _start;
    7. 		_start = new T[v.capacity()];
    9. 		memcpy(_start, v._start, sizeof(T) * v.size());
    10. 	}
    12. 	return *this;
    13. }*/
    14.  
    15. //v1 = v3 现代版本
    16. vector& operator=(vector v)
    17. {
    18. 	swap(v);//this->swap(v);
    19.  
    20. 	return *this;
    21. }

     6、析构函数 

    1.     ~vector()
    2. {
    3. 	if (_start)
    4. 	{
    5. 		delete[]_start;
    6. 		_start = _finish = _endofstorage = nullptr;
    7.     }
    8. }

    二、vector的三种遍历方式

     1、size和capacity(大小和容量)

    原理：指针相减就是指针间的元素个数

    1. 	size_t size()const
    2. 	{
    3. 		return _finish - _start;
    4. 	}
    5. 	size_t capacity()const
    6. 	{
    7. 		return _endofstorage - _start;
    8. 	}

    ①、为什么要加const？

    成员函数只要不改变成员变量的，最好都要加上const  

    2、 operator[]遍历 

    1. T& operator[](size_t i)
    2. {
    3. 	//确保范围的合法性
    4. 	assert(i < size());//记得引头文件assert.h
    5.  
    6. 	return _start[i];
    7. }
    8.  
    9. const T& operator[](size_t i)const
    10. {
    11. 	assert(i < size());
    12.  
    13. 	return _start[i];
    14. }

    ①、为什么要实现两个版本的operator[]？

    直接把非const的operator[]加上const不行吗？不可以，因为operator[]访问完后，有两种状态：1、只读 2、可读可写  你直接加上const就只读了，万一我想改数据又不行了，故写两个版本的（const和非const版本） 

     3、迭代器iterator遍历和范围for

    迭代器有只读的和可读可写的，故也要写两个版本，且一个容器只要支持迭代器，就可以用范围for操作，因为范围for本质也是迭代器

    1. iterator begin()
    2. {
    3. 	return _start;
    4. }
    5.  
    6. iterator end()
    7. {
    8. 	return _finish;
    9. }
    10.  
    11. const_iterator begin()const
    12. {
    13. 	return _start;
    14. }
    15.  
    16. const_iterator end()const
    17. {
    18. 	return _finish;
    19. }

    只要把迭代器写出来了，迭代器遍历和范围for遍历就都可以用了

    测试operator[]和迭代器和范围for三种遍历

    1. void test1()
    2. {
    3. 	vector<int>v;
    4. 	v.push_back(1);
    5. 	v.push_back(2);
    6. 	v.push_back(3);
    7. 	v.push_back(4);
    8.  
    9. 	cout << v.size() << endl;
    10. 	cout << v.capacity() << endl;
    11. 	
    12. 	vector<int>::iterator it = v.begin();
    13. 	while (it != v.end())
    14. 	{
    15. 		*it += 1;
    16. 		cout << *it << " ";
    17. 		++it;
    18. 	}
    19. 	cout << endl; 
    20.  
    21. 	for (auto& e : v)
    22. 	{
    23. 		e -= 1;
    24. 		cout << e << " ";
    25. 	}
    26. 	cout << endl;
    27.  
    28. 	for (size_t i = 0; i < v.size(); ++i)
    29. 	{
    30. 		cout << v[i] << " ";
    31. 	}
    32. 	cout << endl;

    运行结果：

    三、vector相关的增容和删除

     1、reserve (指定容量)

    1. void reserve(size_t n)
    2. {
    3. 	if (n > capacity())
    4. 	{
    5. 		size_t sz = size();//大小要在增容前就算好
    6. 		T* tmp = new T[n];
    7. 		if (_start)
    8. 		{
    9. 			//memcpy(tmp, _start, sizeof(T) * sz);//按字节拷贝，浅拷贝
    10. 			//作深拷贝，使新旧空间指向自己对应的数据
    11. 			for (size_t i = 0; i < sz; ++i)
    12. 			{
    13. 				tmp[i] = _start[i];//调用的是T的operator=，深拷贝
    14. 			}
    15. 			delete[]_start;
    16. 		}
    17. 		_start = tmp;
    18. 		_finish = tmp + sz;//不能写为=tmp + size()
    19. 		_endofstorage = tmp + n;
    20. 	}
    21. }

    ①、为什么要在增容前就算出大小？

    因为增容涉及新和旧空间的问题，比如_finish = tmp + size()，而size的求法是用_finish - _start，但_start已指向新空间，可_finish还是指向旧空间，两块不连续的空间相减就是随机值了，故要在增容之前就把大小算出来，不然增容之后的大小就是随机值了

    ②、为什么reserve要更新_finish？

    reserve不是只改变容量吗，跟大小有什么关系，因为_finish是指针，如果一个对象它上来就reserve保存一定容量，然后直接扩容，这个操作没问题吧，但是插入数据肯定涉及*_finish操作，若不更新_finish，_finish初始为nullptr就非法访问内存了，故reserve中也要更改_finish

    ③、为什么不能用memcpy拷贝数据？

    测试时，当用string作为vector存储的类型时，程序崩溃了，为什么？

    本质原因是因为增容中用了memcpy，memcpy导致了问题的出现，因为memcpy是按字节拷贝的，它本质上造成了浅拷贝问题， memcpy使新旧空间都指向了一份数据，旧空间释放后，它指向的对应数据也被释放，而新空间指针还是指向这份旧空间，这就造成非法访问，所以新空间与旧空间不应指向同一份数据，应该不用memcpy，写成深拷贝

    解决（reserve的实现不用memcpy）： 

    把旧空间的每个值赋值给新空间对应的每个值就好了，就能实现深拷贝了，指向不同的数据

    2、resize（指定大小） 

    1. void resize(size_t n, const T& val = T())//因为不知道T的类型，故给T类型的缺省值
    2. {
    3. 	if (n < size())
    4. 	{
    5. 		_finish = _start + n;
    6. 	}
    7. 	else
    8. 	{
    9. 		if (n > capacity())
    10. 		{
    11. 			reserve(n);
    12. 		}
    13. 		//填数据不能用memset
    14.  
    15. 		//填数据
    16. 		while (_finish < _start + n)
    17. 		{
    18. 			*_finish = val;
    19. 			++_finish;
    20. 		}
    21. 	}
    22. }

    ①、填数据为什么不能用memset？

    当对于a数组，设置为0时，没问题，但各设置为1和2时，就出现随机值了 ，因为memset只适合把所有值初始化为0，当初始化为1时，是把每个字节初始化为1 

    即00000001 00000001 00000001 00000001，这就不是整形的1了（2也同理，就初始化0可以）！memset连内置类型都处理不好，别说自定义类型了，问题会更大，本质上就是因为memxxx类函数都是按字节处理的，

    即慎用memxxx，因为其按字节进行操作

    ②、const T& val = T()中的T()使什么意思？

    因为不知道T的类型，故用T的缺省值

    C++中内置类型也可以像自定义类型那样调用构造函数，严格来说，内置类型是没有构造函数的，但C++强行赋予了这个构造函数概念，是为了更好地支持模板

    1.  
    2.     int i = int();//0
    3.     int j = int(1);//1
    4.     double d = double();//0.0000000000
    5.     double e = double(1.1);//1.100000000

     3、push_back(尾插)

    1. void push_back(const T& x) 
    2. {
    3. 	//方法一
    4. 	if (_finish == _endofstorage)
    5. 	{
    6. 		size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
    7. 		reserve(newcapacity);
    8. 	}
    9. 	*_finish = x;
    10. 	++_finish;
    11.  
    12. 	//方法二、调用insert
    13. 	//insert(_finish, x);
    14. }

     4、pop_back(尾删)

    1. void pop_back()
    2. {
    3. 	//方法一
    4. 	assert(_start < _finish);
    5. 	--_finish;
    6. 	//方法二、复用erase
    7. 	//erase(_finish - 1);
    8. }

    5、insert 

    1. void insert(iterator pos, const T& x)
    2. {
    3. 	assert(pos <= _finish);//pos == _finish时，相当于尾插
    4.  
    5. 	//满了需要扩容
    6. 	if (_finish == _endofstorage)
    7. 	{
    8. 		size_t n = pos - _start;//算出原pos距离
    9. 		size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
    10. 		reserve(newcapacity);
    11. 		//增完容后要更新pos的位置，因为增容后原来的pos就失效了
    12. 		pos = _start + n;//新的_start + n
    13. 	}
    14. 	//插入之前需要往后挪动1个数据
    15. 	iterator end = _finish;
    16. 	while (end > pos)
    17. 	{
    18. 		*end = *(end - 1);
    19. 		--end;
    20. 	}
    21. 	//插入数据
    22. 	*pos = x;
    23. 	++_finish;
    24. }

    为什么需要提前算出n？

    有迭代器失效的问题，因为pos是迭代器类型，扩容前指向旧空间的某一位置，而reserve调用后会扩容，而我们是扩容完才插入数据的，此时pos无效，因为旧空间已经释放了，它这个迭代器还指向那里就失效了，故我们要更新pos位置，使它指向新空间，所以要先算n，即原pos的位置

    6、erase 

    1. iterator erase(iterator pos)
    2. {
    3. 	assert(pos < _finish);
    4.  
    5. 	iterator it = pos + 1;
    6. 	while (it < _finish)
    7. 	{
    8. 		*(it - 1) = *it;
    9. 		++it;
    10. 	}
    11. 	--_finish;
    12.  
    13. 	return pos;//返回被删除数据的下一位置，那就还是原位置，因为那个数据被删除了
    14. }

     注意：erase是返回被删除数据的下一位置，当要被删除的数据被删除了，erase原地不动的话，就已自动指向了下一位置，因为那个数据被删除了

    最后一个问题

    如果T是字符串的话代码逻辑会不会忘掉'\0'？

    不会，vector末尾没有'\0'，string才有，这也是他们的差别

    四、完整代码 

    总共分为两个文件：vector.h和test.cpp

    vector.h: 

    1. #pragma once
    2. #include
    3. #include
    4.  
    5. namespace mz
    6. {
    7. using std::cout;
    8. using std::endl;
    9. using std::string;
    10.  
    11. 	template<class T>
    12. 	class vector
    13. 	{
    14. 	public:
    15. 		typedef T* iterator;
    16. 		typedef const T* const_iterator;
    17.  
    18. 		vector()
    19. 			:_start(nullptr)
    20. 			,_finish(nullptr)
    21. 			,_endofstorage(nullptr)
    22. 		{}
    23.  
    24. 		//v2(v1) 正常版本的实现
    25. 		/*vector(const vector& v)
    26. 		{
    27. 			_start = new T[v.capacity()];
    28. 			_finish = _start;
    29. 			_endofstorage = _start + v.capacity();
    31. 			for (size_t i = 0; i < v.size(); ++i)
    32. 			{
    33. 				*_finish = v[i];
    34. 				++_finish;
    35. 			}
    36. 		}*/
    37.  
    38. 		//v2(v1) 现代版本的实现(更推荐)
    39. 		vector(const vector& v)
    40. 			:_start(nullptr)
    41. 			, _finish(nullptr)
    42. 			, _endofstorage(nullptr)
    43. 		{
    44. 			reserve(v.capacity());
    45.  
    46. 			for (const auto& e : v)
    47. 				push_back(e);
    48. 		}
    49.  
    50. 		//v1 = v3 正常版本的实现
    51. 		/*vector& operator=(const vector& v)
    52. 		{
    53. 			if (this != &v)
    54. 			{
    55. 				delete[] _start;
    56. 				_start = new T[v.capacity()];
    58. 				memcpy(_start, v._start, sizeof(T) * v.size());
    59. 			}
    61. 			return *this;
    62. 		}*/
    63.  
    64. 		//v1 = v3 现代版本
    65. 		vector& operator=(vector v)
    66. 		{
    67. 			swap(v);//this->swap(v);
    68.  
    69. 			return *this;
    70. 		}
    71.  
    72. 		void swap(vector& v)
    73. 		{
    74. 			//调用全局的swap，交换指针,其为内置类型，无需深拷贝
    75. 			//代价相比于直接调用库里面函数交换比较小
    76. 			std::swap(_start, v._start);
    77. 			std::swap(_finish, v._finish);
    78. 			std::swap(_endofstorage, v._endofstorage);
    79. 		}
    80. 		
    81.  
    82. 		iterator begin()
    83. 		{
    84. 			return _start;
    85. 		}
    86.  
    87. 		iterator end()
    88. 		{
    89. 			return _finish;
    90. 		}
    91.  
    92. 		const_iterator begin()const
    93. 		{
    94. 			return _start;
    95. 		}
    96.  
    97. 		const_iterator end()const
    98. 		{
    99. 			return _finish;
    100. 		}
    101.  
    102. 		void reserve(size_t n)
    103. 		{
    104. 			if (n > capacity())
    105. 			{
    106. 				size_t sz = size();//大小要在增容前就算好
    107. 				T* tmp = new T[n];
    108. 				if (_start)
    109. 				{
    110. 					//memcpy(tmp, _start, sizeof(T) * sz);//按字节拷贝，浅拷贝
    111. 					//作深拷贝，使新旧空间指向自己对应的数据
    112. 					for (size_t i = 0; i < sz; ++i)
    113. 					{
    114. 						tmp[i] = _start[i];//调用的是T的operator=，深拷贝
    115. 					}
    116. 					delete[]_start;
    117. 				}
    118. 				_start = tmp;
    119. 				_finish = tmp + sz;//不能写为=tmp + size()
    120. 				_endofstorage = tmp + n;
    121. 			}
    122. 		}
    123.  
    124. 		void resize(size_t n, const T& val = T())//因为不知道T的类型，故给T类型的缺省值
    125. 		{
    126. 			if (n < size())
    127. 			{
    128. 				_finish = _start + n;
    129. 			}
    130. 			else
    131. 			{
    132. 				if (n > capacity())
    133. 				{
    134. 					reserve(n);
    135. 				}
    136. 				//填数据不能用memset
    137.  
    138. 				//填数据
    139. 				while (_finish < _start + n)
    140. 				{
    141. 					*_finish = val;
    142. 					++_finish;
    143. 				}
    144. 			}
    145. 		}
    146.  
    147. 		void push_back(const T& x)
    148. 		{
    149. 			//方法一
    150. 			if (_finish == _endofstorage)
    151. 			{
    152. 				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
    153. 				reserve(newcapacity);
    154. 			}
    155. 			*_finish = x;
    156. 			++_finish;
    157.  
    158. 			//方法二、调用insert
    159. 			//insert(_finish, x);
    160. 		}
    161.  
    162. 		void pop_back()
    163. 		{
    164. 			//方法一
    165. 			assert(_start < _finish);
    166. 			--_finish;
    167. 			//方法二、复用erase
    168. 			//erase(_finish - 1);
    169. 		}
    170.  
    171. 		void insert(iterator pos, const T& x)
    172. 		{
    173. 			assert(pos <= _finish);//pos == _finish时，相当于尾插
    174.  
    175. 			//满了需要扩容
    176. 			if (_finish == _endofstorage)
    177. 			{
    178. 				size_t n = pos - _start;//算出原pos距离
    179. 				size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;
    180. 				reserve(newcapacity);
    181. 				//增完容后要更新pos的位置，因为增容后原来的pos就失效了
    182. 				pos = _start + n;//新的_start + n
    183. 			}
    184. 			//插入之前需要往后挪动1个数据
    185. 			iterator end = _finish;
    186. 			while (end > pos)
    187. 			{
    188. 				*end = *(end - 1);
    189. 				--end;
    190. 			}
    191. 			//插入数据
    192. 			*pos = x;
    193. 			++_finish;
    194. 		}
    195.  
    196. 		iterator erase(iterator pos)
    197. 		{
    198. 			assert(pos < _finish);
    199.  
    200. 			iterator it = pos + 1;
    201. 			while (it < _finish)
    202. 			{
    203. 				*(it - 1) = *it;
    204. 				++it;
    205. 			}
    206. 			--_finish;
    207.  
    208. 			return pos;//返回被删除数据的下一位置，那就还是原位置，因为那个数据被删除了
    209. 		}
    210.  
    211. 		T& operator[](size_t i)
    212. 		{
    213. 			//确保范围的合法性
    214. 			assert(i < size());//记得引头文件assert.h
    215.  
    216. 			return _start[i];
    217. 		}
    218.  
    219. 		const T& operator[](size_t i)const
    220. 		{
    221. 			assert(i < size());
    222.  
    223. 			return _start[i];
    224. 		}
    225.  
    226. 		size_t size()const
    227. 		{
    228. 			return _finish - _start;
    229. 		}
    230.  
    231. 		size_t capacity()const
    232. 		{
    233. 			return _endofstorage - _start;
    234. 		}
    235. 		
    236. 		~vector()
    237. 		{
    238. 			if (_start)
    239. 			{
    240. 				delete[]_start;
    241. 				_start = _finish = _endofstorage = nullptr;
    242. 			}
    243. 		}
    244.  
    245. 	private:
    246. 		iterator _start;
    247. 		iterator _finish;
    248. 		iterator _endofstorage;
    249. 	};
    250.  
    251.  
    252. 	void print_vector(const vector<int>& v)
    253. 	{
    254. 		vector<int>::const_iterator it = v.begin();
    255. 		while (it != v.end())
    256. 		{
    257. 			cout << *it << " ";
    258. 			++it;
    259. 		}
    260. 		cout << endl;
    261. 	}
    262.  
    263. 	void test1()
    264. 	{
    265. 		vector<int>v;
    266. 		v.push_back(1);
    267. 		v.push_back(2);
    268. 		v.push_back(3);
    269. 		v.push_back(4);
    270.  
    271. 		cout << v.size() << endl;
    272. 		cout << v.capacity() << endl;
    273. 		
    274. 		vector<int>::iterator it = v.begin();
    275. 		while (it != v.end())
    276. 		{
    277. 			*it += 1;
    278. 			cout << *it << " ";
    279. 			++it;
    280. 		}
    281. 		cout << endl; 
    282.  
    283. 		for (auto& e : v)
    284. 		{
    285. 			e -= 1;
    286. 			cout << e << " ";
    287. 		}
    288. 		cout << endl;
    289.  
    290. 		for (size_t i = 0; i < v.size(); ++i)
    291. 		{
    292. 			cout << v[i] << " ";
    293. 		}
    294. 		cout << endl;
    295. 	}
    296.  
    297. 	void test2()
    298. 	{
    299. 		vector<int>v;
    300. 		v.push_back(1);
    301. 		v.push_back(2);
    302. 		v.push_back(3);
    303. 		v.push_back(4);
    304. 		v.push_back(5);
    305. 		v.push_back(6);
    306.  
    307. 		v.insert(v.begin(), 0);//头插0
    308. 		print_vector(v);
    309.  
    310. 		//删除偶数
    311. 		vector<int>::iterator it = v.begin();
    312. 		while (it != v.end())
    313. 		{
    314. 			if (*it % 2 == 0)
    315. 			{
    316. 				it = v.erase(it);
    317. 			}
    318. 			else
    319. 			{
    320. 				++it;
    321. 			}
    322. 		}
    323. 		print_vector(v);
    324. 	}
    325.  
    326. 	void test3()
    327. 	{
    328. 		vector<int>v;
    329. 		v.reserve(10);
    330. 		v.push_back(1);
    331. 		v.push_back(2);
    332. 		v.push_back(3);
    333. 		v.push_back(4);
    334. 		v.push_back(5);
    335. 		v.push_back(6);
    336.  
    337. 		v.resize(4);
    338. 		print_vector(v);
    339. 		cout << v.size() << endl;
    340. 		cout << v.capacity() << endl;
    341.  
    342. 		v.resize(8);
    343. 		print_vector(v);
    344. 		cout << v.size() << endl;
    345. 		cout << v.capacity() << endl;
    346.  
    347. 		v.resize(12,int());
    348. 		print_vector(v);
    349. 		cout << v.size() << endl;
    350. 		cout << v.capacity() << endl;
    351.  
    352. 		int i = int();//0
    353. 		int j = int(1);//1
    354. 		double d = double();//0.0000000000
    355. 		double e = double(1.1);//1.100000000
    356. 	}
    357.  
    358. 	void test4()
    359. 	{
    360. 		vector<int>v1;
    361. 		v1.push_back(1);
    362. 		v1.push_back(2);
    363. 		v1.push_back(3);
    364. 		v1.push_back(4);
    365.  
    366. 		vector<int>v2(v1);
    367.  
    368. 		for (size_t i = 0; i < v1.size(); ++i)
    369. 		{
    370. 			cout << v1[i] << " ";
    371. 		}
    372. 		cout << endl;
    373.  
    374. 		for (size_t i = 0; i < v2.size(); ++i)
    375. 		{
    376. 			cout << v2[i] << " ";
    377. 		}
    378. 		cout << endl;
    379. 	
    380. 		vector<int>v3;
    381. 		v3.push_back(10);
    382. 		v3.push_back(20);
    383. 		v3.push_back(30);
    384. 		v3.push_back(40);
    385.  
    386. 		v1 = v3;
    387. 		for (auto e : v1)
    388. 		{
    389. 			cout << e << " ";
    390. 		}
    391. 		cout << endl;
    392. 	}
    393.  
    394. 	void test5()
    395. 	{
    396. 		vectorv;
    397. 		v.push_back("111111111111111111111");
    398. 		v.push_back("222222222222222222222");
    399. 		v.push_back("333333333333333333333");
    400. 		v.push_back("444444444444444444444");
    401.  
    402. 		
    403. 		for (auto e : v)
    404. 		{
    405. 			cout << e << " ";
    406. 		}
    407. 		cout << endl;
    408. 	}
    409. }

    test.cpp:

    1. #include
    2. #include"vector.h"
    3.  
    4. int main()
    5. {
    6. 	mz::test1();
    7. 	//memxxx 按字节处理
    8. 	/*int a[10];
    9. 	memset(a, 0, sizeof(int) * 10);
    10. 	memset(a, 1, sizeof(int) * 10);
    11. 	memset(a, 2, sizeof(int) * 10);*/
    12.  
    13. 	return 0;
    14. }
  • 相关阅读:
    信创办公–基于WPS的EXCEL最佳实践系列 （数据整理复制粘贴）
    un7.29:Linux——如何在docker中安装tomcat？
    工业镜头的景深、分辨率及如何匹配合适的工业相机-51camera
    React(12)-react的生命周期(important)没写完
    大数据分析实践 | 过滤和抽样
    React Native 之 expo-cli使用 （二十四）
    2023年10月12日
    Oracle数据库的配置文件丢失或损失，重新执行pfile启动
    [golang]在Gin框架中使用JWT鉴权
    真香,Java架构进阶全靠这份阿里大佬整理的笔记，图文并茂
  • 原文地址：https://blog.csdn.net/m0_74044018/article/details/132744051