【C++】学习笔记——vector_3

news2024/12/23 20:13:57

文章目录

  • 七、vector
    • 3. vector的模拟实现
    • 4. vector实现代码整合
  • 未完待续

七、vector

3. vector的模拟实现

上篇文章我们讲解了非常 玄幻 的拷贝构造函数，同样的方法，我们也能用这种方法来实现 赋值重载函数 。

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;
}

传值传参会调用拷贝构造，所以我们只需要将其与我们要赋值的给交换即可。
我们来测试一下：

// 测试区
void test06()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);

	vector<int> v1 = v;

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

// test.cpp
#include<iostream>
#include"vector.h"
using namespace std;

int main()
{
	my::test06();
	return 0;
}

在这里插入图片描述

接下来实现一个比较奇怪的东西：迭代器区间构造 。一般容器都会支持这个函数。

// 类模板的成员函数可以是函数模板
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
	//
}

是的，类模板里面又加了一个函数模板，这样的作用是什么呢？这样的作用就是，这个函数模板可以不局限于类内的迭代器，只要符合模板参数，其他类的迭代器同样可以调用该函数 。这样可以使容器与容器之间发生交互。原理就是这样，实现起来也很简单：

// 类模板的成员函数可以是函数模板
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

我们来测试一下：

// 测试区
void test07()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);

	// 这里也可以使用其他容器的迭代器
	vector<int> v1(v.begin() + 1, v.end() - 1);
	for (auto e : v1)
	{
		std::cout << e << " ";
	}
	std::cout << std::endl;
}

// test.cpp
#include<iostream>
#include"vector.h"
using namespace std;

int main()
{
	my::test07();
	return 0;
}

在这里插入图片描述
所以说这个迭代器区间构造也是非常好用的。

还有这个构造函数：构造 n 个给定值

// 和resize差不多
vector(size_t n, const T& val = T())
{
	reserve(n);
	for (size_t = 0; i < n; ++i)
	{
		push_back(val);
	}
}

我们来测试一下：

void test08()
{
	// 初始化 10 个 1
	vector<int> v(10, 1);

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

在这里插入图片描述
啊？哪出问题了？看看错误列表：
在这里插入图片描述
通过错误行数，我们找到了：
在这里插入图片描述

啊？咋调用到这来了，误把我的参数看成迭代器了？该怎么办呢？其实是这样的：我们实现的 构造n个给定值 的构造函数里，第一个参数是 size_t ，而在迭代器区间构造函数里，两个参数是相同的 ，这样会导致，我构造 10 个 1 所给的参数更加符合 迭代器区间构造函数 ，因为对另一个来说，有一个 size_t 参数不匹配，所以优先调用迭代器区间构造函数了。所以怎么办？简简单单：size_t 换成 int 就行 ，虽然对于个数来说， size_t 更加符合，毕竟没有负数，但是 int 也不影响。

vector(int n, const T& val = T())
{
	reserve(n);
	for (size_t i = 0; i < n; ++i)
	{
		push_back(val);
	}
}

在这里插入图片描述
OK，完美解决。
我来给出一个情景：

void test09()
{
	vector<std::string> v;
	v.push_back("11111");
	v.push_back("22222");
	v.push_back("33333");

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

这段程序的结果是什么？
在这里插入图片描述
没错，是不是非常简单？再来看看：

void test09()
{
	vector<std::string> v;
	v.push_back("11111");
	v.push_back("22222");
	v.push_back("33333");
	v.push_back("44444");
	v.push_back("55555");

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

这样呢？
在这里插入图片描述

在这里插入图片描述
蛤，报错了。打印倒是打印出来了，那么问题肯定不是出在打印上面，那就是析构。析构出了问题，我们首先想到的就是深浅拷贝，我们所有的函数都避免了浅拷贝，为什么最后还是会出现析构问题？
在这里插入图片描述
其实问题出在 reserve 函数里的 memcpy 。memcpy其实是浅拷贝，按照字节一个一个拷贝。就出现了如下图的情况。

在这里插入图片描述
这样导致我们在析构 _start 时，将内容也给析构了，所以后面生命周期结束时的析构就出现了多重析构的问题。既然知道了问题所在，那该如何解决问题呢？

void reserve(size_t n)
{
	// 比当前容量大才允许扩容
	if (n > capacity())
	{
		size_t old_size = size();
		// 开空间
		T* tmp = new T[n];

		// for循环赋值
		for (size_t i = 0; i < old_size; ++i)
		{
			tmp[i] = _start[i];
		}
		// 释放旧空间
		delete[] _start;

		// 更改地址
		_start = tmp;
		_finish = _start + old_size;
		_endofstorage = _start + n;
	}
}

换成 for循环赋值就可以了 。
在这里插入图片描述
最后再给大家阐述一下 迭代器失效的问题。我们在 insert 中第一次遇到了迭代器失效的问题，但是我们通过更新地址的问题解决了迭代器失效的问题。

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

	// 记录相对位置
	size_t len = pos - _start;
	if (_finish == _endofstorage)
	{
		reserve(capacity() == 0 ? 4 : 2 * capacity());
	}

	// 如果发生异地扩容，需要更新 迭代器 ，否则将会发生迭代器失效
	pos = _start + len;

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

	*pos = val;
	++_finish;
}

但是，大家有没有想过，这里的迭代器传入的是临时变量，临时变量更新了后，实参并不会修改，所以在外面这个迭代器的值已经 不可信 了。有人说可以将这个迭代器使用 引用传参 ，这样也不可以！

v.insert(v.begin(), 1);

这里传参都是传的临时变量，然而 临时变量具有常性，加了引用就用不了了，除非再加 const ，加了 const 就更不行了，不能修改的迭代器算什么迭代器？所以这里没有一种好的解决办法，想告诉大家的是：迭代器在修改容器的内容后就已经不再可信了 ，若需要再次使用迭代器，重新创建一个即可。
我们知道了 insert 可能产生 迭代器失效，那么 erase 会产生吗？有小伙伴可能会说，erase 根本就不会扩容，没有空间移动，那就不会出现迭代器失效。我再给大家看看一个场景：我们来删除容器里的偶数

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

	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.erase(it);
		}
		++it;
	}

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

