【C++11】 智能指针

news2024/11/18 15:23:38

一、为什么需要智能指针？

下面我们先分析一下下面这段程序有没有什么内存方面的问题？

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");

	return a / b;
}

void f()
{
	pair<string, string>* p1 = new pair<string, string>;
	pair<string, string>* p2 = new pair<string, string>;
	pair<string, string>* p3 = new pair<string, string>;
	pair<string, string>* p4 = new pair<string, string>;

	try 
	{
		div();
	}
	catch (...)
	{
		delete p1;
		cout << "delete:" << p1 << endl;
		throw;
	}

	delete p1;
	cout << "delete:" << p1 << endl;
}

int main()
{
	try
	{
		f();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

如果p1正常new正常delete，那么就不会产生内存泄漏，但如果出现抛异常，那么会影响执行流，即使delete也不会正常释放内存。
因此我们引出try catch捕获异常，并将p1正常delete。但如果我们new了多个，p2、p3、p4，如果p1出现异常，p2、p3、p4就没有办法得到正常释放，我们又要使用更多的try catch，这样会变得非常麻烦。
所以，我们这一章要引入智能指针来解决这个问题。
下面先讲一下内存泄漏

二、内存泄漏

2.1 什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
{
	 // 1.内存申请了忘记释放
	 int* p1 = (int*)malloc(sizeof(int));
	 int* p2 = new int;
	 // 2.异常安全问题
	 int* p3 = new int[10];
	 Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
	 delete[] p3;
}

2.2 内存泄漏分类（了解）

C/C++程序中一般我们关心两种方面的内存泄漏：

  • 堆内存泄漏(Heap leak)

    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

  • 系统资源泄漏

    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

2.3 如何检测内存泄漏（了解）

在linux下内存泄漏检测：linux下几款内存泄漏检测工具
在windows下使用第三方工具：VLD工具说明
其他工具：内存泄漏工具比较

2.4如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
    ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
  2. 采用RAII思想或者智能指针来管理资源。
  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

总结一下:
内存泄漏非常常见，解决方案分为两种：
1、事前预防型。如智能指针等。
2、事后查错型。如泄漏检测工具。

三、智能指针的使用及原理

3.1 RAII

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

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr
{
public:
	// RAII
	// 资源交给对象管理，对象生命周期内，资源有效，对象生命周期到了，释放资源
	// 1、RAII管控资源释放
	// 2、像指针一样
	// 3、拷贝问题
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete(_ptr);
	}
private:
	T* _ptr;
};

void f()
{
	SmartPtr<pair<string, string>> sp1(new pair<string, string>("11111", "22222"));
	div();

	SmartPtr<pair<string, string>> sp2(new pair<string, string>);
	SmartPtr<pair<string, string>> sp3(new pair<string, string>);
	SmartPtr<string> sp4(new string("xxxxx"));
	div();
}

int main()
{
	try
	{
		f();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

运行示例：
第一个div()执行错误，我们可以看到成功将sp1释放，并且退出程序，后面的就没有进行new了，也不用释放了。
在这里插入图片描述
第二个div()执行错误，我们可以看到成功将所有的指针释放。
在这里插入图片描述

3.2 智能指针的原理

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

template<class T>
class SmartPtr
{
public:
	// RAII
	// 资源交给对象管理，对象生命周期内，资源有效，对象生命周期到了，释放资源
	// 1、RAII管控资源释放
	// 2、像指针一样
	// 3、拷贝问题
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		cout << "delete:" << _ptr << endl;
		delete(_ptr);
	}

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

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

void f()
{
	SmartPtr<pair<string, string>> sp1(new pair<string, string>("11111", "22222"));
	div();

	SmartPtr<pair<string, string>> sp2(new pair<string, string>);
	SmartPtr<pair<string, string>> sp3(new pair<string, string>);
	SmartPtr<string> sp4(new string("xxxxx"));
	div();

	cout << *sp4 << endl;
	cout << sp1->first << endl;
	cout << sp1->second << endl;
}

int main()
{
	try
	{
		f();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

运行结果：
重载了和->符号并成功使用
在这里插入图片描述
总结一下智能指针的原理：
1. RAII特性
**2. 重载operator和opertaor->，具有像指针一样的行为。**

3.3 std::auto_ptr

std::auto_ptr文档
C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理

// C++98 管理权转移 auto_ptr
namespace gty
{
	template<class T>
	class auto_ptr
	{
	public:
		//RAII
		//像指针一样
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

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

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

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

		// ap3(ap1)
		// 管理权转移
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}
	private:
		T* _ptr;
	};
}

int main()
{
	// C++98 一般实践中，很多公司明确规定不要用这个
	gty::auto_ptr<A> ap1(new A(1));
	gty::auto_ptr<A> ap2(new A(2));

	// 管理权转移，拷贝时，会把被拷贝对象的资源管理权转移给拷贝对象
	// 隐患：导致被拷贝对象悬空，访问就会出问题
	gty::auto_ptr<A> ap3(ap1);

	// 崩溃
	ap1->_a++;
	ap3->_a++;

	return 0;
}

运行报错：
管理权转移，拷贝时，会把被拷贝对象的资源管理权转移给拷贝对象
隐患：导致被拷贝对象悬空，访问就会出问题
在这里插入图片描述
管理权转让后ap1的指针已经置为nullptr，这里再访问ap1进行++就会报错
在这里插入图片描述

3.4 std::unique_ptr

C++11中开始提供更靠谱的unique_ptr
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理

// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr
// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
namespace gty
{
template<class T>
class unique_ptr
{
public:
	// RAII
	// 像指针一样
	unique_ptr(T* ptr)
		:_ptr(ptr)
	{}

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

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

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

	// ap3(ap1)
	// 管理权转移
	// 防拷贝
	//这两个函数被被明确删除（使用= delete;）是为了强制实施unique_ptr的“唯一所有权”语义。如果你尝试复制或赋值一个unique_ptr，编译器会产生一个错误。
	unique_ptr(unique_ptr<T>& ap) = delete;
	unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;

private:
	T* _ptr;
};

};
}
int main()
{
	// C++11  简单粗暴，不让拷贝
	gty::unique_ptr<A> up1(new A(1));
	gty::unique_ptr<A> up2(new A(2));

	//gty::unique_ptr<A> up3(up1);
	//up1 = up2;

	return 0;
}

使用拷贝和赋值，发现运行报错
在这里插入图片描述
总结：std::unique_ptr相比auto_ptr靠谱了一些，不会出现导致被拷贝对象悬空的问题。
主要原理：将拷贝构造函数和赋值函数用delete禁止使用。

//这两个函数被被明确删除（使用= delete;）是为了强制实施unique_ptr的“唯一所有权”语义。如果你尝试复制或赋值一个unique_ptr，编译器会产生一个错误。
unique_ptr(unique_ptr<T>& ap) = delete;
unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;

但我们始终还是有一些场景是需要拷贝和赋值的。
所以接下来引出了shared_ptr。

3.5 std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
namespace gty
{
		// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		// 像指针一样
		shared_ptr(T* ptr = nullptr)//
			:_ptr(ptr)
			,_pcount(new int(1))
		{}

		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				delete _pcount;
				delete _ptr;
			}
		}

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

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

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

		// sp1 = sp5
		// sp6 = sp6
		// sp4 = sp5
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//自己给自己赋值，不要修改，直接返回this指针
			if (sp._ptr == _ptr)
				return *this;

			//不是自己给自己赋值，先把pcount减1，判断是否需要释放
			if (--(*_pcount) == 0)
			{
				delete _pcount;
				delete _ptr;
			}

			_ptr = sp._ptr;
			_pcount = sp._pcount;
			++(*_pcount);

			return *this;
		}

		int use_count() const
		{
			return *_pcount;
		}

		T* getptr() const
		{
			return _ptr;
		}

	private:
		T* _ptr;
		int* _pcount;//引用计数
	};
}

