C++_vector类

       

目录

一、vector的模拟实现

1、vector的组成结构

2、vector尾插数据 

2.1 析构函数 

3、迭代器实现

4、resize

5、删除数据 

5.1 迭代器失效 

6、指定位置插入数据

6.1 迭代器失效

7、迭代器构造和resize构造

8、深浅拷贝

结语：

前言：

        vector类是STL(标准模板库)中的八大容器之一，而STL属于C++标准库的一部分，所以可以直接使用vector。他的作用类似于数组，是用一段连续的空间来存储元素，因此可以支持下标访问各个元素，其中元素的类型可以是int、char...类型以及自定义类型，所以vector类实际上是一个类模板。但是vector类对空间内存的管理比数组更加严格，且使用起来较数组更简便，因为vector是一个类很多功能都已封装完成，可以直接提供用户使用。

一、vector的模拟实现

1、vector的组成结构

        vector类是由三个成员指针变量构成的，可以把这三个成员命名为：_start、_finish、_end_of_storage。

        1、其中_start的作用类似于数组名，表示首元素地址，因此是用_start来开辟空间的。

        2、而_finish指向最后一个元素的下一个位置。他的作用是减去_start可以得到当前空间的元素个数。（通过指针-指针得到整数的方式）

        3、_end_of_storage指向整个空间的末尾处的下一个位置。他的作用是减去_start可以得到空间容量。

        具体示意图如下：

2、vector尾插数据 

        有了上面的成员介绍就可以写一个简单的尾插函数，代码如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;
#include<assert.h>

namespace ZH
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

		vector()//构造函数
		{}

		size_t size()const//得到元素个数
		{
			return _finish - _start;
		}

		size_t capacity()const//得到空间大小
		{
			return _end_of_storage - _start;
		}

		void reserve(size_t n)//扩容函数
		{
			if (n > capacity())
			{
				T* temp = new T[n];
				size_t poi = _finish-_start;//先把_start和_finish之间的距离记录下来
				if (_start != nullptr)
				{
					memcpy(temp, _start, sizeof(T) * size());//拷贝数据
					delete[] _start;
				}
				_start = temp;//更新_start的指向
				_finish = _start + poi;
				_end_of_storage = _start + n;
			}
		}

		void push_back(const T& val)
		{
			if (_finish == _end_of_storage)//相等说明当前容量不够
			{
				reserve(capacity()==0?4:capacity() * 2);//扩容
			}

			*_finish = val;//尾插
			_finish++;
		}

		T& operator[](size_t i)//解引用运算符重载
		{
			assert(i < size());//检查越界
			return _start[i];
		}

	private:
		iterator _start = nullptr;//缺省值赋予空
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

int main()
{
	//实例化对象v1
	ZH::vector<int> v1;
	//尾插五个数
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	for (size_t i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << endl;
	}
	return 0;
}

  运行结果：

        上述代码需要注意的是：扩容时采用的是异地扩容，因此要注意_start值的变化对_start与_finish之间距离的影响。如下图：

2.1 析构函数 

        因为是_start申请的空间，因此只需要delete _start即可。

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

3、迭代器实现

        vector的迭代器可以看作是一个指针，迭代器实际上就是通过两个成员函数返回的指针实现的，这两个成员函数分别是begin（）和end（），一个返回首元素地址，一个返回末尾元素的下一个地址。然后用一个指针来接收他们的返回值，我们只需要把这个指针封装成迭代器的写法即可。

        迭代器实现代码如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;
#include<assert.h>