在这里插入图片描述
没出现问题，那这样呢：

void test10()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	// 这里有两个 4
	v.push_back(4);
	v.push_back(4);
	v.push_back(5);

	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.erase(it);
		}
		++it;
	}

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

在这里插入图片描述
？这怎么出问题了？

void test10()
{
	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(4);

	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
		{
			v.erase(it);
		}
		++it;
	}

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

在这里插入图片描述
啊？这样程序还能挂掉？
聪明的小伙伴们可以想到，erase 函数删除后会将后面的数据前往移动，删除后迭代器的位置是一个新的数据，然后 ++it 就会错过元素，就会出现答案不对的情况，如果错过了 end 迭代器表示的位置，将会导致循环终止不了，所以引发了一系列问题。那么，该如何解决呢？

auto it = v.begin();
while (it != v.end())
{
	if (*it % 2 == 0)
	{
		v.erase(it);
	}
	else
	{
		++it;
	}
}

这样可以吗？说可以也可以，说不可也不可以。在一般情况下，erase 都不会产生 缩容 的情况，但是没有规定不可以缩容，假如真的有个容器 erase 后会发生缩容问题，那就会导致迭代器失效，就不能使用了。那么库里的 vector 是怎么解决这个问题的呢？我们来看看函数原型：
在这里插入图片描述
在这里插入图片描述
是的，库里 vector 的 erase 会返回一个迭代器，指向刚刚被删除的位置。所以库里的 erase 应该这样使用：

auto it = v.begin();
while (it != v.end())
{
	if (*it % 2 == 0)
	{
		// 更新迭代器
		it = v.erase(it);
	}
	else
	{
		++it;
	}
}

那我们的 erase 就要做出相应的修改：

iterator erase(iterator pos)
{
	assert(pos >= _start);
	// 不要等于 _finish
	assert(pos < _finish);

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

	--_finish;

	return pos;
}

再来测试一下：
在这里插入图片描述ok，实现完毕。到这里我们的 vector 已经非常优秀了。

4. vector实现代码整合

vector.h 头文件：

#pragma once

