C++: Vector的模拟实现

vector.hpp

// 阻止头文件被多次包含
#pragma once

// 包含必要的头文件
#include <iostream>
#include <assert.h>
// 包含自定义的 reverse_iterator.h 头文件，用于实现反向迭代器
#include "reverse_iterator.h"

// 定义一个命名空间 MyVector
namespace MyVector
{
	// 定义一个模板类 vector
	template <class T>
	class vector
	{
	public:
		// 定义迭代器类型
		typedef T *iterator;
		typedef const T *const_iterator;

		// 定义反向迭代器类型
		typedef ReverseIterator<iterator, T &, T *> reverse_iterator;
		typedef ReverseIterator<const_iterator, const T &, const T *> const_reverse_iterator;

		// 默认构造函数
		vector() {}

		// 拷贝构造函数
		vector(const vector<T> &v)
		{
			// 深拷贝
			reserve(v.capacity());
			for (auto e : v)
			{
				push_back(e);
			}
		}

		// 列表初始化构造函数
		vector(initializer_list<T> il)
		{
			reserve(il.size());
			for (auto &e : il)
			{
				push_back(e);
			}
		}

		// 模板构造函数，接受任意类型的输入迭代器
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				first++;
			}
		}

		// 析构函数，释放分配的内存
		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}

		// 反向迭代器的成员函数
		reverse_iterator rbegin() { return reverse_iterator(end()); }
		reverse_iterator rend() { return reverse_iterator(begin()); }
		const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
		const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }

		// 迭代器的成员函数
		iterator begin() { return _start; }
		iterator end() { return _finish; }
		const_iterator begin() const { return _start; }
		const_iterator end() const { return _finish; }

		// 交换两个 vector 对象的内容
		void swap(vector<T> &v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

		// 访问 vector 中的元素
		T &operator[](size_t pos)
		{
			assert(pos < size());
			return _start[pos];
		}

		// 访问 vector 中的元素（const 版本）
		const T &operator[](size_t pos) const
		{
			assert(pos < size());
			return _start[pos];
		}

		// 赋值运算符，使用复制并交换机制
		vector<T> &operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}

		// 检查 vector 是否为空
		bool empty()
		{
			return _start == _finish;
		}

		// 返回 vector 中元素的数量
		size_t size() const
		{
			return _finish - _start;
		}

		// 返回 vector 的容量
		size_t capacity() const
		{
			return _endofstorage - _start;
		}

		// 调整 vector 的容量
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				T *temp = new T[n];
				size_t old_size = size();
				// 大坑！！！对于string、vector等库中的在析构的时候会崩！！！
				// memcpy（按字节拷贝会发生浅拷贝）易发生扩容就会崩！！！
				/*memcpy(temp, _start, size() * sizeof(T));*/
				for (size_t i = 0; i < old_size; i++)
				{
					temp[i] = _start[i];
				}
				delete[] _start;
				_start = temp;
				_finish = _start + old_size;
				_endofstorage = _start + n;
			}
		}

		// 调整 vector 的大小
		void resize(size_t n, const T &val = T())
		{
			if (n > size())
			{
				reserve(n);
				while (_finish < _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

		// 打印 vector 内容的成员函数
		void print_vector() const;

		// 在 vector 尾部添加元素
		void push_back(const T &val);

		// 移除 vector 尾部的元素
		void pop_back();

		// 在指定位置插入元素
		void insert(iterator pos, const T &val);

		// 擦除指定位置的元素
		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it - 1) = *it;
				it++;
			}
			_finish--;
			return pos;
		}

	private:
		// vector 的内部表示，包括起始指针、当前尾部指针和存储结束指针
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;
	};
	template <class T>
	void vector<T>::print_vector() const
	{
		for (int i = 0; i < size(); i++)
		{
			cout << _start[i] << " ";
		}
		cout << endl;
	}

	template <class T>
	void vector<T>::push_back(const T &val)
	{
#if 0
		if (_finish == _endofstorage)
		{
			reserve(capacity() == 0 ? 4 : capacity() * 2);
		}
		*_finish = val;
		_finish++;
#endif
		insert(end(), val);
	}

	template <class T>
	void vector<T>::pop_back()
	{
		/*assert(!empty());
		_finish--;*/
		erase(end() - 1);
	}

	template <class T>
	void vector<T>::insert(iterator pos, const T &val)
	{
		assert(pos >= _start);
		assert(pos <= _finish);
		if (_finish == _endofstorage)
		{
			size_t len = pos - _start;
			reserve(capacity() == 0 ? 4 : capacity() * 2);
			pos = _start + len;
		}
		iterator it = _finish - 1;
		while (it >= pos)
		{
			*(it + 1) = *it;
			it--;
		}
		*pos = val;
		_finish++;
	}
}

 reverse_iterator.hpp(反向迭代器)

#pragma once
namespace MyVector {
	template<class Iterator, class Ref, class Ptr>
	struct ReverseIterator
	{
		typedef ReverseIterator<Iterator, Ref, Ptr> Self;
		Iterator _it;
		ReverseIterator(Iterator it)
			:_it(it)
		{}

		Ref operator*()
		{
			Iterator temp = _it;
			return *(--temp);
		}

		Self& operator++()
		{
			--_it;
			return *this;
		}

		Self& operator--()
		{
			++_it;
			return *this;
		}

		Self operator++(int)
		{
			Self temp(*this);
			--_it;
			return temp;
		}

		Self operator--(int)
		{
			Self temp(*this);
			++_it;
			return temp;
		}

		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}

		bool operator==(const Self& s)
		{
			return _it == s._it;
		}
	};
}

 用用看：

更多学习代码： XiangChao (RuofengMao) - Gitee.com