unoredered_mapunordered_set封装

news2024/11/13 22:16:27

各层封装关系

封装时细节/tips

Rfr Ptr用来constiterator

//HTIterator 模板
template<class K, class T, class Ptr, class Rfr, class KeyOfT, class Hash>
class HTIterator

//普通Iterator类 & const_iterator类
typedef HTIterator<K, T, T*, T&, KeyOfT, Hash> Iterator;
typedef HTIterator<K, T, const T*, const T&, KeyOfT, Hash> ConstIterator;

hashtable中必须写const Begin & const End   ，因为cosntiterator和iterator是两个不同的类，不可自动转换

//错误， iterater & const_iterator不是同一类， 也没有强转函数， 不可转化
bit::HashTable<string, pair<string, string>>::ConstIterator it = ss.Begin();

//正确， 类型匹配
bit::HashTable<string, pair<string, string>>::ConstIterator it = ss.cBegin();

因子比较记得转成小数

//错误， 两整数相除， 结果还是整数， 误差较大
if (_n / _tables.size() >= 1)//扩容

//正确
if (double(_n) / _tables.size() >= 1)//扩容

HTIterator 构造函数， _ptr不可const， _pht 一定要const 为了 constiterator 初始化（传递 const this，要用 const hashtable类接收）

//iterator构造函数
HTIterator(HashNode<T>* p, const HashTable<K, T, KeyOfT, Hash>* pht):
	_ptr(p),
	_pht(pht)
{}

//iterator成员类型
HashNode<T>* _ptr = nullptr;
const HashTable<K, T, KeyOfT, Hash>* _pht;

函数名后的const只修饰this指针

在类中，const成员函数只能调用const成员函数，因为this指针存在

但可以调用非成员函数的非const函数（在保证不权限放大情况下）

源代码：

代码库链接：daily-practice-code: 存放日常练习的代码， 包括网课内容练习， 各种容器/算法模拟实现， I/O好题等

main.cpp

#include "unordered_map.h"
#include "unordered_set.h"
using namespace std;

