【C++进阶之路】第八篇：智能指针

文章目录

  • 一、为什么需要智能指针？
  • 二、内存泄漏
    • 1.什么是内存泄漏，内存泄漏的危害
    • 2.内存泄漏分类（了解）
    • 3.如何检测内存泄漏（了解）
    • 4.如何避免内存泄漏
  • 三、智能指针的使用及原理
    • 1.RAII
    • 2.智能指针的原理
    • 3.std::auto_ptr（了解）
    • 4.std::unique_ptr
    • 5.std::shared_ptr
      • （1）shared_ptr介绍
      • （2）std::shared_ptr的线程安全问题
      • （3）std::shared_ptr的循环引用 [std::weak_ptr]
  • 四、C++11和boost中智能指针的关系（了解）

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

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

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;
}

通过分析上述代码，我们发现，如果只申请资源，不对资源进行管理或清理，就有可能出现内存泄漏的问题。

二、内存泄漏

1.什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

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

2.内存泄漏分类（了解）

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

  • 堆内存泄漏(Heap leak)

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

  • 系统资源泄漏

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

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

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

4.如何避免内存泄漏

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

  2. 采用RAII思想或者智能指针来管理资源。

  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

  4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

总结一下:

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

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

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()
{ShardPtr<int> sp1(new int);ShardPtr<int> sp2(new int);cout << div() << endl;
}int main()
{try {Func();}catch (const exception& e){cout << e.what() << endl;}return 0;
}

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 = 10cout << *sp1 << endl;SmartPtr<int> sparray(new Date);// 需要注意的是这里应该是sparray.operator->()->_year = 2018;// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->sparray->_year = 2018;sparray->_month = 1;sparray->_day = 1;
}

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

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

3.std::auto_ptr（了解）

auto_ptr文档

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

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

// C++98 管理权转移 auto_ptr
namespace test
{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;};
}// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_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;
//}

