《 C++ 容器全景指南：二》如何实现标准库般强大的 C++ Vector？：从动态扩容到移动语义到迭代器全覆盖

置顶 Lenyiin

已于 2024-09-11 01:41:30 修改

阅读量1.6k

点赞数 53

分类专栏：技术指南文章标签： c++ 开发语言 stl

于 2024-09-07 18:13:11 首次发布

本文链接：https://blog.csdn.net/mmlhbjk/article/details/141999922

版权

技术指南专栏收录该内容

7 篇文章 0 订阅

订阅专栏

在 C++ 中，std::vector 是最常用的动态数组容器。它具有高效的内存管理、动态扩容、随机访问等特点。在这篇博客中，我们将从零开始，实现一个功能强大、灵活、并且具有高性能的 Vector 类，具备 std::vector 的大部分功能，包括动态扩容、迭代器、模板支持、随机访问等，尽可能模仿 C++ 标准库中的 std::vector。本文将详细解释每个功能模块，并附加详细的解释和代码注释，以帮助初学者深入理解容器的内部工作原理和实现逻辑。

一、设计目标和规划

在设计一个 Vector 类时，我们需要考虑以下功能：

动态扩容：支持自动增长容量，避免内存溢出。
模板支持：容器应该能够存储任意类型的数据。
迭代器：提供正向和反向迭代器，使得容器可以通过迭代器进行遍历。
边界检查：防止访问越界，提高容器的健壮性。
性能优化：通过使用移动语义和完美转发提升性能，减少不必要的拷贝。
异常安全：确保在操作失败时不出现内存泄漏等问题。

让我们从基础的 Vector 实现开始，逐步添加这些功能。

注意：这篇博客所涉及的所有代码可以从我的代码仓库获得：https://git.lenyiin.com/Lenyiin/Vector

二、Vector 容器的基础实现

首先，我们需要定义一个 Vector 类来管理内部的数据。这个类包含动态分配的数组，维护当前元素数量和容量，并且提供基础的操作方法，比如插入、访问等。

2.1、Vector 容器的成员的设计与初始化

首先，我们定义一个 Vector 类的基础框架，它需要包括以下几个核心成员变量：

_start：指向存储实际元素的数组首地址。
_finish：指向存储实际元素的数组下一个可存储的地址。
_endofstorage：当前已分配的内存空间的末地址。

template<typename T>
class Vector {
public:
    // 默认构造
    Vector()	// 构造函数，初始化为空
        : _start(nullptr), _finish(nullptr), _endofstorage(nullptr)
    {
    }

    // 析构函数
    ~Vector()	// 析构函数，释放动态内存
    {
        if (_start)
        {
            delete[] _start;
        }
        _start = _finish = _endofstorage = nullptr;
    }

private:
	T* _start;
	T* _finish;
	T* _endofstorage;
};

详细解释：

构造函数：在构造函数中，初始状态下 _start 为空，_finish 为空，_endofstorage 也为空。
析构函数：确保当 Vector 对象销毁时释放分配的内存。

2.2、获取容器状态

为了更好的了解容器状态，还需要添加获取容器状态的接口

// 获取当前元素有效个数
size_t size() const
{
	return _finish - _start;
}

// 获取当前容器容量
size_t capacity() const
{
	return _endofstorage - _start;
}

详细解释：

size() 和 capacity() ：分别返回当前的元素个数和容器容量，帮助用户了解容器的状态。

2.3、拷贝与赋值

在 C++ 中，拷贝一个对象时，默认的拷贝行为是浅拷贝，即仅复制对象的指针或引用。这对管理动态内存的类而言，可能会导致问题，例如多个对象指向同一块内存，导致重复释放或修改冲突。为避免这些问题，我们需要实现深拷贝。

2.3.1、拷贝构造函数

拷贝构造函数用于创建一个新对象，该对象是通过复制另一个现有对象生成的。对于 Vector 类，我们需要确保在拷贝时，新对象有自己独立的内存副本。

// 拷贝构造
Vector(const Vector<T>& v)
{
	_start = new T[v.capacity()];
	_finish = _start;
	_endofstorage = _start + v.capacity();

	for (size_t i = 0; i < v.size(); i++)
	{
		*_finish = v[i];
		++_finish;
	}
}

