【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector

文章目录

  • 一、vector的源码分析
    • 1.分析思路
    • 2.构造函数和插入接口
  • 二、手把手教你写一个简单的vector
    • 1.基本结构
    • 2.迭代器与私有成员变量的定义
    • 3.构造函数
    • 4.size和capacity
    • 5.迭代器函数接口
    • 6.析构函数
    • 7.reserve接口
    • 8.尾插
    • 9.operator[]运算符重载
    • 10.简单的测试前面的接口
    • 11.insert以及迭代器失效问题
    • 12.erase以及迭代器失效
    • 13.尾删
    • 14.resize
    • 15.拷贝构造
    • 16.赋值运算符重载
    • 17.再谈reserve
    • 18.再谈拷贝构造
    • 19.用n个val去构造
    • 20.用迭代器区间构造函数
  • 三、vector完整代码

一、vector的源码分析

这里我们只是简单的去了解一下原码即可,后序将会出一个专题着重剖析stl源码

1.分析思路

vector的原码有很多版本,我们采用与侯捷老师的《STL原码剖析》这本书同一个版本的原码

对于我们所看的vector原码,我们首先要关注的是成员变量。这个是最核心的部分。
如下所示,这三个就是我们的成员变量
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第1张图片

可以注意到,vector原码采用的是三个迭代器作为成员变量,这与我们之前的string是有所差异的。既然是迭代器,那么我们就在来找找迭代器真正的类型是什么?

如下图所示【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第2张图片

我们可以注意到在源码中,迭代器实际上就是我们的模板参数T,T就是我们vector里面每个数据的类型,这些迭代器本质就是T的指针。因为对于vector就是一个顺序表,所以它完全可以用原生的指针作为迭代器

现在我们已经知道了成员变量及其类型,可以看到是与我们原来所想的有所差异,那么我们就要进行对比,与正常的顺序表它这些成员变量究竟是什么意思?为了得知这些成员变量是什么意思,我们需要做的就是看构造函数和插入接口

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第3张图片

2.构造函数和插入接口

如下所示,是我们找到的构造函数
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第4张图片对于第一个无参的构造,它的作用是将三个指针全部置空。这里我们似乎也看不出什么来

既然如此,那么我们再来关注一下这个尾插函数
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第5张图片既然关注到了尾插,那么肯定涉及到扩容
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第6张图片

接下来我们就可以根据这两个函数进行猜测成员变量都是啥意思。事实上根据单词的意思,我们已经可以猜测的七七八八了,这两个函数起到的作用就是可以进行验证我们猜测的是否正确

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第7张图片

有了上面的猜测,尾插函数其实我们大概也就能够读懂。至于reserve函数,我们也可以看出来它显示开好空间,然后释放掉原来的空间,在最后的三行中,再次验证了我们的猜测
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第8张图片

二、手把手教你写一个简单的vector

1.基本结构

我们的基本结构如下所示
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第9张图片

2.迭代器与私有成员变量的定义

根据前面的分析,我们很容易写出成员变量和迭代器的定义

	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};

3.构造函数

如下所示,是最基本的无参的构造函数,我们只需要将全部的置空即可

		vector()
			:_start(nullptr)
			,_finish(nullptr)
			,_end_of_storage(nullptr)
		{}

4.size和capacity

这个两个也是很重要的接口,后序的很多测试都是需要依靠他的

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

5.迭代器函数接口

迭代器接口也是比较容易写出来的。和string是类似的,这里不再赘述

		typedef T* iterator;
		typedef const T* const_iterator; 
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}

6.析构函数

析构函数也是最基本必须要完成的默认成员函数之一,我们当_start不为空的时候,直接释放掉内存即可

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

7.reserve接口

