STL详解--vector的应用和模拟实现

最新推荐文章于 2025-03-20 21:56:47 发布

20savage

最新推荐文章于 2025-03-20 21:56:47 发布

阅读量910

点赞数

分类专栏： C++入门文章标签： c++

本文链接：https://blog.youkuaiyun.com/qq_58102870/article/details/124086668

版权

C++入门专栏收录该内容

12 篇文章

订阅专栏

2.3.2reserve和resize的模拟实现

2.4.9.访问操作符，operator[]的重载模拟实现

2.5其他函数的模拟实现

3.vector模拟实现的函数

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统一的迭代器和引用更好。

2.vector的使用及实现

2.1.vector的定义

2.1.1定义

vector()（重点）无参构造

vector（size_type n, const value_type& val = value_type()）构造并初始化n个val vector (const vector& x); （重点）

拷贝构造 vector (InputIterator first, InputIterator last); 使用迭代器进行初始化构造

    vector<int> v1(10,8);//默认构造，定义一个size为10的空间，且初始化为8
	vector<int> v2;//就定义一个变量，不做处理
	vector<int> v3(++v1.begin(), --v1.end());//v3就是把v1的数据拷贝过来，从v1[1]到v1[8].
	vector<int> v4(v3);这也是把v3的数据拷贝过来
    vector<int> v5=v3;

注意：vector<char>不能取代string，这是因为使用vector<char>需要手动加‘\0’,且不支持+=等操作。

2.1.2析构和构造的模拟实现

根据我们的定义方式我们的构造函数要写很多种。

写构造函数之前我通过查阅，vector的成员变量和string的不一样，其实本质是差不多的。

        iterator _start;//开头
		iterator _finish;//size的下一位
		iterator _endofstorage;//capacity

默认构造

vector<int> v2;//就定义一个变量，不做处理

            vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			;
		}

默认构造直接把各个成员变量弄错nullptr就行了。

填充构造

vector（构造个数，初始化的值）

vector<int> v(10,8);
vector<int> v1(10);

        vector(int n, const T& val= T())
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(n);
			for (size_t i = 0; i < capacity(); ++i)
			{
				_start[i] = val;
			}
			_finish = _start + n;
		}

拷贝构造

我们可以使用另一个容器来定义一个新的

vector<int> v(10,8);
vector<int> v1(v);

我们要写拷贝构造需要一个知道一个东西。（迭代器实现和迭代器类型）

重点：迭代器实现和迭代器类型

forwardit,单向迭代器，只能进行++操作的迭代器，其中单链表符合这一种迭代器。
bidirectionalIt，双向迭代器，能进行++和–的迭代器，其中链表，哈希表，红黑树都符合，一般用于不连续的空间。
randomaccessIt,随机迭代器，这种迭代器不仅能进行++和–，还支持随机访问，一般用于连续的空间，vector,string,deque等符合。
我们可以观察到，列表中由上到下，实现的功能越来越多，而偏下行的迭代器又包含偏上行迭代器所有的功能。

        template<class InputIerator>
		vector(InputIerator first, InputIerator end)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			while (first != end)
			{
				push_back(*first);
				++first;
			}
		}

       vector(const vector <T>& v)
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)

		{
			vector <T> tmp(v._start, v._finish);//这里的v._start就是迭代器，就要调用上面的
			swap(tmp);
		}

这里的拷贝构造需要，vector都有一块单独的数组空间，所以我们必须进行深拷贝，不然重复析构会出现问题。

运算符重载构造=

vector<int> v(10,8);
vector<int> v2 = v;

      // vector& operator=(vector v)
		vector<T>& operator=(vector<T> v) // 推荐
		{
			swap(v);

			return *this;
		}

析构函数

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

2.2vector的迭代器

2.2.1迭代器的使用

begin + end（重点）获取第一个数据位置的iterator/const_iterator，获取最后一个数据的下一个位置的iterator/const_iterator

rbegin + rend 获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的 reverse_iterator

vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		*it -= 1;
		cout << *it << " ";
		++it;
	}
	cout << endl;

这里的迭代器是可读可写的，且我们可以把迭代器理解成指针，可以指向某元素.，可以看到，这个迭代器和string的很像。

注：迭代器遵循左闭右开的原则，所以我们要把end写到下一个位置

2.2.2迭代器的模拟实现

template<class T>//类模板参数，可以表示各种各样的数据类型
class vector
{
public:
	typedef T* iterator;
	typedef const T* const_iterator;//常量迭代器
private:
	iterator _start;
	iterator _finish;
	iterator _end_of_storage;
};

        const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

2.3vector容量操作

2.3.1vector容量的基本使用

size 获取数据个数 capacity 获取容量大小

empty 判断是否为空

resize（重点）改变vector的size

reserve （重点）改变vector放入

capacity 获取容器的大小

    vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
    v1.push_back(3);
	v1.push_back(4);

    vector<int> v2;
	v2.push_back(1);
	v2.push_back(2);
    v2.push_back(3);
  	v2.push_back(4);

    v1.reserve(100);
	v2.resize(100，1);

2.3.2reserve和resize的模拟实现

reserve的模拟实现

        vector<int> v(10, 8);
		v.reserve(100);

     void reserve(size_t n)
   		{
			if (n > capacity())
			{
				size_t oldsize = size();
				T* tmp = new T[n];
				if (_start)
				{
					for (int i = 0; i < oldsize; ++i)
						tmp[i] = _start[i];
				}
				_start = tmp;//指向一片新空间
				_finish = tmp + oldsize;//跟随_start指向新空间
				_endofstorage = tmp + n;
			}
		}

在模拟实现的时候我们要知道，这里如果传的n比原capacity大，那么就要进行从新开辟空间，把原来的数据拷贝到新空间中。再释放原空间。

注：不能使用memcpy，因为他是浅拷贝，如果我们的对象需要深拷贝时，在释放空间后，新空间就会成为野指针，会发生奔溃。

resize的模拟实现

        vector<int> v(10, 8);
		v.resize(20,1);

void resize(size_t n, const T& val = T())
		{
			if (n > size())
			{
				if (n > capacity())
				{
					reserve(n);
				}
				iterator cur = _finish;//从size位置开始初始化
				size_t it = size();
				//while (cur != _endofstorage)
				while (it != capacity())
				{
					//*cur = val;
					//cur++;
					cur[it] = val;
					it++;

				}
				_finish =_start+n;
			}
			else
			{
				_finish = _start + n;

			}
		}

这里需要注意的就是cur迭代器失效的问题，如果你输入的新空间大于原空间，要进行扩容，那么原来的_start都会发生变化，那么cur指向的空间就会改变。