int main()
{
	// C++11
	gty::shared_ptr<A> sp1(new A(1));
	gty::shared_ptr<A> sp2(new A(2));

	gty::shared_ptr<A> sp3(sp1);
	sp1->_a++;
	sp3->_a++;

	cout << sp1->_a << endl;

	gty::shared_ptr<A> sp4(sp2);
	gty::shared_ptr<A> sp5(sp4);

	sp1 = sp5;
	sp3 = sp5;

	gty::shared_ptr<A> sp6(new A(6));
	sp6 = sp6;
	sp4 = sp5;

	 cout << sp6->_a << endl;

	return 0;
}

运行结果：
在这里插入图片描述
我们可以看到share_ptr可以实现拷贝构造，赋值重载，通过拷贝或者赋值得到的指针，和原来的指针可以共享资源，共同对数据进行修改。

3.5.1share_ptr的死穴----循环引用

循环引用问题：

struct Node
{
	A _val;

	gty::shared_ptr<Node> _next;
	gty::shared_ptr<Node> _prev;

};

int main()
{
	// 循环引用
	gty::shared_ptr<Node> sp1(new Node);
	gty::shared_ptr<Node> sp2(new Node);

	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;

	sp1->_next = sp2;
	//sp2->_prev = sp1;

	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;

	return 0;
}

