在centos上做网站,商城网站建设策划书,查降权网站,旅游网站国内外研究现状智能指针的认识
智能指针是一种C语言中用于管理动态内存的工具#xff0c;它们可以自动管理内存的分配和释放#xff0c;从而避免内存泄漏和悬空指针等问题。智能指针可以跟踪指向的对象的引用次数#xff0c;并在需要时自动释放被引用的内存#xff0c;这极大地提高了内存…智能指针的认识
智能指针是一种C语言中用于管理动态内存的工具它们可以自动管理内存的分配和释放从而避免内存泄漏和悬空指针等问题。智能指针可以跟踪指向的对象的引用次数并在需要时自动释放被引用的内存这极大地提高了内存管理的安全性和便利性。
C标准库提供了三种类型的智能指针
std::auto_ptr管理权转移的思想当进行赋值操作时会将原对象置空而新对象指向该空间。 std::unique_ptr独占型智能指针表示它所指向的对象只能被一个指针拥有即不能进行赋值一旦该指针销毁它所指向的对象也会被销毁。 std::shared_ptr共享型智能指针允许多个指针共同管理同一个对象通过引用计数来跟踪对象的引用次数当引用计数为0时自动释放对象内存。 其实智能指针的使用是在异常时引出的所以我们先了解一下异常 异常
首先我们其实在堆区new空间的时候就见过异常当我们想要开辟的空间太大而无法申请到就会抛异常
概念
异常是我们处理错误的一种方式当一个函数发现自己无法处理的错误时就可以抛出异常让函数的直接或间接的调用者处理这个错误。
throw: 当问题出现时程序会抛出一个异常。这是通过使用 throw 关键字来完成的。catch: 在您想要处理问题的地方通过异常处理程序捕获异常 catch 关键字用于捕获异常可以有多个catch进行捕获。try:try 块中放置可能抛出异常的代码,它后面通常跟着一个或多个 catch 块。
使用
double Division(int a, int b)//除法计算
{// 当b 0时抛出异常if (b 0)throw 不能除0;elsereturn ((double)a / (double)b);
}
void Func()
{int len, time;cin len time;cout Division(len, time) endl;
}
int main()
{try {Func();}catch (const char* errmsg)//抛出什么类型就捕获什么类型的数据{cout errmsg endl;}catch (...)//捕获抛出的未知异常{cout unkown exception endl;}return 0;
} 我们要知道当我们在throw抛出异常的时候此时就会立马调用最近的catch进行捕获异常 如果没有调用到catch的话或者catch的类型不匹配的话就会出现
而且我们抛异常之后会被立马捕获异常而这之间的代码并不会执行直接就开始执行catch后续代码 。 但是也别忘了在此我们调用函数的过程中是创建了栈帧的所以我们catch捕获异常后会销毁之前的栈帧空间。
实际中抛出和捕获的匹配原则有个例外并不都是类型完全匹配抛出和捕获的匹配原则有个例外并不都是类型完全匹配可以抛出的派生类对象使用基类捕获。这里就引入C标准库异常体系了
C标准库异常体系 这个exception类就是所有标准C异常的父类所以当我们C程序内部抛异常时都可以用父类对象接受捕获异常。
int main()
{try {new int[7000000000];}catch (const exception e){cout e.what() endl;}catch (...){cout Unkown Exception endl;}return 0;
} 异常规范
//C11
thread() noexcept;//表示函数体内一定不会抛异常如果抛了就运行出错
thread (thread x) noexcept;//C98
void fun() throw();//表示函数体内一定不会抛异常如果抛了也会捕获// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(ABCD);
// 这里表示这个函数只会抛出bad_alloc的异常
void fun() throw (std::bad_alloc);我们是否注意到异常的一点缺陷当抛异常后就会立马执行到捕获异常的位置这中途的栈帧都将销毁而代码也不会执行但是如果这之中需要我们释放堆区空间的话那么就会造成内存泄漏。所以我们就有了智能指针的引出
智能指针使用与实现
我们知道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;int* p2 new int;cout div() endl;//调用div()函数delete p1;delete p2;
}
int main()
{try{Func();}catch (exception e){cout e.what() endl;}return 0;
}这里我们发现会调用div函数然后如果抛异常的话就会造成delete函数未执行从而导致内存泄漏的情况因此我们就通过智能指针的方式进行改造以shared_ptr为例
templateclass T
class Smart_ptr
{
public:Smart_ptr(T* ptr nullptr):_ptr(ptr){}~Smart_ptr(){delete _ptr;cout delete[] _ptr endl;}
private:T* _ptr;
};int div()
{int a, b;cin a b;if (b 0)throw invalid_argument(除0错误);return a / b;
}
void Func()
{Smart_ptrint p1 new int;Smart_ptrint p2 new int;cout div() endl;
}
int main()
{try{Func();}catch (exception e){cout e.what() endl;}return 0;
}通过以上的方式我们将需要创建的对象去构造智能指针此时当战争销毁的时候就会自动调用类的析构函数从而释放空间。而这种方式的原理就是就是RAII
RAII
RAIIResource Acquisition Is Initialization是一种利用对象生命周期来控制程序资源如内 存、文件句柄、网络连接、互斥量等等的简单技术。 在对象构造时获取资源接着控制对资源的访问使之在对象的生命周期内始终保持有效最后在 对象析构的时候释放资源。借此我们实际上把管理一份资源的责任托管给了一个对象。这种做 法有两大好处
不需要显式地释放资源。采用这种方式对象所需的资源在其生命期内始终保持有效。 shared_ptr
templateclass T
class Smart_ptr
{
public:Smart_ptr(T* ptr nullptr):_ptr(ptr),_count(new int(1)){}Smart_ptr(const Smart_ptrT tmp)//拷贝构造浅拷贝:_ptr(tmp._ptr),_count(tmp._count){(*_count);//引用计数}Smart_ptrT operator(const Smart_ptrT tmp){if(_ptr!tmp._ptr)//防止自己给自己赋值(){//this-~Smart_ptr();//没问题但是不好if (--(*_count) 0)//该空间可能不仅被一个对象所指所以当前的记数-1{delete[] _ptr;delete _count;//cout delete[] _ptr endl;}_ptr tmp._ptr;_count tmp._count;(*_count);return *this;}}T operator*(){return *_ptr;}T* operator-(){return _ptr;}~Smart_ptr(){if (*_count 1)(*_count)--;else{delete _ptr;delete _count;//cout delete[] _ptr endl;}}
private:T* _ptr;int* _count;//引用计数(关键就是指针存放)//光整型存放会有问题会导致拷贝构造后的数据不是同一个记数
};
虽然说shared_ptr可以解决这种问题但是shared_ptr最大的缺陷就是循环引用而对于循环引用问题的解决就引出了weak_ptr。先看一下什么是循环引用
循环引用
循环引用是指在编程中两个或多个对象相互引用形成一个循环的引用链导致它们无法被正常地回收或释放。
struct ListNode
{int val;Smart_ptrListNode next;Smart_ptrListNode pre;~ListNode(){cout ~ListNode endl;}
};void test()
{Smart_ptrListNode n1(new ListNode);Smart_ptrListNode n2(new ListNode);n1-next n2;n2-pre n1;
}
int main()
{test();return 0;
} 在该种情形时可以分析出n1-nextn2;这段代码使得n2指针指向的空间计数为2,而n2-pren1使得n1指向的空间记数也为2而且当该栈帧空间销毁时会先析构n2这块空间再析构n1这块空间 ~Smart_ptr(){if (*_count 1)(*_count)--;else{delete _ptr;delete _count;//cout delete[] _ptr endl;}}
当析构n2空间时会先引用计数--然后发现n2该对象成员函数是两个内置类型不做处理所以就开始析构n1对象同样是引用计数--此时就程序结束了。
但是_next还指向下一个节点。而且_prev还指向上一个节点。从而导致堆区内存空间未释放所以造成了内存泄漏。所以想要正确释放空间就要析构n1的_next节点释放n2和n2的_pre节点释放n1但是_next是n1的成员_pre又是n2的成员所以想要析构_next和_pre的话就又要析构n1和n2从而形成了闭环。
而以上情形就是循环引用。最终谁都不会释放从而造成内存泄漏。 std::weak_ptr是一种用于解决shared_ptr相互引用时产生死锁问题的智能指针。也就是当多个对象指向同一空间时不会增加引用计数
// 简化版的weak_ptr
templateclass T
class weak_ptr
{
public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptrT sp):_ptr(sp.get()){}weak_ptrT operator(const shared_ptrT sp){_ptr sp.get();return *this;}T operator*(){return *_ptr;}T* operator-(){return _ptr;}
private:T* _ptr;
};此时的_next和_pre 的指针类型就可以是weak_ptr的类型 定制删除器
当我们使用智能指针的时候其实都疏忽了一点空间释放delete对象时的方式当我们new的是单一的空间的时候就直接delete就行了而当我们new的是一段连续的空间的时候就需要delete[]来释放空间此时就很容易的联想到仿函数。我们库里的是采用重载构造函数模版的方式来解决问题 所以我们就可以按照库的解决方式进行改造我们所写的代码
namespace cr
{templateclass Tclass shared_ptr{public:shared_ptr(T* ptr nullptr):_ptr(ptr), _count(new int(1)){}templateclass D//模版类型shared_ptr(T* ptr, D del)//重载构造函数: _ptr(ptr), _count(new int(1)), _del(del)//设置为类成员用于析构调用{}shared_ptr(const shared_ptrT tmp)//拷贝构造浅拷贝:_ptr(tmp._ptr), _count(tmp._count){(*_count);}shared_ptrT operator(const shared_ptrT tmp){if (_ptr ! tmp._ptr)//防止自己给自己赋值{if (--(*_count) 0){del(_ptr);//相当于调用operator()delete _count;}_ptr tmp._ptr;_count tmp._count;(*_count);return *this;}}~shared_ptr(){if (*_count 1)(*_count)--;else{_del(_ptr);//相当于调用operator()delete _count;}}private:T* _ptr;int* _count;functionvoid(T*) _del [](T* ptr)-void {delete ptr; };//默认给缺省值//因为不知道_del的类型采用function包装器包装可以接受函数指针、lambda表达式、仿函数};
} 主函数中进行测试调用
templateclass T
struct del//仿函数
{void operator()(T* ptr){delete[] ptr;}
};
struct ListNode
{int val;cr::shared_ptrListNode next;cr::shared_ptrListNode pre;~ListNode(){cout ~ListNode endl;}
};
int main()
{cr::shared_ptrListNode p1(new ListNode[10],delListNode());cr::shared_ptrListNode p2(new ListNode[10],[](ListNode* ptr)-void{delete[]ptr; });cr::shared_ptrListNode p3(new ListNode);return 0;
}
