C++——智能指针1

news2025/1/10 21:16:16

目录

RAII

auto_ptr模拟实现 

 智能指针拷贝问题

唯一指针 

shared_ptr（可以拷贝） 

shared_ptr模拟实现 

完整代码 

循环引用 

weak_ptr模拟实现  

定制删除器

shared_ptr定制删除器模拟实现 

 内存泄漏

 

RAII

 RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内
存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在
对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做
法有两大好处：
不需要显式地释放资源。
采用这种方式，对象所需的资源在其生命期内始终保持有效.

此时释放了资源

 抛异常后没有释放资源

提供一个类 ，在该类的对象构造时获取资源，析构时释放资源

#include<iostream>
using namespace std;
//利用RAII设计的释放delete资源的类
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* Ptr)//在构造的时候把资源给某个对象
		:_ptr(Ptr)
	{}
	~SmartPtr()//析构的时候把资源进行释放
	{
		delete _ptr;
		cout << "资源释放 " <<"delete:" <<_ptr<< endl;
	}
private:
	T* _ptr;
};
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	// 1、如果p1这里new 抛异常会如何？
	// 2、如果p2这里new 抛异常会如何？
	// 3、如果div调用这里又会抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	SmartPtr<int> sp1(p1);
	SmartPtr<int> sp2(p2);
	cout << div() << endl;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

 抛异常也能进行正常的资源释放

 上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可
以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其
像指针一样去使用。

总结一下智能指针的原理：
1. RAII特性
2. 重载operator*和opertaor->，具有像指针一样的行为。

库里面的智能指针有很多，如auto——ptr

auto_ptr模拟实现 

	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr = nullptr)
			: _ptr(ptr)
		{}

		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}

		// ap1 = ap2;
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			if (this != &ap)
			{
				if (_ptr)
				{
					cout << "Delete:" << _ptr << endl;
					delete _ptr;
				}

				_ptr = ap._ptr;
				ap._ptr = nullptr;
			}

			return *this;
		}

		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
			}
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

	private:
		T* _ptr;
	};

 智能指针拷贝问题

对上面我们写的类，创建俩个对象直接进行拷贝，程序会崩溃

这是因为对空间A析构了俩次，我们虽然没写拷贝构造函数但是这里_ptr是内置类型，对内置类型完成了值拷贝，然后在析构的时候对这块空间析构了俩次，导致程序直接崩溃

库里面的没有崩溃

auto_ptr的拷贝构造在拷贝的时候把资源进行了转移，ap1把资源直接转给了ap2，相当于把ap1进行了剪切，ap1被置空了

 

解决方案：

深拷贝：这里不能用深拷贝，因为违背了功能需求 ，智能指针我们不知道要拷贝多少，拷贝的资源有多大。智能指针只是帮助我们进行托管，像指针一样。这里需要的就是浅拷贝

唯一指针 

禁用了拷贝构造和赋值 ，其它功能都正常

 

 

template<class T>
class unique_ptr
{
private:
	// 防拷贝 C++98
	// 只声明不实现 
	//unique_ptr(unique_ptr<T>& ap);
	//unique_ptr<T>& operator=(unique_ptr<T>& ap);
public:
	unique_ptr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	// 防拷贝 C++11
	unique_ptr(unique_ptr<T>& ap) = delete;//拷贝构造是默认成员函数
	unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;

	~unique_ptr()
	{
		if (_ptr)
		{
			cout << "Delete:" << _ptr << endl;
			delete _ptr;
		}
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

private:
	T* _ptr;
};

 C++98只声明，不实现

 而且必须的私有，不然会报错

 私有化后，赋值和拷贝就不能使用了

 

shared_ptr（可以拷贝） 

 增加了引用计数，表示有n个对象管理这块资源

 

这里的计数不能用静态的， 

析构的时候--计数，减到0了就释放空间

 

出问题