详细解释：

深拷贝：通过分配新内存来创建新对象的独立副本，而不是简单地复制指针。这样，两个 Vector 对象可以独立管理各自的内存，避免潜在的内存管理冲突。
值得注意的是 *_finish = v[i]; 并不是浅拷贝，而是调用了 operator= 赋值运算，是深拷贝。

进阶：

也可以复用插入函数 push_back

Vector(const Vector<T>& v)
	: _start(nullptr), _finish(nullptr), _endofstorage(nullptr)
{
	reserve(v.capacity());
	for (const auto& e : v)
	{
		push_back(e);
	}
}

2.3.2、赋值运算

赋值运算符用于将一个对象的内容复制到另一个已经存在的对象中。为了避免自赋值和内存泄漏，我们需要在实现赋值运算符时特别小心。

// 赋值运算符重载
Vector<T>& operator=(const Vector<T>& v)
{
	if (this != &v)
	{
		delete[] _start;
		_start = new T[v.capacity()];

		//memcpy(_start, v._start, sizeof(T) * v.size());	按字节拷贝，浅拷贝
		for (size_t i = 0; i < v.size(); i++)
		{
			_start[i] = v._start[i];	// 调用的是 operator= 深拷贝
		}

		_finish = _start + v.size();
		_endofstorage = _start + v.capacity();
	}
	return *this;
}

详细解释：

自赋值检查：在赋值运算符实现中，首先检查是否为自赋值，即 this 指针是否与 v 相同。如果是自赋值，则无需进行任何操作，直接返回当前对象。
内存管理：在分配新内存之前，记得释放当前对象所持有的旧内存，防止内存泄漏。
深拷贝：与拷贝构造函数类似，通过分配新内存来存储字符串的副本，确保两个对象独立管理各自的内存。

进阶：

也可以复用拷贝构造函数

// 进阶写法
void swap(Vector<T>& v)
{
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_endofstorage, v._endofstorage);
}

Vector<T>& operator=(Vector<T> v)
{
	swap(v);
	return *this;
}

2.4、移动语义

C++11 引入的移动语义（Move Semantics）是提升性能的一个重要机制，允许在一定条件下避免不必要的深拷贝，从而提高程序性能。移动构造函数和移动赋值运算符是移动语义的核心。

2.4.1、移动构造函数

移动构造函数用于将资源从一个对象 “搬迁” 到另一个对象，而不是复制。这在避免不必要的内存分配和拷贝时非常有用。

// 移动构造函数
Vector(Vector&& v) noexcept 
	: _start(v._start), _finish(v._finish), _endofstorage(v._endofstorage)
{
    v._start = nullptr;
    v._finish = nullptr;
    v._endofstorage = nullptr;
}

详细解释：

移动构造函数：将 v 对象的资源直接转移到当前对象（通过简单地复制指针），然后将 v 的 _start, _finish, _endofstorage 重置为默认状态。通过窃取资源（即指针和相关的大小和容量），避免昂贵的拷贝操作。
noexcept：标记为 noexcept 的函数表示在其内部不会抛出异常。这对移动构造函数尤其重要，因为这确保了在某些情况下（如在标准容器中使用）不会因为抛出异常而触发回滚操作。

2.4.2、移动赋值运算

移动赋值运算用于将资源从一个对象 “搬迁” 到另一个已存在的对象中。

// 移动赋值运算符
Vector& operator=(Vector&& v) noexcept 
{
    if (this != &v) {
        delete[] _start;
        _start = v._start;
        _finish = v._start + v.size();
        _endofstorage = v._start + v.capacity();
        v._start = nullptr;
        v._finish = nullptr;
        v._endofstorage = nullptr;
    }
    return *this;
}

详细解释：

资源搬迁：通过简单地复制指针，将 v 对象的资源转移到当前对象中，并释放当前对象的旧资源。然后，将 v 对象重置为默认状态，避免两个对象共享同一块内存。
自赋值检查：和赋值运算符一样，首先检查是否为自赋值。

2.5、下标运算符重载