这个接口起着扩容的重大作用,当我们增加数据的时候,必须要先判断是否需要进行扩容。当我们要求的容量大于我们实际的容量时候,我们就开辟一块新的空间,然后拷贝数据,最后释放掉原来的数据。最后改变指针的指向,需要注意的是,我们最好提前算好原来的size,以便后来_finish指针的计算。

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				iterator tmp = new T[n];
				int sz = size();
				if (_start)
				{
					memcpy(tmp, _start, sizeof(T) * sz);
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

8.尾插

有了前面的接口,我们现在可以去实现一下尾插的接口,这个逻辑也是很简单的,当finish和end_of_storage相等的时候,就是需要扩容了,然后我们直接插入数据即可

		void push_back(const T& val)
		{
			if (_finish == _end_of_storage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = val;
			_finish++;
		}

9.operator[]运算符重载

对于这个接口,它和string的基本实现也是类似的,需要注意要写两个函数重载,这是为了保证const对象只读和普通对象读写的特性

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

10.简单的测试前面的接口

我们使用如下代码对前面接口进行测试。

void Print(const Sim::vector<int>& v)
{
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}
void testvector2()
{
    Sim::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(4);
    v.push_back(4); 
    for (size_t i = 0; i < v.size(); i++)
    {
        v[i]++;
    }
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    Print(v);
    cout << endl;
}

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第10张图片

经过测试后,符合我们的预期

11.insert以及迭代器失效问题

对于这个接口,我们的思路是这样的,首先我们先断言,pos在合理的范围之内,然后当容量满了以后,我们进行扩容,注意在这里扩容时候要小心,这里当我们扩容以后,pos会失效的,因为pos还是指向原来的空间,我们扩容完以后已经将原来的空间给释放了,所以pos会失效。这就是迭代器失效问题,为了防止pos失效,我们需要先记录pos的相对位置,然后当扩容以后重新加上去就可以计算出新的pos位置了。
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第11张图片

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

			if (_finish == _end_of_storage)
			{
				int sz = pos - _start;
				int newcapacity= capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + sz;
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *(end);
				end--;
			}
			*pos = val;
			_finish++;
		}

最后我们就可以正常的按照我们逻辑进行挪动数据和插入数据了。

下面是我们的测试代码

void testvector3()
{
    Sim::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 10);
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

}

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第12张图片

其实上面的仅仅只是内部的迭代器失效问题,这个问题我们已经得到了解决,还有一类迭代器失效是外部的迭代器失效问题,如下所示的测试代码,当我们想要在某处插入多次数据的时候,可能会引发pos失效的问题,这是因为,在内部插入数据需要扩容的时候已经修改了pos的值,pos的位置已经被改变了。而在外部还在使用原来的pos自然是不行的
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第13张图片

可见,我们的程序引发了断言错误,正是由于pos已被内部所改变了。故同一个pos不可以连续使用
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第14张图片

那么在这里,我们可能会想,能否在传参的时候对pos使用传引用呢。其实这样也是错的,这是因为如果传引用的话,会涉及到权限放大的问题。由于pos里面的数据肯定是要被修改的,所以pos肯定不可以使用const迭代器。故参数必须使用普通的迭代器。而如果我们在传参的时候,我们实参写了一个运算表达式。运算表达式返回一个结果的时候会产生一个临时变量,临时变量具有常性。由此权限放大了。故不可以使用传引用。或者当我们直接使用迭代器begin函数作为实参的话,由于这个迭代器是传值返回,也是会产生临时变量,故仍然会权限放大。再次说明了不可以传引用。

所以insert以后迭代器可能失效
insert以后就不要使用这个形参迭代器了,因为他可能已经失效了
继续使用它就是一个高危行为

在库里面它的解决方案就是带一个返回值
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第15张图片

库里面这个返回值返回的是新插入元素的位置
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第16张图片

这样一来我们就可以从外部规避这个迭代器失效问题了

所以真正的代码应该是这样的:

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

			if (_finish == _end_of_storage)
			{
				int sz = pos - _start;
				int newcapacity= capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + sz;
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *(end);
				end--;
			}
			*pos = val;
			_finish++;
			return pos;
		}

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第17张图片

12.erase以及迭代器失效

对于erase,我们可以很容易的写出如下代码,即依次往前挪动。这个思路看上去确实没什么毛病

		void erase(iterator pos)
		{
			assert(pos >= _start && pos < _finish);
			if (_start)
			{
				iterator end = pos + 1;
				while (end != _finish)
				{
					*(end - 1) = *end;
					end++;
				}
				_finish--;
			}
		}

但是当我做出如下操作的时候,发生了断言错误
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第18张图片【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第19张图片

其实仔细一想也确实是这样的,因为我们删除了倒数第二个值以后, 原来的pos还是指向那个位置,这里的pos已经是最后一个位置了。当再次删除的时候,必然产生pos断言错误。这就意味着pos已经不是指向原来的值了,已经失效了。继续使用pos有可能会越界或者跳过了某些数据。