namespace ZH
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		vector()//构造函数
		{}

		size_t size()const//得到元素个数
		{
			return _finish - _start;
		}

		size_t capacity()const//得到空间大小
		{
			return _end_of_storage - _start;
		}

		void reserve(size_t n)//扩容函数
		{
			if (n > capacity())
			{
				T* temp = new T[n];
				size_t poi = _finish - _start;//先把_start和_finish之间的距离记录下来
				if (_start != nullptr)
				{
					memcpy(temp, _start, sizeof(T) * size());//拷贝数据
					delete[] _start;
				}
				_start = temp;//更新_start的指向
				_finish = _start + poi;
				_end_of_storage = _start + n;
			}
		}

		void push_back(const T& val)
		{
			if (_finish == _end_of_storage)//相等说明当前容量不够
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);//扩容
			}

			*_finish = val;//尾插
			_finish++;
		}
		//普通版本迭代器函数
		iterator begin()
		{
			return _start;
		}

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

		const_iterator end()const
		{
			return _finish;
		}

	private:
		iterator _start = nullptr;//缺省值赋予空
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

int main()
{
	//实例化对象v1
	ZH::vector<int> v1;
	//尾插五个数
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	//普通迭代器
	ZH::vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		(*it)++;
		cout << *it << " ";
		it++;
	}
	cout << endl;
	//const版本的迭代器
	ZH::vector<int>::const_iterator cit = v1.begin();
	while (cit != v1.end())
	{
		//(*cit)++;//const版本迭代器不能通过迭代器修改对象中的内容
		cout << *cit << " ";
		cit++;
	}
	return 0;
}

        运行结果：

4、resize

void resize(size_t n, const T& t = T())
//n表示期望的元素个数
//t表示补齐元素的值

        resize的作用是控制元素个数的多少，如果n大于当前元素的总数，则会在后面补齐元素，并且补齐元素的值为t，如果n大于该对象的容量，则会自动扩容。当n小于当前元素的总数，则该对象内的有效元素个数为n个（注意resize不会进行缩容）。

        模拟实现resize：

#include<iostream>
using namespace std;
#include<assert.h>

namespace ZH
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

		vector()//构造函数
		{}

		size_t size()const//得到元素个数
		{
			return _finish - _start;
		}

		size_t capacity()const//得到空间大小
		{
			return _end_of_storage - _start;
		}

		void reserve(size_t n)//扩容函数
		{
			if (n > capacity())
			{
				T* temp = new T[n];
				size_t poi = _finish - _start;//先把_start和_finish之间的距离记录下来
				if (_start != nullptr)
				{
					memcpy(temp, _start, sizeof(T) * size());//拷贝数据
					delete[] _start;
				}
				_start = temp;//更新_start的指向
				_finish = _start + poi;
				_end_of_storage = _start + n;
			}
		}
		void push_back(const T& val)
					{
						if (_finish == _end_of_storage)//相等说明当前容量不够
						{
							reserve(capacity() == 0 ? 4 : capacity() * 2);//扩容
						}
			
						*_finish = val;//尾插
						_finish++;
					}
		void resize(size_t n, const T& t = T())//匿名对象具有常属性
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				if (n > capacity())
					reserve(n);
				while (_finish != _start + n)
				{
					*_finish = t;
					_finish++;
				}
			}
		}

		//普通版本迭代器函数
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

	private:
		iterator _start = nullptr;//缺省值赋予空
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

int main()
{
	//实例化对象v1
	ZH::vector<int> v1;
	//尾插五个数
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	v1.resize(8);//验证n大于元素总数

	ZH::vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	v1.resize(3);//验证n小于元素总数

	it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}

	return 0;
}

         运行结果：

5、删除数据 

         vector类可以看作是一个数组，数组的删除数据有尾删和指定位置删除，尾删就很简单了，直接让_finish--即可，因为打印数据时不会打印_finish的位置，当指针_finish指向最后一个元素，表示最后一个元素不打印，则达到了间接尾插。

        而指定位置删除就稍微复杂些，比如删除第一个元素，那么要让后面的元素整体往前移到一位，最后再让_finish--，这样挪动数据的消耗是很大的。

        指定位置删除数据代码如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;
#include<assert.h>

