【C++航海王：追寻罗杰的编程之路】智能指针

news2024/9/19 4:35:23

目录

1 -> 为什么需要智能指针？

2 -> 内存泄漏

2.1 ->什么是内存泄漏，以及内存泄漏的危害

2.2 -> 内存泄漏分类

2.3 -> 如何避免内存泄漏

3 -> 智能指针的使用及原理

3.1 -> RAII

3.2 -> 智能指针的原理

3.3 -> std::auto_ptr

3.4 -> std::unique_ptr

3.5 -> std::shared_ptr

4 -> C++11和boost中智能指针的关系

1 -> 为什么需要智能指针？

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

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;

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;

	cout << div() << endl;

	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

2 -> 内存泄漏

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 -> 如何避免内存泄漏

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

总结：

内存泄漏非常常见，解决方案分为两种：

  1. 事前预防型。如智能指针等；
  2. 事后查错型。如泄漏检测工具。

3 -> 智能指针的使用及原理

3.1 -> RAII

RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命周期内始终保持有效。
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}

private:
	T* _ptr;
};

int div()
{
	int a, b;

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

	return a / b;
}
void Func()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(new int);

	cout << div() << endl;
}

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

3.2 -> 智能指针的原理

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

template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}

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

private:
	T* _ptr;
};

struct Date
{
	int _year;
	int _month;
	int _day;
};

int main()
{
	SmartPtr<int> sp1(new int);
	*sp1 = 10;

	cout << *sp1 << endl;

	SmartPtr<Date> sparray(new Date);

	// 需要注意的是这里应该是sparray.operator->()->_year = 2018;
	// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
	sparray->_year = 2018;
	sparray->_month = 1;
	sparray->_day = 1;
}

总结一下智能指针的原理：

  1. RAII特性
  2. 重载operator*和operator->，具有像指针一样的行为。

3.3 -> std::auto_ptr

 std::auto_ptr文档介绍

C++98版本的库中就提供了auto_ptr的智能指针。下面演示auto_ptr的使用及问题。

auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份fyd::auto_ptr来了解它的原理。  

// C++98 管理权转移 auto_ptr
namespace fyd
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			// 管理权转移
			sp._ptr = nullptr;
		}

		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			// 检测是否为自己给自己赋值
			if (this != &ap)
			{
				// 释放当前对象中资源
				if (_ptr)
					delete _ptr;

				// 转移ap中资源到当前对象中
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
		}

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

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

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

	private:
		T* _ptr;
	};
}

//int main()
//{
// std::auto_ptr<int> sp1(new int);
// std::auto_ptr<int> sp2(sp1); // 管理权转移
//
// // sp1悬空
// *sp2 = 10;
// cout << *sp2 << endl;
// cout << *sp1 << endl;
// 
// return 0;
//}

结论：auto_ptr是一个失败的设计，很多公司明确要求不能使用auto_ptr。

3.4 -> std::unique_ptr

std::unique_ptr文档介绍 

C++11中开始提供更靠谱的unique_ptr。

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化实现了一份fyd::unique_ptr来了解它的原理。

// 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 fyd
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

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

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

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

		unique_ptr(const unique_ptr<T>&sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;

	private:
		T* _ptr;
	};
}

//int main()
//{
// fyd::unique_ptr<int> sp1(new int);
// fyd::unique_ptr<int> sp2(sp1);
//
// std::unique_ptr<int> sp1(new int);
// std::unique_ptr<int> sp2(sp1);
//
// return 0;
//}

3.5 -> std::shared_ptr

std::shared_ptr文档介绍

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr。

