vector的实现

news2024/11/14 15:36:11

目录

1.vector的底层

2.vector构造函数的实现

①构造函数

②拷贝构造

3.访问函数实现

3.1迭代器iterator

3.2下标+[]访问

4.析构函数和计算size、capacity、swap简单函数的实现

①析构函数： 

②计算size：

③计算capacity：

④swap函数

5. reserve（提前开空间函数实现）

6.尾插尾删函数

7.insert指定位置插入实现

8.设计程序验证

源代码（vector.h）

1.vector的底层

我们在之前的文章顺序表的实现中了解到：

其底层存在一个指向动态开辟数组的指针、一个表示元素个数的size和一个表示顺序表容量大小的capacity。

而vector使用了一个start、一个finish和一个end_of_storage,虽然二者的表示形式不同，实则都有相同的道理，如图：

现在我们就依据此来实现一下vector。

2.vector构造函数的实现

①构造函数

class vector
{
public:
    vector()
		:_start(nullptr)
		, _finish(nullptr)
		, _endofstorage(nullptr)
		{}
private:
		//全缺省为空
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;
}

②拷贝构造

//①传统写法
		//vector(const vector<T>& v)
		//{
		//	_start = new T[v.capacity()];//先开空间
		//	memcpy(_start, v._start, v.size() * sizeof(T));
		//	_finish = _start + v.size();
		//	_endofstorage = _start + v.capacity();
		//}
		//②现代写法
		vector(const vector<T>& v)
		{
			reserve(v.capacity());//首先开一个与旧空间一样的新空间
			for (const auto& e : v)//添加引用&，防止深拷贝
			{
				push_back(e);//复用push_back函数
			}
		}

③析构函数 

~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _endofstorage = nullptr;
			}
		}

3.访问函数实现

3.1迭代器iterator

①普通迭代器可读可写：

//普通迭代器 可读可写
typedef T* iterator;
		iterator begin()
		{
			return _start;

		}
		iterator end()
		{
			return _finish;
		}

②const迭代器可读不可写：

//const迭代器 可读不可写
typedef const T* const_iterator;
const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}

3.2下标+[]访问

①普通函数，可读可写：

		//①可读可写
		T& operator[](size_t pos)
		{
			assert(pos < size());//检查是否越界

			return _start[pos];//返回pos位置字符的引用，既可读又可写
		}

②const函数，可读不可写：

        //②可读不可写
		const T& operator[](size_t pos) const 
		{
			assert(pos < size());//检查是否越界

			return _start[pos];//返回pos位置字符的引用，既可读又可写
		}

4.析构函数和计算size、capacity、swap简单函数的实现

①析构函数： 

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

②计算size：

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

③计算capacity：

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

④swap函数

void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

有了swap函数，我们就可以复用swap函数实现赋值构造函数：

//赋值
		vector<T>& operator=(vector<T> v)
		//注意这里不能添加&引用，如v3=v1
		//无&引用表示v是v1的临时拷贝，v3再拷贝v，出了作用域v就会被销毁，不会改变v1
		//而加上&引用则直接表示v1与v3交换了，即可以认为这里实现了swap函数的功能
		{
			swap(v);//复用swap函数
			return *this; 
		}

5. reserve（提前开空间函数实现）

void reserve(size_t n)
		{
			if (n > capacity())//如果原容量<需要的新空间，就开辟新空间
			{
				T* tmp = new T[n];//开辟新空间
				if (_start)//判断原vector是否为空
				{
					//如果原vector不为空，就将从_start位置开始的n*sizeof(T)个数据拷贝到新空间tmp里
					memcpy(tmp, _start, n * sizeof(T));
					delete[] _start;//释放旧空间
				}
				//再指向新空间
				_start = tmp;
				_finish = _start + size();
				_endofstorage = _start + capacity()；
		}

这样写程序出现了bug：

这是因为

因为size()=_finish - _start;
 所以_finish=_start+_finish-_start=_finish
可是这里的_start已经指向了新空间，而_finish指向的还是旧空间
一个空间的末尾 - 另一个空间的开头 ==== 错误！
_endofstorage = _start + capacity();
同样的道理，capacity()还是旧空间，_start是新空间 也= 错误！
所以这里正确的做法应该是_endofstorage = _start + n;

正确代码：

void reserve(size_t n)
		{
			if (n > capacity())//如果原容量<需要的新空间，就开辟新空间
			{
				size_t old = size();//在扩容之前将size()先保存一下
				T* tmp = new T[n];//开辟新空间
				if (_start)//判断原vector是否为空
				{
					//如果原vector不为空，就将从_start位置开始的old*sizeof(T)个数据拷贝到新空间tmp里
					memcpy(tmp, _start, old * sizeof(T));
					delete[] _start;//释放旧空间
				}
					//再指向新空间
					_start = tmp;
					_finish = _start + old;
					_endofstorage = _start + n;
			}
		}

完成了reserve函数，我们就可以复用reserve函数实现拷贝构造的现代写法：

//②现代写法
		vector(const vector<T>& v)
		{
			reserve(v.capacity());//首先开一个与旧空间一样的新空间
			for (const auto& e : v)//添加引用&，防止深拷贝
			{
				push_back(e);//复用push_back函数
			}
		}

6.尾插尾删函数

        //尾插函数
		void push_back(const T& x)
		{
			if (_finish == _endofstorage)//判断vector有没有满
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;//如果满了就扩容
				reserve(newcapacity);
			}
			//扩容之后赋值
			*_finish = x;
			++_finish; 
		}

		//尾删函数
		void pop_back()
		{
			assert(size() > 0);
			--_finish;
		}

