vector的使用及其模拟实现

转x33g5p2x  于2022-01-11 转载在 其他  
字(12.9k)|赞(0)|评价(0)|浏览(356)

1.vector的概念

  1. vector是表示可变大小数组的序列容器。

2.就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素
进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自

动处理。
3.本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小

为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是
一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大

小。
4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存

储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是
对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。

5.因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增
长。

6.与其它动态序列容器相比（deques, lists and forward_lists），vector在访问元素的时候更加高效，在
末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和

forward_lists统一的迭代器和引用更好。
学习方法：使用STL的三个境界：能用，明理，能扩展 ，那么下面学习vector，我们也是按照这个方法去学

习

2.vector的构造函数

2.1构造函数
1.vector<int>()创建一个空的vector(注意尖括号里面的代表类型只要是合法的类型都可以

  1. vector<int>();

2.定义一个具有十个元素的的向量（可以给初始值如果不给初始值默认给缺省值）

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1(10);
  6. 	vector<int>v2(10, 1);//可以给这十个元素初始值
  7. }

3.用向量v1拷贝给向量v2

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1(10, 1);
  6. 	vector<int>v2(v1);
  7. 	return 0;
  8. }

4.将向量v1中0~3共4个元素拷贝给v2同时也支持数组

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1(10, 1);
  6. 	vector<int>v2(v1.begin(), v1.begin() + 4);
  7. 	
  8. 	return 0;
  9. }

数组也是可以进行上述操作的：

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	int arr[] = { 1,2,3,4,5,5,6,7,8,8 };
  6. 	vector<int>v2(arr,arr+4);
  7. 	
  8. 	return 0;
  9. }

5.匿名构造法 

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1 = { 1,2,3 };
  6. 	vector<int>v2 = vector<int>(1);//匿名对象
  7. 	return 0;
  8. }

 3.vector的常用操作

vector中的基本常用操作包括了插入删除变量等等

3.1插入操作

vector的插入操作有两种一种是在尾部插入一种是在任意位置插入

void push_back(x);

iterator insert(iterator pos,x);

我们先来看第一种在尾部插入：

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1;
  6. 	v1.push_back(10);
  7. 	v1.push_back(11);
  8. 	v1.push_back(12);
  9. 	for (int i = 0; i < v1.size(); i++) {
  10. 		cout << v1[i] << " ";
  11. 	}
  12. 	return 0;
  13. }

运行结果：

2在任意位置之前插入但是值得注意的是这个位置给的是迭代器。 insert有3个版本

我们先来看第一个在当个位置之前插入：

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1;
  6. 	v1.push_back(10);
  7. 	v1.push_back(11);
  8. 	v1.push_back(12);
  9. 	v1.insert(v1.begin() + 1, 14);//在11位置之前插入一个14；
  10. 	for (int i = 0; i < v1.size(); i++) {
  11. 		cout << v1[i] << " ";
  12. 	}
  13. 	return 0;
  14. }

运行结果：

在这里我们只需要会一个就行了

3.2删除操作
删除操作主要有在尾部删除和任意位置删除

我们首先来看尾删

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1;
  6. 	v1.push_back(10);
  7. 	v1.push_back(11);
  8. 	v1.push_back(12);
  9. 	v1.pop_back();//将尾部的12删除
  10. 	for (int i = 0; i < v1.size(); i++) {
  11. 		cout << v1[i] << " ";
  12. 	}
  13. 	return 0;
  14. }

运行结果：

在任意位置删除同样的要给迭代器才可以删除

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1;
  6. 	v1.push_back(10);
  7. 	v1.push_back(11);
  8. 	v1.push_back(12);
  9. 	v1.erase(v1.begin() + 1);//将11这个元素删除
  10. 	for (int i = 0; i < v1.size(); i++) {
  11. 		cout << v1[i] << " ";
  12. 	}
  13. 	return 0;
  14. }

3.3vector中获取元素的方式：

1.operator[]