shared_ptr的原理：通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

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

		void Release()
		{
			_pmtx->lock();
			bool flag = false;
			if (--(*_pRefCount) == 0 && _ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pRefCount;
				flag = true;
			}
			_pmtx->unlock();
			if (flag == true)
			{
				delete _pmtx;
			}
		}

		void AddRef()
		{
			_pmtx->lock();
			++(*_pRefCount);
			_pmtx->unlock();
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)
			if (_ptr != sp._ptr)
			{
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmtx = sp._pmtx;
				AddRef();
			}

			return *this;
		}

		int use_count()
		{
			return *_pRefCount;
		}

		~shared_ptr()
		{
			Release();
		}

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

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

		T* get() const
		{
			return _ptr;
		}

	private:
		T* _ptr;
		int* _pRefCount;
		mutex* _pmtx;
	};

	// 简化版本的weak_ptr实现
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

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

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

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

	private:
		T* _ptr;
	};
}
// shared_ptr智能指针是线程安全的吗？
// 是的，引用计数的加减是加锁保护的。但是指向资源不是线程安全的
// 指向堆上资源的线程安全问题是访问的人处理的，智能指针不管，也管不了
// 引用计数的线程安全问题，是智能指针要处理的
//int main()
//{
// fyd::shared_ptr<int> sp1(new int);
// fyd::shared_ptr<int> sp2(sp1);
// fyd::shared_ptr<int> sp3(sp1);
//
// fyd::shared_ptr<int> sp4(new int);
// fyd::shared_ptr<int> sp5(sp4);
//
// sp1 = sp1;
// sp1 = sp2;
//
// sp1 = sp4;
// sp2 = sp4;
// sp3 = sp4;
//
// *sp1 = 2;
// *sp2 = 3;
//
// return 0;
//}

std::shared_ptr的线程安全问题

通过下面的程序可以测试shared_ptr的线程安全问题。需要注意的是shared_ptr的线程安全分为两个方面：

  1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或--，引用计数原来是1，++了两次，可能还是2。这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、--是需要加锁的，也就是说引用计数的操作是线程安全的。
  2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。
// 1.演示引用计数线程安全问题，就把AddRefCount和SubRefCount中的锁去掉
// 2.演示可能不出现线程安全问题，因为线程安全问题是偶现性问题，main函数的n改大一些概率就变大了，就容易出现了。
// 3.下面代码我们使用SharedPtr演示，是为了方便演示引用计数的线程安全问题，
// 将代码中的SharedPtr换成shared_ptr进行测试，可以验证库的shared_ptr，发现结论是一样的。
namespace fyd
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pRefCount(new int(1))
			, _pmtx(new mutex)
		{}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			, _pmtx(sp._pmtx)
		{
			AddRef();
		}

		void Release()
		{
			_pmtx->lock();
			bool flag = false;
			if (--(*_pRefCount) == 0 && _ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pRefCount;
				flag = true;
			}
			_pmtx->unlock();
			if (flag == true)
			{
				delete _pmtx;
			}
		}

		void AddRef()
		{
			_pmtx->lock();
			++(*_pRefCount);
			_pmtx->unlock();
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)
			if (_ptr != sp._ptr)
			{
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmtx = sp._pmtx;
				AddRef();
			}

			return *this;
		}

		int use_count()
		{
			return *_pRefCount;
		}

		~shared_ptr()
		{
			Release();
		}

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

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

		T* get() const
		{
			return _ptr;
		}

	private:
		T* _ptr;
		int* _pRefCount;
		mutex* _pmtx;
	};

	// 简化版本的weak_ptr实现
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

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

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

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

	private:
		T* _ptr;
	};
}

struct Date
{
	int _year = 0;
	int _month = 0;
	int _day = 0;
};

void SharePtrFunc(fyd::shared_ptr<Date>& sp, size_t n, mutex& mtx)
{
	cout << sp.get() << endl;
	for (size_t i = 0; i < n; ++i)
	{
		// 这里智能指针拷贝会++计数，智能指针析构会--计数，这里是线程安全的。
		fyd::shared_ptr<Date> copy(sp);
		// 这里智能指针访问管理的资源，不是线程安全的。
		// 所以我们看看这些值两个线程++了2n次，但是最终看到的结果，并一定是加了2n
		{
		unique_lock<mutex> lk(mtx);
		copy->_year++;
		copy->_month++;
		copy->_day++;
		}
	}
}

