文章目录

从零实现 C++ Vector前言1. 基本结构与初始化细分1.1 空构造函数的实现与测试实现代码：测试用例：输出：

1.2 带大小和默认值的构造函数实现代码：测试用例：输出：

1.3 拷贝构造函数实现代码：测试用例：输出：

1.4 赋值操作符的实现实现代码：测试用例：输出：

2. 容量管理的实现与测试2.1 `reserve`函数：动态扩容实现代码：测试用例：输出：

2.2 `resize`函数：改变大小实现代码：测试用例：输出：

3. 元素插入与删除3.1 `push_back`函数：向`vector`末尾插入元素3.1.1 需求分析实现思路实现代码：测试用例：输出：

3.2 `pop_back`函数：删除末尾元素3.2.1 需求分析实现思路实现代码：测试用例：输出：

3.3 `insert`函数：在指定位置插入元素3.3.1 需求分析实现思路实现代码：测试用例：输出：

3.4 `erase`函数：删除指定位置的元素3.4.1 需求分析实现思路实现代码：测试用例：输出：

4. `front`和`back`函数4.1 `front`函数：获取第一个元素4.1.1 需求分析实现代码：测试用例：输出：

4.2 `back`函数：获取最后一个元素4.2.1 需求分析实现代码：测试用例：输出：

5.1 `begin` 与 `end` 函数：迭代器的基本操作5.1.1 需求分析实现代码：测试用例：输出：

5.2 `swap` 函数：交换两个 `vector`5.2.1 需求分析实现代码：测试用例：输出：

5.3 赋值运算符重载：深拷贝 `vector`（现代写法）5.3.1 需求分析实现代码：现代写法说明测试用例：输出：

5.4 优点总结

写在最后

从零实现 C++ Vector

💬 欢迎讨论：学习过程中有问题吗？随时在评论区与我交流。你们的互动是我创作的动力！

👍 支持我：如果你觉得这篇文章对你有帮助，请点赞、收藏并分享给更多朋友吧！

🚀 一起成长：欢迎分享给更多对计算机视觉和图像处理感兴趣的小伙伴，让我们共同进步！

前言

接上篇【C++篇】解密 STL 动态之魂：全面掌握 C++ vector 的高效与优雅

在现代 C++ 编程中，容器类 vector 是不可或缺的数据结构。作为一个动态数组，它提供了高效的随机访问和动态内存管理。为了加深对 vector 的理解，本文将从零开始模拟实现一个 vector，详细解析其核心机制。我们不仅会展示基础的构造、拷贝、扩展和元素插入操作，还将采用现代 C++ 的最佳实践来优化代码，尤其是在异常安全和性能上。

通过从浅入深的分步骤实现与测试，希望让读者能够全面掌握 vector 的核心逻辑与细节。本教程不仅适合初学者，也适合想深入理解 C++ STL 背后实现的开发者。

1. 基本结构与初始化细分

1.1 空构造函数的实现与测试

实现一个空的<code>vector，不分配任何内存。测试是否创建了容量为0的vector。

实现代码：

namespace W { -- -->

template<class T>

class vector {

public:

typedef T* iterator;

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

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

size_t capacity() const { return _endOfStorage - _start; }

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

private:

iterator _start;

iterator _finish;

iterator _endOfStorage;

};

}

测试用例：

void TestEmptyVector() {

W::vector<int> v;

assert(v.size() == 0); // 验证大小

assert(v.capacity() == 0); // 验证容量

assert(v.empty()); // 验证是否为空

std::cout << "TestEmptyVector passed" << std::endl;

}

输出：

TestEmptyVector passed

1.2 带大小和默认值的构造函数

初始化一个给定大小的vector，并使用默认值填充。测试构造后大小、容量是否符合要求。

实现代码：

namespace W {

template<class T>

class vector {

public:

typedef T* iterator;

vector(size_t n, const T& value = T()) {

_start = new T[n];

_finish = _start + n;

_endOfStorage = _finish;

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

_start[i] = value; // 填充默认值

}

}

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

size_t capacity() const { return _endOfStorage - _start; }

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

T& operator[](size_t pos) { return _start[pos]; }

~vector()

{

if (_start)

{

delete[] _start;

_start = _finish = _endOfStorage = nullptr;

}

}

private:

iterator _start;

iterator _finish;

iterator _endOfStorage;

};

}