namespace ZH
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

		vector()//构造函数
		{}

		size_t size()const//得到元素个数
		{
			return _finish - _start;
		}

		size_t capacity()const//得到空间大小
		{
			return _end_of_storage - _start;
		}

		void reserve(size_t n)//扩容函数
		{
			if (n > capacity())
			{
				T* temp = new T[n];
				size_t poi = _finish - _start;//先把_start和_finish之间的距离记录下来
				if (_start != nullptr)
				{
					memcpy(temp, _start, sizeof(T) * size());//拷贝数据
					delete[] _start;
				}
				_start = temp;//更新_start的指向
				_finish = _start + poi;
				_end_of_storage = _start + n;
			}
		}

		void push_back(const T& val)
		{
			if (_finish == _end_of_storage)//相等说明当前容量不够
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);//扩容
			}

			*_finish = val;//尾插
			_finish++;
		}

		iterator erase(iterator pos)//指定位置删除,并返回当下位置
		{
			//检查pos是否合格
			assert(pos >= _start);
			assert(pos < _finish);

			iterator start = pos;
			while (start!=_finish-1)
			{
				*start = *(start + 1);//挪动数据
				start++;
			}
			_finish--;
			return pos;
		}

		//普通版本迭代器函数
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

	private:
		iterator _start = nullptr;//缺省值赋予空
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

int main()
{
	//实例化对象v1
	ZH::vector<int> v1;
	//尾插五个数
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	
	//删除
	ZH::vector<int>::iterator it = v1.begin()+1;//删除第二个元素
	v1.erase(it);//使用完it后，正常来说it是会失效的
	v1.erase(it);//删除第二个元素后，后面的元素往前挪动，则it指向的是第三个元素
	v1.erase(v1.end() - 1);//删除最后一个元素


	it = v1.begin();//it失效了需要重新赋值
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
	
	return 0;
}

         运行结果：

5.1 迭代器失效 

         一般而言，用一个迭代器进行erase后，该迭代器会发生失效，原因就是会出现以下情况：

        因此经过erase之后的迭代器会认为是失效的，即不能继续使用该迭代器。

6、指定位置插入数据

        指定位置插入数据就是将该位置之后的所有数据往后面挪一位，然后直接把要插入的数据放到该位置即可。（注意扩容问题）

        插入代码如下：

#include<iostream>
using namespace std;
#include<assert.h>

namespace ZH
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

		vector()//构造函数
		{}

		size_t size()const//得到元素个数
		{
			return _finish - _start;
		}

		size_t capacity()const//得到空间大小
		{
			return _end_of_storage - _start;
		}

		void reserve(size_t n)//扩容函数
		{
			if (n > capacity())
			{
				T* temp = new T[n];
				size_t poi = _finish - _start;//先把_start和_finish之间的距离记录下来
				if (_start != nullptr)
				{
					memcpy(temp, _start, sizeof(T) * size());//拷贝数据
					delete[] _start;
				}
				_start = temp;//更新_start的指向
				_finish = _start + poi;
				_end_of_storage = _start + n;
			}
		}

		void push_back(const T& val)
					{
						if (_finish == _end_of_storage)//相等说明当前容量不够
						{
							reserve(capacity() == 0 ? 4 : capacity() * 2);//扩容
						}
			
						*_finish = val;//尾插
						_finish++;
					}

		void Insert(iterator pos, const T& val)
		{
			assert(pos >= _start);
			assert(pos <= _finish);

			if (_finish == _end_of_storage)//相等说明当前容量不够
			{
				size_t len = pos - _start;//记录pos与_start之间的距离
				reserve(capacity() == 0 ? 4 : capacity() * 2);//扩容
				pos = _start + len;//依靠len更新pos的新位置
			}

			iterator end = _finish-1;
			while (end>=pos)
			{
				*(end+1) = *end;
				end--;
			}
			
			*pos = val;
			_finish++;
		}
	
		//普通版本迭代器函数
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

	private:
		iterator _start = nullptr;//缺省值赋予空
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

