当前位置：首页 > article >正文

【C++篇】从零实现 C++ Vector：深度剖析 STL 的核心机制与优化

article 2024/9/27 12:03:07

文章目录

从零实现 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 空构造函数的实现与测试

实现一个空的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 的核心机制与优化的内容啦，然后各位大佬有什么问题欢迎在评论区指正，或者私信我也是可以的啦，您的支持是我创作的最大动力！❤️

在这里插入图片描述

查看全文

http://www.kler.cn/news/321719.html

SpringCloud源码：客户端分析（二）- 客户端源码分析

ArduSub程序学习（11）--EKF实现逻辑①

[AI问答] Auto-sklearn和Auto-Keras对比

Ubuntu20.04.6 环境下docker设置proxy

SpringBoot-Starter2.7.3自动装配Redisson升级版本运行时的问题

自动驾驶技术：人工智能驾驶的未来

tauri程序加载本地图片或者文件在前端页面展示

ModStartCMS v8.9.0 图片上传优化，富文本编辑器修复

Spring Boot 实战：使用观察者模式实现实时库存管理

localectl 命令：系统语言、键盘布局和区域设置

CORE 中间件、wwwroot

C++11中引入的thread

正向科技|格雷母线定位系统的设备接线安装示范

脚手架是什么?详细版＋通俗易懂版!!!!!!

DNS与host文件

职业技能大赛-自动化测试笔记（PageObject）分享-4

如何将自定义支付网关与 WooCommerce Checkout 区块集成

HarmonyOS---权限和http/Axios网络请求

处理 VA02修改行项目计划行（SCHEDULE LINES ）报错：不可能确定一个消耗帐户

count(1)、count(*) 与 count(列名) 的区别

zabbix“专家坐诊”第257期问答

19、网络安全合规复盘

C++ | Leetcode C++题解之第440题字典序的第K小数字

【HDP】zookeeper未授权漏洞修复

C语言课程设计题目四：实验设备管理系统设计

Flutter鸿蒙化环境配置（windows）

网站设计中安全方面都需要有哪些考虑

【opencv】——为arm平台交叉编译

Apache Iceberg 数据类型参考表

URL中 / 作为字符串，而不是路径。

文章目录

从零实现 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 需求分析

实现代码：

现代写法说明

测试用例：

2.1 `reserve`函数：动态扩容

2.2 `resize`函数：改变大小

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

3.2 `pop_back`函数：删除末尾元素

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

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

4. `front`和`back`函数

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

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

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

5.2 `swap` 函数：交换两个 `vector`

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