为了支持像数组一样通过下标访问 Vector 中的元素，我们需要重载 operator[]。

T& operator[](size_t index) 
{
    if (index >= size()) 
    {
    	throw std::out_of_range("Index out of range");
    }
    return _start[index];
}

const T& operator[](size_t index) const 
{
    if (index >= size()) 
    {
    	throw std::out_of_range("Index out of range");
    }
    return _start[index];
}

详细解释：

operator[] 重载：支持通过下标访问元素，并且提供 const 版本，确保容器在只读情况下的访问安全性。
越界检查：若访问的下标超出范围，抛出 std::out_of_range 异常，避免非法访问。

三、进阶功能

3.1、动态扩容

C++ 中 std::vector 最强大的功能之一是动态扩容。当容器中的元素超过当前容量时，它会自动分配更大的内存，并将已有的数据复制到新的内存区域。为此，我们实现一个 reserve 和 resize 函数，用于在需要时扩容。

void reserve(size_t newcapacity)
{
	if (newcapacity > capacity())
	{
		T* tmp = new T[newcapacity];	// 分配新内存
		size_t len = size();
		if (_start)
		{
			for (size_t i = 0; i < len; i++)
			{
				tmp[i] = std::move(_start[i]);	// 移动已有数据
			}
			delete[] _start;	// 释放旧的内存
		}
		// 更新指针
		_start = tmp;
		_finish = tmp + len;
		_endofstorage = tmp + newcapacity;
	}
}

// resize 不仅会开空间，还会初始化
void resize(size_t newsize, const T& val = T())
{
	if (newsize < size())
	{
		_finish = _start + newsize;
	}
	else
	{
		if (newsize > capacity())
		{
			reserve(newsize);
		}

		while (_finish < _start + newsize)
		{
			*_finish = val;
			++_finish;
		}
	}
}

详细解释：

reserve 函数：用于重新分配内存，当当前容量不足时，分配一个新的数组并将原有数据复制过去。
resize 函数：用于重置有效数据大小，重置的时候还能进行初始化。当当前容量不足时，分配一个新的数组并将原有数据复制过去。
std::move：我们使用 std::move 来避免不必要的深度拷贝，提升性能。

3.2、插入元素 push_back

向 Vector 中添加元素时，需要判断是否需要扩容。如果当前元素数量已经等于容量，就调用 reserve 函数扩容。

void push_back(const T& data)
{
	if (_finish == _endofstorage)	// 若容量不足，则扩容
	{
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
	}

	*_finish = data;	// 插入新元素
	++_finish;
}

详细解释：

push_back：当 _finish == _endofstorage 时，调用 reserve 扩容，然后插入新元素。
reserve 容量扩充策略：当容器为空时，初次扩容至 4，随后每次扩容翻倍。

3.3、增加迭代器支持

3.3.1、基础迭代器

std::vector 提供了强大的迭代器支持，允许用户使用 for-each 循环来遍历容器。我们可以通过自定义迭代器类，来实现这一功能。

typedef T* iterator;

iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

详细解释：

iterator ：封装了指针，使用默认解引用操作符 * 和递增操作符 ++，支持 for 循环遍历。
begin 与 end 函数：返回指向容器起始和末尾的迭代器，类似 std::vector::begin 和 std::vector::end。

3.3.2、常量迭代器

在一些场景中，我们希望容器只能读取而不能修改数据。为此，我们可以实现 const_iterator 来保证只读遍历。

typedef const T* const_iterator;

const_iterator begin() const
{
	return _start;
}

const_iterator end() const
{
	return _finish;
}

详细解释：

const_iterator：与普通迭代器不同的是，它返回 const T*，确保数据不能被修改。
begin 与 end 函数：返回常量迭代器，支持只读遍历。

3.4、删除元素与清空操作

为了使我们的 Vector 容器更加完整，我们还需要支持删除元素和清空容器的操作。

void pop_back()
{
	assert(_start < _finish);

	--_finish;
}

void clear()
{
	_finish = _start;
}

详细解释：

pop_back 函数：移除最后一个元素，减小 _finish，但不改变已分配的容量。
clear 函数：将 _finish 设为 _start，保留容量但清空元素。