int main()
{
	//实例化对象v1
	ZH::vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	
	v1.Insert(v1.begin()+2, 30);
	
	ZH::vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	
	return 0;
}

         运行结果：

         扩容导致的问题如下图：

6.1 迭代器失效

        用一个迭代器进行插入后，该迭代器也会失效，原因是虽然Insert函数里面的pos进行了位置的更新，但是形参的改变不影响实参，外面的pos实质上还是指向原来空间的位置，此时的pos就处于野指针行为，因此不能进行对其进行使用了。

7、迭代器构造和resize构造

        vector类的构造方式除了上面的默认构造还有迭代器构造和resize构造，即实例化对象就能让该对象中拥有数据。

        两种构造方式代码如下：

#include<iostream>
using namespace std;
#include<assert.h>

namespace ZH
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

		vector()//构造函数
		{}

		vector(size_t n, const T& t = T())//resize构造
		{
			resize(n, t);
		}

		template<class Inputinteraor>
		vector(Inputinteraor left, Inputinteraor right)//迭代器构造
		{
			size_t sz = right - left;
			reserve(sz);
			while (left != right)
			{
				push_back(*left);
				left++;
			}
		}

		void push_back(const T& val)
		{
			if (_finish == _end_of_storage)
				reserve(capacity() == 0 ? 4 : capacity() * 2);

			*_finish = val;
			_finish++;
		}

		void resize(size_t n, const T& t = T())//匿名对象具有常属性
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				if (n > capacity())
					reserve(n);
				while (_finish != _start + n)
				{
					*_finish = t;
					_finish++;
				}
			}
		}

		size_t size()const//得到元素个数
		{
			return _finish - _start;
		}

		size_t capacity()const//得到空间大小
		{
			return _end_of_storage - _start;
		}

		void reserve(size_t n)//扩容函数
		{
			if (n > capacity())
			{
				T* temp = new T[n];
				size_t poi = _finish - _start;//先把_start和_finish之间的距离记录下来
				if (_start != nullptr)
				{
					memcpy(temp, _start, sizeof(T) * size());//拷贝数据
					delete[] _start;
				}
				_start = temp;//更新_start的指向
				_finish = _start + poi;
				_end_of_storage = _start + n;
			}
		}

		//普通版本迭代器函数
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

	private:
		iterator _start = nullptr;//缺省值赋予空
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

int main()
{
	ZH::vector<int> v1(10u, 6);//resize构造
	ZH::vector<int> v2(v1.begin(),v1.end());//迭代器构造

	ZH::vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

	ZH::vector<int>::iterator it2 = v2.begin();
	while (it2 != v2.end())
	{
		cout << *it2 << " ";
		it2++;
	}
	cout << endl;

	return 0;
}

        运行结果：

8、深浅拷贝

        若我们自己不写拷贝构造则系统会自动生成一个拷贝构造，但是系统自动生成的拷贝构造只能完成浅拷贝，即一些成员变量的值拷贝，但是这里的vector涉及到空间的开辟，因此不能用浅拷贝完成vector类型的拷贝，原因如下图：

        我们所期望的是v2指向一块属于自己的空间，如下图：

         但是即便是v2有一块属于自己的空间也不是完全解决了问题，因为vector的类型可以是自定义类型，这时候如果当vector的类型是string类型，那么vector中的每个元素都是string类型，则每个元素自己内部又会新开辟一块空间，这时候就是深拷贝的问题了。

        示意图如下：

        我们所期望的是每个自定义元素也指向一块属于该元素的空间：

        因此当把v1里的元素拷贝给到v2的新空间时，元素之间的拷贝必须也是深拷贝，双重深拷贝代码如下： 

#include<iostream>
using namespace std;
#include<assert.h>