int main()
{
	fyd::shared_ptr<Date> p(new Date);

	cout << p.get() << endl;

	const size_t n = 100000;
	mutex mtx;

	thread t1(SharePtrFunc, std::ref(p), n, std::ref(mtx));
	thread t2(SharePtrFunc, std::ref(p), n, std::ref(mtx));

	t1.join();
	t2.join();

	cout << p->_year << endl;
	cout << p->_month << endl;
	cout << p->_day << endl;
	cout << p.use_count() << endl;

	return 0;
}

std::shared_ptr的循环引用

struct ListNode
{
	int _data;

	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;

	~ListNode() { cout << "~ListNode()" << endl; }
};

int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);

	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;

	node1->_next = node2;
	node2->_prev = node1;

	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;

	return 0;
}

循环引用分析：

  1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
  2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
  3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点，_prev还指向上一个节点。
  4. 也就是说_next析构了，node2就释放了。
  5. 也就是说_prev析构了，node1就释放了。
  6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不释放。

// 解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
// 原理就是，node1->_next = node2;和node2->_prev = node1;时
// weak_ptr的_next和_prev不会增加node1和node2的引用计数。
struct ListNode
{
	int _data;

	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;

	~ListNode() { cout << "~ListNode()" << endl; }
};

int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);

	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;

	node1->_next = node2;
	node2->_prev = node1;

	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;

	return 0;
}

如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题。

// 仿函数的删除器
template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};

template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};

int main()
{
	FreeFunc<int> freeFunc;
	std::shared_ptr<int> sp1((int*)malloc(4), freeFunc);
	DeleteArrayFunc<int> deleteArrayFunc;
	std::shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);

	std::shared_ptr<int> sp4(new int[10], [](int* p) {delete[] p; });
	std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p)
		{fclose(p); });

	return 0;
}

4 -> C++11和boost中智能指针的关系

  1. C++ 98中产生了第一个智能指针auto_ptr。
  2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr。
  3. C++ TR1，引入了shared_ptr等。不过值得注意的是TR1并不是标准版。
  4. C++11，引入了unique_ptr、shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

感谢各位大佬支持！！！

互三啦！！！

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

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

相关文章

IDEA创建普通Java项目

IDEA创建普通Java项目

环境准备 Java环境 运行javac查看java环境是否安装完成 开发工具Intellij IDEA 下载地址&#xff1a;https://www.jetbrains.com/idea/download/?sectionwindows 创建项目 点击新建项目 填入项目名字&#xff0c;项目路径&#xff0c;选择maven,点击下面的创建 运行项目 …
阅读更多...
贪心，CF 1891C - Smilo and Monsters

贪心，CF 1891C - Smilo and Monsters

一、题目 1、题目描述 2、输入输出 2.1输入 2.2输出 3、原题链接 1891C - Smilo and Monsters 二、解题报告 1、思路分析 操作二显然很划算的&#xff0c;但是操作2有代价&#xff0c;为了更划算&#xff0c;我们要让操作2的操作次数最少 即&#xff0c;操作二尽可能用在…
阅读更多...
Apollo docker-compose

Apollo docker-compose

来源 https://www.apolloconfig.com/#/zh/deployment/quick-start-docker 路径 /usr/apollo Sql 自己复制 Vim docker-compose.yml #如果安装过了 记得删除mysql 历史文件 rm -r /var/lib/mysql version: 2.1services:apollo-quick-start:image: nobodyiam/apollo-quick…
阅读更多...
MongoDB教程（六）：mongoDB复制副本集

MongoDB教程（六）：mongoDB复制副本集

&#x1f49d;&#x1f49d;&#x1f49d;首先&#xff0c;欢迎各位来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里不仅可以有所收获&#xff0c;同时也能感受到一份轻松欢乐的氛围&#xff0c;祝你生活愉快&#xff01; 文章目录 引言一、MongoD…
阅读更多...
React 速通笔记

React 速通笔记