void test_hash_bucket()
{
	bit::HashTable<string, pair<string, string>> ss;
	ss.Insert(make_pair("1", "one"));
	ss.Insert(make_pair("2", "two"));
	ss.Insert(make_pair("3", "three"));
	ss.Insert(make_pair("4", "four"));
	ss.Insert(make_pair("5", "five"));
	ss.Insert(make_pair("6", "six"));
	ss.Insert(make_pair("7", "sevent"));
	ss.Insert(make_pair("8", "eight"));
	ss.Insert(make_pair("9", "nine"));
	ss.Insert(make_pair("10 ", "ten"));
	ss.Insert(make_pair("11", "eleven"));
	ss.Insert(make_pair("12", "twelve"));
	ss.Insert(make_pair("13", "thirteen"));
	bit::HashTable<string, pair<string, string>>::ConstIterator it = ss.cBegin();
	while (it != ss.cEnd())
	{
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << "hello unordered" << endl;
}

void test_unordered_map()
{
	bit::unordered_map<string, string> ss;
	ss["1"] = "one";
	ss["2"] = "two";
	ss["3"] = "three";
	ss.insert(make_pair("4", "four"));
	ss.insert(make_pair("5", "five"));
	ss.insert(make_pair("6", "six"));
	ss.insert(make_pair("7", "seven"));
	bit::unordered_map<string, string>::iterator it = ss.begin();
	cout << "before erase:" << endl;
	for (const auto& e: ss)
	{
		cout << e.first << ":" << e.second << endl;
	}
	cout << "fine(\" 2\")" << ":" << ss.find("2")->second << endl;
	it = ss.erase(it);
	cout << "after erase" << endl;
	while (it != ss.end())
	{
		cout << it->first << ":" << it->second << endl;
		++it;
	}

	cout << "ss.bucket_count() == " << ss.bucket_count() << endl;
	cout << "bucket_size(2) == " << ss.bucket_size("2") << endl;
	cout << "hello unordered_map" << endl;
}

void test_unordered_set()
{
	bit::unordered_set<int> ss;
	ss.insert(1);
	ss.insert(2);
	ss.insert(3);
	ss.insert(4);
	ss.insert(5);
	ss.insert(6);
	ss.insert(7);
	ss.insert(8);
	ss.insert(9);
	ss.insert(10);
	ss.insert(11);
	bit::unordered_set<int>::iterator it = ss.begin();
	cout << "before erase:" << endl;
	for (const auto& e : ss)
	{
		cout << e << endl;
	}
	cout << "fine(\" 2\")" << ":" << *(ss.find(2)) << endl;
	it = ss.erase(it);
	cout << "after erase begin" << endl;
	while (it != ss.end())
	{
		cout<<(*it)<< endl;
		++it;
	}

	cout << "ss.bucket_count() == " << ss.bucket_count() << endl;
	cout << "bucket_size(2) == " << ss.bucket_size(2) << endl;
	cout << "successful, unordered_set" << endl;
}

int main()
{
	//test_hash_bucket();
	//test_unordered_map();
	test_unordered_set();
	return 0;
}

unordered_map.h

#include "hash_bucket.h"


namespace bit
{
	
	// unordered_map中存储的是pair<K, V>的键值对，K为key的类型，V为value的类型，HF哈希函数类型
	// unordered_map在实现时，只需将hashbucket中的接口重新封装即可
	template<class K, class V, class HF = HashFunc<K>>
	class unordered_map
	{
		
		// 通过key获取value的操作
		struct KeyOfValue
		{
			const K& operator()(const pair<K, V>& data)
			{
				return data.first;
			}
		};
		typedef bit::HashTable<K, pair<K, V>, KeyOfValue, HF> HT;
	public:
		typedef typename HT::Iterator iterator;
		typedef typename HT::ConstIterator const_iterator;
	public:
		unordered_map() : _ht()
		{}
		
		iterator begin() { return _ht.Begin(); }
		iterator end() { return _ht.End(); }
		
		// capacity
		size_t size()const { return _ht.size(); }
		bool empty()const { return _ht.empty(); }
		///
		// Acess
		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = _ht.InsertUnique(pair<K, V>(key, V()));
			return ret.first->second;
		}
		const V& operator[](const K& key)const
		{
			pair<iterator, bool> ret = _ht.InsertUnique(pair<K, V>(key, V()));
			return ret.fisrt->second;
		}
		//
		// lookup
		iterator find(const K& key) { return _ht.Find(key); }
		size_t count(const K& key) { return _ht.Count(key); }
		/
		// modify
		pair<iterator, bool> insert(const pair<K, V>& valye)
		{
			return _ht.InsertUnique(valye);
		}

		iterator erase(iterator position)
		{
			return _ht.Erase(position);
		}
		
		// bucket
		size_t bucket_count() { return _ht.UnemptyBucketCount(); }
		size_t bucket_size(const K& key) { return _ht.BucketSize(key); }
	private:
		HT _ht;
	};
}

unoredered_set.h

#pragma once
#include "hash_bucket.h"

namespace bit
{
	

	// unordered_set中存储的是K类型，HF哈希函数类型
	// unordered_set在实现时，只需将hashbucket中的接口重新封装即可
	template<class K, class HF = HashFunc<K>>
	class unordered_set
	{
		// 通过key获取value的操作
		struct KeyOfValue
		{
			const K& operator()(const K& data)
			{
				return data;
			}
		};
		typedef bit::HashTable<K, K, KeyOfValue, HF> HT;
	public:
		typedef typename HT::Iterator iterator;
		typedef typename HT::ConstIterator const_iterator;
	public:
		unordered_set() : _ht()
		{}
		
		iterator begin() { return _ht.Begin(); }
		iterator end() { return _ht.End(); }
		
		// capacity
		size_t size()const { return _ht.size(); }
		bool empty()const { return _ht.empty(); }
		///
		// lookup
		iterator find(const K& key) { return _ht.Find(key); }
		size_t count(const K& key) { return _ht.Count(key); }
		/
		// modify
		pair<iterator, bool> insert(const K& value)
		{
			return _ht.InsertUnique(value);
		}

		iterator erase(iterator position)
		{
			return _ht.Erase(position);
		}
		
		// bucket
		size_t bucket_count() { return _ht.UnemptyBucketCount(); }
		size_t bucket_size(const K& key) { return _ht.BucketSize(key); }
	private:
		HT _ht;
	};
}

hash_bucket.h

#pragma once
#pragma once
#include <iostream>
#include <string>
#include <assert.h>
#include <vector>
using namespace std;

