【C++】vector的底层原理讲解及其实现

目录

一、认识vector底层结构
二、初始化vector的函数

1. 构造函数
2. 拷贝构造
3. 赋值构造
4. initializer_list构造
5. 迭代器区间构造

三、迭代器
四、数据的访问
五、容量相关的函数
六、关于数据的增删查改操作

---

一、认识vector底层结构

STL库中实现vector其实是用三个指针来完成的，使用这三个指针（或称为迭代器）变量来管理其内存

其实vector和string的实现非常相似，都是利用了顺序表结构，在vector的实现上我们遵循底层用三个指针来完成，_statr，_finish，_end_fo_storage分别指向顺序表的头，顺序表存储数据的有效个数的位置，顺序表的结束

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

---

二、初始化vector的函数

1、构造函数
①最常用的无参默认构造
vector();

vector()
:_strat(nullptr)
,_finish(nullptr)
,_endofstorage(nullptr)
{}

这个很简单，我就不多讲了，后面遇到难点我会详细说明，便于大家理解

②用n个val构造一个vector
explicit vector (size_type n, const value_type& val = value_type();
库里面用explicit修饰构造函数，是为了防止构造函数发生隐式类型转换

vector(size_t n, const T& val = T())
{
	_start = new T[n];
	_finish = _start;
	while (_finish!=_start+n)
	{
		*_finish = val;
		_finish++;
	}
	_endofstorage = _start + n;
}

2、拷贝构造
vector(const vector& v);
拷贝构造：用一个已经存在的对象来初始化另一个正在创建的对象

vector(const vector& v)
{
	_start = new T[v.size()];
	memcpy(_start, v._start, sizeof(T) * v.size());
	_finish = _start + v.size();
	_endofstorage = _finish;
}

3、赋值构造
赋值构造：两个已经存在的对象，一个赋值给另一个
vector& operator= (const vector& v);

void swap(vector& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstorage, v._endofstorage);
}
//v1=v2;
vector& operator= (vector v)
{
	swap(v);
	return *this;
}

这里我利用库里的函数来实现swap，只交换vector的三个指针更高效，赋值构造的参数是传值传参，会调用拷贝构造，将v2拷贝一份给v，然后之间调用swap函数，将v和this交换，最后返回this即可

4、initializer_list构造
vector (initializer_list<T> il);
tips:这里的initializer_list实际是个类，C++底层将其封装了，里面也有begin，end，size

//vector<int> v={1,2,3,4,5};
vector(initializer_list<T> il)
{
	for (auto e : il)
	{
		push_back(e);
	}
}

---

5、迭代器区间构造
template <class InputIterator> vector(InputIterator first, InputIterator last);

// 类模板的成员函数可以是函数模板
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

注意：如果加了迭代器区间构造会造成一个问题，就是在调用时和vector(size_t n, const T& val = T())会出现冲突，底层给出的解决方案就是加一个重载vector(int n, const T& val = T())

三、迭代器

这里博主就只介绍最重要的迭代器部分

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//加了const修饰，const对象可以调用，非const对象也可以调用
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}
	private:
		iterator _start; //指向空间（顺序表）的开始
		iterator _finish;//指向有效数据个数的位置
		iterator _endofstorage;//指向空间的结束
};

---

四、数据的访问

由于vector底层是连续的物理空间，所以支持下标访问
T& operator[] (size_t n);
const T& operator[] (size_t n) const;

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

---

五、容量相关的函数

size（有效数据个数）和capacity（空间容量大小）

size_t size() const
{
	return _finish - _start;//指针减指针得到两个指针之间的数据个数
}
size_t capacity() const
{
	return _endofstorage - _start;
}

reserve
void reserve (size_t n);
易错点1

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();
		T* temp = new T[n];
		memcpy(temp, _start, sizeof(T) * size());
		delete[]_start;
		_start = temp;
		_finish = _start + old_size;
		_endofstorage = _start+n;
	}
}

改成现在这个样子确实是解决了上图中的问题，但是这个就是对的吗？让我们一起来看一下这个代码究竟对不对

易错点2
其实上面的代码大体逻辑是没有什么问题的，问题就出在这个memcpy上，要知道memcpy底层实现是按字节一个一个拷贝过去的，虽然我们的vector是深拷贝，但是memcpy是浅拷贝，这样写针对内置类型是🆗的，但是针对自定义类型会存在指向同一块空间的问题，两次析构等问题，话不多说，我们看图解

出错案例：

出错图解：

其实要改正这个问题有一个很简单的方式，采用赋值的方式，无论是内置类型还是自定义类型，在赋值时都会调用他的拷贝构造，这样就自动调用该类型的深拷贝了

void reserve(size_t n)
{
	if (n > capacity())
	{
		size_t old_size = size();
		T* temp = new T[n];
		//memcpy(temp, _start, sizeof(T) * size());
		for (size_t i = 0; i < old_size; i++)
		{
			temp[i] = _start[i];
		}
		delete[]_start;
		_start = temp;
		_finish = _start + old_size;
		_endofstorage = _start+n;
	}
}

resize
void resize (size_t n, const T& val=T());

void resize(size_t n, const T& val=T())
{
	if (n > capacity())
	{
		reserve(n);
		for (size_t i = size(); i < n; i++)
		{
			_start[i] = val;
		}
		_finish = _start + n;
	}
	else
	{
		_finish = _start + n;
	}
}

注意：reverse和resize都不会缩容

empty
bool empty() const

bool empty()const
{
	return _finsh == _start;
}

---

六、关于数据的增删查改操作

push_back
void push_back (const T& val);

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

inserrt
void insert (iterator pos, const T& val);

void insert(iterator pos, const T& val)
{
	assert(pos>=_start);
	assert(pos <= _finish);
	size_t d = pos - _start;//先记下pos和_start的相对位置
	if (size() == capacity())
	{
		reserve(capacity() == 0 ? 4 : 2 * capacity());
		//如果扩容了，要更新pos
		pos = _start + d;
	}
	iterator end = _finish;
	while (pos < end)
	{
		*end = *(end - 1);
		end--;
	}
	*pos = val;
	_finish++;
}

erase
iterator erase (iterator pos);

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

clear
void clear();

void clear()
{
	_finish = _start;
}

---

vector章节我们就到这里啦，欢迎大家来学习指教下一篇list章节😘