C++简易日志系统：打造高效、线程安全的日志记录工具

非宁静不致远

 关注

阅读 17

2024-11-06

vector 接口预览

namespace HL
{
	template<class T>
	class vector
	{
		//迭代器iterator
		typedef T* iterator;
		typedef const T* const_iterator;

	public:
		//默认成员函数
		vector();
		vector(size_t n, const T& val = T());
		vector(int n, const T& val = T());
		vector(const vector& v);
		template<class InputIterator>
		vector(InputIterator first, InputIterator last);
		~vector();
		vector<T>& operator=(vector v);
		//Iterator
		iterator& begin();
		iterator& end();
		const_iterator begin() const;
		const_iterator& end() const;
		//Capacity
		size_t size() const;
		size_t capacity() const;
		bool empty() const;
		void reserve(size_t n);
		void resize(size_t n, const T& val = T());
		//Modifiers
		void push_back(const T& val);
		void pop_back();
		void insert(iterator pos, const T& val);
		template<class InputIterator>
		void insert(iterator pos, InputIterator first, InputIterator last);
		iterator erase(iterator pos);
		void swap(vector<T>& v);
		//Element access:
		T& operator[](size_t i);
		const T& operator[](size_t i) const;
		
	private:
		iterator start;
		iterator finish;
		iterator end_of_storage;
	};

};

vector模拟实现

vector成员变量

​ vector成员变量，和顺序表的成员变量有所不同，不再是指针、size和capacity了，而是迭代器 start、finish和end_of_storage。
在这里插入图片描述

start指向起始位置、finish指向最后一个数据的下一个位置（表示数据的末尾）、end_of_storage指向这一块空间的最后。

默认成员函数

构造函数

1、无参构造

​ 无参构造，就是默认构造函数，将成员变量都初始化成nullptr。

vector()
	:start(nullptr)
	,finish(nullptr)
	,end_of_storage(nullptr)
{}
2、构造并初始化成n个val值

​ 理论上，我们只需要写一个函数vector(size_t n, const T& val = T());即可，但是如果两个参数都是int类型，（即vector v(5,1);）编译器在编译时，认为T已经实例化成了int，对于两个int类型，编译器就会选择更为匹配的模版

template vector(InputIterator first, InputIterator last);

所以这里写一个vector(int n, const T& val = T()); 让上面这种情况匹配这个函数。

vector(size_t n, const T& val = T())
{
	start = new T[n];
	for (size_t i = 0; i < n; i++)
	{
		start[i] = val;
	}
	end_of_storage = finish = start + n;
}
vector(int n, const T& val = T())
{
	start = new T[n];
	for (int i = 0; i < n; i++)
	{
		start[i] = val;
	}
	end_of_storage = finish = start + n;
}
3、使用一段迭代器区间进行初始化

​ 使用迭代器区间进行初始化，这里不一定是vector的迭代器，所以写成模板。

		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			size_t sz = last - first;
			start = new T[sz];
			finish = start;
			while (first != last)
			{
				*finish = *first;
				++finish;
				++first;
			}
			end_of_storage = start + sz;
		}
4、拷贝构造

​ 这里要注意，需要深拷贝，而不是浅拷贝。

		vector(const vector& v)
		{
			size_t sz = v.size();
			size_t cp = v.capacity();
			start = new T[sz];
			for (int i = 0; i < sz; i++)
			{
				start[i] = v[i];
			}
			finish = start + sz;
			end_of_storage = start + cp;
		}

析构函数

​ 析构函数比较简单，释放动态开辟的空间即可。

		~vector()
		{
			if (start)
				delete[] start;
			start = finish = end_of_storage = nullptr;
		}

赋值运算符重载

​ 赋值运算符重载，这个编译器自动生成的是浅拷贝，我们需要写一个深拷贝的。

这里有多种写法，首先就是传统写法，我们自己释放、开辟空间再拷贝数据

		vector<T>& operator=(const vector& v)
		{
			if (start)
				delete[] start;
			size_t sz = v.size();
			start = new T[sz];
			for (int i = 0; i < sz; i++)
			{
				start[i] = v[i];
			}
			finish = end_of_storage = start + sz;
		}

​ 还有现代写法，我们这里传参不使用引用，而使用传值传参；这样生成的形参对象再与我们的this(对象)进行交换；这样形参出了作用域就自动调用析构函数，不用我们去处理了。（这个需要先实现交换函数）

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

​ 注意事项： 在赋值的过程中没有使用memcpy函数，因为这个函数只是将数值拷贝过去(浅拷贝)；

如果我们vector 示例化是vector 这样的自定义类型，使用浅拷贝就可能会出现问题；所以这里采用一个一个进行赋值操作，这样就会去调用自定义类型的赋值运算符重载；而不只是简单的浅拷贝了。