 这里空间被释放了俩次 ，还有一次未被释放。

注释掉后面俩个，也被释放了俩次

 本应是这样，静态成员变量是所有类共享的

sp4 来了之后，计数又变为了1，因为类型不一样，由于这些计数是共享的导致sp1,sp2,sp3的计数也变成了1

 所以我们在这里采用指针，

一个资源，配一个计数，多个智能指针对象共管。

如果用静态计数，静态计数对象所有资源都只有一个计数， 因为静态成员属于整个类，属于类的所有对象。

shared_ptr模拟实现 

operator=

void Release()
	{
		if (--(*_pCount) == 0)
		{
			cout << "Delete:" << _ptr << endl;
			delete _ptr;
			delete _pCount;
		}
	}
	shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		//if (this == &sp)
		if (_ptr == sp._ptr)
		{
			return *this;
		}

		// 减减被赋值对象的计数，如果是最后一个对象，要释放资源
		/*if (--(*_pCount) == 0)
		{
			delete _ptr;
			delete _pCount;
		}*/
		Release();

		// 共管新资源，++计数
		_ptr = sp._ptr;
		_pCount = sp._pCount;

		(*_pCount)++;

		return *this;
	}

 如果没有中间的Realse，sp1指向sp5之后，图中最上面那块空间计数还是3，如果是0就直接释放空间

完整代码 

template<class T>
class shared_ptr
{
public:
	shared_ptr(T* ptr = nullptr)
		: _ptr(ptr)
		, _pCount(new int(1))
	{}

	void Release()
	{
		if (--(*_pCount) == 0)
		{
			cout << "Delete:" << _ptr << endl;
			delete _ptr;
			delete _pCount;
		}
	}

	~shared_ptr()
	{
		Release();
	}

	// sp1(sp2)
	shared_ptr(const shared_ptr<T>& sp)
		: _ptr(sp._ptr)
		, _pCount(sp._pCount)//把计数也要给拷贝，拷贝完之后++即可
	{
		(*_pCount)++;
	}

	shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		//if (this == &sp)
		if (_ptr == sp._ptr)
		{
			return *this;
		}

		// 减减被赋值对象的计数，如果是最后一个对象，要释放资源
		/*if (--(*_pCount) == 0)
		{
			delete _ptr;
			delete _pCount;
		}*/
		Release();

		// 共管新资源，++计数
		_ptr = sp._ptr;
		_pCount = sp._pCount;

		(*_pCount)++;

		return *this;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

private:
	T* _ptr;

	// 引用计数
	int* _pCount;
};

循环引用 

 C++98不支持n2这种方式，必须得和n1一样，不允许隐式类型转换

 此时会报错，因为n2是智能指针，next是原生指针

将next改成智能指针后，程序可以正常运行

 

n2->prve指向n1

此时又不释放空间

 这是因为函数结束得时候，n2先析构，n1后析构

 next析构右边就释放(delete)，prev析构左边就释放（delete），_next在左边，左边的节点被delete时调用析构函数，_next作为成员才会析构，而要释放左边的节点,_prev就得先释放，释放_prev就要先释放右边的节点，右边的节点是否释放又取决于_next，所以俩边互相克制

用weak_ptr就能解决这种问题，这不是常规的智能指针，没有RAII，不支持直接管理资源，wak_ptr主要用于shared_ptr构造，用来解决shared_ptr的循环引用问题。

 _next和_prev时weak_ptr时，他不参与释放资源管理，可以访问和修改到资源，但是不增加计数，不存在循环引用的问题

shared_ptr中有一个use_count专门用来查看计数

  

这里可以看到赋值前后的计数没有变 

weak_ptr模拟实现  

weak_ptr是辅助型智能指针，解决配合shared_ptr循环引用问题 

 