template <class T, class K>//默认pair
struct KOT
{
	K operator()(const T& kv)
	{
		return kv.first;
	}
};


template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

// 哈希表中支持字符串的操作
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		return stoi(key);
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}

		return hash;
	}
};

namespace bit
{
	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;
		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{}
	};

	// 前置声明
	template<class K, class T, class KeyOfT, class Hash>
	class HashTable;

	template<class K, class T, class Ptr, class Rfr, class KeyOfT, class Hash>
	class HTIterator
	{
		typedef HTIterator<K, T, Ptr, Rfr, KeyOfT, Hash> Self;
	public:
		HTIterator(HashNode<T>* p, const HashTable<K, T, KeyOfT, Hash>* pht):
			_ptr(p),
			_pht(pht)
		{}
		Rfr operator*()
		{
			return _ptr->_data;
		 }
		Self operator++()
		{
			decltype(_ptr) cur = _ptr->_next;
			if (cur)//cur不为空
			{
				_ptr = cur;
				return Self(_ptr, _pht);
			}
			//cur为空
			size_t int_key = hash(kot(_ptr->_data));
			int_key %= _pht->_tables.size();
			int_key++;
			while (int_key < _pht->_tables.size())
			{
				if (_pht->_tables[int_key])//不为空
				{
					_ptr = _pht->_tables[int_key];
					return Self(_ptr, _pht);
				}
				int_key++;
			}
			_ptr = nullptr;
			return Self(nullptr, _pht);
		}
		Ptr operator->()
		{
			return &(_ptr->_data);
		 }

		bool operator==(const Self& other) const
		{
			return _ptr == other._ptr;
		}
		bool operator!=(const Self other) const
		{
			return _ptr != other._ptr;
		}

	private:
		HashNode<T>* _ptr = nullptr;
		const HashTable<K, T, KeyOfT, Hash>* _pht;
		Hash hash;
		KeyOfT kot;
	};

	// K 为 T 中key的类型
	// T 可能是键值对，也可能是K
	// KeyOfT: 从T中提取key
	// Hash将key转化为整形，因为哈市函数使用除留余数法
	template<class K, class T, class KeyOfT = KOT<T, K>, class Hash = HashFunc<K>>
	class HashTable
	{
		template<class K, class T,class Ptr, class Rfr, class KeyOfT, class Hash >
		friend class HTIterator;
		typedef HashNode<T> Node;
	public:
		typedef HTIterator<K, T, T*, T&, KeyOfT, Hash> Iterator;
		typedef HTIterator<K, T, const T*, const T&, KeyOfT, Hash> ConstIterator;

		HashTable()
		{
			_tables.resize(10, nullptr);
		}

		// 哈希桶的销毁
		~HashTable()
		{
			for (auto e : _tables)
			{
				while (e)
				{
					auto next = e->_next;
					delete e;
					e = next;
				}
			}
		}

		// 插入值为data的元素，如果data存在则不插入
		bool Insert(const T& data)
		{
			if (Find(kot(data))!= Iterator(nullptr, this)) return false;
			if (double(_n) / _tables.size() >= 1)//扩容
			{
				HashTable<K, T, KeyOfT, Hash> new_hash;
				new_hash._tables.resize(_tables.size() * 2);
				for (auto e : _tables)
				{
					while (e)
					{
						new_hash.Insert(e->_data);
						e = e->_next;
					}
				}
				_tables.swap(new_hash._tables);
				Insert(data);
				return true;
			}
			Node* ptr = new Node(data);
			int key = hash(kot(data));
			key %= _tables.size();
			ptr->_next = _tables[key];
			_tables[key] = ptr;
			_n++;
			return true;
		}

		pair<Iterator, bool> InsertUnique(const T& data)
		{
			if (Find(kot(data)) != Iterator(nullptr, this)) return make_pair(Find(kot(data)),false);
			if (double(_n) / _tables.size() >= 1)//扩容
			{
				HashTable<K, T, KeyOfT, Hash> new_hash;
				new_hash._tables.resize(_tables.size() * 2);
				for (auto e : _tables)
				{
					while (e)
					{
						new_hash.Insert(e->_data);
						e = e->_next;
					}
				}
				_tables.swap(new_hash._tables);
				
				return make_pair(InsertUnique(data).first, true);
			}
			Node* ptr = new Node(data);
			int key = hash(kot(data));
			key %= _tables.size();
			ptr->_next = _tables[key];
			_tables[key] = ptr;
			_n++;
			return make_pair(Iterator(ptr, this), true);
		}

		// 在哈希桶中查找值为key的元素，存在返回true否则返回false
		Iterator Find(const K& key)
		{
			int int_key = hash(key);
			int_key %= _tables.size();
			auto ptr = _tables[int_key];
			while (ptr)
			{
				if (kot(ptr->_data) == key) return Iterator(ptr, this);
				ptr = ptr->_next;
			}
			return Iterator(nullptr, this);
		}

		// 哈希桶中删除key的元素，删除成功返回true，否则返回false
		pair<Iterator, bool> Erase(const K& key)
		{
			if (Find(key)== End()) return make_pair(Iterator(nullptr, this), false);//找不到key
			//存在key
			int int_key = hash(key);
			int_key %= _tables.size();
			auto ptr = _tables[int_key];
			Node* prev = ptr;
			while (ptr)
			{
				if (kot(ptr->_data) == key)
				{//ptr为要删除结点
					if (prev == ptr)//ptr为头节点
					{
						_tables[int_key] = ptr->_next;
					}
					else prev->_next = ptr->_next;
					Iterator it(ptr, this);
					++it;
					delete ptr;
					_n--;
					return make_pair(it, true);
				}
				prev = ptr;
				ptr = ptr->_next;
			}
			//找不到删除节点
			return make_pair(Iterator(nullptr, this), false);
		}

		Iterator Erase(Iterator it)
		{
			return Erase(kot(*it)).first;
		}

		size_t size() const
		{
			return size_t(_n);
		}

		bool empty() const
		{
			return _n == 0;
		}

		size_t Count(const K& key) 
		{
			size_t ret = 0;
			Iterator it = Begin();
			while (it != End())
			{
				if (it->first == key)
				{
					ret++;
				}
				++it;
			}
			return ret;
		}

		size_t TotalBucketCount()
		{
			return _tables.size();
		}

		size_t UnemptyBucketCount()
		{
			size_t ret = 0;
			for (const auto& e : _tables)
			{
				if (e) ++ret;
			}
			return ret;
		}

		size_t BucketSize(const K& key)
		{
			int int_key = hash(key);
			Node* cur = _tables[int_key];
			size_t ret = 0;
			while (cur)
			{
				ret++;
				cur = cur->_next;
			}
			return ret;
		}

		Iterator Begin()
		{
			int cur = 0;
			while (cur < this->_tables.size())
			{
				if (_tables[cur])
				{
					return Iterator(_tables[cur], this);
				}
				cur++;
			}
			return End();
		}

		ConstIterator cBegin() const
		{
			int cur = 0;
			while (cur < this->_tables.size())
			{
				if (_tables[cur])
				{
					return ConstIterator(_tables[cur], this);
				}
				cur++;
			}
			return cEnd();
		}

		Iterator End()
		{
			return Iterator(nullptr, this);
		}

		ConstIterator cEnd() const
		{
			return ConstIterator(nullptr, this);
		}

		void Print(const string& str = "")
		{
			cout << str << endl;
			for (auto e : _tables)
			{
				while (e)
				{
					cout << e->_data.first << ":" << e->_data.second << endl;
					e = e->_next;
				}
			}
		}

	private:
		vector<Node*> _tables;  // 指针数组
		size_t _n = 0;			// 表中存储数据个数
		KeyOfT kot;
		Hash hash;
	};
}

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

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