2.对象.at(下标）；

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1;
  6. 	v1.push_back(10);
  7. 	v1.push_back(11);
  8. 	v1.push_back(12);
  9. 	cout << v1[0] << " " << v1.at(0) << endl;
  10. 	return 0;
  11. }

运行结果：

那[]和at有什么区别吗？区别就是当这个下标不合法时[]会直接断言终止掉程序而at会抛出异常 

初学者在operator[]非常容易错的地方是operator只能获取已经存在的元素 很有肯能就写出来这样的错误代码

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1;
  6. 	cout << v1[1] << endl;//这是错误的应为v1是一个空对象
  7. 	return 0;
  8. }

vector中还支持直接获取头部元素和尾部元素 。

1.对象.front() 

2.对象.back();

对应代码：

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1{ 1,2,3,4 };
  6. 	cout << v1.front() << " " << v1.back() << endl;
  7. 	return 0;
  8. }

3.4vector中的迭代器

vector容器中的迭代器begin ,end,rbegin,rend,cbegin,cend;

注意在vector中begin指向的是第一个元素而end指向的不是最后一个元素而是最后一个元素的下一个位置

而rbegin()和rend（）则与此正好相反rend指向第一个元素的前一个位置而rbegin指向最后一个位置

3.4vector中的遍历方式：

1.和数组一样通过operator[]遍历或者at

2.通过迭代器遍历

3.通过范围for遍历

4.通过算法中的for_each遍历

1.和数组一样遍历：

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1{ 1,2,3,4 };
  6. 	for (int i = 0; i < v1.size(); i++) {
  7. 		cout << v1[i] << " ";
  8. 	 }
  9. 	return 0;
  10. }

2.迭代器方式遍历:

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1{ 1,2,3,4 };
  6. 	auto it = v1.begin();
  7. 	while (it != v1.end()) {
  8. 		cout << *it << " ";
  9. 		it++;
  10. 	}
  11. 	return 0;
  12. }

3.通过范围for遍历

  1. #include<iostream>
  2. #include<vector>
  3. using  namespace std;
  4. int main() {
  5. 	vector<int>v1{ 1,2,3,4 };
  6. 	for (auto x : v1) {
  7. 		cout << x << " ";
  8. 	}
  9. 	return 0;
  10. }

方式四：通过for_each遍历：

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<vector>
  4. using  namespace std;
  5. int main() {
  6. 	vector<int>v1{ 1,2,3,4 };
  7. 	for_each(v1.begin(), v1.end(),[](int val) {cout << val << " "; });//第三个参数可以填仿函数或者lamber表达式
  8. 	return 0;
  9. }

运行结果均为:

注意在范围for中如果要修改vector中的值这样是无法修改的

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<vector>
  4. using  namespace std;
  5. int main() {
  6. 	vector<int>v1{ 1,2,3,4 };
  7. 	for (auto x : v1) {
  8. 		x -= 1;
  9. 	}
  10. 	for (int i = 0; i < v1.size(); i++) {
  11. 		cout << v1[i] << " ";
  12. 	}
  13. 	return 0;
  14. }

运行结果：

这是为什么了呢？这是因为 范围for中只是将v1中的值赋值给x，x的改变不会v1中值，而x是一个局部变量出了作用域就不在了。如果要想改变v1中的值就要使用引用。

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<vector>
  4. using  namespace std;
  5. int main() {
  6. 	vector<int>v1{ 1,2,3,4 };
  7. 	for (auto& x : v1) {
  8. 		x -= 1;
  9. 	}
  10. 	for (int i = 0; i < v1.size(); i++) {
  11. 		cout << v1[i] << " ";
  12. 	}
  13. 	return 0;
  14. }

运行结果：

迭代器失效

向容器中添加或者删除元素的操作可能会使指向容器元素的迭代器失效，失效的迭代器将不指向任何元素。
一般有两种情况无法通过迭代器++操作遍历整个stl容器; 无法通过迭代器存取迭代器所指向的内存。

vector中常见的迭代器失效