四、扩展功能

4.1、插入与删除

标准库的 std::vector 还支持在中间位置插入和删除元素。我们可以通过移动元素来实现这些功能。

iterator insert(iterator pos, const T& data)
{
	assert(pos <= _finish);

	if (_finish == _endofstorage)
	{
		size_t len = pos - _start;
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);

		// 如果增容，原来的pos就失效了，这里需要重新计算位置
		pos = _start + len;
	}

	iterator end = _finish - 1;
	while (end >= pos)
	{
		*(end + 1) = *end;
		--end;
	}

	*pos = data;
	++_finish;

	return pos;
}

iterator erase(iterator pos)
{
	assert(pos < _finish);

	iterator it = pos;
	while (it < _finish)
	{
		*it = *(it + 1);
		++it;
	}
	--_finish;

	return pos;
}

详细解释：

insert 函数：在指定位置插入元素，插入后，所有后续元素向后移动一位。
erase 函数：删除指定位置的元素，删除后，所有后续元素向前移动一位。

4.2、模板支持

我们通过使用模板，使 Vector 能够存储任意类型的元素。C++ 的模板机制允许我们实现对不同数据类型的支持，而无需为每种类型编写单独的代码。在上面的代码中，我们已经通过 template<typename T> 实现了模板支持。只需传递类型参数，即可为任何类型创建 Vector 容器。

Vector<int> intVector;
Vector<std::string> stringVector;

4.3、使用移动语义与完美转发

在 C++11 中引入的移动语义和完美转发是提升性能的重要工具，特别是在处理对象拷贝时。为了避免不必要的深度拷贝，我们可以使用 std::move 和 std::forward。

void push_back(T&& data) 	// 移动版本
{ 
    if (_finish == _endofstorage) 
    {
    	reserve(capacity() == 0 ? 4 : capacity() * 2);
    }
    *_finish = std::move(data); // 使用 move 语义
    ++_finish;
}

详细解释：

push_back (移动版本)：允许直接移动元素，而不是进行拷贝操作，大大提升了效率。

4.4、完善边界检查与防止越界访问

为了使容器更加安全，我们可以在访问元素时进行边界检查，防止越界访问导致程序崩溃。

T& at(size_t index) 
{
    if (index >= size()) {
    	throw std::out_of_range("Index out of bounds");
    }
    return _start[index];
}

详细解释：

at 函数：提供安全的数组访问方法，超出范围时抛出 std::out_of_range 异常。

五、完整实现代码和测试

5.1、Vector.hpp

新建头文件 Vector.hpp

#pragma once

#include <iostream>
#include <assert.h>

using namespace std;

namespace Lenyiin
{
	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
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

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

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

		// 默认构造
		Vector()
			: _start(nullptr), _finish(nullptr), _endofstorage(nullptr)
		{
		}

		// 拷贝构造
		//Vector(const Vector<T>& v)
		//{
		//	_start = new T[v.capacity()];
		//	_finish = _start;
		//	_endofstorage = _start + v.capacity();

		//	for (size_t i = 0; i < v.size(); i++)
		//	{
		//		*_finish = v[i];
		//		++_finish;
		//	}
		//}

		// 进阶写法
		Vector(const Vector<T>& v)
			: _start(nullptr), _finish(nullptr), _endofstorage(nullptr)
		{
			reserve(v.capacity());
			for (const auto& e : v)
			{
				push_back(e);
			}
		}

		// 赋值运算符重载
		//Vector<T>& operator=(const Vector<T>& v)
		//{
		//	if (this != &v)
		//	{
		//		delete[] _start;
		//		_start = new T[v.capacity()];

		//		//memcpy(_start, v._start, sizeof(T) * v.size());	按字节拷贝，浅拷贝
		//		for (size_t i = 0; i < v.size(); i++)
		//		{
		//			_start[i] = v._start[i];	// 调用的是 operator= 深拷贝
		//		}

		//		_finish = _start + v.size();
		//		_endofstorage = _start + v.capacity();
		//	}
		//	return *this;
		//}

		// 进阶写法
		void swap(Vector<T>& v)	// 自己写的swap是浅拷贝，代价小
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

