C++智能指针

最新推荐文章于 2024-11-03 16:33:38 发布
最新推荐文章于 2024-11-03 16:33:38 发布
阅读量718 收藏 2
点赞数
文章标签： c++ delete class struct .net java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglibin_1222/article/details/5447156
版权

C++没有像Java、.NET一样的垃圾回收机制，内存泄露的预防和解决一向是程序编写中的要点。

如果在一个类中进行了动态分配，一般实现“智能指针”行为或值型行为。下面是一个“智能指针”行为类的例子：

#include <iostream>

class Hello

{

public:

       Hello(){std::cout<<"Hello()"<<std::endl;}

       ~Hello(){std::cout<<"~Hello()"<<std::endl;}

};

class World

{

public:

       World(Hello*);

       World(const World&);

       World&operator=(const World&);

       ~World();

private:

       struct SmartP

       {

              friend World;

              SmartP(Hello*);

              ~SmartP();

              unsigned use;

              Hello *ptr;

       };

       SmartP *ptr;

};

inline World::World(Hello*p):ptr(new SmartP(p)){}

inline World::World(const World&w):ptr(w.ptr){++(ptr->use);}

inline World&World::operator=(const World&w)

{

       ++(w.ptr->use);

       this->~World();

       ptr=w.ptr;

       return *this;

}

inline World::~World(){if(0==--(ptr->use))delete ptr;}

inline World::SmartP::SmartP(Hello*p):ptr(p),use(1){}

inline World::SmartP::~SmartP(){delete ptr;}

对这段代码不是很明白的同学可以参照《C++ Primer 中文版 第四版》13.5.1 定义智能指针类。

如果在程序中大量使用这种技巧，是非常劳民伤财的。于是，我们追求一种通用的解决技巧——智能指针。

template<typename T>class SmartP

{

public:

       SmartP(T* =0)throw();

       SmartP(const SmartP&)throw();

       SmartP&operator=(const SmartP&)throw();

       ~SmartP()throw();

       T&operator*()const throw();

       T*operator->()const throw();

private:

       T*p_;

       unsigned*use_;

};

template<typename T>inline SmartP<T>::SmartP(T*p):p_(p),use_(new unsigned(1)){}

template<typename T>

inline SmartP<T>::SmartP(const SmartP&s):p_(s.p_),use_(s.use_){++*use_;}

template<typename T>inline SmartP<T>&SmartP<T>::operator=(const SmartP&s)

{

       ++*s.use_;

       this->~SmartP();

       p_=s.p_;

       use_=s.use_;

       return *this;

}

template<typename T>inline SmartP<T>::~SmartP()

{if(0==--*use_){delete p_;delete use_;}}

template<typename T>inline T&SmartP<T>::operator*()const{return *p_;}

template<typename T>inline T*SmartP<T>::operator->()const{return p_;}

在这里我们使用了使用计数分离技术。World类在使用智能指针后变成了：

class World

{

public:

       World(Hello*);

private:

       SmartP<Hello> ptr;

};

inline World::World(Hello*p):ptr(p){}

真的非常的简练。

在这之后的使用过程中，我发现了一个BUG。

class Hello

{

public:

       Hello(){std::cout<<"Hello()"<<std::endl;}

       ~Hello(){std::cout<<"~Hello()"<<std::endl;}

       void Func(){SmartP<Hello> p=this;}

};

void Test()

{

       SmartP<Hello> p=new Hello();

       p->Func();

}

这会导致重复释放，一个危险的问题。原计划在智能指针中加一个全局Map变量来解决这个问题。但是，由于全局依赖问题和效率问题，改为将使用计数与对象捆绑在一起。那样的话，找到动态分配的对象的同时找到了使用计数变量。

我们知道，多态使用的前提是：使用指向派生类对象的基类指针（或引用派生类对象的引用）调用基类的virtual函数。但是，我们设计的智能指针却没有这个功能。这个问题有两种解决方案。第一种解决方案：重载默认转换操作符。第二种解决方案：重载构造函数和赋值操作符。为了使软件可维护，我们采用第一种解决方案。

这两个问题的同时解决使得下面的代码有一定的难度。

template<typename T>class SmartP