测试用例：

void TestInitVector() {

W::vector<int> v(5, 10);

assert(v.size() == 5); // 验证大小

assert(v.capacity() == 5); // 验证容量

assert(!v.empty()); // 验证非空

for (size_t i = 0; i < 5; ++i) {

assert(v[i] == 10); // 验证默认值

}

std::cout << "TestInitVector passed" << std::endl;

}

输出：

TestInitVector passed

1.3 拷贝构造函数

实现vector的拷贝构造函数。测试拷贝后的vector是否完全复制原来的内容和容量。

实现代码：

namespace W {

template<class T>

class vector {

public:

typedef T* iterator;

vector(const vector<T>& v) {

size_t n = v.size();

_start = new T[n];

_finish = _start + n;

_endOfStorage = _finish;

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

_start[i] = v._start[i]; // 复制数据

}

}

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

size_t capacity() const { return _endOfStorage - _start; }

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

T& operator[](size_t pos) { return _start[pos]; }

~vector()

{

if (_start)

{

delete[] _start;

_start = _finish = _endOfStorage = nullptr;

}

}

private:

iterator _start;

iterator _finish;

iterator _endOfStorage;

};

}

测试用例：

void TestCopyVector() {

W::vector<int> v1(5, 10);

W::vector<int> v2(v1);

assert(v2.size() == 5); // 验证大小

assert(v2.capacity() == 5); // 验证容量

for (size_t i = 0; i < 5; ++i) {

assert(v2[i] == 10); // 验证数据拷贝

}

std::cout << "TestCopyVector passed" << std::endl;

}

输出：

TestCopyVector passed

1.4 赋值操作符的实现

实现赋值操作符重载。测试两个vector赋值后，是否正确拷贝了内容和容量。

实现代码：

namespace W {

template<class T>

class vector {

public:

typedef T* iterator;

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

if (this != &v) {

delete[] _start; // 释放旧的空间

size_t n = v.size();

_start = new T[n];

_finish = _start + n;

_endOfStorage = _finish;

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

_start[i] = v._start[i]; // 复制数据

}

}

return *this;

}

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

size_t capacity() const { return _endOfStorage - _start; }

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

T& operator[](size_t pos) { return _start[pos]; }

~vector()

{

if (_start)

{

delete[] _start;

_start = _finish = _endOfStorage = nullptr;

}

}

private:

iterator _start;

iterator _finish;

iterator _endOfStorage;

};

}

测试用例：

void TestAssignVector() {

W::vector<int> v1(5, 10);

W::vector<int> v2 = v1; // 赋值操作

assert(v2.size() == 5); // 验证大小

assert(v2.capacity() == 5); // 验证容量

for (size_t i = 0; i < 5; ++i) {

assert(v2[i] == 10); // 验证数据拷贝

}

std::cout << "TestAssignVector passed" << std::endl;

}

输出：

TestAssignVector passed

---

2. 容量管理的实现与测试

2.1 reserve函数：动态扩容

实现reserve函数，测试在容量不足时是否能正确扩展。

实现代码：

namespace W {

template<class T>

class vector {

public:

void reserve(size_t n) {

if (n > capacity()) {

size_t oldSize = size();

T* tmp = new T[n];

for (size_t i = 0; i < oldSize; ++i) {

tmp[i] = _start[i];

}

delete[] _start;

_start = tmp;

_finish = _start + oldSize;

_endOfStorage = _start + n;

}

}

};

}

测试用例：

void TestReserveVector() {

W::vector<int> v(5, 10);

v.reserve(10); // 预留容量

assert(v.capacity() == 10); // 验证容量扩展

for (size_t i = 0; i < 5; ++i) {

assert(v[i] == 10); // 验证数据保持不变

}

std::cout << "TestReserveVector passed" << std::endl;

}

输出：

TestReserveVector passed

2.2 resize函数：改变大小

实现resize函数，测试增加或减少vector大小。

实现代码：

namespace W {

template<class T>

class vector {

public:

void resize(size_t n, const T& value = T()) {

if (n < size()) {

_finish = _start + n; // 缩小大小

} else {

reserve(n);

for (iterator it = _finish; it != _start + n; ++it)

{

*it = value; // 填充新值

}

_finish = _start + n;

}

}

};

}

测试用例：