		Vector<T>& operator=(Vector<T> v)
		{
			swap(v);	// 库里面的swap是深拷贝，代价极大
			return *this;
		}

		// 移动构造函数
		Vector(Vector&& v) noexcept
			: _start(v._start), _finish(v._finish), _endofstorage(v._endofstorage)
		{
			v._start = nullptr;
			v._finish = nullptr;
			v._endofstorage = nullptr;
		}

		// 移动赋值运算符
		Vector& operator=(Vector&& v) noexcept
		{
			if (this != &v) {
				delete[] _start;
				_start = v._start;
				_finish = v._start + v.size();
				_endofstorage = v._start + v.capacity();
				v._start = nullptr;
				v._finish = nullptr;
				v._endofstorage = nullptr;
			}
			return *this;
		}

		// 析构函数
		~Vector()
		{
			if (_start)
			{
				delete[] _start;
			}
			_start = _finish = _endofstorage = nullptr;
		}

		// 下标运算符重载
		T& operator[](size_t index)
		{
			if (index >= size())
			{
				throw std::out_of_range("Index out of range");
			}
			return _start[index];
		}

		const T& operator[](size_t index) const
		{
			if (index >= size())
			{
				throw std::out_of_range("Index out of range");
			}
			return _start[index];
		}

		// 动态扩容
		void reserve(size_t newcapacity)
		{
			if (newcapacity > capacity())
			{
				T* tmp = new T[newcapacity];	// 分配新内存
				size_t len = size();
				if (_start)
				{
					for (size_t i = 0; i < len; i++)
					{
						tmp[i] = std::move(_start[i]);	// 移动已有数据
					}
					delete[] _start;	// 释放旧的内存
				}
				// 更新指针
				_start = tmp;
				_finish = tmp + len;
				_endofstorage = tmp + newcapacity;
			}
		}

		// resize 不仅会开空间，还会初始化
		void resize(size_t newsize, const T& val = T())
		{
			if (newsize < size())
			{
				_finish = _start + newsize;
			}
			else
			{
				if (newsize > capacity())
				{
					reserve(newsize);
				}

				while (_finish < _start + newsize)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

		void push_back(const T& data)
		{
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}

			*_finish = data;
			++_finish;
		}

		// 移动版本
		void push_back(T&& data)
		{
			if (_finish == _endofstorage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}
			*_finish = std::move(data); // 使用 move 语义
			++_finish;
		}

		// 更安全的访问方式
		T& at(size_t index)
		{
			if (index >= size()) {
				throw std::out_of_range("Index out of bounds");
			}
			return _start[index];
		}

		void pop_back()
		{
			assert(_start < _finish);

			--_finish;
		}

		void clear()
		{
			_finish = _start;
		}

		iterator insert(iterator pos, const T& data)
		{
			assert(pos <= _finish);

			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);

				// 如果增容，原来的pos就失效了，这里需要重新计算位置
				pos = _start + len;
			}

			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}

			*pos = data;
			++_finish;

			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos < _finish);

			iterator it = pos;
			while (it < _finish)
			{
				*it = *(it + 1);
				++it;
			}
			--_finish;

			return pos;
		}

	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};
}

5.2、Vector.cpp

新建测试文件 Vector.cpp

#include "Vector.hpp"
#include <string>

using namespace Lenyiin;

void print_Vector(const Vector<int>& v)
{
    Vector<int>::const_iterator it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;
}

// Vector 容器遍历
void test1()
{
	Vector<int> v;

	// 插入
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);

    // 查看容量
    cout << v.size() << endl;
    cout << v.capacity() << endl << endl;;

    // 1. 下标运算符 [] 遍历
    cout << "1. 下标运算符 [] 遍历 \t\t";
    for (size_t i = 0; i < v.size(); i++)
    {
        cout << v[i] << " ";
    }
    cout << endl;

    // 2. 迭代器遍历
    cout << "2. 迭代器遍历 \t\t\t";
    Vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    // 3. const_iterator 迭代器遍历
    cout << "3. const_iterator 迭代器遍历 \t";
    print_Vector(v);

    // 4. 范围 for 遍历
    cout << "4. 范围 for 遍历 \t\t";
    for (auto& e : v)
    {
        cout << e << " ";
    }
    cout << endl;

    // 4. 范围 for 遍历 const
    cout << "5. 范围 for 遍历 const \t\t";
    for (const auto& e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}

