【C++】智能指针【内存泄漏|智能指针原理及使用|RAII】

2023-11-06 23:20
文章标签 c++ 指针 使用 内存 智能 原理 泄漏 raii

本文主要是介绍【C++】智能指针【内存泄漏|智能指针原理及使用|RAII】，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

1、了解内存泄露

1.1 内存泄漏的定义及危害

1.2 内存泄漏分类（了解）

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

1.4如何避免内存泄漏

2、智能指针的引出

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

3.1 RAII

3.2 智能指针的原理

3.3 std::auto_ptr

3.4 std::unique_ptr

3.5 std::shared_ptr

3.6 定制删除器(了解)

 

1、了解内存泄露

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

1.2 内存泄漏分类（了解）

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

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

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

1.4如何避免内存泄漏

1. 工程前期养成良好的设计规范和编码规范，申请的内存空间记着匹配的去释放。ps： 这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要智能指针来管理才有保证。
2. 采用 RAII 思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 已经出 问题了使用内存泄漏工具检测。 ps ：不过很多工具都不够靠谱，或者收费昂贵。【valgrind是一个Linux下的强大内存泄漏检测工具】
总结一下:
内存泄漏非常常见。
解决方案分为两种：
  • 事前预防型。如智能指针等。
  • 事后查错型。如泄漏检测工具

2、智能指针的引出

因为内存泄漏的危害，故下列场景针对内存的释放，异常都是格外小心的处理

问题场景一。缺陷：不确定是否要抛异常，但是你都会catch捕获

int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void Func()
{int* p1 = new int;//这种写法的问题：不确定是否要抛异常，但你都catch捕获了try{cout << div() << endl;}//catch (exception& e)//{//	delete p1;//	throw e;//}catch (...){//下面这种写法也可以//拦截下来先释放，再抛异常delete p1;throw;}delete p1;
}
int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

 问题场景二、多个new抛异常。缺陷：不确定哪个对象会new失败

 针对以上问题，引出智能指针

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;//无论是函数正常结束，还是抛异常，都会导致sp对象的生命周期到了后析构函数释放资源
}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;SmartPtr<pair<int, int>> sp2(new pair<int, int>);sp2->first = 20;sp2->second = 30;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* 和 opertaor-> ，具有像指针一样的行为。
注：RAII和智能指针的关系:RAII是一个托管资源的思想，智能指针是依靠这种RAII实现的，（unique_lock/lock_guard也依靠RAII），其 基于RAII思想设计一个类，把需要释放的资源交给类对象，通过对象生命周期来管理，在对象析构时释放资源
潜在的问题：

若在上述代码主函数添加 SmartPtr<int> sp3 = sp1（调用编译器自动生成的拷贝构造：浅拷贝）; 则会出现问题，因为指向同一块资源会导致析构两次。

那这里能不能深拷贝？不能！

针对这个问题，解决方案如下：

  • 1、管理权转移 C++98 auto_ptr
  • 2、防拷贝 C++11 unique_ptr
  • 3、引用计数的共享拷贝 C++11 shared_ptr

3.3 std::auto_ptr