4.std::unique_ptr

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

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 test
{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()
//{
// /*test::unique_ptr<int> sp1(new int);
// test::unique_ptr<int> sp2(sp1);*/
//
// std::unique_ptr<int> sp1(new int);
// //std::unique_ptr<int> sp2(sp1);
//
// return 0;
//}

5.std::shared_ptr

（1）shared_ptr介绍

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

shared_ptr

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。例如：学校老师晚上在下班之前都会通知，让最后走的学生记得把门锁下。

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。

  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。

  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；

  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace test
{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()
//{
// test::shared_ptr<int> sp1(new int);
// test::shared_ptr<int> sp2(sp1);
// test::shared_ptr<int> sp3(sp1);
//
// test::shared_ptr<int> sp4(new int);
// test::shared_ptr<int> sp5(sp4);
//
// //sp1 = sp1;
// //sp1 = sp2;
//
// //sp1 = sp4;
// //sp2 = sp4;
// //sp3 = sp4;
//
// *sp1 = 2;
// *sp2 = 3;
//
// return 0;
//}

（2）std::shared_ptr的线程安全问题

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

  1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2。这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、–是需要加锁的，也就是说引用计数的操作是线程安全的。

  2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

// 1.演示引用计数线程安全问题，就把AddRefCount和SubRefCount中的锁去掉
// 2.演示可能不出现线程安全问题，因为线程安全问题是偶现性问题，main函数的n改大一些概率就
变大了，就容易出现了。
// 3.下面代码我们使用SharedPtr演示，是为了方便演示引用计数的线程安全问题，将代码中的
SharedPtr换成shared_ptr进行测试，可以验证库的shared_ptr，发现结论是一样的。
struct Date
{int _year = 0;int _month = 0;int _day = 0;
};void SharePtrFunc(test::shared_ptr<Date>& sp, size_t n, mutex& mtx)
{cout << sp.get() << endl;for (size_t i = 0; i < n; ++i){// 这里智能指针拷贝会++计数，智能指针析构会--计数，这里是线程安全的。test::shared_ptr<Date> copy(sp);// 这里智能指针访问管理的资源，不是线程安全的。所以我们看看这些值两个线程++了2n次，但是最终看到的结果，并一定是加了2n{unique_lock<mutex> lk(mtx);copy->_year++;copy->_month++;copy->_day++;}}
}int main()
{test::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;
}

（3）std::shared_ptr的循环引用 [std::weak_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设计了一个删除器来解决这个问题（ps：删除器这个问题我们了解一下）

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<A> sp4(new A[10], [](A* p) {delete[] p; });std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p){fclose(p); });return 0;
}

四、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中的实现的。

🌹🌹 智能指针 的知识大概就讲到这里啦，博主后续会继续更新更多C++ 和 Linux的相关知识，干货满满，如果觉得博主写的还不错的话，希望各位小伙伴不要吝啬手中的三连哦！你们的支持是博主坚持创作的动力！💪💪

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

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

相关文章

气相色谱质谱仪样品传输装置中电动针阀和微泄漏阀的解决方案

气相色谱质谱仪样品传输装置中电动针阀和微泄漏阀的解决方案

标题 摘要&#xff1a;针对目前国内外各种质谱仪压差法进样装置无法准确控制进气流量&#xff0c;且无相应配套产品的问题&#xff0c;本文提出了相应的解决方案和配套部件。解决方案主要解决了制作更小流量毛细管和毛细管进气端真空压力精密控制问题&#xff0c;微流量毛细管的…
阅读更多...
Flutter：多线程Isolate的简单使用

Flutter：多线程Isolate的简单使用

在flutter中如果要使用线程&#xff0c;需要借助Isolate来实现。 简介 在Flutter中&#xff0c;Isolate是一种轻量级的线程解决方案&#xff0c;用于在应用程序中执行并发任务。Isolate可以被认为是独立于主线程的工作单元&#xff0c;它们可以在后台执行任务而不会阻塞应用程…
阅读更多...
C++入门第八篇---STL模板---list的模拟实现

C++入门第八篇---STL模板---list的模拟实现

前言&#xff1a; 有了前面的string和vector两个模板的基础&#xff0c;我们接下来就来模拟实现一下list链表模板&#xff0c;我还是要强调的一点是&#xff0c;我们模拟实现模板的目的是熟练的去使用以及去学习一些对于我们本身学习C有用的知识和用法&#xff0c;而不是单纯的…
阅读更多...
基于SpringBoot+MyBatis-Plus的校园图书管理系统

基于SpringBoot+MyBatis-Plus的校园图书管理系统

基于SpringBootMyBatis-Plus的校园图书管理系统 校园图书管理系统开发技术功能模块代码结构数据库设计运行截图源码获取 校园图书管理系统 欢迎访问此博客&#xff0c;是否为自己的毕业设计而担忧呢&#xff1f;是否感觉自己的时间不够做毕业设计呢&#xff1f;那你不妨看一下…
阅读更多...
2023年DevOps国际峰会暨BizDevOps企业峰会（DOIS北京站）-核心PPT资料下载

2023年DevOps国际峰会暨BizDevOps企业峰会（DOIS北京站）-核心PPT资料下载

一、峰会简介 在数字化转型的大背景下&#xff0c;企业选择实践 DevOps 来提升 IT 效能成为常态&#xff0c;BizDevOps 作为企业自身数字化变革的重要主题之一&#xff0c;需要全行业共同努力促进繁荣和发展。从 DevOps 到 BizDevOps&#xff0c;业务与技术如何融合&#xff1…
阅读更多...
CentOS用nginx搭建文件下载服务器

CentOS用nginx搭建文件下载服务器

Nginx 是开源、高性能、高可靠的 Web 和反向代理服务器&#xff0c;而且支持热部署&#xff0c;几乎可以做到 7 * 24 小时不间断运行&#xff0c;即使运行几个月也不需要重新启动。在工作中&#xff0c;我们经常会用到需要搭建文件服务器的情况&#xff0c;这里就以在linux下搭…
阅读更多...
不会代码也能拿高薪？掌握面试法宝，轻松10000+

不会代码也能拿高薪？掌握面试法宝，轻松10000+

快速排序&#xff08;Quicksort&#xff09;是对冒泡排序的一种改进。 快速排序由 C.A.R.Hoare 在 1962 年提出。 它的基本思想是&#xff1a;通过一趟排序将要排序的数据分割成独立的两部分&#xff0c;其中一部分的所有数据都比另外一部分的所有数据都要小&#xff0c;然后…
阅读更多...
最新版本的橙色前端微信去水印小程序源码

最新版本的橙色前端微信去水印小程序源码

好像最近去水印小程序挺火的&#xff0c;你看这就不来了一个新的去水印小程序。 橙色前端是最近比较流行的&#xff0c;很多小程序也都是这种样式&#xff0c;如果你需要其它颜色的&#xff0c;可以自己修改一下CSS即可&#xff0c;小程序云开发的&#xff0c;无需服务器。 打…
阅读更多...
2023年11月15号期中测验判断题（Java）

2023年11月15号期中测验判断题（Java）

本篇还有3篇相关文章-> 2023年11月15号期中测验选择题&#xff08;Java&#xff09;-CSDN博客 2023年11月15号期中测验编程题&#xff08;Java&#xff09;-CSDN博客 2023年11月15号期中测验主观题&#xff08;Java&#xff09;-CSDN博客 判断题-> T F 1-1 局…
阅读更多...
编译器安全

编译器安全

在供应链安全中&#xff0c;大家一直关注采用SCA工具分析开源组件中的安全漏洞以及许可证的合规性。但是对于底层软件开发使用的编译器、链接器等安全却容易被忽视&#xff0c;其中有没有安全漏洞、有没有运行时缺陷、有没有被植入漏洞、木马等&#xff0c;似乎并没有引起多少人…
阅读更多...
selenium判断元素是否存在的方法

selenium判断元素是否存在的方法

文章目录 快捷方法完整示例程序 快捷方法 selenium没有exist_xxx相关的方法&#xff0c;无法直接判断元素存在。但是锁定元素时使用的browser.find_elements(By.CSS_SELECTOR, "css元素")会返回一个列表list&#xff0c;如果不存在这个元素就会返回一个空列表。因此…
阅读更多...
【20年扬大真题】设顺序表va中的数据元素递增有序。试写一算法，将x插入到顺序表的适当位置上，以保障该表的有序性。

【20年扬大真题】设顺序表va中的数据元素递增有序。试写一算法，将x插入到顺序表的适当位置上，以保障该表的有序性。

【20年扬大真题】 设顺序表va中的数据元素递增有序。 试写一算法&#xff0c;将x插入到顺序表的适当位置上&#xff0c;以保障该表的有序性。 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<malloc.h> #define MaxSize 9//定义最大长度 int InitAr…
阅读更多...
第4章 向量、SIMD和GPU体系结构中的数据级并行

第4章 向量、SIMD和GPU体系结构中的数据级并行

4.1 引言 有多少应用程序拥有大量的数据级并行DLP&#xff1f;SIMD分类Flyn被提出后5年。答案不仅包括科学运算中的矩阵运算&#xff0c;还包括面向多媒体的图像和声音处理以及机器学习算法。 由于SIMD可以执行多个数据操作&#xff0c;能效比MIMD要高&#xff0c;使得SIMD对…
阅读更多...
Day37力扣打卡

Day37力扣打卡

打卡记录 美化数组的最少删除数&#xff08;贪心&#xff09; 链接 class Solution:def minDeletion(self, nums: List[int]) -> int:n, cnt len(nums), 0for i in range(n):if (i - cnt) % 2 0 and i 1 < n and nums[i] nums[i 1]:cnt 1return cnt 1 if (n - c…
阅读更多...
x shell 用作串口调试助手

x shell 用作串口调试助手

x shell 用作串口调试助手 Xshell 介绍 是一个强大的安全终端模拟软件&#xff0c;它支持SSH1, SSH2, 以及Microsoft Windows 平台的TELNET 协议。Xshell 通过互联网到远程主机的安全连接以及它创新性的设计和特色帮助用户在复杂的网络环境中享受他们的工作。 Xshell可以在Wi…
阅读更多...
【Java】异常处理及其语法、抛出异常、自定义异常（完结）

【Java】异常处理及其语法、抛出异常、自定义异常（完结）

&#x1f33a;个人主页&#xff1a;Dawn黎明开始 &#x1f380;系列专栏&#xff1a;Java ⭐每日一句&#xff1a;道阻且长&#xff0c;行则将至 &#x1f4e2;欢迎大家&#xff1a;关注&#x1f50d;点赞&#x1f44d;评论&#x1f4dd;收藏⭐️ 文章目录 一.&#x1f510;异…
阅读更多...
【C++进阶之路】第七篇：异常

【C++进阶之路】第七篇：异常

文章目录 一、C语言传统的处理错误的方式二、 C异常概念三、异常的使用1.异常的抛出和捕获2.异常的重新抛出3.异常安全4.异常规范 四、自定义异常体系五、C标准库的异常体系&#xff08;了解&#xff09;六、异常的优缺点 一、C语言传统的处理错误的方式 传统的错误处理机制&am…
阅读更多...
java中，通过替换word模板中的关键字后输出一个新文档

java中，通过替换word模板中的关键字后输出一个新文档

一、要用到的jar包 我已上传了相关的jar包&#xff0c;需要的可以通过以下链接直接下载&#xff1a; https://download.csdn.net/download/qq_27387133/88558034 具体jar包截图&#xff1a; 二、实现的代码 注意&#xff1a;文件要用docx格式!!! word变量替换的方法&#…
阅读更多...
场景驱动的 AI 体验设计：如何让智能 IDE 赋能遗留系统重写

场景驱动的 AI 体验设计：如何让智能 IDE 赋能遗留系统重写

作为 AutoDev 的核心开发&#xff0c;我们不仅在不断丰富 AutoDev 的功能以满足不同公司的定制需求&#xff0c;还在与各种团队进行持续交流。在处理遗留系统时&#xff0c;我们发现程序员们日常工作中需要面对大量使用过时技术、基础设施混乱的系统。 在这个背景下&#xff0c…
阅读更多...
leetcode：20. 有效的括号

leetcode：20. 有效的括号

一、题目&#xff1a; 链接&#xff1a;20. 有效的括号 - 力扣&#xff08;LeetCode&#xff09; 函数原型&#xff1a;bool isValid(char* s) 二、思路&#xff1a; 利用栈来解这道题会方便许多&#xff1a; 遍历字符串s&#xff0c;当遇到左括号就将其压入栈中&#xff1b;遇…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023