namespace bit
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			: _ptr(ptr)
			, _pCount(new int(1))
		{}

		void Release()
		{
			if (--(*_pCount) == 0)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
				delete _pCount;
			}
		}

		~shared_ptr()
		{
			Release();
		}

		// sp1(sp2)
		shared_ptr(const shared_ptr<T>& sp)
			: _ptr(sp._ptr)
			, _pCount(sp._pCount)//把计数也要给拷贝，拷贝完之后++即可
		{
			(*_pCount)++;
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this == &sp)
			if (_ptr == sp._ptr)
			{
				return *this;
			}

			// 减减被赋值对象的计数，如果是最后一个对象，要释放资源
			/*if (--(*_pCount) == 0)
			{
				delete _ptr;
				delete _pCount;
			}*/
			Release();

			// 共管新资源，++计数
			_ptr = sp._ptr;
			_pCount = sp._pCount;

			(*_pCount)++;

			return *this;
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}
		int use_count()
		{
			return *_pCount;
		}
		T* get()const//直接获得指针
		{
			return _ptr;
		}
	private:
		T* _ptr;

		// 引用计数
		int* _pCount;
	};
	template <class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}
		weak_ptr(const weak_ptr<T>& sp)//俩个拷贝构造函数
			:_ptr(sp._ptr)
		{}
		//不写析构，不释放资源
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		
		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//这里赋值不需要考虑释放资源，因为weak_ptr不参与管理资源
			_ptr = sp.get();
			return *this;
		}
		
	private:
		T* _ptr;
	};
}
struct Node
{
	int _val;
	bit::shared_ptr<Node> _next;
	bit::shared_ptr<Node> _prev;
	~Node()
	{
		cout << "~Node" << endl;
	}
};

  

 

没有增加引用计数，没有打印delete 

定制删除器

 

 

程序直接崩掉，因为没有匹配使用

当换成内置类型后，程序正常运行

 

当屏蔽掉自定义类型的析构函数时，程序不会报错，当析构函数存在时，函数会报错

这些问题跟new实现相关，new底层调用malloc，delete底层调用free， vs平台上new内置类型[5]，如new int[5]，用delete释放没问题，但是在其它平台上可能会出问题，对于自定义类型要调构造函数和析构函数。

 

如果不写析构函数，编译器就会进行优化，对析构函数就不再调用，就只剩free,所以不会报错，当析构函数写了，就会调用，我们new Node[5],而delete却不知道要调用多少次析构函数，delete不知道[]中的数字，语法规定delete使用时是delete[],所以delete不知道要析构多少次。

vs下如果要开60byte空间，会多给4byte，总共开64byte，这4个byte用来记录次数

 当释放的时候把ptr强转为char*然后-4，ptr此时指向记录次数这块空间，然后转为int*，再解引用就可获得析构次数，之后开始调用析构函数，free的时候，free的是ptr-4这个位置就是开头的位置。

 

shared_ptr的定制删除器 ，del可以是仿函数

 unique_ptr也支持

跟C++11相结合

 

 

 unique必须跟传模板参数一样，传过去

 

 

模仿shared_ptr这种方式也不行

 需要这样传参

 

 当我们自己要模拟实现定制删除器时，我们上面写的shared_ptr和unique_ptr都无法支持定制删除器。

在类模板增加一个参数D，当引用计数--后等于0时， 下面是调用D operator(),根据D重载()的内容，对ptr进行处理

写一个删除器

 

shared_ptr定制删除器模拟实现 

template<class T>
struct Delete
{
	void operator()(T* ptr)
	{
		cout << "delete:" << ptr << endl;
		delete ptr;
	}
};

template<class T, class D = Delete<T>>
class shared_ptr
{
public:
	shared_ptr(T* ptr = nullptr)
		: _ptr(ptr)
		, _pCount(new int(1))
	{}

	void Release()
	{
		if (--(*_pCount) == 0)
		{
			//cout << "Delete:" << _ptr << endl;
			//delete _ptr;

			//D del;
			//del(_ptr);
			D()(_ptr);

			delete _pCount;
		}
	}