如果是vs的std库里面的话,直接程序报错

下图的其实不算足够严谨,因为我们已经改变了pos,相当于我们没有连续使用同一个迭代器,vs不会直接暴力报错。这里崩溃原因其实还是因为越界了。
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第20张图片

如下图所示,还算比较严谨,因为我们连续使用同一个pos,vs直接暴力检查,直接报错。但是在linux下,并没有如此暴力的检查。但是我们还是不能这样写,因为我们不可以让一个代码可以在linux下可以跑,但是vs下不能跑,这样代码移植性太差了。
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第21张图片

也就是说
erase以后,迭代器失效了,vs进行了强制检查,直接报错,必须要重新给pos赋值,才可以不报错
而在linux下的g++编译器,并没有做直接报错的处理,但是结果很可能不符合我们的预期,有可能会产生非常危险的现象

标准为了避免迭代器失效,所以就要给pos重新赋值,那么我们只能给函数添加返回值了
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第22张图片

如上可知,它这个返回的是刚刚被删除的那个元素的下一个位置。

所以最终代码是这样的

		iterator erase(iterator pos)
		{
			assert(pos >= _start && pos < _finish);
			if (_start)
			{
				iterator end = pos + 1;
				while (end != _finish)
				{
					*(end - 1) = *end;
					end++;
				}
				_finish--;
			}
			return pos;
		}

总结:vector在使用完erase和insert迭代器对象以后,不能在使用这个迭代器了,我们认为迭代器失效了,因为结果是未定义的

13.尾删

如下所示,我们既可以直接调用erase复用,也可以自己直接写一个都是可以的。

		void pop_back()
		{
			if (_start)
			{
				_finish--;
			}
			//erase(_finish-1);
		}

14.resize

resize的基本逻辑我们都明白,但是有一点需要注意的是,如果处理第二个缺省参数,对于内置类型我们直接给0当然是可以的,但是倘若是构造类型的话,显然是不可以的。我们这里的策略是给一个匿名对象,这个匿名对象就是默认构造出来的,这就意味着我们每一个对象最好都写上默认构造函数,否则迟早会出问题的。但是内置类型严格来说是没有默认构造函数这一说法的。但是C++中对内置类型做了升级。让内置类型也类似于有了默认构造。

如下代码所示。
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第23张图片

最终我们代码如下所示

		void resize(size_t n, const T& val = T())
		{
			if (n < size())
			{
				_finish = _start + n;

			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
		}

如下是测试结果
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第24张图片

15.拷贝构造

如下代码所示,这是一个典型的深拷贝问题。

		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			_start = new T[v.capacity()];
			memcpy(_start, v._start, sizeof(T) * v.size());
			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

运行结果如下所示
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第25张图片

当然拷贝构造不仅仅这一种写法,还有很多种写法。如下所示

		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			reserve(v.capacity());
			for (auto e : v)
			{
				push_back(e);
			}
		}

16.赋值运算符重载

这里我们可以直接使用现代写法,比较容易简洁

		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish,v._finish);
			std::swap(_end_of_storage,v._end_of_storage);
		}
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}

测试结果如下所示:
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第26张图片

17.再谈reserve

当我们写出这样的代码的时候,我们惊讶的发现,居然报错了