7.insert指定位置插入实现

void insert(iterator pos, const T& x)//在pos位置之前插入x
		{
			assert(pos <= _finish && pos >= _start);//检查pos是否合法

			//检查vector是否充满
			if (_finish == _endofstorage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);//若充满则扩容
			}
			//把从pos位置开始，往后的sizeof(T) * (_finish - pos)个元素复制到pos+1位置
			memmove(pos + 1, pos, sizeof(T) * (_finish - pos));
			*pos = x;//挪动之后再把x放到pos位置
			++_finish;
		}

这段代码在实际运行时有时会出现错误，这是为什么呢？

原因是：

reserve(capacity() == 0 ? 4 : capacity() * 2);//若充满则扩容
观察reserve函数：不扩容还好，当发生扩容时，reserve会销毁旧空间
此时_start指向新空间，pos仍然指向旧空间，pos在扩容之后失效了
因此这里的解决办法就是计算偏移量，更新一下pos的值

正确代码：

void insert(iterator pos, const T& x)//在pos位置之前插入x
		{
			assert(pos <= _finish && pos >= _start);//检查pos是否合法

			//检查vector是否充满
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);//若充满则扩容
				pos = _start + len;
			}
			//把从pos位置开始，往后的sizeof(T) * (_finish - pos)个元素复制到pos+1位置
			memmove(pos + 1, pos, sizeof(T) * (_finish - pos));
			*pos = x;//挪动之后再把x放到pos位置
			++_finish;
		}

8.设计程序验证