	~shared_ptr()
	{
		Release();
	}

	// sp1(sp2)
	shared_ptr(const shared_ptr<T>& sp)
		: _ptr(sp._ptr)
		, _pCount(sp._pCount)
	{
		(*_pCount)++;
	}

	shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		//if (this == &sp)
		if (_ptr == sp._ptr)
		{
			return *this;
		}

		// 减减被赋值对象的计数，如果是最后一个对象，要释放资源
		/*if (--(*_pCount) == 0)
		{
			delete _ptr;
			delete _pCount;
		}*/
		Release();

		// 共管新资源，++计数
		_ptr = sp._ptr;
		_pCount = sp._pCount;

		(*_pCount)++;

		return *this;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	int use_count()
	{
		return *_pCount;
	}

	T* get() const
	{
		return _ptr;
	}

private:
	T* _ptr;

	// 引用计数
	int* _pCount;
};

这里必须显示的传第二个模板参数，不然delete次数会匹配不上，程序会崩溃

 内存泄漏

 C/C++程序中一般我们关心两种方面的内存泄漏：
堆内存泄漏(Heap leak)
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一
块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分
内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放
掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

 如何检测内存泄漏（了解）
在linux下内存泄漏检测：(39条消息) Linux下几款C++程序中的内存泄露检查工具_CHENG Jian的博客-CSDN博客_linux c++ 内存泄露 检测
在windows下使用第三方工具：(39条消息) VS编程内存泄漏：VLD(Visual LeakDetector)内存泄露库_波波在学习的博客-CSDN博客
其他工具：内存泄露检测工具比较 - 默默淡然 - 博客园 (cnblogs.com)

 内存泄漏是指针丢了还是内存丢了？

答：指针丢了，通过指针去释放指针，内存本身不存在丢失，当进程正常结束，内存也会释放，要避免僵尸进程和长期运行的程序的内存泄漏。

 如何避免内存泄漏
1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：
这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智
能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。

3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄
漏检测工具。

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

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

相关文章

SkyWalking使用案例

SkyWalking使用案例

SkyWalking监控java项目Halo博客 Halo是一个开源的博客项目&#xff0c;使用java编写&#xff0c;官网地址&#xff1a;https://halo.run/ 安装java环境&#xff0c;Halo对java版本有限制&#xff0c;1.4.3版本以上需要使用java11以上 apt -y install openjdk-11-jdk java -…
阅读更多...
matplotlib常用操作

matplotlib常用操作

文章目录1 matplotlib绘图1.1 绘图步骤2 matplotlib基本元素2.1 matplotlib 画布2.2 设置坐标轴长度和范围2.3 设置图形的线型和颜色2.4 设置图形刻度范围、刻度标签和坐标轴标签等2.4.1 设置刻度范围2.4.2 设置坐标轴刻度2.5 文本标签图例3 matplotlib的ax对象绘图4 绘制子图5…
阅读更多...
2.3 黑群晖驱动：开启nvme缓存、将nvme缓存作为存储盘 教程

2.3 黑群晖驱动：开启nvme缓存、将nvme缓存作为存储盘 教程

黑群晖驱动安装工具下载&#xff1a;链接&#xff1a;https://pan.baidu.com/s/1CMLl6waOuW-Ys2gKZx7Jgg?pwdchct提取码&#xff1a;chct一、开启NVME缓存在群辉->控制面板->终端机和SNMP->终端机中 勾选“启动SSH”功能&#xff0c;并点击应用&#xff1b;下载安装P…
阅读更多...
HACKTHEBOX——Teacher

HACKTHEBOX——Teacher

nmapnmap -sV -sC -p- -T4 -oA nmap 10.10.10.153nmap只发现了对外开放了80端口&#xff0c;从http-title看出可能是某个中学的官网http打开网站确实是一个官网&#xff0c;查看每个接口看看有没有可以利用的地方发现了一个接口&#xff0c;/images/5.png&#xff0c;但是响应包…
阅读更多...
国内有哪些支持定制化的低代码平台？