屏蔽sp2->_prev = sp1;运行结果：
在这里插入图片描述
可以看到这种情况俩个指针都析构了
但是，当我们加上sp2->_prev = sp1;，再来看运行结果：
在这里插入图片描述
我们发现，这次俩个指针都没有释放，造成了内存泄漏，这是什么原因导致的呢？
我们来看下面这张图
在这里插入图片描述
我们看到，在初始化俩个shared_ptr之后，他们的引用计数都变为1，但当我执行这俩个语句，prev管着左边的节点next管着右边的节点

sp1->_next = sp2;
sp2->_prev = sp1;

我们，sp1就变成俩个指针管理，一个是sp1，另一个是sp2->_prev，
sp2也变成俩个指针管理，一个是sp2，另一个是sp1->_next 。
我们再来看：
在这里插入图片描述
所以就造成这个死循环，导致俩个shared_ptr没办法析构，进而造成内存泄漏。
那我们怎么解决这个问题呢？
使用weak_ptr可以解决这个问题，下面我们来看weak_ptr。

3.6 std::weak_ptr

weak_ptr不是RAII，它的存在只有一个意义，就是解决shared_ptr的循环引用问题
实现原理：支持用shared_ptr构造和赋值出weak_ptr。
weak_ptr不增加引用计数，可以访问资源，不参与资源释放的管理。

namespace gty
{
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr(T* ptr)
			:_ptr(nullptr)
		{}

		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

		weak_ptr<T>& (const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}


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

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

	private:
		T* _ptr;
	};
}

struct Node
{
	A _val;

	//bit::shared_ptr<Node> _next;
	//bit::shared_ptr<Node> _prev;

	gty::weak_ptr<Node> _next;
	gty::weak_ptr<Node> _prev;
	// weak_ptr不是RAII智能指针，专门用来解决shared_ptr循环引用问题
	// weak_ptr不增加引用计数，可以访问资源，不参与资源释放的管理
};

int main()
{
	// 循环引用
	gty::shared_ptr<Node> sp1(new Node);
	gty::shared_ptr<Node> sp2(new Node);

	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;

	sp1->_next = sp2;
	sp2->_prev = sp1;

	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;

	return 0;
}

运行结果：
在这里插入图片描述
可以看到这次引用计数没有增加，俩个shared_ptr指针也成功释放了