iterator 迭代器

​ vector 的迭代器这里实现的是原生指针；迭代器相关函数：begin()、end()这些都比较简单就不过多描述了。

		//迭代器iterator
		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;
		}

Capacity

​ capacity容量相关的函数，主要在于调整空间大小和设置内容。

size、capacity、empty

		size_t size() const
		{
			return finish - start;
		}
		size_t capacity() const
		{
			end_of_storage - start;
		}
		bool empty() const
		{
			return start == finish;
		}

reserve

​ reserve，调整空间大小；即扩容。

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				iterator tmp = T[n];
				size_t sz = size();
				for (int i = 0; i < sz; i++)
				{
					tmp[i] = start[i];
				}
				if (start)
					delete[] start;
				start = tmp;
				finish = start + sz;
				end_of_storage = start + n;
			}
		}

resize()

		void resize(size_t n, const T& val = T())
		{
			reserve(n);
			if (n < size())
			{
				finish = start + n;
			}
			else {
				for (int i = size(); i < n; i++)
				{
					start[i] = val;
				}
				finish = start + n;
			}
		}

Modifiers

​ modifiers 增删查改、vector头插头删效率很低，就不提供头插头删接口了。

push_back、pop_back

​ 尾差、尾删，直接在vector最后插入删除数据。

		void push_back(const T& val)
		{
			if (capacity() == size())
			{
				size_t n = (capacity() == 0) ? 4 : 2 * capacity();
				reserve(n);
			}
			*finish = val;
			++finish;
		}
		void pop_back()
		{
			assert(start != finish);
			--finish;
		}

insert

insert函数，在某个位置插入n(可以是1)个数据。或者插入一段迭代器区间的数据。

iterator insert(iterator pos, const T& val)
{
	// 空间不够先进行增容
	if (finish == end_of_storage)
	{
		size_t newCapacity = (capacity() == 0) ? 1 : capacity() * 2;
		reserve(newCapacity);

		// 如果发生了增容，需要重置pos
		pos = _start + size();
	}
	//挪动数据
	iterator p = finish;
	while (p != pos)
	{
		*p = *(p - 1);
		--p;
	}
	*pos = val;
	finish += 1;
	return pos;
}
template<class InputIterator>
void insert(iterator pos, InputIterator first, InputIterator last)
{
	//这里如果迭代器不是原生指针或者内存空间不连续就不能进行 - 操作了
	size_t sz = last - first;
	size_t n = pos - start;
	reserve(sz + size());
	pos = start + n;
	//挪数据
	iterator p = finish - 1;
	while (p >= pos)
	{
		*(p + sz) = *p;
		--p;
	}
	//插入数据
	for (size_t i = 0; i < sz; i++)
	{
		pos[i] = first[i];
	}
	finish += sz;
}

​ 这里，扩容之后还用一个迭代器失效问题，需要重新给pos赋值。

erase

​ erase就是删除某个位置的数据，直接将后面数据往前移动即可

		iterator erase(iterator pos)
		{
			size_t sz = finish - pos;
			for (int i = 0; i < sz; i++)
			{
				pos[i] = pos[i + 1];
			}
			finish -= 1;
			return pos;
		}

clear、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);
		}
		void clear()
		{
			finish = start;
		}

Element access

operator[ ]

​ 下标访问，直接返回start[i]即可。

		T& operator[](size_t i)
		{
			return start[i];
		}
		const T& operator[](size_t i) const
		{
			return start[i];
		}

代码总览

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

namespace HL
{
	template<class T>
	class vector
	{
		//迭代器iterator
		typedef T* iterator;
		typedef const T* const_iterator;