void TestResizeVector() {

W::vector<int> v(5, 10);

v.resize(8, 20); // 扩展大小并填充新值

assert(v.size() == 8); // 验证扩展后大小

for (size_t i = 0; i < 5; ++i) {

assert(v[i] == 10); // 验证原值不变

}

for (size_t i = 5; i < 8; ++i) {

assert(v[i] == 20); // 验证新值

}

std::cout << "TestResizeVector passed" << std::endl;

}

输出：

TestResizeVector passed

---

3. 元素插入与删除

3.1 push_back函数：向vector末尾插入元素

3.1.1 需求分析

push_back是vector中最常用的操作之一。需要确保：

当空间不足时，进行自动扩容。插入的元素位于现有元素的末尾。

实现思路

检查容量是否足够，若不足则扩容（通常容量加倍）。将新元素插入到当前末尾。更新_finish指针，指向新的末尾。

实现代码：

namespace W {

template<class T>

class vector {

public:

void push_back(const T& x) {

// 如果空间不足，扩展容量为当前容量的两倍

if (_finish == _endOfStorage) {

size_t newCapacity = capacity() == 0 ? 1 : capacity() * 2;

reserve(newCapacity);

}

// 在末尾插入新元素

*_finish = x;

++_finish;

}

private:

T* _start;

T* _finish;

T* _endOfStorage;

};

}

测试用例：

void TestPushBackVector() {

W::vector<int> v;

v.push_back(1);

v.push_back(2);

v.push_back(3);

assert(v.size() == 3); // 验证插入后的大小

assert(v.capacity() >= 3); // 验证容量是否自动扩展

assert(v[0] == 1 && v[1] == 2 && v[2] == 3); // 验证插入的元素是否正确

std::cout << "TestPushBackVector passed" << std::endl;

}

输出：

TestPushBackVector passed

3.2 pop_back函数：删除末尾元素

3.2.1 需求分析

pop_back用于删除vector中的最后一个元素。需要确保：

删除后更新_finish指针。元素已经从逻辑上被移除，但空间不回收。

实现思路

将_finish指针向前移动一位，即删除最后一个元素。不释放空间。

实现代码：

namespace W {

template<class T>

class vector {

public:

void pop_back() {

assert(_finish != _start); // 确保vector非空

--_finish; // 逻辑删除最后一个元素

}

private:

T* _start;

T* _finish;

T* _endOfStorage;

};

}

测试用例：

void TestPopBackVector() {

W::vector<int> v;

v.push_back(1);

v.push_back(2);

v.push_back(3);

v.pop_back();

assert(v.size() == 2); // 验证删除后的大小

assert(v[0] == 1 && v[1] == 2); // 验证剩余元素是否正确

std::cout << "TestPopBackVector passed" << std::endl;

}

输出：

TestPopBackVector passed

3.3 insert函数：在指定位置插入元素

3.3.1 需求分析

insert用于在vector的任意位置插入元素。需要确保：

插入位置之后的元素向后移动。插入前检查容量是否足够，必要时扩容。

实现思路

检查容量是否足够，不足时扩容。将插入位置及其后的元素整体向后移动。将新元素插入指定位置。更新_finish指针。

实现代码：

namespace W {

template<class T>

class vector {

public:

T* insert(T* pos, const T& value) {

assert(pos >= _start && pos <= _finish); // 确保pos是有效指针

// 检查空间是否足够

if (_finish == _endOfStorage) {

size_t newCapacity = capacity() == 0 ? 1 : capacity() * 2;

size_t offset = pos - _start; // 记录插入位置

reserve(newCapacity); // 扩容

pos = _start + offset; // 更新插入位置

}

// 将插入位置之后的元素整体向后移动

for (T* it = _finish; it > pos; --it) {

*it = *(it - 1);

}

// 插入新元素

*pos = value;

++_finish;

return pos;

}

private:

T* _start;

T* _finish;

T* _endOfStorage;

};

}

测试用例：

void TestInsertVector() {

W::vector<int> v;

v.push_back(1);

v.push_back(2);

v.push_back(4);

v.insert(v.begin() + 2, 3); // 在第2个位置插入3

assert(v.size() == 4); // 验证插入后的大小

assert(v[0] == 1 && v[1] == 2 && v[2] == 3 && v[3] == 4); // 验证插入的元素是否正确

std::cout << "TestInsertVector passed" << std::endl;

}

输出：

TestInsertVector passed

3.4 erase函数：删除指定位置的元素