前言 最近刚学完 React&#xff0c;想着把笔记分享给大家&#xff0c;本笔记特别适合从事后端想要学习前端的人。我看视频是黑马最新的 React 视频&#xff08;黑马程序员前端React18入门到实战视频教程&#xff0c;从reacthooks核心基础到企业级项目开发实战&#xff08;B站评…
阅读更多...
Windows 2012安装之实现远程连接

Windows 2012安装之实现远程连接

新建虚拟机 点击稍后安装操作系统 点击Microsoft Windows(W) 选择Windows Server 2012 设置虚拟机名称、安装位置 选择你的电脑核数 点击编辑虚拟机设置 点击CD/DVD(SATA) 使用ISO映像文件(M) 配置完之后点击确定 然后开启虚拟机 下一步&#xff1a; 点击现在安装&#xff1a…
阅读更多...
51单片机(STC8H8K64U/STC8051U34K64)_RA8889驱动大屏_硬件SPI4_参考代码（v1.3)

51单片机(STC8H8K64U/STC8051U34K64)_RA8889驱动大屏_硬件SPI4_参考代码（v1.3)

单片机实际不限&#xff0c;这里采用的STC最新、主推的型号&#xff0c;比如STC8H8K64U、STC8051U34K64进行实验测试&#xff0c;您可以换用不同型号。目前测试这两个系列&#xff0c;显示速度均相当不错&#xff0c;软件设计也是极为简单。各篇文章下方均提供源码供参考下载。…
阅读更多...
Java 反射用法和8道练习题

Java 反射用法和8道练习题

目录 一、什么是反射二、反射的核心接口和类三、测试代码 Bean 类和目录结构Person 类代码目录结构 四、获取 Class 对象五、获取构造方法 Constructor 并使用六、获取成员变量 Field 并使用七、获取成员方法 Method 并使用八、练习1. 使用反射获取String类的所有公有方法&…
阅读更多...
在python里构建你的投资组合portfolio--最好用的pandas零基础

在python里构建你的投资组合portfolio--最好用的pandas零基础

有人可能觉得软件数据分析门槛很高&#xff0c;自学也坚持不下来&#xff0c; 其实分解成一个小的功能和任务&#xff0c;对零基础自学者非常有帮助。 今天用python中最好用的数据分析包pandas为例&#xff1a; 用最简单的代码完成全流程 构建投资组合 → 获取数据 → 进行分…
阅读更多...
均匀性大于98%均匀光源积分球

均匀性大于98%均匀光源积分球

在光学技术的浩瀚星空中&#xff0c;均匀光源积分球犹如一颗璀璨的明珠&#xff0c;以其卓越的均匀性能&#xff0c;照亮了科研、检测、照明等多个领域的探索之路。当谈及均匀性超过98%的积分球时&#xff0c;我们不禁要深入其内部&#xff0c;探索这一科技奇迹背后的原理与应用…
阅读更多...
phenocycler发现免疫治疗反应关键的肿瘤微环境区域

phenocycler发现免疫治疗反应关键的肿瘤微环境区域

T 细胞介导的抗原特异性反应对于有效的免疫监视至关重要。然而T细胞如何进入肿瘤微环境并操纵局部组织微环境来实现效应器功能&#xff0c;以及这些局部的细胞结构如何对T细胞疗法或者其他免疫治疗做出反应仍然不清楚。近期来自斯坦福大学的研究者利用小鼠模型和临床患者样本&a…
阅读更多...
10位工程师做SW大装配设计工作站怎么选

10位工程师做SW大装配设计工作站怎么选

在日益复杂的工程环境中&#xff0c;SolidWorks&#xff08;SW&#xff09;作为一款全球装机量较大的三维设计、动画、仿真模拟计算软件&#xff0c;已成为工程师们不可或缺的工具。 对于涉及大型装配设计的项目&#xff0c;选择一款合适的SW工作站显得尤为关键。在选择SW大装…
阅读更多...
【0630开发者活动】机器学习算法在存内计算芯片WTM2101上的部署

【0630开发者活动】机器学习算法在存内计算芯片WTM2101上的部署