void testvector6()
{
    Sim::vector<string> v;
    v.push_back("1111");
    v.push_back("2222");
    v.push_back("3333");
    v.push_back("4444");
    v.push_back("5555");
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第27张图片

这个代码咋一看好像没什么大问题,而且在我们使用内置类型的连续尾插时候也没有出现问题,那么这里为什么会出现问题呢?
我们可以将内存图给画出来

如下图所示,这是我们一开始的情形
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第28张图片

当我们再次插入数据的时候,我们发现需要进行扩容了,于是在我们扩容的时候,我们使用reserve函数,它里面有个部分是memcpy
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第29张图片

注意,这里的memcpy就是原罪。因为我们这里对于vector来说,确实是一个深拷贝,但是对于string而言,它里面的数据是一个浅拷贝。
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第30张图片

当我们程序结束需要delete的时候,就会出事了,程序第二次析构。

所以这里的问题就是:vector是深拷贝,但是vector空间上存的对象是string数组,使用memcpy会导致string对象的浅拷贝

解决方案也很简单,把这行代码给替换一下,下面我们所使用的看似简单,实则内藏玄机,注意看,我们看似使用了一个简单的变量,在这个遍历中,我们将原来的每一个_start所指向的数组依次使用赋值运算符重载交给新的数组中,这样一来深拷贝的问题就交给了赋值运算符重载。从而成功的规避了这个问题

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				iterator tmp = new T[n];
				int sz = size();
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);
					for (size_t i = 0; i < size(); i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

现在我们的代码就可以正常运行了
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第31张图片

18.再谈拷贝构造

reserve存在浅拷贝的问题,那么拷贝构造是否也存在呢?因为我们的拷贝构造也是使用了memcpy,我们可以验证一下。结果发现确实也存在问题
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第32张图片既然如此,那么我们也进行一次修正,去处理掉这个问题

		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			_start = new T[v.capacity()];
			//memcpy(_start, v._start, sizeof(T) * v.size());
			for (size_t i = 0; i < v.size(); i++)
			{
				_start[i] = v[i];
			}
			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

这里笔者在给一段测试代码,这段代码的拷贝构造部分的分析极其复杂,有兴趣的可以去研究一下。

void testvector7()
{
    Sim::vector<Sim::vector<int>> v;
    Sim::vector<int> vv;
    vv.push_back(1);
    v.push_back(vv);
    v.push_back(vv);
    v.push_back(vv);
    v.push_back(vv);
    v.push_back(vv);
    Sim::vector<Sim::vector<int>> v1(v);
    for (Sim::vector<int> e : v)
    {
        for (int c : e)
        {
            cout << c << " ";
        }
        cout << endl;
    }
}

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第33张图片

19.用n个val去构造

这个代码我们可以直接复用前面的resize

需要注意的是,这个初始化列表一定要写,或者给成员变量写缺省参数都是可以的。如果不写的话,那么会出现很多问题的。

		vector(size_t n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			resize(n, val);
		}

如下是一个简单的测试代码

void testvector8()
{
    Sim::vector<int> v(10, 1);
    for (int e : v)
    {
        cout << e << " ";
    }
    cout << endl;

}

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第34张图片

20.用迭代器区间构造函数

我们可以很容易的写出以下代码

		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}

但是当我们运行的时候,发现了一个很奇怪的错误
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第35张图片

为什么说奇怪呢?首先是我们测试用例并没有做出任何改变,我们仅仅只是加了一个迭代器区间构造函数,而且报的错误是非法的间接寻址。

事实上这是编译器的选择函数的问题

是由于以下两个函数产生冲突了
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第36张图片

我们写的参数是10和1,编译器会认为是int类型的,但是第一个函数的第一个参数是无符号的整型,第二个的参数是可变的,理论上来说第二个是更匹配的。故编译器选择了第二个函数使用。而迭代器本应类似一个指针,这里却是一个普通的变量,当然会发生问题了。这个问题正好就是非法的间接寻址。

如果我们将代码写成10u的话,也就意味着第一个参数变为了无符号的整型。第二个参数是int是满足第一个函数的形式的,且不可能满足第二个函数的参数,因为第二个的两个参数必须是一致的,故这样下,编译器才会正确的选择函数

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第37张图片

或者说,当我们的第二个参数确定好了,不可能与第一个是一样的,那这样编译器也不会错误的识别函数。比如说字符串类型等等

这样一来我们现在测试一下我们的迭代器区间初始化,可见符合我们的预期

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第38张图片

这样还是不符合我们本应该的想法的,我们不可能每次都记得要多写一个u,在编译器中解决的方案就是多写了几个函数重载,改变了第一个参数的类型。这样的话编译器发现有一个是编译失败的,那么自然就会选择可以编译正确的函数。

【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第39张图片
【C++从0到王者】第十三站:vector源码分析及手把手教你如何写一个简单的vector_第40张图片

三、vector完整代码

vector完整代码

#pragma once
#include
#include
#include
#include
using namespace std;