3.4.1 需求分析

erase用于删除vector中的某个位置的元素。需要确保：

删除后，删除位置之后的元素向前移动。删除后更新_finish指针。

实现思路

将erase位置之后的元素向前移动一位。更新_finish指针。

实现代码：

namespace W {

template<class T>

class vector {

public:

T* erase(T* pos) {

assert(pos >= _start && pos < _finish); // 确保pos是有效指针

// 将pos之后的元素向前移动

for (T* it = pos; it < _finish - 1; ++it) {

*it = *(it + 1);

}

--_finish; // 更新_finish指针

return pos;

}

private:

T* _start;

T* _finish;

T* _endOfStorage;

};

}

测试用例：

void TestEraseVector() {

W::vector<int> v;

v.push_back(1);

v.push_back(2);

v.push_back(3);

v.push_back(4);

v.erase(v.begin() + 2); // 删除第2个元素

assert(v.size() == 3); // 验证删除后的大小

assert(v[0] == 1 && v[1] == 2 && v[2] == 4); // 验证删除后的元素顺序

std::cout << "TestEraseVector passed" << std::endl;

}

输出：

TestEraseVector passed

---

4. front和back函数

4.1 front函数：获取第一个元素

4.1.1 需求分析

front函数返回vector的第一个元素。需要确保：

当vector非空时，返回正确的第一个元素。

实现代码：

namespace W {

template<class T>

class vector {

public:

T& front() {

assert(!empty()); // 确保vector非空

return *_start; // 返回第一个元素

}

private:

T* _start;

T* _finish;

T* _endOfStorage;

};

}

测试用例：

void TestFrontVector() {

W::vector<int> v;

v.push_back(10);

assert(v.front() == 10); // 验证front

v.push_back(20);

assert(v.front() == 10); // 验证front不变

std::cout << "TestFrontVector passed" << std::endl;

}

输出：

TestFrontVector passed

---

4.2 back函数：获取最后一个元素

4.2.1 需求分析

back函数返回vector的最后一个元素。需要确保：

当vector非空时，返回正确的最后一个元素。

实现代码：

namespace W {

template<class T>

class vector {

public:

T& back() {

assert(!empty()); // 确保vector非空

return *(_finish - 1); // 返回最后一个元素

}

private:

T* _start;

T* _finish;

T* _endOfStorage;

};

}

测试用例：

void TestBackVector() {

W::vector<int> v;

v.push_back(10);

assert(v.back() == 10); // 验证back

v.push_back(20);

assert(v.back() == 20); // 验证back变化

std::cout << "TestBackVector passed" << std::endl;

}

输出：

TestBackVector passed

---

5.1 begin 与 end 函数：迭代器的基本操作

5.1.1 需求分析

begin 函数返回指向 vector 起始位置的迭代器（即指向第一个元素）。end 函数返回指向 vector 末尾的迭代器（即指向最后一个元素的下一个位置）。两者结合可以用于遍历 vector 中的元素。

实现代码：

namespace W {

template<class T>

class vector {

public:

typedef T* iterator; // 使用原生指针作为迭代器

iterator begin() {

return _start;

}

iterator end() {

return _finish;

}

private:

T* _start;

T* _finish;

T* _endOfStorage;

};

}

测试用例：

void TestIteratorVector() {

W::vector<int> v;

v.push_back(10);

v.push_back(20);

v.push_back(30);

// 使用迭代器遍历 vector

for (W::vector<int>::iterator it = v.begin(); it != v.end(); ++it) {

std::cout << *it << " ";

}

std::cout << std::endl;

std::cout << "TestIteratorVector passed" << std::endl;

}

输出：

10 20 30

TestIteratorVector passed

---

5.2 swap 函数：交换两个 vector

5.2.1 需求分析

swap 函数用于交换两个 vector 的内容，包括它们的起始指针、结束指针和容量指针。swap 函数是常用的优化操作，特别是在实现移动语义时能大大提高效率。

实现代码：

namespace W {

template<class T>

class vector {

public:

void swap(vector<T>& v) {

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

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

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

}

private:

T* _start;

T* _finish;

T* _endOfStorage;

};

}

测试用例：