国内有哪些支持定制化的低代码平台？

编者按&#xff1a;贴合企业业务需求的系统才是好系统&#xff0c;高程度的定制能力平台意味着可以提供更高契合度的产品&#xff0c;更好地匹配业务需求。本文介绍了国内支持定制化的老厂商低代码平台&#xff0c;具有源码交付、私有化部署、国产化、数据对接等优势。关键词&a…
阅读更多...
服务端开发之Java备战秋招面试篇5

服务端开发之Java备战秋招面试篇5

努力了那么多年,回头一望,几乎全是漫长的挫折和煎熬。对于大多数人的一生来说,顺风顺水只是偶尔,挫折、不堪、焦虑和迷茫才是主旋律。我们登上并非我们所选择的舞台,演出并非我们所选择的剧本。继续加油吧&#xff01; 目录 1.ArrayList与LinkedList区别&#xff0c; 应用场景…
阅读更多...
免费数据恢复软件哪个好？排名前十的软件有这些！

免费数据恢复软件哪个好？排名前十的软件有这些！

我们经常会使用电脑&#xff0c;有时是为了放松娱乐&#xff0c;有时是为了处理工作。里面保存着大大小小的数据&#xff0c;多的数不胜数。如果我们的数据丢失&#xff0c;通过很多方法都没有办法恢复&#xff0c;那么软件可以帮助用户轻松处理各种丢失的文件&#xff0c;并可…
阅读更多...
IDEA git cherry pick 简单使用

IDEA git cherry pick 简单使用

cherry pick的作用&#xff1a; 参考了一些博客&#xff0c; eg&#xff1a;参考博客1 参考博客2 再做了个小案例后&#xff0c;我目前的理解是&#xff0c;cherry pick的作用是将一个分支的部分提交/历史提交,可以合并到另外一个分支。这也只是解决办法之一,之后遇到详细真实场…
阅读更多...
普元EOS中导出excl页面下载

普元EOS中导出excl页面下载

起因 需要做一个筛选功能的导出表格 解决办法 这个垃圾eos我是真受不了，sb玩意的缺点三天三夜也说不完 后边就没法整response的这些个东西，可真是够愁人的 在网上搜了搜 在普元的帮助文档里也看了看 普元提供的像是老太太的裹脚布一般又臭又长 参照这个可以看一下
阅读更多...
怕被AI取代快想办法“攒”个“数字第二大脑”

怕被AI取代快想办法“攒”个“数字第二大脑”

每日经济新闻发文：来自央视财经微博2月27日消息，美国《财富》杂志网站近日报道，美国一家提供就业服务的平台对1000家企业进行了调查。结果显示，美国最新调查显示50%企业已在用ChatGPT，其中48%已让其代替员工，有公司省下10多万美元！还有30%表示，有计划使用。
阅读更多...
4年经验来面试20K的测试岗，一问三不知，我还真不如去招应届生。

4年经验来面试20K的测试岗，一问三不知，我还真不如去招应届生。

公司前段缺人&#xff0c;也面了不少测试&#xff0c;结果竟然没有一个合适的。一开始瞄准的就是中级的水准&#xff0c;也没指望来大牛&#xff0c;提供的薪资在10-20k&#xff0c;面试的人很多&#xff0c;但平均水平很让人失望。看简历很多都是4年工作经验&#xff0c;但面试…
阅读更多...
华为OD机试题【找出通过车辆最多颜色】用 C++ 进行编码 （2023.Q1）

华为OD机试题【找出通过车辆最多颜色】用 C++ 进行编码 （2023.Q1）

最近更新的博客 华为od 2023 | 什么是华为od，od 薪资待遇，od机试题清单华为OD机试真题大全，用 Python 解华为机试题 | 机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为od机试，独家整理 已参加机试人员的实战技巧文章目录 最近更新的博客使用说明找出通…
阅读更多...
4.7 全文本搜索