C++98 版本的库中就提供了 auto_ptr 的智能指针。 auto_ptr 的实现原理：管理权转移的思想。
下面简化模拟实现了一份a uto_ptr 来了解它的原 理： 
// C++98 管理权转移 auto_ptr
//模拟实现库中的auto_ptr
namespace mz
{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()
{mz::auto_ptr<int> sp1(new int);//用sp1拷贝sp2后，sp2就指向了sp1原指向的空间，而sp1会被置空（不指向任何空间）mz::auto_ptr<int> sp2(sp1); // 管理权转移（空间的管理权转移）// sp1悬空（因为s1已经指向空了！）*sp2 = 10;cout << *sp2 << endl;cout << *sp1 << endl;return 0;
}

auto_ptr缺陷：sp2 = sp1【赋值重载】或 sp2(sp1)【拷贝构造】场景下sp1就悬空了（nullptr），此时访问sp1就会报错，若不熟悉auto_ptr的特性就会被坑，故我们不推荐用甚至不让用auto_ptr

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 mz
{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()
{/*mz::unique_ptr<int> sp1(new int);mz::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

C++11 中开始提供更靠谱的并且支持拷贝的 shared_ptr。
shared_ptr 的原理：是通过引用计数的方式来实现多个 shared_ptr 对象之间共享资源 。
  • 1. shared_ptr在其内部，给每个资源都维护了一份计数，用来记录该份资源被几个对象共享。
  • 2. 在对象被销毁时(即析构函数的调用)，就说明自己不使用该资源了，对象的引用计数减一。
  • 3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源。
  • 4. 如果不是0，说明除了自己还有其他对象在用该份资源，不能释放该资源，否则其他对象就成野指针了。
1、关于引用计数到底用什么类型的问题
①、int _count（不行） 
// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace mz
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr),_count(1){}shared_ptr(shared_ptr<T>& sp):_ptr(sp._ptr), _count(sp._count){//两个对象的引用计数都++++_count;++sp._count;} ~shared_ptr(){if (--_count == 0 && _ptr){//只有当引用计数为0且_ptr!=nullptr时，才会释放这份资源cout << "delete:" << _ptr << endl;//打印地址方便观察delete _ptr;_ptr = nullptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;int _count; //引用计数};
}int main()
{mz::shared_ptr<int> sp1(new int);mz::shared_ptr<int> sp2(sp1);return 0;
}

运行结果：什么都没有（代码中析构了会打印地址），为什么？

因为sp1和sp2是类对象，sp1初始的_count为1，用sp1拷贝sp2后，sp2的_count也变为1，然后sp2和sp1的_count都++变为2，等到要析构时，sp1和sp2的_count--变为1，没变为0，故不析构，所以是因为sp1和sp2各有各的_count，故_count定义为int类型不可以

②、static int_count（不行）

// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace mz
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr){_count = 1;//不能放在列表初始化里，会被认为是初始化，但是函数体内可以}shared_ptr(shared_ptr<T>& sp):_ptr(sp._ptr){++_count;//静态成员变量++} shared_ptr<T>& operator=(const shared_ptr<T>& sp){//if (this != &sp)if (_ptr != sp._ptr){}return *this;}~shared_ptr(){if (--_count == 0 && _ptr){//只有当引用计数为0且_ptr!=nullptr时，才会释放这份资源cout << "delete:" << _ptr << endl;//打印地址方便观察delete _ptr;_ptr = nullptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;static int _count; //引用计数};template<class T>int shared_ptr<T>::_count = 0;//成员变量类内定义，类外初始化
}int main()
{mz::shared_ptr<int> sp1(new int);mz::shared_ptr<int> sp2(sp1);mz::shared_ptr<int> sp3(new int);return 0;
}

运行结果：

两块资源只析构了一次？原因如下： 

 

③、int& _count（不行）

 引用是外面传一个来引用计数，每个对象都用这个引用计数。缺点：外面可以改传进来的引用计数，而且容易造成混乱。这是利用外面来控制的，不好！

④、int* _pcount（可行）

// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace mz
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr),_pcount(new int(1)){}shared_ptr(shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount){++(*_pcount);//对同时管理的这块资源的引用计数++} //sp1 = sp4shared_ptr<T>& operator=(shared_ptr<T>& sp){//if (this != &sp)这种写法也可以if (_ptr != sp._ptr)//如果管理的不是同一块资源，才会赋值{//判断是否需要释放旧空间资源//若我是最后一个管理资源的对象，则需要释放资源if (--(*_pcount) == 0){	//释放旧空间资源delete _pcount;delete _ptr;}//管理同一份空间资源_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);//引用计数++}return *this;}~shared_ptr(){if (--(*_pcount) == 0 && _ptr){//只有当引用计数为0且_ptr!=nullptr时，才会释放这份资源cout << "delete:" << _ptr << endl;//打印地址方便观察delete _ptr;_ptr = nullptr;delete _pcount;_pcount = nullptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;int* _pcount; //引用计数：有多少个对象一起共享管理资源};
}int main()
{mz::shared_ptr<int> sp1(new int);mz::shared_ptr<int> sp2(sp1);mz::shared_ptr<int> sp3(new int);mz::shared_ptr<int> sp4(sp3);mz::shared_ptr<int> sp5(sp3);return 0;
}

运行结果：

 线程安全问题：

shared_ptr的线程安全分两方面：

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

 原因：shared_ptr的引用计数是在堆上 

 测试进程安全问题：

修改代码：加锁 （一个线程完事了才能让另一个线程开始）


// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
//shared_ptr的拷贝赋值时线程安全问题
//shared_ptr是否是线程安全的，答：注意这里的shared_ptr对象拷贝和析构++/--引用计数
//是否是安全的，库中的实现是安全的
#include<thread>
#include<mutex>namespace mz
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr),_pcount(new int(1)),_pmtx(new mutex){}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr),_pcount(sp._pcount),_pmtx(sp._pmtx){add_ref_count();//对同时管理的这块资源的引用计数++} //sp1 = sp4shared_ptr<T>& operator=(const shared_ptr<T>& sp){5//if (this != &sp)这种写法也可以if (_ptr != sp._ptr)//如果管理的不是同一块资源，才会赋值{//判断是否需要释放旧空间资源//若我是最后一个管理资源的对象，则需要释放资源release();//管理同一份空间资源_ptr = sp._ptr;_pcount = sp._pcount;_pmtx = sp._pmtx;add_ref_count();}return *this;}void add_ref_count(){_pmtx->lock();++(*_pcount);_pmtx->unlock();}//两个线程若同时去释放，也会出现问题void release(){bool flag = false;_pmtx->lock();if (--(*_pcount) == 0 && _ptr){cout << "delete:" << _ptr << endl;delete _ptr;delete _pcount;_ptr = nullptr;_pcount = nullptr;//delete _pmtx;//这里不能直接释放锁，因为unlock还没执行呢，故用flagflag = true;}_pmtx->unlock();if (flag == true){//要保证资源释放完了，才能释放锁delete _pmtx;_pmtx = nullptr;}}~shared_ptr(){release();}int use_count(){return *_pcount;}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;int* _pcount; //引用计数：有多少个对象一起共享管理资源mutex* _pmtx; //互斥锁：为了保护引用计数，管理同一份资源的对象共用一个锁};
}
int main()
{mz::shared_ptr<int> sp(new int);cout << sp.use_count() << endl; //1int n = 10000;//单纯两个拷贝出现出现问题的概率很小/*std::thread t1([&]() {mz::shared_ptr<int> sp1(sp);});std::thread t2([&]() {mz::shared_ptr<int> sp2(sp);});*///出了作用域sp1和sp2就销毁了（一个{}算一个作用域）//若同时进行10000次就会出现线程安全问题（100,1000次都不一定出现问题）std::thread t1([&]() {for (int i = 0; i < n; ++i){mz::shared_ptr<int> sp1(sp);}});std::thread t2([&]() {for (int i = 0; i < n; ++i){mz::shared_ptr<int> sp2(sp);}});t1.join();t2.join();cout << sp.use_count() << endl; //1return 0;
}

加锁后结果正确： 

 这里为什么要用锁而不用原子操作？

原子操作可以保护计数，但可能没办法保护释放过程，要用原子操作还要改结构，会复杂点

总结shared_ptr： 

优点：引用计数，可以拷贝

缺陷：循环引用（特殊场景下出现）

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

本质原因： 智能指针对象_prev和_next是属于节点的，而节点是new出来的空间，这块空间被delete了，节点的成员才会被释放。

针对shared_ptr这个缺陷，用weak_ptr来弥补:

解决循环引用方案：

在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了。

因为当sp1->_next = sp2; sp2->_prev = sp1;时weak_ptr的_next和_prev不会增加sp1和sp2的引用计数了

//严格来说，weak_ptr不是智能指针，因为他没有RAII资源管理
//专门解决shared_ptr的循环引用问题
//简化版本的weak_ptr实现
namespace mz
{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* get() const{return _ptr;//获取原生指针}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}
struct ListNode
{int _data;mz::weak_ptr<ListNode> _prev;mz::weak_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{shared_ptr<ListNode> sp1(new ListNode);shared_ptr<ListNode> sp2(new ListNode);cout << sp1.use_count() << endl;cout << sp2.use_count() << endl;//循环引用sp1->_next = sp2; //解决方式：使用wear_ptr，不增加引用计数sp2->_prev = sp1;cout << sp1.use_count() << endl;cout << sp2.use_count() << endl;return 0;
}

3.6 定制删除器(了解)

定制删除器就是传一个实现对应释放方式的仿函数对象进去给智能指针，因为智能指针默认析构是用delete，但是delete[]、malloc和文件等场景下，析构就不能用delete那么简单了，故要让我们自己实现个定制删除器

//定制删除器（了解）
#include<memory>
#include<cstdlib>
class A
{
public:~A(){cout << "~A()" << endl;}private:int _a1;int _a2;
};//解决：写个仿函数传给智能指针即可完成析构
template<class T>
struct DeleteArry
{void operator()(T* pa){delete[] pa;}
};struct  Free
{void operator()(void* p){cout << "Free(p)" << endl;free(p);}
};struct Fclose
{void operator()(FILE* p){cout << "Fclose(p)" << endl;fclose(p);}
};int main()
{std::shared_ptr<A> sp1(new A);//new出来的对象会正常析构//因为智能指针的析构就是delete，没有delete[]等//std::shared_ptr<A> sp2(new A[10]);//程序崩溃//std::shared_ptr<A> sp3((A*)malloc(sizeof(A)));//程序崩溃//std::shared_ptr<FILE> sp4(fopen("text.txt", "w"));//程序崩溃//针对特殊的析构，利用仿函数，而不用本来的delete了std::shared_ptr<A> sp2(new A[10], DeleteArry<A>());std::shared_ptr<A> sp3((A*)malloc(sizeof(A)), Free());std::shared_ptr<FILE> sp4(fopen("text.txt", "w"), Fclose());return 0;
}

运行结果：

 3.7 lock_guard（补充知识）

 观察下面代码：

引入锁管理守卫：lock_guard

我们模拟实现一个

#include<mutex>//使用RAII思想设计的锁管理守卫
template<class Lock>
class LockGuard
{
public:LockGuard(Lock& lock):_lk(lock){//因为锁不支持拷贝，所以_lk加&就可以解决_lk.lock();}~LockGuard(){cout << "解锁" << endl;_lk.unlock();}//锁守卫也不允许拷贝和赋值LockGuard(LockGuard<Lock>&) = delete;LockGuard<Lock>& operator()(LockGuard<Lock>&) = delete;private:Lock& _lk; //注意用引用是因为锁不支持拷贝，那就和外面传进来的锁用一个即可
};int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void f()
{mutex mtx;LockGuard<mutex> lg(mtx);//无论是否抛异常都会正常解锁cout << div() << endl; //div函数有可能抛异常
}int main()
{try{f();}catch (exception& e){cout << e.what() << endl;}return 0;
}

这篇关于【C++】智能指针【内存泄漏|智能指针原理及使用|RAII】的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/359671。

相关文章

中文分词jieba库的使用与实景应用（一）

中文分词jieba库的使用与实景应用（一）

知识星球：https://articles.zsxq.com/id_fxvgc803qmr2.html 目录 一.定义： 精确模式（默认模式）： 全模式： 搜索引擎模式： paddle 模式（基于深度学习的分词模式）： 二 自定义词典 三.文本解析   调整词出现的频率 四. 关键词提取 A. 基于TF-IDF算法的关键词提取 B. 基于TextRank算法的关键词提取
阅读更多...
使用SecondaryNameNode恢复NameNode的数据

使用SecondaryNameNode恢复NameNode的数据

1）需求： NameNode进程挂了并且存储的数据也丢失了，如何恢复NameNode 此种方式恢复的数据可能存在小部分数据的丢失。 2）故障模拟 （1）kill -9 NameNode进程 [lytfly@hadoop102 current]$ kill -9 19886 （2）删除NameNode存储的数据（/opt/module/hadoop-3.1.4/data/tmp/dfs/na
阅读更多...
NameNode内存生产配置

NameNode内存生产配置

Hadoop2.x 系列，配置 NameNode 内存 NameNode 内存默认 2000m ，如果服务器内存 4G ， NameNode 内存可以配置 3g 。在 hadoop-env.sh 文件中配置如下。 HADOOP_NAMENODE_OPTS=-Xmx3072m Hadoop3.x 系列，配置 Nam
阅读更多...
Hadoop数据压缩使用介绍

Hadoop数据压缩使用介绍

一、压缩原则 （1）运算密集型的Job，少用压缩 （2）IO密集型的Job，多用压缩 二、压缩算法比较 三、压缩位置选择 四、压缩参数配置 1）为了支持多种压缩/解压缩算法，Hadoop引入了编码/解码器 2）要在Hadoop中启用压缩，可以配置如下参数
阅读更多...
Makefile简明使用教程

Makefile简明使用教程

文章目录 规则makefile文件的基本语法：加在命令前的特殊符号：.PHONY伪目标: Makefilev1 直观写法v2 加上中间过程v3 伪目标v4 变量 make 选项-f-n-C Make 是一种流行的构建工具，常用于将源代码转换成可执行文件或者其他形式的输出文件(如库文件、文档等)。Make 可以自动化地执行编译、链接等一系列操作。 规则 makefile文件
阅读更多...
【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
深入探索协同过滤：从原理到推荐模块案例

深入探索协同过滤：从原理到推荐模块案例

文章目录 前言一、协同过滤1. 基于用户的协同过滤（UserCF）2. 基于物品的协同过滤（ItemCF）3. 相似度计算方法 二、相似度计算方法1. 欧氏距离2. 皮尔逊相关系数3. 杰卡德相似系数4. 余弦相似度 三、推荐模块案例1.基于文章的协同过滤推荐功能2.基于用户的协同过滤推荐功能 前言     在信息过载的时代，推荐系统成为连接用户与内容的桥梁。本文聚焦于
阅读更多...
使用opencv优化图片（画面变清晰）

使用opencv优化图片（画面变清晰）

文章目录 需求影响照片清晰度的因素 实现降噪测试代码 锐化空间锐化Unsharp Masking频率域锐化对比测试 对比度增强常用算法对比测试 需求 对图像进行优化，使其看起来更清晰，同时保持尺寸不变，通常涉及到图像处理技术如锐化、降噪、对比度增强等 影响照片清晰度的因素 影响照片清晰度的因素有很多，主要可以从以下几个方面来分析 1. 拍摄设备 相机传感器：相机传
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
嵌入式QT开发：构建高效智能的嵌入式系统

嵌入式QT开发：构建高效智能的嵌入式系统

摘要： 本文深入探讨了嵌入式 QT 相关的各个方面。从 QT 框架的基础架构和核心概念出发，详细阐述了其在嵌入式环境中的优势与特点。文中分析了嵌入式 QT 的开发环境搭建过程，包括交叉编译工具链的配置等关键步骤。进一步探讨了嵌入式 QT 的界面设计与开发，涵盖了从基本控件的使用到复杂界面布局的构建。同时也深入研究了信号与槽机制在嵌入式系统中的应用，以及嵌入式 QT 与硬件设备的交互，包括输入输出设
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2