总结：
auto ptr 管理权转移，会导致被拷贝对象悬空，建议不要使用它
unique_ptr 禁止拷贝，简单粗暴。日常使用，不需要拷贝的场景，建议使用它
shared ptr 引用计数支持拷贝，需要拷贝的场景，就使用它。但是要小心构成循环引用，循环引用会导致内存泄漏
weak ptr 专门解决shared ptr的循环引用问题

四、定制删除器

我们前面自定义的智能指针析构函数都是delete，然而，当我们new[],或者malloc的时候，析构函数就没有对应的语句进行释放。
在这里插入图片描述
运行示例：
报错
在这里插入图片描述
因此，我们要引入定制删除器来解决不同情况下的释放。

下面我们先来看一下库里面是如何实现定制删除器的：
在这里插入图片描述
可以看到库中是用了一个仿函数，默认情况下是delete，我们可以将其他需要的释放情况用仿函数的方式传入。
下面简单的看俩个使用例子：

template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};

int main()
{
	shared_ptr<A> sp1(new A[10], DeleteArray<A>());
	shared_ptr<A> sp2((A*)malloc(sizeof(A)), [](A* ptr) {free(ptr); });
	shared_ptr<FILE> sp3(fopen("Test.cpp", "r"), [](FILE* ptr) {
		cout << "fclose:" << ptr << endl;
		fclose(ptr);
		});

	return 0;
}

在这里插入图片描述
可以看到，这次我们成功的将所有内存释放。
在sp1中，我们传入了一个delete[]的仿函数；sp2中，我们用了一个lambda表达式；
sp3中，我们还可以进行文件的打开和关闭，同样也是传入了一个lambda表达式。

下面我们来模拟实现一下定制删除器：
我们发现我们的仿函数都有一个共同的特点，就是返回值是void，函数参数是T*
，所以我们利用function包装器来模拟定制删除器
首先我们用function定义一个_del,这里我们要注意，要将默认的释放方式delete传给_del，否则当我们没有传仿函数或者lambda表达式时，会报错。
在这里插入图片描述
如何再对构造函数和析构函数进行修改
用模板的方式在创建一个函数参数del，传入仿函数或者lambda表达式给到_del
然后再析构函数利用_del对_ptr进行释放。
在这里插入图片描述
最后我们来进行测试：
在这里插入图片描述
可以看到这次我们成功的将所有内存释放。

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

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

相关文章

Linux编译内核添加Bcache模块

Linux编译内核添加Bcache模块

由于Bcache是在linux kernel 3.10之后才加入的&#xff0c;所以要使用Bcache&#xff0c;首先必须确保内核版本至少是3.10或及以上&#xff0c;可以使用uname -a查看内核版本 [rootceph01 ~]# uname -a Linux ceph01 4.18.0-305.3.1.el8.x86_64 #1 SMP Tue Jun 1 16:14:33 UTC…
阅读更多...
打桩机液压系统比例阀放大板

打桩机液压系统比例阀放大板

打桩机液压系统主要由液压油箱、液压泵、液压马达、各种阀门、管道、油缸、活塞等组成。 打桩机液压系统以液压油为工作介质&#xff0c;利用液压油的压力能来驱动执行机构完成所需的各种动作。打桩机液压系统采用液体进行驱动&#xff0c;可以使打桩机在开启时迅速达到理想工…
阅读更多...
el-input单独校验

el-input单独校验

el-input单独校验,效果图如下 <el-col :span"24"><el-form-item label"修订次数:" prop"sPublish"><el-input-numberv-model"addForm.sPublish":min"0":controls"false":precision"0"p…
阅读更多...
10月份stable diffusion animatediff等插件使用指南，又来更新了

10月份stable diffusion animatediff等插件使用指南，又来更新了

插件一直会更新&#xff0c;包含了基本市面上流行的90%插件&#xff0c;好用的插件更是不会错过&#xff0c;往期插件请看往期文章&#xff0c;如果你没有时间一直关注sd更新的进展&#xff0c;请关注我&#xff0c;一个月用几个小时看一下我的文章&#xff0c;最短时间跟进sd。…
阅读更多...
在中国可以使用 HubSpot 吗？