1.删除当前的iterator会使后面所有元素的iterator都失效。这是因为顺序容器内存是连续分配（分配一个数组作为内存），删除一个元素导致后面所有的元素会向前移动一个位置。（删除了一个元素，该元素后面的所有元素都要挪位置，所以，it++，已经指向的是未知内存）。 

2.迭代器在内存连续的容器中插入元素迭代器失效这是因为扩容的过程中可能重新开辟了空间不在是原来那一块空间了，内存非连续得容器插入迭代器不失效。

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<vector>
  4. using  namespace std;
  5. int main() {
  6. 	vector<int>v1{ 1,2,3,4 };
  7. 	auto it = v1.begin();
  8. 	while (it!=v1.end()) {
  9. 		if (*it % 2 == 0) {//删除偶数
  10. 			v1.erase(it);
  11. 		}
  12. 		else {
  13. 			it++;
  14. 		}
  15. 	}
  16. 	return 0;
  17. }

比如这个我们想要删除所有偶数的程序初学者可能会认为这是没有问题的但是实际上当删除一个偶数时迭代器已经失效了此时层序会崩溃 

如何解决这个问题呢？我们可以利用erase的返回值返回下一个迭代器给it即可

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<vector>
  4. using  namespace std;
  5. int main() {
  6. 	vector<int>v1{ 1,2,3,4 };
  7. 	auto it = v1.begin();
  8. 	while (it!=v1.end()) {
  9. 		if (*it % 2 == 0) {
  10. 			it=v1.erase(it);
  11. 		}
  12. 		else {
  13. 			it++;
  14. 		}
  15. 	}
  16. 	return 0;
  17. }

vector中还有一些接口：
size

获取数据个数
capacity

获取容量大小
empty

判断是否为空
resize（重点）

改变vector的size
reserve（重点）预留空间

在这里面要注意的是resize是开空间并且初始化而reserve是只开空间

resize的规则：

1.当所给值大于当前的capacity时将capacity扩容到该值，扩容的第二个参数为所给值如果没有给出则默认是T（）即T的缺省值

2.当所给值小于当前size时当size减小到该值即可

reserve的规则：

1.当所给值小于当前capacity则什么都不做

2.当所给值大于当前capacity则扩容到该值即可

 4.vector的模拟实现

一般vector对象中会有三个成员变量_start指向容器中有效位置的头，_finish指向容器中有效位置的尾，_endofstorage指向整个容器的尾

  1. private:
  2. 		iterator _start;//开始
  3. 		iterator _finish;
  4. 		iterator _endofstorage;//空间的末尾

而iterator是typedef出来的

  1. typedef T* iterator;
  2. 		typedef const T* const_iterator;

4.1构造函数

默认的构造函数和半缺省构造函数

  1. vector(int Size=0, const T& val=T())//
  2. 		:_start(nullptr)
  3. 		,_finish(nullptr)
  4. 		,_endofstorage(nullptr)
  5. 		{
  6. 			assert(Size >0);
  7. 			_start = new T[Size];
  8. 			if (_start>=0) {
  9. 				for (int i = 0; i < Size; i++) {//给每一个位置赋值
  10. 					_start[i] = val;
  11. 				}
  12. 				_finish = _start + Size;
  13. 				_endofstorage = _start + Size;
  14. 			}
  16. 		}

4.2拷贝构造函数

拷贝构造函数有现代写法和传统写法

传统写法：

  1. vector(const vector<int>& v)
  2. 		:_start(nullptr)
  3. 		,_finish(nullptr)
  4. 		,_endofstorage(nullptr){
  5.             _start = new T[v.capacity()];//开空间
  6. 			_finish = _start;
  7. 			_endofstorage = _start + v.capacity();
  8. 			for (int i = 0; i < v.size(); i++) {//赋值
  9. 				*_finish = v[i];
  10. 				++_finish;
  11. 			}
  12. }

在这里需要注意的是不要使用memcopy来拷贝数据这是因为memcopy是浅拷贝是按字节拷贝的当vector中的T为string 类型会发生同一块内存析构两次从而使程序崩溃。在这里我们可以通过赋值的方式调用string 中自己的operator=赋值运算符重载 