前言 WTM2101芯片是由Witin知存科技开发的高性能存内计算芯片&#xff0c;专为加速AI计算设计&#xff0c;如图1.1所示。存内计算作为一种革命性技术&#xff0c;其主要优势在于将计算功能直接集成到存储器中&#xff0c;从而显著减少数据在芯片内部的传输距离&#xff0c;降低…
阅读更多...
【学术会议征稿】2024年第三届信息学，网络与计算技术国际学术会议(ICINC2024)

【学术会议征稿】2024年第三届信息学，网络与计算技术国际学术会议(ICINC2024)

2024年第三届信息学&#xff0c;网络与计算技术国际学术会议(ICINC2024) 2024 3rd International Conference on Informatics,Networking and Computing (ICINC 2024) 2024年第三届信息学&#xff0c;网络与计算技术国际学术会议(ICINC2024)将于2024年10月25-27日于中国郑州召…
阅读更多...
Django任务管理：项目定时执行及简单管理界面

Django任务管理：项目定时执行及简单管理界面

1、用django-admin命令创建一个Django项目 django-admin startproject task_manager 2、进入到项目下用命令创建一个应用 cd task_manager python manage.py startapp tasks 3、进入models.py定义数学模型 第2步得到的只是应用的必要空文件&#xff0c;要开始增加各文件实际…
阅读更多...
PostgreSQL的学习心得和知识总结（一百四十八）|查看 PostgreSQL 17 中的新内置排序规则提供程序

PostgreSQL的学习心得和知识总结（一百四十八）|查看 PostgreSQL 17 中的新内置排序规则提供程序

目录结构 注&#xff1a;提前言明 本文借鉴了以下博主、书籍或网站的内容&#xff0c;其列表如下&#xff1a; 1、参考书籍&#xff1a;《PostgreSQL数据库内核分析》 2、参考书籍&#xff1a;《数据库事务处理的艺术&#xff1a;事务管理与并发控制》 3、PostgreSQL数据库仓库…
阅读更多...
MongoDB Atlas Vector Search再度荣获最受欢迎的向量数据库称号

MongoDB Atlas Vector Search再度荣获最受欢迎的向量数据库称号

最新发布的《2024 年 Retool AI 现状报告》显示&#xff0c;MongoDB Atlas Vector Search 再次荣获最受欢迎的向量数据库称号&#xff0c;这已是它连续第二年获此殊荣。 Atlas Vector Search 在净推荐值 &#xff08;NPS&#xff09;方面斩获最高分&#xff0c;这一指标精准反映…
阅读更多...
【python】pandas报错：UnicodeDecodeError详细分析，解决方案以及如何避免

【python】pandas报错：UnicodeDecodeError详细分析，解决方案以及如何避免

✨✨ 欢迎大家来到景天科技苑✨✨ &#x1f388;&#x1f388; 养成好习惯&#xff0c;先赞后看哦~&#x1f388;&#x1f388; &#x1f3c6; 作者简介&#xff1a;景天科技苑 &#x1f3c6;《头衔》&#xff1a;大厂架构师&#xff0c;华为云开发者社区专家博主&#xff0c;…
阅读更多...
一文带你看懂SAP-HANA的基本架构与原理

一文带你看懂SAP-HANA的基本架构与原理

注&#xff1a;本篇主要对SAP HANA做了总结与论述&#xff0c;如有错误欢迎读者提出并补充 创作不易,希望大家一键三连支持!!!♥♥♥ 创作不易,希望大家一键三连支持!!!♥♥♥ 创作不易,希望大家一键三连支持!!!♥♥♥ 目录 一. 背景引入1.1 硬件与数据库系统1.2 行业现状 …
阅读更多...
MongoDB自学笔记（一）

MongoDB自学笔记（一）

一、MongoDB简介 MongoDB是一款基于C开发的文档型数据库。与传统的关系型数据库有所不同&#xff0c;MongoDB面向的是文档&#xff0c;所谓的文档是一种名为BSON &#xff08;Binary JSON&#xff1a;二进制JSON格式&#xff09;是非关系数据库当中功能最丰富&#xff0c;最像…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023