在中国可以使用 HubSpot 吗？

当谈到市场营销和客户关系管理工具时&#xff0c;HubSpot通常是一家企业的首选。然而&#xff0c;对于许多中国的企业来说&#xff0c;一个重要的问题是&#xff1a;在中国可以使用HubSpot吗&#xff1f;这个问题涉及到不同的方面&#xff0c;包括政策法规、社交媒体平台、语言…
阅读更多...
Flask Web 安装bootstrap失败pip install bootstrap

Flask Web 安装bootstrap失败pip install bootstrap

失败原因&#xff1a;网速太慢了 把公共wifi换成手机热点&#xff0c;成功&#xff1a;&#xff09; &#x1f603; 更新&#xff1a;开了手机热点还是报下面的错&#xff0c;但是把科学上网关了&#xff0c;就成功了&#xff0c;反正就是网络问题
阅读更多...
深入使用探讨 PuppeteerSharp 抓取 LinkedIn 页面的步骤

深入使用探讨 PuppeteerSharp 抓取 LinkedIn 页面的步骤

LinkedIn是全球最大的职业社交平台之一&#xff0c;拥有大量的用户和企业信息。用户可以在上面建立个人职业资料、与其他用户建立联系、分享职业经验和获取行业动态。由于其庞大的用户群体和丰富的数据资源&#xff0c;开发者们对于获取LinkedIn数据的需求日益增长。 Puppeteer…
阅读更多...
华为云云耀云服务器L实例评测｜使用clickhouse-benchmark工具对ClickHouse的性能测试

华为云云耀云服务器L实例评测｜使用clickhouse-benchmark工具对ClickHouse的性能测试

目录 引言 1 ClickHouse简介 2 利用docker安装ClickHouse 2.1 安装Docker 2.2 下载ClickHouse Docker镜像 2.3 创建ClickHouse容器 2.4 访问ClickHouse 3 创建测试表 4 运行 clickhouse-benchmark 5 分析结果 结语 引言 利用华为云的云耀云服务器L实例&#xff0c…
阅读更多...
如何开启POP3/SMTP免费邮件代发授权

如何开启POP3/SMTP免费邮件代发授权

如何开启POP3/SMTP免费邮件代发授权 一、开启126、163邮箱的免费邮件代发授权服务&#xff08;获取授权码&#xff09;1.登录“网易邮箱”官网客户端2.进入“设置-邮箱设置-邮箱安全设置”3.进入“POP3/SMTP/IMAP”4.验证并开启“POP3/SMTP”服务5.获取到“POP3/SMTP”授权码 二…
阅读更多...
再扩国产化信创版图！朗思科技与中科方德完成产品兼容性互认证

再扩国产化信创版图！朗思科技与中科方德完成产品兼容性互认证

近日&#xff0c;北京朗思智能科技有限公司&#xff08;以下简称“朗思科技”&#xff09;自主研发的数字员工产品与中科方德桌面操作系统完成产品认证。测试结果显示&#xff0c;双方产品完全兼容&#xff0c;整体运行稳定&#xff0c;在功能、性能及兼容性方面表现良好&#…
阅读更多...
python数据挖掘从入门到实战

python数据挖掘从入门到实战

欢迎关注博主 Mindtechnist 或加入【智能科技社区】一起学习和分享Linux、C、C、Python、Matlab&#xff0c;机器人运动控制、多机器人协作&#xff0c;智能优化算法&#xff0c;滤波估计、多传感器信息融合&#xff0c;机器学习&#xff0c;人工智能等相关领域的知识和技术。关…
阅读更多...
C++11——lambda表达式

C++11——lambda表达式