namespace ZH
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;

		vector()//构造函数
		{}

		void push_back(const T& val)
		{
			if (_finish == _end_of_storage)
				reserve(capacity() == 0 ? 4 : capacity() * 2);

			*_finish = val;
			_finish++;
		}

		size_t size()const//得到元素个数
		{
			return _finish - _start;
		}

		size_t capacity()const//得到空间大小
		{
			return _end_of_storage - _start;
		}

		void reserve(size_t n)//扩容函数
		{
			if (n > capacity())
			{
				T* temp = new T[n];
				size_t poi = _finish - _start;//先把_start和_finish之间的距离记录下来
				if (_start != nullptr)
				{
					memcpy(temp, _start, sizeof(T) * size());//拷贝数据
					delete[] _start;
				}
				_start = temp;//更新_start的指向
				_finish = _start + poi;
				_end_of_storage = _start + n;
			}
		}

		vector(const vector<T>& val)//深拷贝构造
		{
			_start = new T[val.capacity()];
			for (size_t i = 0; i < val.size(); i++)
			{
				//会调用string的运算符重载，而sting的运算符重载本身就是深拷贝
				_start[i] = val._start[i];
			}
			_finish = _start + val.size();
			_end_of_storage = _start + val.capacity();
		}

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

		//普通版本迭代器函数
		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

	private:
		iterator _start = nullptr;//缺省值赋予空
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