{

public:

       SmartP(T*)throw();

       SmartP(T*,unsigned)throw();

       SmartP(const SmartP&)throw();

       SmartP&operator=(const SmartP&)throw();

       ~SmartP()throw();

       T&operator*()const throw();

       T*operator->()const throw();

       template<typename T>operator SmartP<T>()const throw();

private:

       unsigned&Count()const throw();

       T*p_;

};

template<typename T>inline SmartP<T>::SmartP(T*p):p_(p){++Count();}

template<typename T>inline SmartP<T>::SmartP(T*p,unsigned):p_(p){}

template<typename T>inline SmartP<T>::SmartP(const SmartP&s):p_(s.p_){++Count();}

template<typename T>inline SmartP<T>&SmartP<T>::operator=(const SmartP&s)

{

       ++s.Count();

       this->~SmartP();

       p_=s.p_;

       return *this;

}

template<typename T>inline SmartP<T>::~SmartP()

{if(0==--Count()){p_->~T();delete &Count();}}

template<typename T>inline T&SmartP<T>::operator*()const{return *p_;}

template<typename T>inline T*SmartP<T>::operator->()const{return p_;}

template<typename T>

inline unsigned&SmartP<T>::Count()const{return *((unsigned*)(p_)-1);}

template<typename T0>template<typename T1>

SmartP<T0>::operator SmartP<T1>()const{return SmartP<T1>(p_);}

#define NEW(T,P) /

SmartP<T>(new(new(new unsigned char[sizeof(unsigned)+sizeof(T)])/

unsigned(1)+1)T P,0)

很多时候，我们在定义一个智能指针的时候，没有必要立即用它指向一个对象。这是“委托模式”的一个事例。仔细的读者已经发现我们的智能指针现在不具有这种功能了。

很多时候，我们在智能指针的生命期结束之前，需要将使用计数减一。其中一部分情况是为了效率，另一部分是为了实现类似流对象的close函数的功能。

template<typename T>class SmartP

{

public:

       SmartP()throw();

       SmartP(T*)throw();

       SmartP(T*,unsigned)throw();

       SmartP(const SmartP&)throw();

       SmartP&operator=(const SmartP&)throw();

       ~SmartP()throw();

       T&operator*()const throw();

       T*operator->()const throw();

       template<typename T>operator SmartP<T>()const throw();

private:

       unsigned&Count()const throw();

       T*p_;

};

template<typename T>inline SmartP<T>::SmartP():p_(0){}

template<typename T>inline SmartP<T>::SmartP(T*p):p_(p){++Count();}

template<typename T>inline SmartP<T>::SmartP(T*p,unsigned):p_(p){}

template<typename T>

inline SmartP<T>::SmartP(const SmartP&s):p_(s.p_){if(p_)++Count();}

template<typename T>inline SmartP<T>&SmartP<T>::operator=(const SmartP&s)

{

       if(s.p_)++s.Count();

       this->~SmartP();

       p_=s.p_;

       return *this;

}

template<typename T>inline SmartP<T>::~SmartP()

{if(p_&&0==--Count()){p_->~T();delete &Count();}p_=0;}

template<typename T>inline T&SmartP<T>::operator*()const{return *p_;}

template<typename T>inline T*SmartP<T>::operator->()const{return p_;}

template<typename T>

inline unsigned&SmartP<T>::Count()const{return *((unsigned*)(p_)-1);}

template<typename T0>template<typename T1>

SmartP<T0>::operator SmartP<T1>()const{return SmartP<T1>(p_);}

#define NEW(T,P) /

SmartP<T>(new(new(new unsigned char[sizeof(unsigned)+sizeof(T)])/

unsigned(1)+1)T P,0)

下面的代码可以看做是SmartP的简单测试。

class Hello

{

public:

       Hello(){SmartP<Hello>p=this;std::cout<<"Hello()"<<std::endl;}

       virtual ~Hello(){std::cout<<"~Hello()"<<std::endl;}

       void Func(){SmartP<Hello>p=this;std::cout<<"Func"<<std::endl;}

};

class World:public Hello

{

public:

       World(){std::cout<<"World()"<<std::endl;}

       ~World(){std::cout<<"~World()"<<std::endl;}

};

void Test()

{

       SmartP<Hello> p;

       SmartP<Hello> p0=NEW(World,);

       SmartP<World> p1=NEW(World,);

       p0=p1;

       SmartP<Hello> p2(p1);

       SmartP<Hello> p3=p1;

       p3.~SmartP();

       p0->Func();

       p=p0;

       p=p3;

}