现代写法：

  1. vector(const vector<int>& v)
  2. 		:_start(nullptr)
  3. 		,_finish(nullptr)
  4. 		,_endofstorage(nullptr)
  5. 		{
  6. 			reserve(v.capacity());//先预留和v一样的空间
  7. 			for (const auto& x : v) {
  8. 				push_back(x);//将v中的数据一个一个尾插过来
  9. 			}
  11. 		}

4.3析构函数

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

4.4赋值运算符重载

同样的赋值运算符重载也有现代写法和传统写法

传统写法：

  1. vector<T>& operator=(const vector<T>&v) {
  2. 			if (this != &v) {
  3. 				delete[]_start;//释放旧空间
  4. 				_start = new T[v.capacity()];
  5. 				for (int i = 0; i < v.size(); i++) {
  6. 					(_start + i) = v[i];//拷数据
  7. 				}
  8. 				_endofstorage = _start + v.capacity();//整个容器的尾
  9. 				_finish = _start + v.size();//有效数据的尾
  10. 			}
  11. 			return *this;//支持连等
  12. 		}

现代写法 ：

  1. vector<T>& operator=(vector<T>v) {
  2. 			if (this != &v) {//防止自己给自己赋值
  3. 				swap(_start, v._start);
  4. 				swap(_finish, v._finish);
  5. 				swap(_endofstorage, v._endofstorage);
  6. 			}
  7. 			return *this;//支持连等
  8. 		}

利用传参时 拷贝出来的v将v的成员和自己的成员一换即可。注意不要用算法库里面的因为算法库里面的是深拷贝代价极大

4.5swap 

  1. void swap(vector<int>& v) {
  2. 			::swap(_start, v._start);
  3. 			::swap(_finish, v._finish);
  4. 			::swap(_endofstorage, v._endofstorage);
  5. 		}

swap函数的作用是交换两个容器中的数据我们可以直接调用算法库中的swap函数交换各自对应的成员变量即可 

4.6容量函数

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

利用指针减指针为两个指针之间数据的个数

4.7迭代器

在vector中迭代器实际上底层是原生指针 

  1. typedef T* iterator;
  2. 		typedef const T* const_iterator;
  1. const_iterator begin()const {
  2. 			return _start;//返回容器中的首地址
  3. 		}
  5. 		iterator begin() {
  6. 			return _start;//返回容器中的首地址
  7. 		}
  9. 		iterator end(){
  10. 			return _finish;//返回容器中最后一个位置的下一个位置
  11. 		} 
  13. 		const_iterator end()const  {
  14. 			return _finish;//返回容器中最后一个位置的下一个位置
  15. 		}

此处有两个版本的原因是为了让const对象也能调迭代器的接口 

4.8 reserve

  1. void reserve(int n) {
  2. 			if (n > capacity()) {
  3. 				int len = size();
  4. 				T* tmp = new T[n];//开空间
  5. 				if (_start) {
  6. 					memcpy(tmp, _start, sizeof(T) * len);//拷数据
  7. 					delete[]_start;//释放旧空间
  8. 				}
  9.                 //指向新空间
  10. 				_start = tmp;
  11. 				_finish = tmp + len;
  12. 				_endofstorage = tmp + n;
  13. 				
  14. 			}
  15. 		  }

4.9尾插push_back（）

  1. void push_back(const T& x) {
  2. 			if (_finish == _endofstorage) {//判断是否需要增容
  3. 				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
  4. 				reserve(newcapacity);//开空间
  5. 			}
  6. 			*_finish = x;
  7. 			++_finish;
  8. }


   

首先判断是否需要增容然后直接将数据放到_finish即可，在将_finish往后移即可

4.10 resize

我们根据resize的规则 

1.当所给值大于当前的capacity时将capacity扩容到该值，扩容的第二个参数为所给值如果没有给出则默认是T（）即T的缺省值

