🔥个人主页:guoguoqiang. 🔥专栏:我与C++的爱恋
文章目录
1.为什么需要智能指针
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;
}
问题分析:上面的问题分析出来我们发现有什么问题?
动态内存分配没有释放:在 Func 函数中,您使用了 new int 来动态分配内存,但是在函数结束时,您没有释放这些内存。这将导致内存泄漏,因为这些动态分配的内存块不会被释放,最终可能会耗尽系统的内存资源。
异常安全性:在 div 函数中,如果除数 b 为0,会抛出一个 invalid_argument 异常。如果这个异常被抛出,那么在 Func 函数中分配的内存(p1 和 p2)不会被释放,这同样会导致内存泄漏。
main 函数中的异常处理:在 main 函数中,您捕获了所有类型的异常,包括 invalid_argument。但是,您没有检查捕获到的异常类型,这意味着任何类型的异常都会被打印出来。这可能会掩盖其他潜在的内存泄漏问题。
int div() {
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
int result = a / b;
return result;
}
void Func() {
int* p1 = new int;
int* p2 = new int;
try {
cout << div() << endl;
} catch (invalid_argument& e) {
cout << e.what() << endl;
delete p1;
delete p2; // 释放动态分配的内存
return; // 提前退出函数
}
delete p1;
delete p2;
}
int main() {
try {
Func();
} catch (exception& e) {
cout << e.what() << endl;
}
return 0;
}
智能指针的引入:
double Division(int a, int b)
{
// 当b == 0时抛出异常
if (b == 0)
{
throw "Division by zero condition!";
}
return (double)a / (double)b;
}
struct A
{
~A() noexcept
{
cout << "~A()" << endl;
}
int _a1 = 0;
int _a2 = 0;
};
template<class T>
class SmartPtr
{
public:
// RAII
SmartPtr(T* ptr)
:_ptr(ptr)
{}
~SmartPtr()
{
delete _ptr;
}
// 重载运算符,模拟指针的行为
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
void Func()
{
// 更好解决方案是智能指针
shared_ptr<A> sp1(new A);
SmartPtr<A> sp2(new A);
sp1->_a1++;
sp1->_a2++;
// 智能指针麻烦的是拷贝
// SmartPtr<A> sp3(sp1);
//unique_ptr 不让拷贝
//unique_ptr<A> sp3(sp1);
//shared_ptr 支持拷贝
shared_ptr<A> sp3(sp1);
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (const exception& e)
{
cout << e.what() << endl;
}
catch (...)
{
cout << "未知异常"<< 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如何避免内存泄漏
- 工程前期良好的设计规范,养成良好的编码规范,申请的内存空间记着匹配的去释放。ps:
这个理想状态。但是如果碰上异常时,就算注意释放了,还是可能会出问题。需要下一条智
能指针来管理才有保证。 - 采用RAII思想或者智能指针来管理资源。
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
- 出问题了使用内存泄漏工具检测。ps:不过很多工具都不够靠谱,或者收费昂贵。
总结一下:
内存泄漏非常常见,解决方案分为两种:1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。
3.智能指针的使用及原理
3.1 RAII
RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。在对象构造时获取资源,接着控制对资源的访问使之在对象的生命周期内始终保持有效,最后在对象析构的时候释放资源。借此,我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处:
1.不需要显式地释放资源。
2.采用这种方式,对象所需的资源在其生命期内始终保持有效
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr{
private:
T* _ptr;
public:
SmartPtr(T* ptr = nullptr)
:_ptr(ptr)
{
}
~SmartPtr(){
if(_ptr)
delete _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;
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)
{}
~Date()
{
cout << "~Date()" << endl;
}
};
int main()
{
SmartPtr<Date> sp1(new Date);
SmartPtr<Date> sp2(sp1);
sp1->_year++;
return 0;
默认的拷贝构造函数和赋值运算符会进行浅拷贝,就会造成同一块区域析构两次,然后出错。
智能指针的历史很早,最早来源于C++98中的 auto_ptr
auto_ptr的实现原理:管理权转移的思想,能造成管理权限悬空
std::auto_ptr<Date> ap1(new Date);
// 拷贝时,管理权限转移,被拷贝悬空
std::auto_ptr<Date> ap2(ap1);//ap1被悬空
auto_ptr(auto_ptr<T> &sp)
:_ptr(sp._ptr)
{
//管理权转移
sp._ptr = nullptr;
}
看看他的实现原理
namespace gwq {
template <class T>
class auto_ptr{
private:
T* _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;
}
};
}
// 结论: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;
//}
所以库建议使用unique_ptr代替auto_ptr
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 gwq
{
template<class T>
class unique_ptr
{
private:
T* _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;
};
}
//int main()
//{
// /*nanyi::unique_ptr<int> sp1(new int);
// nanyi::unique_ptr<int> sp2(sp1);*/
//
// std::unique_ptr<int> sp1(new int);
// //std::unique_ptr<int> sp2(sp1);
//
// return 0;
//}
unique_ptr 不支持拷贝,如果想拷贝就用shared_ptr.
我们有时候需要定制删除器,例如有防止拷贝等等
struct Date
{
int _year;
int _month;
int _day;
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)
{}
~Date()
{
cout << "~Date()" << endl;
}
};
template<class T>
class DeleteArray
{
public:
void operator()(T* ptr)
{
delete[] ptr;
}
};
class Fclose
{
public:
void operator()(FILE* ptr)
{
cout << "fclose:" << ptr << endl;
fclose(ptr);
}
};
shared_ptr的原理:是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
- shared_ptr在其内部,给每个资源都维护了着一份计数,用来记录该份资源被几个对象共享。
- 在对象被销毁时(也就是析构函数调用),就说明自己不使用该资源了,对象的引用计数减一。
- 如果引用计数是0,就说明自己是最后一个使用该资源的对象,必须释放该资源;
- 如果不是0,就说明除了自己还有其他对象在使用该份资源,不能释放该资源,否则其他对象就成野指针了。
namespace gwq {
template<class T>
class shared_ptr{
private:
T* _ptr;
int* _pcount;
function<void(T* ptr)> _del = [](T* ptr) {delete ptr; };//解决释放资源方式的问题
public:
shared_ptr(T* ptr = nullptr)
:_ptr(ptr),
_pcount(new int(1))
{
}
template<class D>
shared_ptr(T* ptr ,D del)
:_ptr(ptr),
_pcount(new int(1)),
_del(del)
{
}
void release(){
if(--(*_pcount) == 0){
//delete _ptr;
_del(_ptr);
delete _pcount;
_ptr = nullptr;
_pcount = nullptr;
}
}
//sp2(sp1)
shared_ptr(const shared_ptr<T>& sp)
//指向传来的对象的空间--->共享一块空间
:_ptr(sp._ptr)
,_pcount(sp._pcount)
{
//只对引用计数进行++
++(*_pcount);
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp){
if(_ptr != sp._ptr)
{
release();
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);
}
return *this;
}
T* get() const
{
return _ptr;
}
int use_count() const
{
return *_pcount;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
~shared_ptr(){
release();
}
};
}
int main()
{
// gwq::shared_ptr<Date> sp1(new Date);
// gwq::shared_ptr<Date> sp2(sp1);
// gwq::shared_ptr<Date> sp3(new Date);
// // 自己给自己赋值
// sp3 = sp3;
// sp1 = sp2;
// sp1 = sp3;
// sp2 = sp3;
gwq::shared_ptr<FILE> sp5(fopen("test.cpp", "r"), Fclose());
gwq::shared_ptr<int> sp6((int*)malloc(40), [](int* ptr)
{
cout << "free:" << ptr << endl;
free(ptr);
});
return 0;
}
shared_ptr循环引用
struct ListNode {
int _data;
gwq::weak_ptr<ListNode> _next;
gwq::weak_ptr<ListNode> _prev;
~ListNode() {
cout << "~ListNode()" << endl;
}
};
int main()
{
// 循环引用 -- 内存泄露
gwq::shared_ptr<ListNode> n1(new ListNode);
gwq::shared_ptr<ListNode> n2(new ListNode);
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
n1->_next = n2;
n2->_prev = n1;
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
// weak_ptr不支持管理资源,不支持RAII
//std::weak_ptr<ListNode> wp(new ListNode);
return 0;
}
循环引用分析:
- node1和node2两个智能指针对象指向两个节点,引用计数变成1,我们不需要手动
delete。 - node1的_next指向node2,node2的_prev指向node1,引用计数变成2。
- node1和node2析构,引用计数减到1,但是_next还指向下一个节点。但是_prev还指向上
一个节点。 - 也就是说_next析构了,node2就释放了。
- 也就是说_prev析构了,node1就释放了。
- 但是_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;
gwq::weak_ptr<ListNode> _next;
gwq::weak_ptr<ListNode> _prev;
~ListNode() {
cout << "~ListNode()" << endl;
}
};
template<class T>
class weak_ptr
{
public:
weak_ptr()
{}
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{}
weak_ptr<T>& operator=(const shared_ptr<T>& sp)
{
_ptr = sp.get();
return *this;
}
private:
T* _ptr = nullptr;
//T* _pcount
};
int main()
{
// 循环引用 -- 内存泄露
gwq::shared_ptr<ListNode> n1(new ListNode);
gwq::shared_ptr<ListNode> n2(new ListNode);
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
n1->_next = n2;
n2->_prev = n1;
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
// weak_ptr不支持管理资源,不支持RAII
//std::weak_ptr<ListNode> wp(new ListNode);
return 0;
}
4.C++11和boost中智能指针的关系
- C++ 98 中产生了第一个智能指针auto_ptr.
- C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
- C++ TR1,引入了shared_ptr等。不过注意的是TR1并不是标准版。
- C++ 11,引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost
的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。