C++之unordered封装

目录

一、哈希表的修改

1.1、哈希表节点结构

1.2、迭代器

1.3、哈希表结构

1.4、完整代码

二、unordered_map的实现

二、unordered_set的实现

一、哈希表的修改

注意：这里我们使用哈希桶来封装unordered_map和unordered_set。

1.1、哈希表节点结构

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

因为我们要复用哈希表，即使用同一份哈希表代码来封装unordered_map和unordered_set，所以这里将模版参数改为T，T即要存储的数据类型，对于unordered_set而言，T直接就是要存储的数据类型；对于unordered_map而言，T是pair类型的。

在插入方法中，我们使用有参构造，在创建节点时直接将数据通过构造函数赋值进去，所以这里还实现了一个构造函数。

1.2、迭代器

iterator核心源码：

template <class Value, class Key, class HashFcn,class ExtractKey, class EqualKey, class Alloc>struct __hashtable_iterator {typedef hashtable<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc>hashtable;typedef __hashtable_iterator<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc>iterator;typedef __hashtable_const_iterator<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc>const_iterator;typedef __hashtable_node<Value> node;typedef forward_iterator_tag iterator_category;typedef Value value_type;node* cur;hashtable* ht;__hashtable_iterator(node* n, hashtable* tab) : cur(n), ht(tab) {}__hashtable_iterator() {}reference operator*() const { return cur->val; }#ifndef __SGI_STL_NO_ARROW_OPERATORpointer operator->() const { return &(operator*()); }#endif /* __SGI_STL_NO_ARROW_OPERATOR */
iterator& operator++();iterator operator++(int);bool operator==(const iterator& it) const { return cur == it.cur; }bool operator!=(const iterator& it) const { return cur != it.cur; }
};template <class V, class K, class HF, class ExK, class EqK, class A>
__hashtable_iterator<V, K, HF, ExK, EqK, A>&
__hashtable_iterator<V, K, HF, ExK, EqK, A>::operator++()
{const node* old = cur;cur = cur->next;if (!cur) {size_type bucket = ht->bkt_num(old->val);while (!cur && ++bucket < ht->buckets.size())cur = ht->buckets[bucket];}return *this;
}

iterator实现思路分析：

  • iterator实现的⼤框架跟list的iterator思路是⼀致的，⽤⼀个类型封装结点的指针，再通过重载运算 符实现，迭代器像指针⼀样访问的⾏为，要注意的是哈希表的迭代器是单向迭代器。
  • 这⾥的难点是operator++的实现。iterator中有⼀个指向结点的指针，如果当前桶下⾯还有结点， 则结点的指针指向下⼀个结点即可。如果当前桶⾛完了，则需要想办法计算找到下⼀个桶。这⾥的难点是反⽽是结构设计的问题，参考上面源码，我们可以知道iterator中除了有结点的指针，还有哈希表对象的指针，这样当前桶⾛完了，要计算下⼀个桶就相对容易多了，⽤key值计算出当前桶位置，依次往后找下⼀个不为空的桶即可。
  • begin()返回第⼀个不为空的桶中第⼀个节点指针构造的迭代器，这⾥end()返回迭代器可以⽤空指针表⽰。
  • unordered_map的iterator不⽀持修改key但是可以修改value，我们把unordered_map的第⼆个模板参数pair的第⼀个参数改成const K即可，HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;（不允许修改Key是因为数据在哈希表中存储的地址是通过Key映射的，如果修改Key，破坏了哈希表的结构）。
  • unordered_set的iterator也不⽀持修改，我们把unordered_set的第⼆个模板参数改成const K即可，HashTable<K, const K, SetKeyOfT, Hash> _ht;（和unordered_map同理）。