相关文章

芯片中的电源VDD和地VSS

芯片中的电源VDD和地VSS

一、原理图中的电源和地符号 在绘制原理图的时候您应该会发现某个芯片上有VBAT VDD VSS VDDA VSSA那么他们都是什么意思呢&#xff0c;分别代表什么&#xff1f; 二、与常说的VCC的区别 可以看到VSS是表示GND 数字和模拟是分开的默认是数字&#xff0c;VDD表示电源&#xff0c;…
阅读更多...
DC-DC开关电源稳压电路设计——7- 40V转换5V和3.3V

DC-DC开关电源稳压电路设计——7- 40V转换5V和3.3V

本篇文章记录分享DC-DC开关电源稳压&#xff08;7-40V转换5V和3.3V&#xff09;电路设计的思路及原理图。 目录 一、电路稳压原理图 二、开关稳压芯片 1、BUCK降压电路 2.LM2596 &#xff08;1&#xff09;、LM2596简介 &#xff08;2&#xff09;、LM2596原理 1. 基…
阅读更多...
Python计算机视觉 第3章-图像到图像的映射

Python计算机视觉 第3章-图像到图像的映射

Python计算机视觉 第3章-图像到图像的映射 3.1　单应性变换 单应性变换&#xff08;Homography&#xff09;是计算机视觉中非常重要的一种几何变换&#xff0c;它用于将一个平面内的点映射到另一个平面内。具体来说&#xff0c;单应性变换可以描述一个图像在摄像机视角变化、…
阅读更多...
音视频封装格式之FLV