void TestSwapVector() {

W::vector<int> v1;

W::vector<int> v2;

v1.push_back(1);

v1.push_back(2);

v2.push_back(3);

v2.push_back(4);

v1.swap(v2);

// 验证 v1 和 v2 交换后内容是否正确

for (auto e : v1) {

std::cout << e << " ";

}

std::cout << std::endl;

for (auto e : v2) {

std::cout << e << " ";

}

std::cout << std::endl;

std::cout << "TestSwapVector passed" << std::endl;

}

输出：

3 4

1 2

TestSwapVector passed

---

5.3 赋值运算符重载：深拷贝 vector（现代写法）

5.3.1 需求分析

拷贝构造函数的任务是创建一个全新的 vector，并确保与原 vector 独立，使用深拷贝拷贝元素。赋值运算符重载代码大致也是相同的，那有没有办法简化呢？为了使用现代 C++ 的最佳实践，我们可以采用 拷贝并交换（Copy and Swap） 技术，这种技术可以减少重复代码并提高异常安全性。使用 传值（pass-by-value）参数，配合 swap 函数，使代码简洁高效，且异常安全。

实现代码：

namespace W {

template<class T>

class vector {

public:

//这里可以服用reserve和push_back函数了

vector(const vector<T>& v)

: _start(nullptr), _finish(nullptr), _endOfStorage(nullptr)

{

reserve(v.size()); // 分配所需空间

for (const T& elem : v) {

push_back(elem); // 拷贝每个元素

}

}

// 赋值操作符，使用拷贝并交换技术

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

swap(v); // 调用 swap 函数交换内容

return *this;

}

// swap 函数

void swap(vector<T>& v) {

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

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

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

}

// 其他成员函数同之前实现...

private:

T* _start;

T* _finish;

T* _endOfStorage;

};

}

现代写法说明

传值参数：通过传递 vector<T> 的值作为参数，创建一个临时对象 v。调用拷贝构造函数时自动执行拷贝，然后在赋值操作中与现有对象交换内容。传值是安全的，避免了手动内存管理问题。swap：通过交换数据成员 _start、_finish 和 _endOfStorage，避免手动内存释放，简化代码逻辑。交换后的临时对象 v 离开作用域时自动销毁，保证资源释放。

测试用例：

void TestCopyAndAssignVector() {

// 测试拷贝构造函数

W::vector<int> v1;

v1.push_back(1);

v1.push_back(2);

v1.push_back(3);

W::vector<int> v2(v1); // 使用拷贝构造函数

for (size_t i = 0; i < v2.size(); ++i) {

assert(v2[i] == v1[i]); // 验证每个元素是否相同

}

// 测试赋值操作符

W::vector<int> v3;

v3 = v1; // 使用赋值操作符

for (size_t i = 0; i < v3.size(); ++i) {

assert(v3[i] == v1[i]); // 验证每个元素是否相同

}

std::cout << "TestCopyAndAssignVector passed" << std::endl;

}

输出：

TestCopyAndAssignVector passed

5.4 优点总结

简化代码：通过传值和 swap，避免了重复的深拷贝代码。异常安全性：无论是在构造过程中出现异常，还是在赋值操作中，资源都可以安全地释放，避免内存泄漏。效率：现代 C++ 的传值优化会确保性能不会显著下降，并且在支持移动语义的场景下，效率非常高。

---

写在最后

至此，我们完成了 vector 的从零实现，并深入分析了其中的每个细节，包括动态内存管理、迭代器操作、容量管理、拷贝构造与赋值重载等。通过这次实现，我们可以更清晰地理解标准库中的 vector 是如何通过高效的内存分配、深拷贝与异常安全机制来确保性能和安全的。

在实际开发中，理解这些细节不仅能够帮助我们更好地使用 vector，也为日后设计自己的容器类打下了坚实的基础。希望通过这个过程，读者能够更深刻地感受到 C++ 的强大与精妙。

💬 欢迎讨论：本文对 vector 容器的实现进行了细致的分析与讲解，如果你在学习过程中遇到问题或有任何建议，欢迎在评论区与我交流。期待与你一起探讨更多相关知识！

👍 支持一下：如果你觉得这篇文章对你有帮助，请点赞、收藏并分享给更多朋友！你们的支持是我创作的最大动力！

---

以上就是关于【C++篇】从零实现 C++ Vector：深度剖析 STL 的核心机制与优化的内容啦，然后各位大佬有什么问题欢迎在评论区指正，或者私信我也是可以的啦，您的支持是我创作的最大动力！❤️