int main()
{
	ZH::vector<string> v1;
	v1.push_back("hello");
	v1.push_back("hello");

	ZH::vector<string> v2 = v1;//双重深拷贝构造
	//打印v2的值
	ZH::vector<string>::iterator it = v2.begin();
	while (it != v2.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

	return 0;
}

        运行结果：

        这里值得注意的是代码可以正常运行，意味着析构的时候没有出问题，即没有出现同一块空间被析构两次的情况。 

结语：

        以上就是关于vector的模拟实现，通过模拟实现可以帮助我们更深层次的了解vector类，vector类实质上就是一个动态的数组，只不过用起来更加便捷。最后希望本文可以给你带来更多的收获，如果本文对你起到了帮助，希望可以动动小指头帮忙点赞👍+关注😎+收藏👌！如果有遗漏或者有误的地方欢迎大家在评论区补充，谢谢大家！！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

计算机二级WPS Office考试须知、如何备考、备考建议

计算机二级WPS Office考试须知、如何备考、备考建议

本文从计算机二级考试须知、如何备考、备考建议以及考试的注意事项等方面进行讲述&#xff0c;认认真真看&#xff0c;对你受益匪浅。 一、计算机二级考试须知 2021年3月27日至29日将举办第60次全国计算机等级考试&#xff08;NCRE&#xff09;&#xff0c;从今年起&#xff0…
阅读更多...
加速你的数据库：公司中SQL优化的八大绝招

加速你的数据库：公司中SQL优化的八大绝招

前言 SQL优化这个问题也是老生常谈了&#xff0c;很多都还是在八股文中了解到&#xff0c;那么公司里的SQL都是咋优化的呢&#xff1f;和八股文一样吗&#xff1f;下面&#xff0c;我将与大家分享我在公司里学到的SQL优化知识。SQL优化是提高数据库性能和减少资源消耗的重要一环…
阅读更多...
设计模式之空对象模式

设计模式之空对象模式

目录 1.简介 2.结构图 3.实例 4.优缺点 1.简介 空对象模式也是我们平时编程用的比较多的一种行为型设计模式&#xff0c;它的宗旨在解决空对象引起的异常报错问题&#xff1b;在空对象模式&#xff08;Null Object Pattern&#xff09;中&#xff0c;一个空对象取代 NULL 对…
阅读更多...
【一文详解】知识分享:(MySQL关系型数据库快速入门)

【一文详解】知识分享:(MySQL关系型数据库快速入门)

mysql基础 数据类型 整型 类型名称取值范围大小TINYINT-128〜1271个字节SMALLINT-32768〜327672个宇节MEDIUMINT-8388608〜83886073个字节INT (INTEGHR)-2147483648〜21474836474个字节BIGINT-9223372036854775808〜92233720368547758078个字节 注: 无符号在数据类型后加 un…
阅读更多...
免费申请SSL证书

免费申请SSL证书

首先&#xff0c;让我们了解一下SSL证书的作用。SSL&#xff08;Secure Sockets Layer&#xff09;证书是一种数字证书&#xff0c;它可以加密网站与用户之间的通信数据&#xff0c;防止信息在传输过程中被窃取或篡改&#xff0c;同时也可以验证网站的真实身份&#xff0c;避免…
阅读更多...
electron+vue编辑Office Word?

electron+vue编辑Office Word?

Electron 桌面应用是基于 Chromium 内核的&#xff0c;而谷歌Chrome取消了对PPAPI插件支持后&#xff0c;在线Office方案纷纷失效&#xff0c;只能更换国产浏览器在低版本浏览器苟延残喘&#xff0c;不能用于electronvue项目。 经过小编不断的寻找&#xff0c;终于找到一款至今…
阅读更多...
对git中tag, branch的重新理解

对git中tag, branch的重新理解

1. 问题背景 项目中之前一个tag&#xff08;v1.0&#xff09;打错了&#xff0c;想删除它&#xff0c;但我们从此tag v1.0中迁出新建分支Branch_v1.0,在此分支下修复了bug&#xff0c;想重新打一个tag v1.0&#xff0c;原来的tag v1.0可以删除掉吗&#xff1f; 错误的理解&am…
阅读更多...
Starrocks监控方案

Starrocks监控方案

下载安装包 Download | Prometheus Download Grafana | Grafana Labs 部署prometheus 配置文件 global: scrape_interval: 15s evaluation_interval: 15s scrape_configs: - job_name: StarRocks_Cluster metrics_path: /metrics static_configs: - targets: [192.168.110…
阅读更多...
【BetterBench】2024年都有哪些数学建模竞赛和大数据竞赛？

【BetterBench】2024年都有哪些数学建模竞赛和大数据竞赛？

2024年每个月有哪些竞赛&#xff1f; 2024年32个数学建模和数据挖掘竞赛重磅来袭&#xff01;&#xff01;&#xff01; 2024年数学建模和数学挖掘竞赛时间目录汇总 一月 &#xff08;1&#xff09;2024年第二届“华数杯”国际大学生数学建模竞赛 报名时间&#xff1a;即日起…
阅读更多...
同城短视频矩阵怎么做？小魔推助力实体行业高效视频分发

同城短视频矩阵怎么做？小魔推助力实体行业高效视频分发

在如今的互联网时代&#xff0c;各个行业的实体老板都在考虑转型的方向&#xff0c;希望能有更多的发展&#xff0c;特别是抖音短视频做作为日活8亿用户的超大平台&#xff0c;吸引了无数的实体老板入场做宣传&#xff0c;来做自己门店、品牌的曝光获客动作&#xff0c;但引流并…
阅读更多...
C++力扣题目104--二叉树的最大深度

C++力扣题目104--二叉树的最大深度

给定一个二叉树&#xff0c;找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例&#xff1a; 给定二叉树 [3,9,20,null,null,15,7]&#xff0c; 返回它的最大深度 3 。 思路 看完本篇可以一起做了如下…
阅读更多...
Apache Doris (六十三）： Spark Doris Connector - (3)-配置型及列映射关系

Apache Doris (六十三）： Spark Doris Connector - (3)-配置型及列映射关系

🏡 个人主页：IT贫道-CSDN博客 🚩 私聊博主：私聊博主加WX好友，获取更多资料哦~ 🔔 博主个人B栈地址：豹哥教你学编程的个人空间-豹哥教你学编程个人主页-哔哩哔哩视频 目录 1. Spark 操作Doris配置项
阅读更多...
CentOS中静态HTTP服务的最佳实践和优化技巧

CentOS中静态HTTP服务的最佳实践和优化技巧

在CentOS中提供静态HTTP服务是常见的需求&#xff0c;尤其是在构建Web应用程序、托管网站或提供文件下载时。为了确保高效、安全且可靠的传输&#xff0c;这里提供了一些最佳实践和优化技巧。 1. 选择合适的HTTP服务器软件 Nginx: 轻量级、高效&#xff0c;支持HTTP/2&#x…
阅读更多...
【安卓模拟器】雷电模拟器9 v9.0.64 绿色版（免安装版，一键绿化）

【安卓模拟器】雷电模拟器9 v9.0.64 绿色版（免安装版，一键绿化）

下载地址 极核GetShell 简介 雷电模拟器9是一款安卓模拟器&#xff0c;支持安卓9版本。安卓模拟器除了能够运行游戏娱乐&#xff0c;对于渗透测试&移动安全测试也有举足轻重的作用。 软件截图 绿化教程 视频教程 下载地址提供了视频绿化教程&#xff0c;有需要的可以…
阅读更多...
工单系统：助力传统服务行业实现数字化转型的关键要素

工单系统：助力传统服务行业实现数字化转型的关键要素

数字化转型的浪潮冲击着传统服务业&#xff0c;对其造成了巨大的影响。其中&#xff0c;工单系统以其多样和强大的功能性&#xff0c;成为传统服务行业必备的数字工具。今天&#xff0c;小编就来大家来聊聊工单系统对传统服务行业有哪些影响&#xff1f;希望对于还未投入使用的…
阅读更多...
视频壁纸制作Dynamic Wallpaper中文

视频壁纸制作Dynamic Wallpaper中文

Dynamic Wallpaper是一款专门为macOS用户设计的动态壁纸软件。它可以将视频、图片、音乐等多种元素融合在一起&#xff0c;为用户的桌面带来生动、个性化的视觉效果。Dynamic Wallpaper内置了大量动态壁纸&#xff0c;包括自然风景、城市风貌、抽象艺术等多种主题。用户可以根据…
阅读更多...
【大数据OLAP引擎】StarRocks为什么快？

【大数据OLAP引擎】StarRocks为什么快？

StarRocks的优势 StarRocks最初主要的优势是性能&#xff0c;当时在单表查询方面与性能标杆ClickHouse不相上下&#xff0c;而join优化特性使其在多表关联查询场景下的性能表现要远远优于ClickHouse&#xff0c;替换ClickHouse自然也就成了StarRocks的第一个目标。 而StarRoc…
阅读更多...
2024年口碑好的外贸CRM软件推荐

2024年口碑好的外贸CRM软件推荐

外贸CRM软件是指专门为外贸行业设计开发的客户关系管理软件。它通过集成各种功能模块&#xff0c;帮助外贸企业管理客户信息、销售机会、订单跟踪、市场活动等重要业务流程。外贸CRM软件可以提高外贸企业的销售效率和客户满意度&#xff0c;帮助企业建立良好的客户关系&#xf…
阅读更多...
（详细版）Vary: Scaling up the Vision Vocabulary for Large Vision-Language Models

（详细版）Vary: Scaling up the Vision Vocabulary for Large Vision-Language Models

Haoran Wei1∗, Lingyu Kong2∗, Jinyue Chen2, Liang Zhao1, Zheng Ge1†, Jinrong Yang3, Jianjian Sun1, Chunrui Han1, Xiangyu Zhang1 1MEGVII Technology 2University of Chinese Academy of Sciences 3Huazhong University of Science and Technology arXiv 2023.12.11 …
阅读更多...
卖家必看！跨境电商独立站选品思路——电商API接口采集更便捷高效的选品方式

卖家必看！跨境电商独立站选品思路——电商API接口采集更便捷高效的选品方式

要想打造一个成功的独立站&#xff0c;选品过程至关重要。只有先确定选品&#xff0c;才能完成后续的具体定价、库存备货、店铺风格、匹配支付和物流等等。那么&#xff0c;对于需要搭建独立站的卖家而言&#xff0c;该如何去进行选品&#xff0c;有哪些思路和方法呢&#xff1…
阅读更多...
最新文章

Copyright @ 2022~2023