void test2()
{
    Vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);
    v.push_back(6);
    print_Vector(v);
    cout << v.size() << endl;
    cout << v.capacity() << endl << endl;;

    // 随即插入
    v.insert(v.begin(), 0);
    print_Vector(v);

    // 删除所有偶数
    Vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        if (*it % 2 == 0)
        {
            it = v.erase(it);
        }
        else
        {
            it++;
        }
    }
    print_Vector(v);
}

void test3()
{
    Vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);
    v.push_back(6);
    v.push_back(7);

    print_Vector(v);
    cout << v.size() << endl;
    cout << v.capacity() << endl << endl;;

    // resize
    v.resize(4);
    print_Vector(v);
    cout << v.size() << endl;
    cout << v.capacity() << endl << endl;;

    v.resize(8);
    print_Vector(v);
    cout << v.size() << endl;
    cout << v.capacity() << endl << endl;;

    v.resize(15);
    print_Vector(v);
    cout << v.size() << endl;
    cout << v.capacity() << endl << endl;;

    // 清除
    v.clear();
    print_Vector(v);
    cout << v.size() << endl;
    cout << v.capacity() << endl << endl;;

    // reserve
    v.reserve(20);
    print_Vector(v);
    cout << v.size() << endl;
    cout << v.capacity() << endl << endl;;
}

void test4()
{
    // 默认构造
    Vector<int> v1;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);
    v1.push_back(5);
    v1.push_back(6);
    v1.push_back(7);
    print_Vector(v1);

    // 拷贝构造
    Vector<int> v2(v1);
    print_Vector(v2);

    Vector<int> v3;
    v3.push_back(10);
    v3.push_back(20);
    v3.push_back(30);
    v3.push_back(40);

    // 赋值
    v1 = v3;
    print_Vector(v1);
    print_Vector(v3);
}

void test5()
{
    // 模板
    Vector<string> v;
    v.push_back("111");
    v.push_back("222");
    v.push_back("333");
    v.push_back("444");

    for (auto e : v)
    {
        cout << e << " ";
    }
    cout << endl;
}

int main()
{
    //test1();
    //test2();
    //test3();
    test4();
    //test5();

    return 0;
}

六、总结

通过这篇博客，我们从最基础的存储与管理机制开始，逐步构建了一个强大且灵活的 Vector 容器，具备动态扩容、模板支持、迭代器、常量迭代器、移动语义、边界检查等高级功能，能够媲美 std::vector。在这一过程中，我们学会了如何高效管理内存、优化性能并保证容器的安全性。此外，我们还增加了随机访问、边界检查、插入删除、异常处理等高级功能。通过这篇文章的学习，你应该对 C++ 容器的内部实现有了更深入的理解，并掌握了构建自定义容器的关键技术。

希望这篇博客对您有所帮助，也欢迎您在此基础上进行更多的探索和改进。如果您有任何问题或建议，欢迎在评论区留言，我们可以共同探讨和学习。更多知识分享可以访问我的个人博客网站： https://blog.lenyiin.com/ 。本博客所设计的代码也可以访问我的 git 仓库获取：https://git.lenyiin.com/Lenyiin/Vector

Lenyiin

关注

53
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
0
评论
《 C++ 容器全景指南：二》如何实现标准库般强大的 C++ Vector？：从动态扩容到移动语义到迭代器全覆盖

在本文中，我们详细介绍了如何从零开始在 C++ 中实现一个功能强大的 Vector 容器，该容器能够媲美标准库中的 std::vector。我们从基础的内存管理和动态扩容机制入手，逐步构建支持模板化、迭代器、常量迭代器、随机访问和边界检查等功能的容器。此外，文章还探讨了如何利用 C++11 的移动语义来提升性能，并通过详细的注释和代码解释，让读者深入理解每一个实现步骤。最终，读者将掌握如何构建一个安全高效的动态数组容器。
复制链接

扫一扫