void test_vector()
	{
		vector <int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(5);

		//迭代器访问
		vector <int>::iterator it = v1.begin();
		while (it != v1.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
		//范围for访问
		for (auto e : v1)
		{
			cout << e << " ";
		}
		cout << endl;
		//下标+[]访问
		for (size_t i = 0; i < v1.size(); i++)
		{
			cout << v1[i] << " ";
		}
		cout << endl;
	}

源代码（vector.h）

#pragma once

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

using namespace std;


namespace xxk
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;//普通迭代器 可读可写
		typedef const T* const_iterator;//const迭代器 可读不可写

		//构造函数
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{}

		//拷贝构造
		//①传统写法
		//vector(const vector<T>& v)
		//{
		//	_start = new T[v.capacity()];//先开空间
		//	memcpy(_start, v._start, v.size() * sizeof(T));
		//	_finish = _start + v.size();
		//	_endofstorage = _start + v.capacity();
		//}
		//②现代写法
		vector(const vector<T>& v)
		{
			reserve(v.capacity());//首先开一个与旧空间一样的新空间
			for (const auto& e : v)//添加引用&，防止深拷贝
			{
				push_back(e);//复用push_back函数
			}
		}

		//赋值
		vector<T>& operator=(vector<T> v)
		//注意这里不能添加&引用，如v3=v1
		//无&引用表示v是v1的临时拷贝，v3再拷贝v，出了作用域v就会被销毁，不会改变v1
		//而加上&引用则直接表示v1与v3交换了，即可以认为这里实现了swap函数的功能
		{
			swap(v);//复用swap函数
			return *this; 
		}

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

		//迭代器begin()和end()实现
		//普通迭代器 可读可写
		iterator begin()
		{
			return _start;

		}
		iterator end()
		{
			return _finish;
		}
		//const迭代器 可读不可写
		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}


		//size capacity函数
		size_t size() const
		{
			return _finish - _start;
		}
		size_t capacity() const
		{
			return _endofstorage - _start;
		}

		//下标+[]访问函数的实现
		//①可读可写
		T& operator[](size_t pos)
		{
			assert(pos < size());//检查是否越界

			return _start[pos];//返回pos位置字符的引用，既可读又可写
		}
		//②可读不可写
		const T& operator[](size_t pos) const 
		{
			assert(pos < size());//检查是否越界

			return _start[pos];//返回pos位置字符的引用，既可读又可写
		}

		//reserve扩容函数
		//error：
		//void reserve(size_t n)
		//{
		//	if (n > capacity())//如果原容量<需要的新空间，就开辟新空间
		//	{
		//		T* tmp = new T[n];//开辟新空间
		//		if (_start)//判断原vector是否为空
		//		{
		//			//如果原vector不为空，就将从_start位置开始的n*sizeof(T)个数据拷贝到新空间tmp里
		//			memcpy(tmp, _start, n * sizeof(T));
		//			delete[] _start;//释放旧空间
		//		}
		//		//再指向新空间
		//		_start = tmp;
		//		_finish = _start + size();
		//		//因为size()=_finish - _start;
		//		//所以_finish=_start+_finish-_start=_finish
		//		//可是这里的_start已经指向了新空间，而_finish指向的还是旧空间
		//		//一个空间的末尾 - 另一个空间的开头 ==== 错误！
		//		_endofstorage = _start + capacity();
		//		//同样的道理，capacity()还是旧空间，_start是新空间 也= 错误！
		//		//所以这里正确的做法应该是_endofstorage = _start + n;
		//	}
		//}

		void reserve(size_t n)
		{
			if (n > capacity())//如果原容量<需要的新空间，就开辟新空间
			{
				size_t old = size();//在扩容之前将size()先保存一下
				T* tmp = new T[n];//开辟新空间
				if (_start)//判断原vector是否为空
				{
					//如果原vector不为空，就将从_start位置开始的old*sizeof(T)个数据拷贝到新空间tmp里
					memcpy(tmp, _start, old * sizeof(T));
					delete[] _start;//释放旧空间
				}
					//再指向新空间
					_start = tmp;
					_finish = _start + old;
					_endofstorage = _start + n;
			}
		}

		//resize函数


		//尾插函数
		void push_back(const T& x)
		{
			if (_finish == _endofstorage)//判断vector有没有满
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;//如果满了就扩容
				reserve(newcapacity);
			}
			//扩容之后赋值
			*_finish = x;
			++_finish; 
		}

		//尾删函数
		void pop_back()
		{
			assert(size() > 0);
			--_finish;
		}

		//指定位置插入（insert）函数
		//error:
		//void insert(iterator pos, const T& x)//在pos位置之前插入x
		//{
		//	assert(pos <= _finish && pos >= _start);//检查pos是否合法

		//	//检查vector是否充满
		//	if (_finish == _endofstorage)
		//	{
				//reserve(capacity() == 0 ? 4 : capacity() * 2);//若充满则扩容
				观察reserve函数：不扩容还好，当发生扩容时，reserve会销毁旧空间
				此时_start指向新空间，pos仍然指向旧空间，pos在扩容之后失效了
				因此这里的解决办法就是计算偏移量，更新一下pos的值
		//	}
		//	//把从pos位置开始，往后的sizeof(T) * (_finish - pos)个元素复制到pos+1位置
		//	memmove(pos + 1, pos, sizeof(T) * (_finish - pos));
		//	*pos = x;//挪动之后再把x放到pos位置
		//	++_finish;
		//}

		void insert(iterator pos, const T& x)//在pos位置之前插入x
		{
			assert(pos <= _finish && pos >= _start);//检查pos是否合法

			//检查vector是否充满
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);//若充满则扩容
				pos = _start + len;
			}
			//把从pos位置开始，往后的sizeof(T) * (_finish - pos)个元素复制到pos+1位置
			memmove(pos + 1, pos, sizeof(T) * (_finish - pos));
			*pos = x;//挪动之后再把x放到pos位置
			++_finish;
		}

		//swap函数
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

	private:
		//全缺省为空
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;
	};
	
	void test_vector()
	{
		vector <int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(5);

		//迭代器访问
		vector <int>::iterator it = v1.begin();
		while (it != v1.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
		//范围for访问
		for (auto e : v1)
		{
			cout << e << " ";
		}
		cout << endl;
		//下标+[]访问
		for (size_t i = 0; i < v1.size(); i++)
		{
			cout << v1[i] << " ";
		}
		cout << endl;
	}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2101912.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

嵌入式软件--51单片机 DAY 3

嵌入式软件--51单片机 DAY 3

一、独立按键 按键的作用相当于一个开关&#xff0c;按下时接通&#xff08;或断开&#xff09;&#xff0c;松开后断开&#xff08;或接通&#xff09;。 &#xff08;1&#xff09;需求 通过SW1、SW2、SW3、SW4四个独立按键分别控制LED1、LED2、LED3、LED4的亮灭&#xff0…
阅读更多...
爬虫数据解析

爬虫数据解析

## 数据解析 聚焦爬虫 爬取页面中指定的页面内容 编码流程 指定url发起请求获取响应数据数据解析持久化存储 数据解析分类 正则bs4xpath&#xff08;***&#xff09; 数据解析原理概述 解析的局部的文本内容都会在标签之间或者标签对应的属性中进行存储进行指定标签的定…
阅读更多...
最小生成树的两种算法模板

最小生成树的两种算法模板

第一种模板&#xff1a; 思路&#xff1a;对于prime算法来说其实与朴素的dij算法差不多&#xff0c;都是找到最近的点然后更新其他的点 模板&#xff1a; #include<bits/stdc.h>using namespace std;const int N 100010;int n; int g[110][110]; int dis[110]; int st…
阅读更多...
VMware Workstation 17.6 Pro 发布下载，新增功能概览

VMware Workstation 17.6 Pro 发布下载，新增功能概览

VMware Workstation 17.6 Pro 发布下载&#xff0c;新增功能概览 VMware Workstation 17.6 Pro for Windows & Linux - 领先的免费桌面虚拟化软件 基于 x86 的 Windows、Linux 桌面虚拟化软件 请访问原文链接&#xff1a;https://sysin.org/blog/vmware-workstation-17/…
阅读更多...
Linux日志-wtmp日志

Linux日志-wtmp日志

作者介绍&#xff1a;简历上没有一个精通的运维工程师。希望大家多多关注作者&#xff0c;下面的思维导图也是预计更新的内容和当前进度(不定时更新)。 Linux 系统中的日志是记录系统活动和事件的重要工具&#xff0c;它们可以帮助管理员监视系统状态、调查问题以及了解系统运行…
阅读更多...
B端系统门门清之：QMS-质量管理，泰山之重。

B端系统门门清之：QMS-质量管理，泰山之重。

质量重于泰山&#xff0c;QMS&#xff08;质量管理系统&#xff09;在生产企业的经营中非常重要&#xff0c;质量的积累可以成就一个企业&#xff0c;想要毁掉一个企业&#xff0c;也是瞬间的事情&#xff0c;本文就和大家重点分享一下QMS系统。 一、什么是QMS系统&#xff0c…
阅读更多...
SpringCloud开发实战（二）：通过RestTemplate实现远程调用

SpringCloud开发实战（二）：通过RestTemplate实现远程调用

目录 SpringCloud开发实战&#xff08;一&#xff09;&#xff1a;搭建SpringCloud框架 RestTemplate介绍 RestTemplate 是 Spring 框架中的一个类&#xff0c;它用于促进 HTTP 请求的发送和接收&#xff0c;并且简化了与 RESTful 服务的交互。RestTemplate 提供了许多便利的方…
阅读更多...
C++ 学习 2024.9.3

C++ 学习 2024.9.3

封装栈与队列 栈: #include <iostream>using namespace std;class Stack { private:int *a; //动态数组存储元素int size; //栈容量int top; //栈顶元素索引 public://有参构造Stack(int size):size(size),top(-1){anew int[size];}//析构~Stack(){delete[]a…
阅读更多...
八月二十九日（day 39）docker6

八月二十九日（day 39）docker6

1.前端&#xff08;nginx&#xff09; [rootlocalhost ~]# docker pull nginx //拉取nginx镜像 [rootlocalhost ~]# docker images REPOSITORY TAG IMAGE ID CREATED SIZE nginx latest 5ef79149e0ec 2 we…
阅读更多...
【Godot4.3】基于纯绘图函数自定义的线框图控件

【Godot4.3】基于纯绘图函数自定义的线框图控件

概述 同样是来自2023年7月份的一项实验性工作&#xff0c;基于纯绘图函数扩展的一套线框图控件。初期只实现了三个组件&#xff0c;矩形、占位框和垂直滚动条。 本文中的三个控件类已经经过了继承化的修改&#xff0c;使得代码更少。它们的继承关系如下&#xff1a; 源代码 W…
阅读更多...
抽象和接口

抽象和接口

a.抽象&#xff08;abstract&#xff09; 1. 定义 a. 抽象类&#xff1a;在普通类里增加了抽象方法。 b. 抽象方法&#xff1a;没有具体的执行方法&#xff0c;没有方法体的方法。 2. 总结 a. 因为抽象方法没有方法体&#xff0c;无法执行&#xff0c;所以不能…
阅读更多...
WEB服务与虚拟主机/IIS中间件部署

WEB服务与虚拟主机/IIS中间件部署

WWW&#xff08;庞大的信息系统&#xff09;是基于客户机/服务器⽅式的信息发现技术和超⽂本技术的综合。网页浏览器//网页服务器 WWW的构建基于三项核⼼技术&#xff1a; HTTP&#xff1a;超文本传输协议&#xff0c;⽤于在Web服务器和客户端之间传输数据。HTML&#xff1a;⽤…
阅读更多...
xml转txt，适应各种图片格式，如jpg，png，jpeg，PNG，JPEG等

xml转txt，适应各种图片格式，如jpg，png，jpeg，PNG，JPEG等

xml转txt&#xff0c;适应各种图片格式&#xff0c;如jpg&#xff0c;png&#xff0c;jpeg&#xff0c;PNG&#xff0c;JPEG等 import xml.etree.ElementTree as ET import os import cv2 import numpy as np import globclasses []def convert(size, box):dw 1. / (size[0]…
阅读更多...
力扣面试150 旋转链表 闭链成环

力扣面试150 旋转链表 闭链成环

Problem: 61. 旋转链表 &#x1f468;‍&#x1f3eb; 力扣官解 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode nex…
阅读更多...
一小时教你学会C语言系统！C语言实战教程-学生信息管理系统源码

一小时教你学会C语言系统！C语言实战教程-学生信息管理系统源码

本次教程带大家做一个C语言学生信息管理系统&#xff0c;带教程视频 C语言实战教程-XX管理系统 期末C语言课设不会做&#xff1f; 想学习一下怎么用C语言做出一个完整的系统&#xff1f;完整的步骤是怎么样的&#xff1f; 本教程就教你怎么从0搭建一个系统并且完美运行起来…
阅读更多...
Python基础语法（多进程开发进程建数据共享进程锁进程池）

Python基础语法（多进程开发进程建数据共享进程锁进程池）

Python基础语法文章导航&#xff1a; Python基础&#xff08;01初识数据类型&变量&#xff09;Python基础&#xff08;02条件&循环语句&#xff09;Python基础&#xff08;03字符串格式化&运算符&进制&编码&#xff09;Python基础&#xff08;04 基础练习…
阅读更多...
93.游戏的启动与多开-进程枚举多开检测

93.游戏的启动与多开-进程枚举多开检测

免责声明&#xff1a;内容仅供学习参考&#xff0c;请合法利用知识&#xff0c;禁止进行违法犯罪活动&#xff01; 内容参考于&#xff1a;易道云信息技术研究院 上一个内容&#xff1a;92.游戏的启动与多开-多开检测概述 枚举多开检测在事前检测用的很少&#xff0c;在事中…
阅读更多...
Https配置免费SSL证书

Https配置免费SSL证书

本文目录 前言一、前提1.1 服务器1.2 域名 二、Certbot简介2.1 Apache服务器2.2 Nginx服务器 三、自动更新证书四、效果 前言 HTTPS &#xff08;全称&#xff1a;Hypertext Transfer Protocol Secure &#xff09;&#xff0c;是以安全为目标的 HTTP 通道&#xff0c;在HTTP的…
阅读更多...
【重学 MySQL】二、MySQL 介绍

【重学 MySQL】二、MySQL 介绍

【重学 MySQL】二、MySQL 介绍 MySQL 概述MySQL 的主要特点MySQL 的应用场景结论 MySQL 发展史初始创建与发布开源与快速成长重要版本发布收购与变革分支与竞争持续发展与现代应用 关于 MySQL8.0主要新特性和改进兼容性和迁移应用场景总结 为什么选择 MySQLOracle VS MySQL基本…
阅读更多...
【Elasticsearch】Elasticsearch集群在分布式环境下的管理

【Elasticsearch】Elasticsearch集群在分布式环境下的管理

文章目录 &#x1f4d1;前言一、集群规划与设计1.1 集群拓扑结构设计1.2 节点角色分配1.3 分片与副本配置 二、集群管理与运维2.1 集群监控2.2 故障处理2.3 性能优化 三、扩展与升级3.1 集群扩展3.2 集群升级3.3 灾备与容灾 &#x1f324;️总结 &#x1f4d1;前言 Elasticsear…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023