#include<assert.h>

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

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		// 类模板的成员函数可以是函数模板
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		vector()
		{}

		vector(const vector<T>& v)
		{
			reserve(v.capacity());
			for (auto& e : v)
			{
				push_back(e);
			}
		}

		vector(int n, const T& val = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; ++i)
			{
				push_back(val);
			}
		}

		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;
		}

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

		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];
		}

		void reserve(size_t n)
		{
			// 比当前容量大才允许扩容
			if (n > capacity())
			{
				size_t old_size = size();
				// 开空间
				T* tmp = new T[n];

				// for循环赋值
				for (size_t i = 0; i < old_size; ++i)
				{
					tmp[i] = _start[i];
				}
				// 释放旧空间
				delete[] _start;

				// 更改地址
				_start = tmp;
				_finish = _start + old_size;
				_endofstorage = _start + n;
			}
		}

		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;
			}
		}

		void push_back(const T& val)
		{
			 判断扩容
			//if (_finish == _endofstorage)
			//{
			//	reserve(capacity() == 0 ? 4 : 2 * capacity());
			//}

			 插入数据
			//*_finish = val;
			//++_finish;
			insert(end(), val);
		}

		// 尾删
		void pop_back()
		{
			//assert(!empty());
			//
			//--_finish;
			erase(end() - 1);
			--_finish;
		}

		// 判断容器是否为空
		bool empty()
		{
			return _start == _finish;
		}

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

			// 记录相对位置
			size_t len = pos - _start;
			if (_finish == _endofstorage)
			{
				reserve(capacity() == 0 ? 4 : 2 * capacity());
			}

			// 如果发生异地扩容，需要更新 迭代器 ，否则将会发生迭代器失效
			pos = _start + len;

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

			*pos = val;
			++_finish;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			// 不要等于 _finish
			assert(pos < _finish);

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

			--_finish;

			return pos;
		}
	private:
		// 数据起始地址
		iterator _start = nullptr;
		// 数据末尾的下一个地址
		iterator _finish = nullptr;
		// 容量末尾的下一个地址
		iterator _endofstorage = nullptr;
	};
	
	// 测试区
	void test01()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

		for (int i = 0; i < v.size(); ++i)
		{
			std::cout << v[i] << " ";
		}
		std::cout << std::endl;
	}

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

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

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

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

		// 头部插入一个0
		v.insert(v.begin(), 0);
		// 尾删
		v.pop_back();

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

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

		v.resize(10);
		for (auto e : v)
		{
			std::cout << e << " ";
		}
		std::cout << std::endl;

		v.resize(30, 7);
		for (auto e : v)
		{
			std::cout << e << " ";
		}
		std::cout << std::endl;

		v.resize(3);
		for (auto e : v)
		{
			std::cout << e << " ";
		}
		std::cout << std::endl;
	}

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

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

		vector<int> v1(v);

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

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

		vector<int> v1 = v;

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

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

		// 这里也可以使用其他容器的迭代器
		vector<int> v1(v.begin() + 1, v.end() - 1);
		for (auto e : v1)
		{
			std::cout << e << " ";
		}
		std::cout << std::endl;
	}

	void test08()
	{
		// 初始化 10 个 1
		vector<int> v(10, 1);

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

	void test09()
	{
		vector<std::string> v;
		v.push_back("11111");
		v.push_back("22222");
		v.push_back("33333");
		v.push_back("44444");
		v.push_back("55555");

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

	void test10()
	{
		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(4);

		auto it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				it = v.erase(it);
			}
			else
			{
				++it;
			}
		}

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

tset.cpp 源文件

#include<iostream>
#include"vector.h"
using namespace std;

int main()
{
	my::test10();
	return 0;
}

未完待续

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

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

相关文章

哈尔滨等保测评模拟题

哈尔滨等保测评模拟题

《中华人民共和国网络安全法》中规定计算机信息系统安全保护等级共分为五级。&#xff08; t &#xff09;2019年&#xff0c;随着标准GB/T22239的更新&#xff0c;等级保护进入2.0时代。&#xff08; t&#xff09;某单位信息系统的等级定义为S2A3G2&#xff0c;根据取高原则…
阅读更多...
自学Python爬虫js逆向（二）chrome浏览器开发者工具的使用

自学Python爬虫js逆向（二）chrome浏览器开发者工具的使用

js逆向中很多工作需要使用浏览器中的开发者工具&#xff0c;所以这里以chrome为例&#xff0c;先把开发者工具的使用总结一下&#xff0c;后面用到的时候可以回来查询。 Google Chrome浏览器的开发者工具是前端开发者的利器&#xff0c;它不仅提供了丰富的功能用于开发、调试和…
阅读更多...
实验九 Java 语言网络通信程序设计练习(课内实验)

实验九 Java 语言网络通信程序设计练习(课内实验)

一、实验目的 本次实验的主要目的是练习网络通信程序的设计方法&#xff0c;并掌握计算机网络基 础知识、Java语言网络通信程序类库的结构和使用方法。 二、实验要求 1. 认真阅读实验内容&#xff0c;完成实验内容所设的题目。 2. 能够应用多种编辑环境编写Java语言源程序…
阅读更多...
如何使用DEEPL免费翻译PDF

如何使用DEEPL免费翻译PDF

如何使用DEEPL免费翻译PDF 安装DEEPL取消PDF限制 安装DEEPL 安装教程比较多&#xff0c;这里不重复。 把英文pdf拖进去&#xff0c;点翻译&#xff0c;在下面的框中有已经翻译完毕的文档。 但是存在两个问题 问题1&#xff1a;这些文档是加密的。 问题2&#xff1a;带有DeepL标…
阅读更多...
去掉antd design vue组件库中表格的分割线

去掉antd design vue组件库中表格的分割线

前言&#xff1a; 最近在公司完成UI设计稿的时候&#xff0c;需要使用antd design vue组件库中表格&#xff0c;但是UI设计稿中并不需要表格分割线&#xff0c;尝试了多种方式最后实现如下&#xff1a; <style lang"scss" scoped>::v-deep .ant-table-cell::…
阅读更多...
Django中如何让页面之间建立关系

Django中如何让页面之间建立关系

今天给大家讲解两种让页面建立联系的方式 一、重定向 二、表单提交 先看第一种方式&#xff0c;重定向 首先需要了解客户端发起请求的过程 1、客户端向服务端发起请求,比如请求地址是&#xff1a;http://127.0.0.1:8000/lili/submit/ 2、程序根据路由找到视图函数 3、执行视…
阅读更多...
汽车 - 什么是车轮抱死

汽车 - 什么是车轮抱死

车轮抱死分为两种情况&#xff0c;一种是车辆故障层面&#xff0c;另一种是驾驶过程中的物理现象。我们先来说最通俗的刹车车轮抱死吧。 刹车制动车轮抱死 车轮停止轴向转动就是抱死&#xff0c;有速度的情况下抱死车轮&#xff0c;如果车辆的惯性动能大于轮胎抓地力&#xff0…
阅读更多...
How Linux Works I - How Linux Start Up

How Linux Works I - How Linux Start Up

目录 Linux如何启动&#xff1f; 启动信息 内核启动初始化与启动选项 写在前面&#xff1a;上一个专栏中我写完了内核源码层面看Linux&#xff0c;我们把抽象层拉高一点&#xff0c;看看Linux是如何工作的&#xff01; Linux如何启动&#xff1f; BIOS&#xff08;Basic Inpu…
阅读更多...
CSS探索之旅:定位

CSS探索之旅:定位

前言 欢迎来到我的博客 个人主页:北岭敲键盘的荒漠猫-CSDN博客 本文我们详细介绍 css中定位的相关知识点 定位的用处 先简单认识一下定位是做什么的。 其实&#xff0c;定位的功能就像他的名字一样&#xff0c;可以规定显示在网页的一个位置。 其他布局的效果 我们之前默认…
阅读更多...
C语言：环形链表

C语言：环形链表

1.例子1&#xff1a;环形链表 142. 环形链表 II - 力扣&#xff08;LeetCode&#xff09; 思路&#xff1a;我们先定义两个变量slow和fast&#xff0c;slow每次走一步&#xff0c;fast每次走两步&#xff0c;如果链表是环形链表&#xff0c;那么必定存在fast不会走到链表的最后…
阅读更多...
利用github pages建立Serverless个人博客

利用github pages建立Serverless个人博客

利用github pages建立Serverless个人博客 概述 使用github pages&#xff0c;可以在github上部署静态网站。利用这个功能&#xff0c;可以很方便地实现个人博客的发布托管。 比如我的个人博客&#xff1a;Buttering’s Blog 对应代码仓库&#xff1a;buttering/EasyBlog: 自…
阅读更多...
从一到无穷大 #26 Velox：Meta用cpp实现的大一统模块化执行引擎

从一到无穷大 #26 Velox：Meta用cpp实现的大一统模块化执行引擎

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。 本作品 (李兆龙 博文, 由 李兆龙 创作)&#xff0c;由 李兆龙 确认&#xff0c;转载请注明版权。 文章目录 引言业务案例PrestoSparkXStreamDistributed messaging systemData IngestionData Pr…
阅读更多...
【软件测试理论001】认识软件测试、测试分类、测试原则

【软件测试理论001】认识软件测试、测试分类、测试原则

目录 1 认识软件测试 1.1 什么是软件 1.2 什么是软件测试 1.3 软件测试的发展历程 1.4 为什么要进行软件测试 1.5 软件测试职业规划 2 软件测试的分类 2.1 按开发阶段划分 单元测试&#xff08;Unit Testing&#xff09; 集成测试&#xff08;Integration Testing&am…
阅读更多...
【ChatGPT with Date】使用 ChatGPT 时显示消息时间的插件

【ChatGPT with Date】使用 ChatGPT 时显示消息时间的插件

文章目录 1. 介绍2. 使用方法2.1 安装 Tampermonkey2.2 安装脚本2.3 使用 3. 配置3.1 时间格式3.2 时间位置3.3 高级配置(1) 生命周期钩子函数(2) 示例 4. 反馈5. 未来计划6. 开源协议7. 供给开发者自定义修改脚本的文档7.1 项目组织架构7.2 定义新的 Component(1) 定义一个新的…
阅读更多...
Vue2——前端笔记

Vue2——前端笔记

Vue 一、Vue核心1.1、vue简介1.2、初始vue1.3、模板语法1.4、数据绑定1.5、el与data的两种写法1.6、MVVM模型1.7、Vue中的数据代理1.7.1、Object.defineProperty() 理解1.7.2、Vue中的数据代理 1.8、事件处理1.8.1、事件的基本用法1.8.2、事件修饰符1.8.3、键盘事件 1.9、计算属…
阅读更多...
电商中文场景多模态测试prompt

电商中文场景多模态测试prompt

魔搭社区汇聚各领域最先进的机器学习模型&#xff0c;提供模型探索体验、推理、训练、部署和应用的一站式服务。https://www.modelscope.cn/datasets 多模态大模型Yi-VL-plus体验 效果很棒 - 知乎最近测了一下零一万物的多模态大模型Yi-VL-plus的效果&#xff0c;发现多模态理解…
阅读更多...
CNN实现卫星图像分类(tensorflow)

CNN实现卫星图像分类(tensorflow)

使用的数据集卫星图像有两类&#xff0c;airplane和lake&#xff0c;每个类别样本量各700张&#xff0c;大小为256*256&#xff0c;RGB三通道彩色卫星影像。搭建深度卷积神经网络&#xff0c;实现卫星影像二分类。 数据链接百度网盘地址&#xff0c;提取码: cq47 1、查看tenso…
阅读更多...
【一刷《剑指Offer》】面试题 14：调整数组顺序使奇数位于偶数前面

【一刷《剑指Offer》】面试题 14：调整数组顺序使奇数位于偶数前面

力扣对应题目链接&#xff1a;LCR 139. 训练计划 I - 力扣&#xff08;LeetCode&#xff09; 牛客对应题目链接&#xff1a;调整数组顺序使奇数位于偶数前面(二)_牛客题霸_牛客网 (nowcoder.com) 核心考点&#xff1a;数组操作&#xff0c;排序思想的扩展使用。 一、《剑指Off…
阅读更多...
LAME及 iOS 编译

LAME及 iOS 编译

文章目录 关于 LAME编译 for iOS 关于 LAME 官网&#xff1a;https://lame.sourceforge.io LAME是根据LGPL许可的高质量MPEG音频层III&#xff08;MP3&#xff09;编码器。 LAME的开发始于1998年年中左右。Mike Cheng 最开始将它作为针对8hz-MP3编码器源的补丁。在其他人提出…
阅读更多...
docker-本地私有仓库、harbor私有仓库部署与管理

docker-本地私有仓库、harbor私有仓库部署与管理

一、本地私有仓库&#xff1a; 1、本地私有仓库简介&#xff1a; docker本地仓库&#xff0c;存放镜像&#xff0c;本地的机器上传和下载&#xff0c;pull/push。 使用私有仓库有许多优点&#xff1a; 节省网络带宽&#xff0c;针对于每个镜像不用每个人都去中央仓库上面去下…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023