4.7 全文本搜索

文章目录1.概述2.使用全文本搜索2.1 启用全文本搜索支持2.2 进行全文本搜索2.3 使用查询拓展2.4 布尔文本搜索3.全文本搜索使用说明1.概述 首先我们要知道&#xff0c;不是所有搜索引擎都支持全文本搜索&#xff0c;前边我们介绍过MySql支持多种数据类型&#xff0c;而其默认的…
阅读更多...
【微服务】-微服务环境搭建

【微服务】-微服务环境搭建

目录 2.1 技术选型 2.2 模块设计 2.3 微服务调用 2.4 创建⽗⼯程 2.5 创建商品微服务 2.6 创建订单微服务 2.1 技术选型 持久层: SpingData Jpa 数据库: MySQL5.7 其他: SpringCloud Alibaba 技术栈 2.2 模块设计 --- shop-parent ⽗⼯程 --- shop-product-api 商品微服…
阅读更多...
go提高升阶（四） I/O流学习

go提高升阶（四） I/O流学习

I/O 官网课程 购买课程找博主推荐 文章目录I/O文件信息创建文件、目录IO读IO写(权限)文件复制Seeker接口断点续传遍历文件夹bufio电脑中一切&#xff0c;都是以 二进制流的形式存在的。jpg&#xff1a;010100000010010101001010101010010101010 编码格式&#xff0c;还原为一个…
阅读更多...
（02）Unity HDRP Volume 详解

（02）Unity HDRP Volume 详解

1.概述这篇文章主要针对HDRP中的Volume和Volume Post-processing进行解释&#xff0c;针对于各个组件只能进行部分参数的解释&#xff0c;具体的信息可参考官方资料&#xff0c;这里只是对官方文档的图片效果补充以及笔者自己的理解。看到这里进入正文&#xff0c;请确保你的Un…
阅读更多...
企业IT信息化，BI 能做什么？

企业IT信息化，BI 能做什么？

随着数字化相关技术、应用的发展&#xff0c;社会总体的数字化发展进入了加速阶段&#xff0c;各行各业都开始有了数字化的身影&#xff0c;在这种情况下&#xff0c;数据已经成为了越来越多企业的重要资产&#xff0c;所以如何处理数据&#xff0c;让数据从资产转化为实际的价…
阅读更多...
【Linux】理解文件系统

【Linux】理解文件系统

文章目录理解文件系统了解磁盘结构inode理解文件系统 了解磁盘结构 磁盘是计算机中的一个 机械设备 这个磁盘的盘片就像光盘一样,数据就在盘片上放着, 但是光盘是只读的,磁盘是可读可写的 机械硬盘的寻址的工作方式: 盘片不断旋转,磁头不断摆动,定位到特定的位置 我们可以把…
阅读更多...
代码随想录算法训练营day46 | 动态规划之背包问题 139.单词拆分

代码随想录算法训练营day46 | 动态规划之背包问题 139.单词拆分

day46139.单词拆分1.确定dp数组以及下标的含义2.确定递推公式3.dp数组如何初始化4.确定遍历顺序5.举例推导dp[i]139.单词拆分 题目链接 解题思路&#xff1a;单词就是物品&#xff0c;字符串s就是背包&#xff0c;单词能否组成字符串s&#xff0c;就是问物品能不能把背包装满。…
阅读更多...
NJ+SCU42做Modbus RTU从站

NJ+SCU42做Modbus RTU从站

NJSCU42做Modbus RTU从站实验时间&#xff1a;2023.2.28 硬件设备&#xff1a;NJ501-1300&#xff0c;CJ1W-SCU42 软件&#xff1a;Sysmac Studio&#xff0c;Commix串口调试助手 案例简介&#xff1a;发送Modbus RTU命令读取NJ里的数据 1. 系统概述 264 ​ 本次实验使用C…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023