音视频封装格式之FLV

FLV&#xff08;Flash Video&#xff09;是一种常见的视频文件格式&#xff0c;FLV 格式最初是由 Adobe 公司开发的&#xff0c;旨在为网络视频提供一种高效、可扩展且易于流式传输的解决方案。随着在线视频的迅速发展&#xff0c;FLV 因其良好的兼容性和流式传输性能&#xff…
阅读更多...
4.2较难的栈和队列OJ

4.2较难的栈和队列OJ

本篇博客来手撕三道稍有难度的栈和队列相关OJ&#xff0c;题目均已插入超链接&#xff0c;点击即可跳转~ 一、设计循环队列 1、题目描述 设计你的循环队列实现。 循环队列是一种线性数据结构&#xff0c;其操作表现基于 FIFO&#xff08;先进先出&#xff0c;即first in fir…
阅读更多...
day39.动态规划+MySQL数据库复习

day39.动态规划+MySQL数据库复习

一.动态规划: 198.打家劫舍 你是一个专业的小偷&#xff0c;计划偷窃沿街的房屋。每间房内都藏有一定的现金&#xff0c;影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统&#xff0c;如果两间相邻的房屋在同一晚上被小偷闯入&#xff0c;系统会自动报警。 给定…
阅读更多...
深入浅出消息队列----【Broker 集群】

深入浅出消息队列----【Broker 集群】

深入浅出消息队列----【Broker 集群】 单 master多 master多 master 多 slave 异步复制多 master 多 slave 同步复制Dledger 本文仅是文章笔记&#xff0c;整理了原文章中重要的知识点、记录了个人的看法 文章来源&#xff1a;编程导航-鱼皮【yes哥深入浅出消息队列专栏】 Brok…
阅读更多...
LeetCode100.删除链表的倒数第 N 个结点

LeetCode100.删除链表的倒数第 N 个结点

1. 题目大意 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 进阶&#xff1a;你能尝试使用一趟扫描实现吗&#xff1f; 2. 思路分析 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]我们可以先遍历一遍链表求出…
阅读更多...
Data Localization Software Architecture - SAAS Localization CyberWin Future

Data Localization Software Architecture - SAAS Localization CyberWin Future

一、Future Window Industry Application Cross-platform Architecture The cross-platform architecture of Future Window adopts Hybird (hybrid mode mobile application), which is a mobile application development model that combines the characteristics of native …
阅读更多...
golang学习笔记——grom连接mysql

golang学习笔记——grom连接mysql