namespace Sim
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator; 
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}


		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}
		vector(const vector<T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			_start = new T[v.capacity()];
			//memcpy(_start, v._start, sizeof(T) * v.size());
			for (size_t i = 0; i < v.size(); i++)
			{
				_start[i] = v[i];
			}
			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}
		//vector(const vector& v)
		//	:_start(nullptr)
		//	, _finish(nullptr)
		//	, _end_of_storage(nullptr)
		//{
		//	reserve(v.capacity());
		//	for (auto e : v)
		//	{
		//		push_back(e);
		//	}
		//}
		vector(size_t n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			resize(n, val);
		}
		vector(int n, const T& val = T())
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			resize(n, val);
		}
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}


		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish,v._finish);
			std::swap(_end_of_storage,v._end_of_storage);
		}
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}
		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = nullptr;
				_finish = nullptr;
				_end_of_storage = nullptr;
			}
		}

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				iterator tmp = new T[n];
				int sz = size();
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);
					for (size_t i = 0; i < size(); i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n, const T& val = T())
		{
			if (n < size())
			{
				_finish = _start + n;

			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
		}

		void push_back(const T& val)
		{
			if (_finish == _end_of_storage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = val;
			_finish++;
		}

		void pop_back()
		{
			if (_start)
			{
				_finish--;
			}
			//erase(_finish-1);
		}

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

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

			if (_finish == _end_of_storage)
			{
				int sz = pos - _start;
				int newcapacity= capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + sz;
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *(end);
				end--;
			}
			*pos = val;
			_finish++;
			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start && pos < _finish);
			if (_start)
			{
				iterator end = pos + 1;
				while (end != _finish)
				{
					*(end - 1) = *end;
					end++;
				}
				_finish--;
			}
			return pos;
		}


	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}

测试代码

#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
#include"vector.h"

void Print(const Sim::vector<int>& v)
{
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}
void testvector1()
{
    Sim::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(4);
    v.push_back(4);

    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}
void testvector2()
{
    Sim::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(4);
    v.push_back(4); 
    for (size_t i = 0; i < v.size(); i++)
    {
        v[i]++;
    }
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    Print(v);
    cout << endl;
}
void testvector3()
{
    Sim::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 10);
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    //在第三个数据位置处进行插入多次数据
    Sim::vector<int>::iterator pos = v.begin() + 2;
    pos = v.insert(pos, 222);
    pos = v.insert(pos, 333);
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;



}
void testvector4()
{
    Sim::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 20);
    v.insert(v.begin(), 30);
    v.insert(v.begin(), 40);
    v.insert(v.begin(), 50);
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
    Sim::vector<int>::iterator pos = v.begin()+6;
    pos = v.erase(pos);
    pos = v.erase(pos);
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
    v.pop_back();
    v.pop_back(); 
    v.pop_back();   

    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}



void test()
{
    int i = 0;
    int j = int();
    int k = int(1);
    cout << "i=" << i << endl;
    cout << "j=" << j << endl;
    cout << "k=" << k << endl;
}

void testvector5()
{
    Sim::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.insert(v.begin(), 10);
    v.insert(v.begin(), 20);
    v.insert(v.begin(), 30);
    v.insert(v.begin(), 40);
    v.insert(v.begin(), 50);

    v.resize(10, 100);
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    v.resize(5, 10);
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    Sim::vector<int> v1(v);
    for (auto e : v1)
    {
        cout << e << " ";
    }
    cout << endl;


    auto v2 = v;
    for (auto e : v1)
    {
        cout << e << " ";
    }
    cout << endl;
}
void testvector6()
{
    Sim::vector<string> v;
    v.push_back("1111");
    v.push_back("2222");
    v.push_back("3333");
    v.push_back("4444");
    v.push_back("5555");
    Sim::vector<string> v1(v);
    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;


}
void testvector7()
{
    Sim::vector<Sim::vector<int>> v;
    Sim::vector<int> vv;
    vv.push_back(1);
    v.push_back(vv);
    v.push_back(vv);
    v.push_back(vv);
    v.push_back(vv);
    v.push_back(vv);
    Sim::vector<Sim::vector<int>> v1(v);
    for (Sim::vector<int> e : v)
    {
        for (int c : e)
        {
            cout << c << " ";
        }
        cout << endl;
    }
}
void testvector8()
{
    Sim::vector<int> v(10, 1);
    for (int e : v)
    {
        cout << e << " ";
    }
    cout << endl;
    Sim::vector<int> v1(v.begin(), v.end());
    for (int e : v1)
    {
        cout << e << " ";
    }
    cout << endl;
}
int main()
{
    testvector8();
    return 0;
}

好了,本期内容就到这里了
如果对你有帮助的话,不要忘记点赞加收藏哦!!!

你可能感兴趣的:(【C++】,c++,java,开发语言,c,算法,类和对象)