具体代码：

	// 前置声明template<class K, class T, class KeyOfT, class Hash>class HashTable;template<class K, class T, class Ptr, class Ref, class KeyOfT, class Hash>struct HTIterator{typedef HashNode<T> Node;typedef HTIterator<K, T, Ptr, Ref, KeyOfT, Hash> Self;Node* _node;const HashTable<K, T, KeyOfT, Hash>* _pht;HTIterator(Node* node, const HashTable<K, T, KeyOfT, Hash>* pht):_node(node),_pht(pht){}Self& operator++(){if (_node->_next){//当前桶还有节点_node = _node->_next;}else{//当前桶走完了，找下一个不为空的桶KeyOfT kot;Hash hs;size_t hashi = hs(kot(_node->_data)) % _pht->_tables.size();++hashi;while (hashi < _pht->_tables.size()){if (_pht->_tables[hashi]){break;}++hashi;}if (hashi == _pht->_tables.size()){_node = nullptr; //end()}else{_node = _pht->_tables[hashi];}}return *this;}Ref operator*(){return _node->_data;}Ptr operator->(){return &_node->_data;}bool operator!=(const Self& s){return _node != s._node;}};

注意：这里需要对哈希表进行前置声明，因为在迭代器中用到了哈希表，但是编译器编译时是向上查找，而哈希表在下面，会因为找不到而报错，将哈希表放到上面也不行，因为哈希表里也会封装迭代器，如果哈希表在上面向上查找时就会找不到迭代器，总之必须有一个进行前置声明。另外，迭代器中重载++运算符时为了确定当前节点的位置访问了哈希表的私有成员，所以后面在哈希表中还需要进行友元声明。

