- 1 智能指针
- 1.1 智能指针的作用
- 1.2 智能指针有哪些
- 1.3 nullptr
- 1.4 shared_ptr
- 1.4.1 内存资源管理不当案例
- 1.4.2 垃圾回收机制
- 1.4.3 shared_ptr指针初始化
- 1.4.4 成员方法
- 1.5 unique_ptr
- 1.5.1 unique_ptr智能指针的创建
- 1.5.2 释放堆内存
- 1.5.3 成员方法
- 1.6 weak_ptr
- 1.6.1 weak_ptr指针的创建
- 1.6.2 weak_ptr成员方法
智能指针的行为类似常规指针,重要的区别是它负责自动释放所指向的对象。
1.2 智能指针有哪些智能指针在C++11版本之后提供,包含在头文件
专用于初始化空类型指针
void f(void *c) { cout<<"nullptr"<1.4 shared_ptr 1.4.1 内存资源管理不当案例 1.4.2 垃圾回收机制
- 有些内存资源已经被释放,但指向它的指针并没有改变指向(成为了野指针),并且后续还在使用;
- 有些内存资源已经被释放,后期又试图再释放一次(重复释放同一块内存会导致程序运行崩溃);
- 没有及时释放不再使用的内存资源,造成内存泄漏,程序占用的内存资源越来越多。
如java的gc垃圾回收机制,很多语言都有对内存自动管理,即所谓的垃圾回收机制。所谓垃圾,指的是那些不再使用或者没有任何指针指向的内存空间,而“回收”则指的是将这些“垃圾”收集起来以便再次利用。C++也开始加入这个行列。
C++采用 unique_ptr、shared_ptr 以及 weak_ptr 这 3 个智能指针来实现堆内存的自动回收。来实现自动释放分配的内存。底层原理:C++ 智能指针底层是采用引用计数的方式实现的。简单的理解,智能指针在申请堆内存空间的同时,会为其配备一个整形值(初始值为 1),每当有新对象使用此堆内存时,该整形值 +1;反之,每当使用此堆内存的对象被释放时,该整形值减 1。当堆空间对应的整形值为 0 时,即表明不再有对象使用它,该堆空间就会被释放掉。
1.4.3 shared_ptr指针初始化std::shared_ptr1.4.4 成员方法p1; //不传入任何实参 std::shared_ptr p2(nullptr); //传入空指针 nullptr std::shared_ptr p3(new int(10)); std::shared_ptr p3 = std::make_shared (10); std::shared_ptr p4(p3);//或者 std::shared_ptr p4 = p3; 对于申请的动态数组来说,shared_ptr 指针默认的释放规则是不支持释放数组的,只能自定义对应的释放规则,才能正确地释放申请的堆内存。 //指定 default_delete 作为释放规则 std::shared_ptr p6(new int[10], std::default_delete ()); //自定义释放规则 void deleteInt(int*p) { delete []p; } //初始化智能指针,并自定义释放规则 std::shared_ptr p7(new int[10], deleteInt); #include1.5 unique_ptr#include using namespace std; int main() { //构建 2 个智能指针 std::shared_ptr p1(new int(10)); std::shared_ptr p2(p1); //输出 p2 指向的数据 cout << *p2 << endl; p1.reset();//引用计数减 1,p1为空指针 if (p1) { cout << "p1 不为空" << endl; } else { cout << "p1 为空" << endl; } //以上操作,并不会影响 p2 cout << *p2 << endl; //判断当前和 p2 同指向的智能指针有多少个 cout << p2.use_count() << endl; return 0; } 和 shared_ptr 指针最大的不同之处在于,unique_ptr 指针指向的堆内存无法同其它 unique_ptr 共享,也就是说,每个 unique_ptr 指针都独自拥有对其所指堆内存空间的所有权。
1.5.1 unique_ptr智能指针的创建
这也就意味着,每个 unique_ptr 指针指向的堆内存空间的引用计数,都只能为 1,一旦该 unique_ptr 指针放弃对所指堆内存空间的所有权,则该空间会被立即释放回收。std::unique_ptr1.5.2 释放堆内存p1(); std::unique_ptr p2(nullptr); std::unique_ptr p3(new int); 和可以用 make_shared () 模板函数初始化 shared_ptr 指针不同,C++11 标准中并没有为 unique_ptr 类型指针添加类似的模板函数。 std::unique_ptr p4(new int); std::unique_ptr p5(p4);//错误,堆内存不共享 std::unique_ptr p5(std::move(p4));//正确,调用移动构造函数 默认情况下,unique_ptr 指针采用 std::default_delete 方法释放堆内存。当然,我们也可以自定义符合实际场景的释放规则。值得一提的是,和 shared_ptr 指针不同,为 unique_ptr 自定义释放规则,只能采用函数对象的方式。例如:
//自定义的释放规则 struct myDel { void operator()(int *p) { delete p; } }; std::unique_ptr1.5.3 成员方法p6(new int); //std::unique_ptr p6(new int, myDel()); #include1.6 weak_ptr#include using namespace std; int main() { std::unique_ptr p5(new int); *p5 = 10; // p 接收 p5 释放的堆内存 int * p = p5.release(); cout << *p << endl; //判断 p5 是否为空指针 if (p5) { cout << "p5 is not nullptr" << endl; } else { cout << "p5 is nullptr" << endl; } std::unique_ptr p6; //p6 获取 p 的所有权 p6.reset(p); cout << *p6 << endl;; return 0; } 该类型指针通常不单独使用(没有实际用处),只能和 shared_ptr 类型指针搭配使用。
借助 weak_ptr 类型指针, 我们可以获取 shared_ptr 指针的一些状态信息,比如有多少指向相同的 shared_ptr 指针、shared_ptr 指针指向的堆内存是否已经被释放等等。需要注意的是,当 weak_ptr 类型指针的指向和某一 shared_ptr 指针相同时,weak_ptr 指针并不会使所指堆内存的引用计数加 1;同样,当 weak_ptr 指针被释放时,之前所指堆内存的引用计数也不会因此而减 1。也就是说,weak_ptr 类型指针并不会影响所指堆内存空间的引用计数。
1.6.1 weak_ptr指针的创建std::shared_ptr1.6.2 weak_ptr成员方法sp (new int); std::weak_ptr wp3 (sp); #include#include using namespace std; int main() { std::shared_ptr sp1(new int(10)); std::shared_ptr sp2(sp1); std::weak_ptr wp(sp2); //输出和 wp 同指向的 shared_ptr 类型指针的数量 cout << wp.use_count() << endl; //释放 sp2 sp2.reset(); cout << wp.use_count() << endl; //借助 lock() 函数,返回一个和 wp 同指向的 shared_ptr 类型指针,获取其存储的数据 cout << *(wp.lock()) << endl; return 0; } #include#include using namespace std; // 1.支持 -> 访问 Node 成员函数 // 2.支持 (*obj). 访问 Node 成员函数,obj 表示 SPNode对象 // 3.支持判断内部指针是否为空的判断:if (obj) {} class Node { public: Node(int age, std::string name) : nAge(age), strName(name) {} void SetAge(int age) { nAge = age; } int GetAge() { return nAge; } void SetName(std::string name) { strName = name; } std::string GetName() { return strName; } private: int nAge; std::string strName; }; class SPNode { public: SPNode(Node *node) { m_pNode = node; refCount = (unsigned*)malloc(sizeof(unsigned*)); *refCount = 1; } ~SPNode() { (*refCount)--; if (*refCount == 0) { delete m_pNode; free(refCount); m_pNode = NULL; refCount = NULL; } } Node& operator*(){ return *m_pNode; } Node* operator->(){ return m_pNode; } private: Node *m_pNode; unsigned *refCount; // 注意为什么是unsigned,还是指针 }; int main() { return 0; } 欢迎分享,转载请注明来源:内存溢出
评论列表(0条)