	public:
		//默认成员函数
		vector()
			:start(nullptr)
			,finish(nullptr)
			,end_of_storage(nullptr)
		{}
		vector(size_t n, const T& val = T())
		{
			start = new T[n];
			for (size_t i = 0; i < n; i++)
			{
				start[i] = val;
			}
			end_of_storage = finish = start + n;
		}
		vector(int n, const T& val = T())
		{
			start = new T[n];
			for (int i = 0; i < n; i++)
			{
				start[i] = val;
			}
			end_of_storage = finish = start + n;
		}
		vector(const vector& v)
		{
			size_t sz = v.size();
			size_t cp = v.capacity();
			start = new T[sz];
			for (int i = 0; i < sz; i++)
			{
				start[i] = v[i];
			}
			finish = start + sz;
			end_of_storage = start + cp;
		}
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			size_t sz = last - first;
			start = new T[sz];
			finish = start;
			while (first != last)
			{
				*finish = *first;
				++finish;
				++first;
			}
			end_of_storage = start + sz;
		}
		~vector()
		{
			if (start)
				delete[] start;
			start = finish = end_of_storage = nullptr;
		}
		/*vector<T>& operator=(vector v)
		{
			swap(v);
			return *this;
		}*/
		vector<T>& operator=(const vector& v)
		{
			if (start)
				delete[] start;
			size_t sz = v.size();
			start = new T[sz];
			for (int i = 0; i < sz; i++)
			{
				start[i] = v[i];
			}
			finish = end_of_storage = start + sz;
		}
		//Iterator
		iterator& begin()
		{
			return start;
		}
		iterator& end()
		{
			return finish;
		}
		const_iterator begin() const
		{
			return start;
		}
		const_iterator& end() const
		{
			return finish;
		}
		//Capacity
		size_t size() const
		{
			return finish - start;
		}
		size_t capacity() const
		{
			end_of_storage - start;
		}
		bool empty() const
		{
			return start == finish;
		}
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				iterator tmp = T[n];
				size_t sz = size();
				for (int i = 0; i < sz; i++)
				{
					tmp[i] = start[i];
				}
				if (start)
					delete[] start;
				start = tmp;
				finish = start + sz;
				end_of_storage = start + n;
			}
		}
		void resize(size_t n, const T& val = T())
		{
			reserve(n);
			if (n < size())
			{
				finish = start + n;
			}
			else {
				for (int i = size(); i < n; i++)
				{
					start[i] = val;
				}
				finish = start + n;
			}
		}
		//Modifiers
		void push_back(const T& val)
		{
			if (capacity() == size())
			{
				size_t n = (capacity() == 0) ? 4 : 2 * capacity();
				reserve(n);
			}
			*finish = val;
			++finish;
		}
		void pop_back()
		{
			assert(start != finish);
			--finish;
		}
		iterator insert(iterator pos, const T& val)
		{
			// 空间不够先进行增容
			if (finish == end_of_storage)
			{
				size_t newCapacity = (capacity() == 0) ? 1 : capacity() * 2;
				reserve(newCapacity);

				// 如果发生了增容，需要重置pos
				pos = _start + size();
			}
			//挪动数据
			iterator p = finish;
			while (p != pos)
			{
				*p = *(p - 1);
				--p;
			}
			*pos = val;
			finish += 1;
			return pos;
		}
		template<class InputIterator>
		void insert(iterator pos, InputIterator first, InputIterator last)
		{
			//这里如果迭代器不是原生指针或者内存空间不连续就不能进行 - 操作了
			size_t sz = last - first;
			size_t n = pos - start;
			reserve(sz + size());
			pos = start + n;
			//挪数据
			iterator p = finish - 1;
			while (p >= pos)
			{
				*(p + sz) = *p;
				--p;
			}
			//插入数据
			for (size_t i = 0; i < sz; i++)
			{
				pos[i] = first[i];
			}
			finish += sz;
		}
		iterator erase(iterator pos)
		{
			size_t sz = finish - pos;
			for (int i = 0; i < sz; i++)
			{
				pos[i] = pos[i + 1];
			}
			finish -= 1;
			return pos;
		}
		void swap(vector<T>& v)
		{
			std::swap(start, v.start);
			std::swap(finish, v.finish);
			std::swap(end_of_storage, v.end_of_storage);
		}
		void clear()
		{
			finish = start;
		}
		//Element access:
		T& operator[](size_t i)
		{
			return start[i];
		}
		const T& operator[](size_t i) const
		{
			return start[i];
		}
		
	private:
		iterator start;
		iterator finish;
		iterator end_of_storage;
	};

};

到这里，vector模拟实现就结束了，希望你能有所收获

感谢各位大佬支持并指出问题

​ 如果本篇内容对你有帮助，可以一键三连支持以下，感谢支持！！！

img

相关推荐

C#高效异步文件监控与日志记录工具

陌岛 7 0 0

日志记录工具

有态度的萌狮子 342 0 0

C/C++ 查询系统日志

慕容冲_a4b8 61 0 0

集成 Logrus 到 Gin：打造高效的 Go Web 日志系统

minute_5 19 0 0

C++多线程异步日志实现

木樨点点 35 0 0

linux 日志 系统安全日志 web日志

郝春妮 73 0 0

基于SpEL的操作日志记录工具

求阙者 121 0 0

多线程异步日志系统，高效、强悍的实现方式-双缓冲

登高且赋 113 0 0

C# 异常日志记录

花姐的职场人生 47 0 0

logging 为全局的日志工具对象添加日志记录器

Xin_So 180 0 0

精彩评论（0）

0 0 举报