文章目录 1. C98对自定义类型的排序2. lambda表达式语法2.1 捕捉列表 3. lambda底层原理 1. C98对自定义类型的排序 在C98中&#xff0c;想要对自定义类型就行排序&#xff0c;我们得自己写仿函数来表明我们相对哪一项进行排序 struct Student {Student(string name, long id…
阅读更多...
2023年电工（中级）证模拟考试题库及电工（中级）理论考试试题

2023年电工（中级）证模拟考试题库及电工（中级）理论考试试题

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 2023年电工&#xff08;中级&#xff09;证模拟考试题库及电工&#xff08;中级&#xff09;理论考试试题是由安全生产模拟考试一点通提供&#xff0c;电工&#xff08;中级&#xff09;证模拟考试题库是根据电工&…
阅读更多...
vue3使用swiper6.7.0写轮播图，按钮在轮播图外面

vue3使用swiper6.7.0写轮播图，按钮在轮播图外面

应用场景&#xff1a;需要在header区域&#xff0c;写24小时天气预测轮播&#xff0c;按钮在轮播图外面&#xff0c;默认隐藏左侧按钮&#xff0c;当点击右侧按钮后&#xff0c;左侧按钮显示&#xff0c;当点击到最后一个轮播图的显示时&#xff0c;隐藏右侧按钮。通过获取索引…
阅读更多...
使用REPLACE将数据库某一列字段进行字符串操作

使用REPLACE将数据库某一列字段进行字符串操作

REPLACE可以将表里的数据进行替换操作 如&#xff1a;需要把这一列里面的 # 去掉&#xff0c;经过测试&#xff0c;无论是开头、句中还是结尾都可以删除 UPDATE 表名 SET 字段名 REPLACE(字段名 , #, )
阅读更多...
解决容器内deepspeed微调大模型报错

解决容器内deepspeed微调大模型报错

解决容器内deepspeed微调大模型报错&#xff1a;[launch.py:315:sigkill_handler] Killing subprocess 问题描述&#xff1a;解决办法 问题描述&#xff1a; 在容器中用deepspeed微调百川大模型2时&#xff0c;出现上述错误&#xff0c;错误是由于生成容器时&#xff0c;共享内…
阅读更多...
2023 年值得关注的软件测试趋势（3）

2023 年值得关注的软件测试趋势（3）

16.云性能工程对业务连续性的影响 检查和改进基于云的应用程序和服务的性能是云性能工程的主要目标&#xff0c;是各种软件测试趋势中云计算的重要组成部分。云提供了无与伦比的可扩展性、灵活性和成本节约&#xff0c;但如果没有适当的性能工程&#xff0c;组织将面临应用程序…
阅读更多...
Spark第一课

Spark第一课

从数据处理的方式角度: 流式: 一条数据一条数据的处理 微批量: 一小批一小批的处理 批量: 一批数据一批数据的处理(Spark) 从数据处理的延迟角度 离线: 数据处理的延迟是以小时,天为单位 准(近)实时: 以秒为单位 实时:延迟以毫秒为单位, Spark是一个批量数据处理的离线数据分…
阅读更多...
微积分(一) 函数的极限

微积分(一) 函数的极限

前言 微积分“以直代曲”的思想就是将整体非线性化为局部线性的一个经典的例子&#xff0c;尽管高等数学在定义微分时并没有用到一点线性代数的内容。许多非线性问题的处理――譬如流形、微分几何等&#xff0c;最后往往转化为线性问题。 函数 定义&#xff1a;设 x x x 和 …
阅读更多...
京东手机销售数据：2023年9月京东手机行业TOP10品牌排行榜

京东手机销售数据：2023年9月京东手机行业TOP10品牌排行榜

鲸参谋监测的京东平台9月份手机市场销售数据已出炉&#xff01; 9月份&#xff0c;手机市场销售整体呈现下滑。鲸参谋数据显示&#xff0c;今年9月&#xff0c;京东平台手机销量为300万&#xff0c;环比下降约20%&#xff0c;同比下降约18%&#xff1b;销售额为92亿&#xff0c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023