2.当所给值小于当前size时当size减小到该值即可

  1. void  resize(size_t n,const T&val=T()) {
  2. 			if (n < size()) {//n小于当前的size
  3. 				_finish = _start + n;
  4. 			}
  5. 			else {
  6. 				if (n > capacity()) {//判断是否需要增容
  7. 					reserve(n);//开空间
  8. 				}
  9. 				while (_finish < _start + n) {
  10. 					*(_finish) = val;//初始化
  11. 					++_finish;
  12. 				}
  13. 			}
  14. 		}

4.11判断是否为空对象 empty

  1. bool empty(){
  2. 			return _start == _finish;
  3. 		}

4.12 尾删pop_back()

我们只需要将_finish往前移即可 

  1. void pop_back() {
  2. 			assert(_start<_finish);
  3. 			--_finish;
  4. 		}

4.13 insert

  1. iterator Insert(iterator pos,const T&x) {
  2. 			assert(pos <= _finish);
  3. 			if (_finish == _endofstorage) {
  4. 				size_t n = pos - _start;
  5. 				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
  6. 				reserve(newcapacity);//扩容
  7. 				pos = _start + n;//计算pos在新空间中的位置
  8. 			}
  9. 		
  10. 			iterator end = _finish-1;
  11. 			while (end >= pos) {
  12. 				*(end + 1) = *end;//移动数据
  13. 				--end;
  14. 			}
  16. 			*pos = x;//将数据放到对应的位置即可
  17. 			++_finish;// 后移
  18. 			return pos;//返回pos所指向元素的位置
  19. 		}

4.12 earse

  1. iterator Erase(iterator pos) {
  2. 			assert(pos < _finish);
  3. 			iterator it = pos;
  4. 			while (it< _finish) {
  5. 				*it = *(it + 1);//移动数据将pos位置的数据覆盖
  6. 				++it;
  7. 			}
  8. 			--_finish;
  9. 			return pos;//返回pos所指向的位置
  11. 		}

4.13opeator[]

  1. T&operator[](size_t i) {
  2. 			assert(i < size());
  3. 			return _start[i];
  4. 		}
  6. 		const T& operator[](size_t i) const{
  7. 			assert(i < size());
  8. 			return _start[i];
  9. 		}