还有一类问题——循环引用。这个问题使用引用计数无法解决。但是，我们的智能指针允许手动释放循环引用。下面是一个小例：

class World;

class Hello

{

public:

       Hello(){std::cout<<"Hello()"<<std::endl;}

       virtual ~Hello(){std::cout<<"~Hello()"<<std::endl;}

       SmartP<World> p_;

};

class World

{

public:

       World(){std::cout<<"World()"<<std::endl;}

       ~World(){std::cout<<"~World()"<<std::endl;}

       SmartP<Hello> p_;

};

void Test()

{

       SmartP<Hello> p=NEW(Hello,);

       p->p_=NEW(World,);

       p->p_->p_=p;

       p->p_.~SmartP();

}

到目前为止，我们的智能指针解决了我发现的所有问题。

如果，读者发现了新的问题，请发送邮件到    zhanglibin_1222@163.com    ，或者到我的博客       http://blog.csdn.net/zhanglibin_1222     进行讨论。

zhanglibin_1222
关注
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
c++智能指针
08-15
C++中的智能指针是一种特殊的类模板，用于自动化内存管理，以帮助避免诸如内存泄漏、重复释放等问题。在C++11及以后的版本中，最常用的智能指针类型包括std::shared_ptr、std::unique_ptr和std::weak_ptr。 在讨论...
C++智能指针知识学习笔记
08-20
C++智能指针知识学习笔记
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 213
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 247
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2289
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 586
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1204
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 188
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
【C++】string 类模拟实现：深入探索字符串操作原理
A Charmer 的博客
11-01 1035
本文详细介绍了 C++中模拟实现 string 类。从 string 类的功能需求入手，涵盖存储字符串、获取长度、比较、连接、修改和内存管理等方面。阐述了 MyString 类的定义及各函数实现，包括构造函数、析构函数、多种操作函数及内存管理函数。代码均有注释，易于理解。通过对每个函数的解析，让读者深入了解字符串处理原理。文末提供了 main 函数示例展示用法。这有助于读者掌握模拟 string 类的应用，提升 C++编程技能，更好地理解字符串操作背后的机制。
c加加11第一弹~
2301_81230745的博客
10-30 942
在C++98中的普通引用与const引用在引用实体上的区别int main()// 普通类型引用只能引用左值，不能引用右值int a = 10;// ra为a的别名// 编译失败，因为10是右值return 0;
C++ 游戏开发快速入门
wuzigege666的博客
10-29 569
通过本文，你应该已经对 C++ 游戏开发有了基本的了解，并能够创建一个简单的游戏项目。C++ 的强大之处在于它的性能和灵活性，无论是简单的 2D 游戏还是复杂的 3D 游戏，C++ 都能提供强大的支持。希望这篇文章对你有所帮助，祝你在 C++ 游戏开发的道路上一切顺利！
Java数组的地址和元素访问 C语言空指针与野指针
l13849427451的博客
10-30 332
/[表示地址 I表示数据类型 @表示间隔符号（固定格式）//10f87f48表示地址值 平时习惯把整体叫做地址值。//b的内存空间销毁。//空指针 是一个确切的值。//错误，p是野指针。
C++ | Leetcode C++题解之第522题最长特殊序列II
Ddddddd_158的博客
10-31 217
C++ | Leetcode C++题解之第522题最长特殊序列II
C/C++ 矩阵的QR分解
moonlightpeng的博客
10-31 291
【代码】C/C++ 矩阵的QR分解。
C语言 | Leetcode C语言题解之第522题最长特殊序列II
m0_59237910的博客
10-31 310
C语言 | Leetcode C语言题解之第522题最长特殊序列II
跟我学C++中级篇——std::any的特殊用法
最新发布
fpcc的专栏
11-03 207
用std::any尽量控制应用的范围，即自己开发自己用，尽量不要向外暴露。不管是为了安全还是为易用，也是便于维护，都是一个比较好的习惯。但刀握在开发者的手里，想怎么用，还是根据自己的情况来。
C++智能指针实例详解：内存管理神器
C++智能指针实例详解深入解析了C++编程中解决内存管理问题的关键工具。C++语言原生缺乏自动内存回收功能，导致程序员在使用new分配内存后必须手动调用delete来释放，这易引发内存泄漏或因异常而未释放内存的问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值