目录

Vector的模拟实现

一、vector的核心框架

二、成员变量和迭代器

三、构造函数

1. 无参构造函数

2. 带参构造函数

3. 区间构造函数

4. 拷贝构造函数

5.列表赋值

6.operate=

四、析构函数

五、容量相关函数

1. size和capacity

2. reserve

3.resize

六、容器相关操作 

 1. push_back

 2. pop_back

 3.insert

 4.erase

5.swap

⭐Vector的模拟实现

在C++中，<code>vector是一个非常常用的容器，它提供了一种动态数组的实现方式，允许我们在运行时动态地增加或减少元素的数量。vector的内部实现主要依赖于动态分配的内存和连续存储的元素。

关于vector的使用可以转至【C++】深入探索vector，让你一次性学懂！-CSDN博客

⭐一、vector的核心框架

在STL的vector中，主要通过三个指针来控制数据的个数以及容量的大小：

start指针：指向数据的开始位置。finish指针：指向最后一个数据的下一个位置。endOfStorage指针：指向vector所开辟的空间中的最后一个位置。

template<class T>

class vector

{

private:

iterator _start;// 指向数据块的开始

iterator _finish;// 指向有效数据的尾

iterator _endOfStorage; // 指向存储容量的尾

};

通过这三个指针，我们可以很方便地计算出数据的个数（<code>finish - start）和容量的大小（endOfStorage - start）。 

⭐二、成员变量和迭代器

在模拟实现vector时，我们首先需要定义这些成员变量，并定义迭代器类型。迭代器实际上就是原生指针的封装，因为vector是连续存储的。

template<class T>

class vector

{

public:

//常规迭代器和const迭代器

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;

}

private:

//定义成员变量

iterator _start = nullptr;

iterator _finish = nullptr;

iterator _endOfStorage = nullptr;

};

⭐三、构造函数

📖1. 无参构造函数

无参构造函数只需将三个指针初始化为nullptr。

template<class T>

class vector{

// ...

public:

vector() {}

// 编译器会自动调用默认初始化列表

};

📖2. 带参构造函数

通过给定的数量和值来初始化vector。

vector(size_t n, const T& val = T())

{

reserve(n);

for (size_t i = 0; i < n; i++)

{

push_back(val);

}

}

当vector<int>(10,1)这样初始化时，传值的两个类型都是int，与下面的那个区间构造函数(vector(InputIterator first, InputIterator last))更加匹配，当前构造函数这个需要进行类型转换，所以会报错,只有这一个会报错，其他的vector<int>v(10,'a') \vector<int>v(10u,5)...都是对的再写一个int类型的重载版本就可以解决：

vector(int n, const T& val = T())

{

reserve(n);

for (size_t i = 0; i < n; i++)

{

push_back(val);//下面会实现

}

}

📖3. 区间构造函数

通过一段迭代器区间来初始化vector。

//类模板的成员函数可以是函数模板

//使用这个模板，就可以用其他容器的迭代器初始化

template <class InputIterator>

vector(InputIterator first, InputIterator last)

{

while (first != last)

{

push_back(*first);

++first;

}

}

📖4. 拷贝构造函数

拷贝构造函数需要分配新的内存，并复制原有vector的元素。

可以使用reserve()函数，先看出空间，再插入。 

//v2(v1)

vector(const vector<T>& v)

{

reserve(v.capacity());//下面会实现

for (auto e : v)

{

push_back(e);

}

}

📖5.列表赋值

该构造函数接受一个initializer_list<T>作为参数，并使用该初始化列表中的元素来初始化vector对象。

//vector<int>v = {1, 2, 3, 4}

vector(initializer_list<T> il)

{

reserve(il.size());

for (auto& e : il)

{

push_back(e);

}

}

📖6.operate=

使用 = 赋值。

//v1 = v2

//

//故意使用传值

//v是v2的拷贝

vector<T>& operator=(vector<T> v)

{

swap(v);//后面实现

return *this;

}

⭐四、析构函数

析构函数负责释放vector所占用的内存。

~vector()

{

delete[] _start;

_start = _finish = _end_of_storage = nullptr;

}

⭐五、容量相关函数

📖1. size和capacity

<code>size_t size() const

{

return _finish - _start;

}

size_t capacity() const

{

return _end_of_storage - _start;

}

📖2. reserve

reserve函数用于预留空间。

void reserve(size_t n)

{

if (n > capacity())

{

size_t sz = size();

T* tmp = new T[n];

//如果T 是string或者vector，使用memcpy就容易造成string的浅拷贝

// 后面delete[] _start会释放空间，还会对每个string调用析构函数,如果使用memcpy，那么在delete之后，新空间中的string还是析构的string

//memcpy(tmp, _start, size() * sizeof(T));

for (int i = 0; i < sz; i++)

{

tmp[i] = _start[i];

}

delete[] _start;

_start = tmp;

//_finish = tmp + size();//这里调用 size() 函数的时候，_start已经发生了变化，此时的返回值（ _finish - _start） 并不是真正的size

_finish = tmp + sz;

_end_of_storage = tmp + n;

}

}

📖3.resize

调整容器大小，当新的size小于原来的时，会发生阶段；反之，则会将新增加的元素复制为val（默认为0）。

<code>void resize(size_t n, const T& val = T())//调用对应的默认构造,int这些内置类型在模板出来以后也有了自己的构造,如int i = int(1);

{

if (n > size())

{

//插入

reserve(n);

while (_finish < _start + n)

{

*_finish = val;

_finish++;

}

}

else

{

//删除

_finish = _start + n;

}

}

⭐六、容器相关操作 

📖 1. push_back

向容器尾部插入元素

void push_back(const T& val)

{

//扩容

if (_finish == _end_of_storage)

{

reserve(capacity() == 0 ? 4 : 2 * capacity());

}

*_finish = val;

++_finish;

}

 📖2. pop_back

删除容器尾部的元素

void pop_back()

{

assert(!empty());

_finish--;

}

📖 3.insert

在指定元素之前插入新元素；

需要判断容器容量够不够插入新的元素，如果不够，则需要扩容。

void insert(iterator pos, const T& val)

{

assert(pos >= _start);

assert(pos <= _finish);

if (_finish == _end_of_storage)

{

size_t p = pos - _start;

reserve(capacity() == 0 ? 4 : 2 * capacity());//原来的空间回收了，pos指向的地址失效

pos = p + _start;

}

iterator it = _finish - 1;

while (it >= pos)

{

*(it + 1) = *it;

it--;

}

*pos = val;

++_finish;

}

📖 4.erase

删除指定元素

iterator erase(iterator pos)

{

assert(pos >= _start);

assert(pos < _finish);

iterator it = pos + 1;

while (it <= _finish)

{

*(it - 1) = *it;

it++;

}

--_finish;

return pos;

}

📖5.swap

 调用std::swap()函数进行交换。

void swap(vector<T>& v)

{

std::swap(_start, v._start);

std::swap(_finish, v._finish);

std::swap(_end_of_storage, v._end_of_storage);

}

____________________

⭐感谢你的阅读，希望本文能够对你有所帮助。如果你喜欢我的内容，记得点赞关注收藏我的博客，我会继续分享更多的内容。⭐