GORM 指南 The fantastic ORM library for Golang aims to be developer friendly. Golang的ORM库旨在对开发人员友好。 特性 全功能 ORM关联 (Has One&#xff0c;Has Many&#xff0c;Belongs To&#xff0c;Many To Many&#xff0c;多态&#xff0c;单表继承)Create&…
阅读更多...
【Redis】渐进式遍历和数据库管理

【Redis】渐进式遍历和数据库管理

渐进式遍历和数据库管理 渐进式遍历scan 数据库管理切换数据库清除数据库 渐进式遍历 Redis 使⽤ scan 命令进⾏渐进式遍历键&#xff0c;进⽽解决直接使⽤ keys 获取键时可能出现的阻塞问题。每次 scan 命令的时间复杂度是 O(1)&#xff0c;但是要完整地完成所有键的遍历&…
阅读更多...
数学建模笔记（三）：拟合算法

数学建模笔记（三）：拟合算法

前面介绍的插值方法&#xff0c;我们可以发现他的特点在于最终得到的曲线一定要经过已经给出的样本点的&#xff0c;而这次要介绍的拟合方法的区别在于&#xff0c;拟合不要求曲线一定要经过所有的样本点&#xff0c;只要这个曲线与样本点之间的误差足够小&#xff0c;距离足够…
阅读更多...
unity AssetBundle 使用_什么是AssetBundle_导入必要的插件_创建AssetBundles_AB包资源下载_大文件下载

unity AssetBundle 使用_什么是AssetBundle_导入必要的插件_创建AssetBundles_AB包资源下载_大文件下载

一、什么是AssetBundle&#xff1f; 定义AssetBundle。 AssetBundle 是一个存档文件&#xff0c;包含可在运行时由 Unity 加载的特定于平台的非代码资源&#xff08;比如模型、纹理、预制件、音频剪辑甚至整个场景&#xff09;。AssetBundle 可以表示彼此之间的依赖关系&…
阅读更多...
PD取电快充协议方案

PD取电快充协议方案

PD快充协议是通过调整电压和电流来提供不同的充电功率。它采用了一种基于USB-C端口的通信协议&#xff0c;实现了充电器于设备之间的信息交换。在充电过程中设备会向充电器发出请求&#xff0c;要求提供不同的电压和电流&#xff0c;充电器接收到请求后&#xff0c;会根据设备的…
阅读更多...
数据本地化软件架构-SAAS本地化未来之窗行业应用跨平台架构

数据本地化软件架构-SAAS本地化未来之窗行业应用跨平台架构

一、未来之窗行业应用跨平台架构 未来之窗跨平台架构采用Hybird&#xff08;混合模式移动应用&#xff09;是一种结合了原生应用&#xff08;Native App&#xff09;和网页应用&#xff08;Web App&#xff09;特点的移动应用开发模式。 二、特点 2.1. 开发成本相对较低 - 与…
阅读更多...
C++码表之Unicode

C++码表之Unicode

今日诗词&#xff1a; 折花逢驿使&#xff0c;寄与陇头人。 江南无所有&#xff0c;聊赠一枝春。 ——《赠范晔诗》【南北朝】陆凯 引言&#xff1a; 上一期我们说到了ASCII码表&#xff0c;这是一种现如今不是那么通用的机制&#xff0c;随着计算机的普及&#xff0c;越来越…
阅读更多...
电脑ip地址为什么会自己变更？电脑ip怎么改

电脑ip地址为什么会自己变更？电脑ip怎么改

在当今这个高度依赖互联网的时代&#xff0c;IP地址作为网络设备的身份标识&#xff0c;其稳定性和可管理性对于网络通信的顺畅至关重要。然而&#xff0c;许多用户可能会遇到电脑IP地址自动变更的情况&#xff0c;这不仅可能影响到网络连接的稳定性&#xff0c;还可能给远程访…
阅读更多...
怎么使用win10录屏快捷键 ？分享三款录屏工具

怎么使用win10录屏快捷键 ？分享三款录屏工具

录屏软件在我们日常生活中越来越常见&#xff0c;无论是做教程、记录游戏精彩瞬间还是进行远程教学&#xff0c;一个好的录屏软件都能让我们的生活变得更加便捷。不少人也会选怎win10自带的录屏&#xff0c;使用WIN10 录屏快捷键【winG】&#xff0c;就可以唤出录屏工具&#x…
阅读更多...
【Node】【1】node和nvm安装

【Node】【1】node和nvm安装

安装nvm、node、npm 安装node 18 &#xff0c;最简单的办法是使用nvm&#xff0c;就不用手动安装了&#xff0c;那么就得先安装nvm。 NVM 是Node Version Manager&#xff0c;用于管理 Node.js 版本。你设备上的不同项目可能使用不同版本的 Node.js。通过 nvm&#xff0c;用户…
阅读更多...
Redis | 非关系型数据库Redis的初步认识

Redis | 非关系型数据库Redis的初步认识

本节内容相对理论&#xff0c;着重看基础通用命令这一节 Redis 非关 kv型{字典} 概念应用ubuntu安装配置 windows添加密码 可能问题【ubuntu】远程连接 基础通用命令 ⭐ 概念 特点&#xff1a; 1、开源的&#xff0c;使用C编写&#xff0c;基于内存且支持持久化 2、没有表 支持…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023