1.3、哈希表结构

	template<class K, class T, class KeyOfT, class Hash>class HashTable{// 友元声明template<class K, class T, class Ptr, class Ref, class KeyOfT, class Hash>friend struct 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;Iterator Begin(){if (_n == 0) //没有有效数据{return End();}for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];if (cur){return Iterator(cur, this);}}return End();}Iterator End(){return Iterator(nullptr, this);}ConstIterator Begin() const{if (_n == 0)return End();for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];if (cur){return ConstIterator(cur, this);}}return End();}ConstIterator End() const{return ConstIterator(nullptr, this);}HashTable(){_tables.resize(10, nullptr);}~HashTable(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;}}pair<Iterator,bool> Insert(const T& data){KeyOfT kot;Iterator it = Find(kot(data));//去重if (it != End()){return make_pair(it,false);}Hash hs;size_t hashi = hs(kot(data)) % _tables.size();//负载因子==1  扩容if (_n == _tables.size()){// 需要新建节点和释放旧节点，效率较低//	HashTable<K, V, Hash> newHT;//	for (size_t i = 0; i < _tables.size(); i++)//	{//		Node* cur = _tables[i];//		while (cur)//		{//			newHT.Insert(cur->_kv);//			cur = cur->_next;//		}//	}//	_tables.swap(newHT._tables);vector<Node*> newtables(_tables.size() * 2, nullptr);for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;//旧表中的节点重新映射在新表中的位置size_t hashi = hs(kot(cur->_data)) % newtables.size();cur->_next = newtables[hashi];newtables[hashi] = cur;cur = next;}//节点都挪到新表上了，旧表置空_tables[i] = nullptr;}_tables.swap(newtables);}//头插Node* newnode = new Node(data);newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_n;return make_pair(Iterator(newnode,this),true);}Iterator Find(const K& key){KeyOfT kot;Hash hs;size_t hashi = hs(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){return Iterator(cur,this);}cur = cur->_next;}return End();}bool Erase(const K& key){KeyOfT kot;Hash hs;size_t hashi = hs(key) % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;--_n;return true;}prev = cur;cur = cur->_next;}return false;}private:vector<Node*> _tables; //指针数组size_t _n; //表中存储数据个数};}

为什么需要KeyOfT模版参数：

跟map和set相⽐⽽⾔unordered_map和unordered_set的模拟实现类结构更复杂⼀点，但是⼤框架和思路是完全类似的。因为HashTable实现了泛型不知道T参数是K，还是pair， 那么insert内部进⾏插⼊时要⽤K对象转换成整形取模和K⽐较相等(去重)，因为pair的value不需要参与计算取模，且pair默认⽀持的是key和value⼀起⽐较相等，但实际上我们需要的是任何时候只需要⽐较K对象，所以我们在unordered_map和unordered_set层分别实现⼀个MapKeyOfT和SetKeyOfT的仿函数传给 HashTable的KeyOfT，然后HashTable中通过KeyOfT仿函数取出T类型对象中的K对象，再转换成整形取模和K⽐较相等。

返回值的修改：

这里为了符合unordered_map和unordered_set的使用将Find方法的返回值改为迭代器，为了实现unordered_map的 [ ] 运算符重载，将Insert方法的返回值该为pair类型，其中返回的pair对象的first属性的值是新插入节点/原有节点的迭代器，second属性的值是bool类型，代表是否插入成功。

1.4、完整代码

namespace hash_bucket
{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 Ref, class KeyOfT, class Hash>struct HTIterator{typedef HashNode<T> Node;typedef HTIterator<K, T, Ptr, Ref, KeyOfT, Hash> Self;Node* _node;const HashTable<K, T, KeyOfT, Hash>* _pht;HTIterator(Node* node, const HashTable<K, T, KeyOfT, Hash>* pht):_node(node),_pht(pht){}Self& operator++(){if (_node->_next){//当前桶还有节点_node = _node->_next;}else{//当前桶走完了，找下一个不为空的桶KeyOfT kot;Hash hs;size_t hashi = hs(kot(_node->_data)) % _pht->_tables.size();++hashi;while (hashi < _pht->_tables.size()){if (_pht->_tables[hashi]){break;}++hashi;}if (hashi == _pht->_tables.size()){_node = nullptr; //end()}else{_node = _pht->_tables[hashi];}}return *this;}Ref operator*(){return _node->_data;}Ptr operator->(){return &_node->_data;}bool operator!=(const Self& s){return _node != s._node;}};template<class K, class T, class KeyOfT, class Hash>class HashTable{// 友元声明template<class K, class T, class Ptr, class Ref, class KeyOfT, class Hash>friend struct 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;Iterator Begin(){if (_n == 0) //没有有效数据{return End();}for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];if (cur){return Iterator(cur, this);}}return End();}Iterator End(){return Iterator(nullptr, this);}ConstIterator Begin() const{if (_n == 0)return End();for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];if (cur){return ConstIterator(cur, this);}}return End();}ConstIterator End() const{return ConstIterator(nullptr, this);}HashTable(){_tables.resize(10, nullptr);}~HashTable(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;}}pair<Iterator,bool> Insert(const T& data){KeyOfT kot;Iterator it = Find(kot(data));//去重if (it != End()){return make_pair(it,false);}Hash hs;size_t hashi = hs(kot(data)) % _tables.size();//负载因子==1  扩容if (_n == _tables.size()){// 需要新建节点和释放旧节点，效率较低//	HashTable<K, V, Hash> newHT;//	for (size_t i = 0; i < _tables.size(); i++)//	{//		Node* cur = _tables[i];//		while (cur)//		{//			newHT.Insert(cur->_kv);//			cur = cur->_next;//		}//	}//	_tables.swap(newHT._tables);vector<Node*> newtables(_tables.size() * 2, nullptr);for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;//旧表中的节点重新映射在新表中的位置size_t hashi = hs(kot(cur->_data)) % newtables.size();cur->_next = newtables[hashi];newtables[hashi] = cur;cur = next;}//节点都挪到新表上了，旧表置空_tables[i] = nullptr;}_tables.swap(newtables);}//头插Node* newnode = new Node(data);newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_n;return make_pair(Iterator(newnode,this),true);}Iterator Find(const K& key){KeyOfT kot;Hash hs;size_t hashi = hs(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){return Iterator(cur,this);}cur = cur->_next;}return End();}bool Erase(const K& key){KeyOfT kot;Hash hs;size_t hashi = hs(key) % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;--_n;return true;}prev = cur;cur = cur->_next;}return false;}private:vector<Node*> _tables; //指针数组size_t _n; //表中存储数据个数};}

二、unordered_map的实现

这里的实现没有什么困难，就是直接套一层壳，所有的调用最终还是去调哈希表的方法，所以这里就不在赘述了，直接上代码。

#include"HashTable.h"namespace bit
{template<class K, class V, class Hash = HashFunc<K>>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::Iterator iterator;typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::ConstIterator const_iterator;iterator begin(){return _ht.Begin();}iterator end(){return _ht.End();}const_iterator begin() const{return _ht.Begin();}const_iterator end() const{return _ht.End();}V& operator[](const K& key){pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));return ret.first->second;}pair<iterator, bool> insert(const pair<K, V>& kv){return _ht.Insert(kv);}iterator find(const K& key){return _ht.Find(key);}bool erase(const K& key){return _ht.Erase(key);}private:hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;};void test_map(){unordered_map<string, string> dict;dict.insert({ "sort", "排序" });dict.insert({ "left", "左边" });dict.insert({ "right", "右边" });dict["left"] = "左边，剩余";dict["insert"] = "插入";dict["string"];unordered_map<string, string>::iterator it = dict.begin();while (it != dict.end()){// 不能修改first，可以修改second//it->first += 'x';it->second += 'x';cout << it->first << ":" << it->second << endl;++it;}cout << endl;}
}

二、unordered_set的实现

这里和unordered_map一样，就是直接套一层壳，所有的调用最终还是去调哈希表的方法，所以这里就不在赘述了，直接上代码。

#include"HashTable.h"namespace bit
{template<class K, class Hash = HashFunc<K>>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::Iterator iterator;typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::ConstIterator const_iterator;iterator begin(){return _ht.Begin();}iterator end(){return _ht.End();}const_iterator begin() const{return _ht.Begin();}const_iterator end() const{return _ht.End();}pair<iterator, bool> insert(const K& key){return _ht.Insert(key);}iterator find(const K& key){return _ht.Find(key);}bool erase(const K& key){return _ht.Erase(key);}private:hash_bucket::HashTable<K, const K, SetKeyOfT, Hash> _ht;};void Print(const unordered_set<int>& s){unordered_set<int>::const_iterator it = s.begin();while (it != s.end()){// *it += 1;cout << *it << " ";++it;}cout << endl;}struct Date{int _year;int _month;int _day;bool operator==(const Date& d) const{return _year == d._year&& _month == d._month&& _day == d._day;}};struct HashDate{size_t operator()(const Date& key){// 112// 121return (key._year * 31 + key._month) * 31 + key._day;}};void test_set(){unordered_set<int> s;int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14, 3,3,15 };for (auto e : a){s.insert(e);}for (auto e : s){cout << e << " ";}cout << endl;unordered_set<int>::iterator it = s.begin();while (it != s.end()){//*it += 1;cout << *it << " ";++it;}cout << endl;unordered_set<Date, HashDate> us;us.insert({ 2024, 7, 25 });us.insert({ 2024, 7, 26 });Print(s);}
}

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

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

相关文章

[渗透测试]渗透测试靶场docker搭建 — —全集

[渗透测试]渗透测试靶场docker搭建 — —全集

[渗透测试]渗透测试靶场docker搭建 — —全集 对于初学者来说&#xff0c;仅仅了解漏洞原理是不够的&#xff0c;还需要进行实操。对于公网上的服务我们肯定不能轻易验证某些漏洞&#xff0c;否则可能触犯法律。这是就需要用到靶场。 本文主要给大家介绍几种常见漏洞对应的靶场…
阅读更多...
Docker如何更换镜像源提高拉取速度

Docker如何更换镜像源提高拉取速度

在国内&#xff0c;由于网络政策和限制&#xff0c;直接访问DockerHub速度很慢&#xff0c;尤其是在拉取大型镜像时。为了解决这个问题&#xff0c;常用的方法就是更换镜像源。本文将详细介绍如何更换Docker镜像源&#xff0c;并提供当前可用的镜像源。 换源方法 方法1&#x…
阅读更多...
第一篇：从哲学到管理——实践论与矛盾论如何重塑企业思维

第一篇：从哲学到管理——实践论与矛盾论如何重塑企业思维

引言&#xff1a;当革命哲学照亮现代商业 1937年&#xff0c;毛泽东在战火中写就的《实践论》《矛盾论》&#xff0c;为中国共产党提供了认识世界的方法论。今天&#xff0c;这两部著作正成为企业破解管理困局的“思维操作系统”&#xff1a; 战略模糊&#xff1a;据Gartner统…
阅读更多...
云原生--基础篇-2--云计算概述（云计算是云原生的基础，IaaS、PaaS和SaaS服务模型）

云原生--基础篇-2--云计算概述（云计算是云原生的基础，IaaS、PaaS和SaaS服务模型）

1、云计算概念 云计算是一种通过互联网提供计算资源&#xff08;包括服务器、存储、数据库、网络、软件等&#xff09;和服务的技术模式。用户无需拥有和维护物理硬件&#xff0c;而是可以根据需要租用这些资源&#xff0c;并按使用量付费。 2、云计算特点 &#xff08;1&am…
阅读更多...
一级滤波器设计：IL_cmdm ＞ 80dB

一级滤波器设计：IL_cmdm ＞ 80dB

目录 背景 目的 操作 仿真测试 搭建仿真模型 插入损耗测试 优化设计后重新测试 思考 背景 在选购共模电感时&#xff0c;规格书中通常会提供插损曲线或者阻抗-频率曲线&#xff0c;但这些数据都是在特定条件下测试获得的。如果将其集中在我们的样机中性能会如何&#…
阅读更多...
qt 配置 mysql 驱动问题：Cannot load library qsqlmysql；QMYSQL driver not loaded

qt 配置 mysql 驱动问题：Cannot load library qsqlmysql；QMYSQL driver not loaded

项目场景&#xff1a; 环境版本&#xff1a; qt &#xff1a;5.14.2 mysql&#xff1a;8.0 windows&#xff1a;10 提示&#xff1a;qt 配置 mysql 驱动&#xff1a; 项目场景&#xff1a;qt 配置 mysql 驱动 问题描述 提示&#xff1a;这里描述项目中遇到的问题&#xff1a;…
阅读更多...
Kubernetes相关的名词解释Container（16）

Kubernetes相关的名词解释Container（16）

什么是Container&#xff1f; 在 Kubernetes 中&#xff0c;Container&#xff08;容器&#xff09; 是一个核心概念&#xff0c;你可以将镜像&#xff08;Image&#xff09;类比为程序的“源代码”&#xff0c;而容器是这段“代码”运行时的进程。例如&#xff0c;一个 nginx…
阅读更多...
学习设计模式《四》——单例模式

学习设计模式《四》——单例模式

一、基础概念 单例模式的本质【控制实例数目】&#xff1b; 单例模式的定义&#xff1a;是用来保证这个类在运行期间只会被创建一个类实例&#xff1b;单例模式还提供了一个全局唯一访问这个类实例的访问点&#xff08;即GetInstance方法&#xff09;单例模式只关心类实例的创建…
阅读更多...
零基础上手Python数据分析 (19)：Matplotlib 高级图表定制 - 精雕细琢，让你的图表脱颖而出！

零基础上手Python数据分析 (19)：Matplotlib 高级图表定制 - 精雕细琢，让你的图表脱颖而出！

写在前面 —— 超越默认样式，掌握 Matplotlib 精细控制，打造专业级可视化图表 上一篇博客，我们学习了 Matplotlib 的基础绘图功能，掌握了如何绘制常见的折线图、柱状图、散点图和饼图，并进行了基本的图表元素定制，例如添加标题、标签、图例等。 这些基础技能已经能让我…
阅读更多...
信奥中的数学

信奥中的数学

信奥赛的数学大纲 ps:知识点是其他小伙伴分享的&#xff0c;我现在在做一下系列视频 会逐步更新&#xff0c;希望大家支持喜欢。 1.基础数学 数论 整数和自然数 素数、合数和因数分解 最大公约数(GCD)和最小公倍数(LCM) 同余和取模运算 欧几里得算法 扩展欧几里得算法 中国…
阅读更多...
PHP腾讯云人脸核身获取Access Token

PHP腾讯云人脸核身获取Access Token

参考腾讯云官方文档&#xff1a; 人脸核身 获取 Access Token_腾讯云 public function getAccessToken(){$data [appId > , //WBappid,https://cloud.tencent.com/document/product/1007/49634secret > ,grant_type > client_credential, //授权类型version > 1…
阅读更多...
《作用域大冒险：从闭包到内存泄漏的终极探索》

《作用域大冒险：从闭包到内存泄漏的终极探索》

“爱自有天意&#xff0c;天有道自不会让有情人分离” 大家好&#xff0c;关于闭包问题其实实际上是js作用域的问题&#xff0c;那么js有几种作用域呢&#xff1f; 作用域类型关键字/场景作用域范围示例全局作用域var&#xff08;无声明&#xff09;整个程序var x 10;函数作用…
阅读更多...
为什么Makefile中的clean需要.PHONY

为什么Makefile中的clean需要.PHONY

原因一&#xff1a;避免Makefile检查时间戳 前置知识&#xff1a;makefile在依赖文件没有改变时不会执行编译命令 #第一次执行&#xff0c;OK [rootVM-16-14-centos ~]# make g -E main.cc -o main.i g -S main.i -o main.s g -c main.s -o main.o g main.o -o main#第二…
阅读更多...
垂直行业突围：工业软件在汽车、航空领域的 “破壁” 实践

垂直行业突围：工业软件在汽车、航空领域的 “破壁” 实践

在当今科技高速发展的时代&#xff0c;工业软件已悄然完成从通用工具到垂直行业 “战略武器” 的蜕变。特别是在汽车与航空这两大高端制造领域&#xff0c;工业软件的价值早已超越单纯的效率提升&#xff0c;成为关乎核心技术自主可控的关键要素&#xff0c;一场围绕工业软件的…
阅读更多...
07.Python代码NumPy-排序sort，argsort，lexsort

07.Python代码NumPy-排序sort，argsort，lexsort

07.Python代码NumPy-排序sort&#xff0c;argsort&#xff0c;lexsort 提示&#xff1a;帮帮志会陆续更新非常多的IT技术知识&#xff0c;希望分享的内容对您有用。本章分享的是NumPy的使用语法。前后每一小节的内容是存在的有&#xff1a;学习and理解的关联性&#xff0c;希望…
阅读更多...
LVDS系列8：Xilinx 7系可编程输入延迟(一)

LVDS系列8：Xilinx 7系可编程输入延迟(一)

在解析LVDS信号时&#xff0c;十分重要的一环就是LVDS输入信号线在经过PCB输入到FPGA中后&#xff0c;本来该严格对齐的信号线会出现时延&#xff0c;所以需要在FPGA内部对其进行延时对齐后再进行解析。 Xilinx 7系器件中用于输入信号延时的组件为IDELAYE2可编程原语&#xff0…
阅读更多...
AI驱动研发效率在中后台的实践

AI驱动研发效率在中后台的实践

本文探讨了AI驱动的中后台前端研发实践&#xff0c; 涵盖设计出码、接口定义转换、代码拟合、自动化测试等多个环节&#xff0c;通过具体案例展示了AI技术如何优化研发流程并提升效率。特别是在UI代码编写和接口联调阶段&#xff0c;并提出了设计出码&#xff08;Design to Cod…
阅读更多...
【Rust 精进之路之第6篇-流程之舞】控制流：`if/else`, `loop`, `while`, `for` 与模式匹配初窥

【Rust 精进之路之第6篇-流程之舞】控制流：`if/else`, `loop`, `while`, `for` 与模式匹配初窥

系列： Rust 精进之路：构建可靠、高效软件的底层逻辑 作者： 码觉客 发布日期： 2025-04-20 引言：让代码“活”起来——指令的流动 在前面的文章中，我们已经掌握了 Rust 的基础数据类型（标量和复合类型）以及如何通过变量绑定来存储和命名它们。这相当于我们准备好了程序…
阅读更多...
C++ 表达式求值的基础（四十九）

C++ 表达式求值的基础（四十九）

1. 运算符的分类 1.1 按操作数个数 一元运算符&#xff08;Unary&#xff09; 作用于单个操作数&#xff1a; 取地址 &obj解引用 *ptr逻辑非 !b一元加减 x, -x递增递减 i, i-- 二元运算符&#xff08;Binary&#xff09; 作用于两个操作数&#xff1a; 算术运算 a b, a …
阅读更多...
Three.js + React 实战系列 : 从零搭建 3D 个人主页

Three.js + React 实战系列 : 从零搭建 3D 个人主页

可能你对tailiwindcss毫不了解&#xff0c;别紧张&#xff0c;记住我们只是在学习&#xff0c;学习的是作者的思想和技巧&#xff0c;并不是某一行代码。 在之前的几篇文章中&#xff0c;我们已经熟悉了 Three.js 的基本用法&#xff0c;并通过 react-three-fiber 快速构建了一…
阅读更多...
最新文章

Copyright @ 2022~2023