代码汇总：

  1. #pragma once
  2. #include<assert.h>
  3. #include<iostream>
  4. using namespace std;
  5. namespace ksy
  6. {
  7. 	template<class T>
  8. 	class vector
  9. 	{
  10. 	public:
  11. 		typedef T* iterator;
  12. 		typedef const T* const_iterator;
  13. 		vector(int Size=0, const T& val=T())//
  14. 		:_start(nullptr)
  15. 		,_finish(nullptr)
  16. 		,_endofstorage(nullptr)
  17. 		{
  18. 			assert(Size >0);
  19. 			_start = new T[Size];
  20. 			if (_start>=0) {
  21. 				for (int i = 0; i < Size; i++) {//给每一个位置赋值
  22. 					_start[i] = val;
  23. 				}
  24. 				_finish = _start + Size;
  25. 				_endofstorage = _start + Size;
  26. 			}
  28. 		}
  29. 		vector<T>& operator=(const vector<T>&v) {
  30. 			if (this != &v) {
  31. 				delete[]_start;//释放旧空间
  32. 				_start = new T[v.capacity()];
  33. 				for (int i = 0; i < v.size(); i++) {
  34. 					(_start + i) = v[i];//拷数据
  35. 				}
  36. 				_endofstorage = _start + v.capacity();//整个容器的尾
  37. 				_finish = _start + v.size();//有效数据的尾
  38. 			}
  39. 			return *this;//支持连等
  40. 		}
  42. 		void swap(vector<int>& v) {
  43. 			::swap(_start, v._start);
  44. 			::swap(_finish, v._finish);
  45. 			::swap(_endofstorage, v._endofstorage);
  46. 		}
  47. 		~vector()
  48. 		{
  49. 			if (_start) {
  50. 				delete[] _start;//释放空间
  51. 				_start = _finish = _endofstorage = nullptr;
  52. 			}
  53. 		}
  54. 		vector(const vector<int>& v)
  55. 		:_start(nullptr)
  56. 		,_finish(nullptr)
  57. 		,_endofstorage(nullptr)
  58. 		{
  59. 			reserve(v.capacity());
  60. 			for (const auto& x : v) {
  61. 				push_back(x);
  62. 			}
  64. 		}
  65. 		const_iterator begin()const {
  66. 			return _start;
  67. 		}
  69. 		iterator begin() {
  70. 			return _start;
  71. 		}
  73. 		iterator end(){
  74. 			return _finish;
  75. 		} 
  77. 		const_iterator end()const  {
  78. 			return _finish;
  79. 		}
  81. 		iterator Erase(iterator pos) {
  82. 			assert(pos < _finish);
  83. 			iterator it = pos;
  84. 			while (it< _finish) {
  85. 				*it = *(it + 1);
  86. 				++it;
  87. 			}
  88. 			--_finish;
  89. 			return pos;
  91. 		}
  92. 		void pop_back() {
  93. 			assert(_start<_finish);
  94. 			--_finish;
  95. 		}
  96. 		bool empty(){
  97. 			return _start == _finish;
  98. 		}
  99. 		
  100. 		iterator Insert(iterator pos,const T&x) {
  101. 			assert(pos <= _finish);
  102. 			if (_finish == _endofstorage) {
  103. 				size_t n = pos - _start;
  104. 				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
  105. 				reserve(newcapacity);//扩容
  106. 				pos = _start + n;//计算pos在新空间中的位置
  107. 			}
  108. 		
  109. 			iterator end = _finish-1;
  110. 			while (end >= pos) {
  111. 				*(end + 1) = *end;//移动数据
  112. 				--end;
  113. 			}
  115. 			*pos = x;//将数据放到对应的位置即可
  116. 			++_finish;// 后移
  117. 			return pos;
  118. 		}
  120. 		void  resize(size_t n,const T&val=T()) {
  121. 			if (n < size()) {
  122. 				_finish = _start + n;
  123. 			}
  124. 			else {
  125. 				if (n > capacity()) {
  126. 					reserve(n);
  127. 				}
  128. 				while (_finish < _start + n) {
  129. 					*(_finish) = val;
  130. 					++_finish;
  131. 				}
  132. 			}
  133. 		}
  135. 		void reserve(int n) {
  136. 			if (n > capacity()) {
  137. 				int len = size();
  138. 				T* tmp = new T[n];
  139. 				if (_start) {
  140. 					memcpy(tmp, _start, sizeof(T) * len);
  141. 					delete[]_start;
  142. 				}
  143. 				_start = tmp;
  144. 				_finish = tmp + len;
  145. 				_endofstorage = tmp + n;
  146. 				
  147. 			}
  148. 		  }
  149. 		 
  151. 		void push_back(const T& x) {
  152. 			if (_finish == _endofstorage) {
  153. 				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
  154. 				reserve(newcapacity);
  155. 			}
  156. 			*_finish = x;
  157. 			++_finish;
  158. 			Insert(_finish, x);
  160. 		}
  162. 		T&operator[](size_t i) {
  163. 			assert(i < size());
  164. 			return _start[i];
  165. 		}
  167. 		const T& operator[](size_t i) const{
  168. 			assert(i < size());
  169. 			return _start[i];
  170. 		}
  172. 		size_t size() const
  173. 		{
  174. 			return _finish - _start;
  175. 		}
  177. 		size_t capacity()const {
  178. 			return _endofstorage - _start;
  179. 	}
  180. 	private:
  181. 		iterator _start;
  182. 		iterator _finish;
  183. 		iterator _endofstorage;
  185. 	};
  186. 	
  187. 	void test_vector()
  188. 	{
  189. 		vector<int>ans(3);
  190. 	
  191. 		for (int i = 0; i < 3; i++) {
  192. 			cout << ans[i];
  193. 		}
  194. 	}
  195. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_56999918/article/details/122380793

内容来源于网络，如有侵权，请联系作者删除！

c++容器运维

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com