一个智能指针的实现(代码)

最新推荐文章于 2024-07-05 15:31:29 发布
最新推荐文章于 2024-07-05 15:31:29 发布
阅读量676 收藏
点赞数
分类专栏： C/C++ 文章标签： null class constructor delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/benny5609/article/details/2294819
版权

///

//

//            template class shared_ptr

//            2004-6-12

//            Chengliang Shan

//            simouse@126.com

//

///

#ifndef SHARED_PTR_H_

#define SHARED_PTR_H_

 

namespace clshan{

 

       template<class T>

       class shared_ptr;

 

       template<class T>

       class shared_data

       {

       private:

              friend class shared_ptr<T>;

 

              explicit shared_data(T* pT):_M_ptr(pT) {

                     _M_nCount = 1;

              }

 

              ~shared_data() {

                     delete _M_ptr;

              }

             

              void operator++ () {

                     ++_M_nCount;

              }

             

              operator-- () {

                     --_M_nCount;

                     if (_M_nCount == 0) {

                            delete this;

                     }

              }

 

              T&  operator* () const {

                     return *_M_ptr;

              }

 

              T*   operator-> () const {

                     return _M_ptr;

              }

 

              bool operator== (T* pT) const {

                     return _M_ptr == pT;

              }

             

              T*   get() {

                     return _M_ptr;

              }

 

              int use_count() {

                     return _M_nCount;

              }

 

       private:

              T*   _M_ptr;

              unsigned int    _M_nCount;

       };

 

       template<class T>

       class shared_ptr

       {

              typedef shared_data<T> element;

       public:

              explicit shared_ptr(T* pT):_M_pD(NULL) {

                     _M_pD = new element(pT);

              }

 

              explicit shared_ptr():_M_pD(NULL){

              }

 

              // copy constructor

              shared_ptr(const shared_ptr<T>& rT) {

                     _M_pD = rT.get_element();

                     if (_M_pD != NULL) {

                            ++(*_M_pD);

                     }

              }

 

              ~shared_ptr() {

                     if (_M_pD != NULL) {

                            --(*_M_pD);

                     }

              }

 

              // assignment operator

              shared_ptr<T>& operator = (shared_ptr<T>& rT) {

                     if (_M_pD != NULL) {

                            --(*_M_pD);

                     }

                     _M_pD = rT.get_element();

                     if (_M_pD != NULL){

                            ++(*_M_pD);

                     }

                     return *this;

              }

 

              T&  operator* () const {

                     return _M_pD->operator *();

              }

 

              T*   operator-> () const {

                     return _M_pD->operator ->();

              }

 

              bool operator== (shared_ptr<T>& rT) const {

                     return rT.get_element() == _M_pD;

              }

             

              bool operator== (T* pT) const {

                     if (_M_pD == NULL){

                            return pT == NULL;

                     }

                     return *_M_pD == pT;

              }

             

              T* get() {

                     if (_M_pD == NULL) {

                            return NULL;

                     }

                     else {

                            return _M_pD->get();

                     }

              }

      

              void release() {

                     if (_M_pD != NULL) {

                            --(*_M_pD);

                            _M_pD = NULL;

                     }                  

              }

             

              void reset(T* pT) {

                     if (_M_pD != NULL) {

                            --(*_M_pD);

                            _M_pD = NULL;

                     }

                     _M_pD = new element(pT);

              }

 

       private:

              element* get_element()const  {

                     return _M_pD;

              }

 

              element* _M_pD;

       };

}

 

#endif

 
benny5609
关注
专栏目录
C++智能指针测试代码
04-15
C++ 7种智能指针测试代码
智能指针小代码
wuan584974722的专栏
10-12 216
智能指针就是封装一个模板类。里面有一个计数器。方便我们去创建，他会自动去回收指针，而不用我们去delete。 #include #include #include using namespace std; class Stub{ public: string str; void print() { cout } ~Stub(){ cout } }
C++11新特性之智能指针源码详解
最新发布
jyd185348578的博客
07-05 751
智能指针的核心思想就是将要在堆内存中创建的对象放到栈中来进行管理，具体做法就是使用模板类封装指针，在类中分配内存，析构函数中释放内存，这个模板对象建立在栈中，当作用域结束自动调用该对象的析构函数。unique中没有拷贝构造和赋值构造，只有构造初始化shared只有第一个使用构造初始化，其他的shared对这个对象使用拷贝构造和赋值构造实现多个指针指向同一块的地址和统计个数，每个对象析构的时候计数减1，直到为0才会释放那块内存weak。
自己写的一个智能指针类
01-27 568
<br />#pragma once<br />template <typename T><br />class PtrData<br />{<br /> friend class CSmartPtr<T>;<br />public:<br /> explicit PtrData( const T* pT):p_(pT) { count_ = 1; }<br /> ~PtrData() { delete p_; count_ = 0; }<br /> void operator ++ () { ++coun
智能指针类的编写
AndrewYZWang的博客
12-12 272
····································································································································· 1.指针在使用的过程中经常会遇到内存泄漏和内存多次被释放的 2.解决方案：例如使用Boost库的智能指针 在项目开发的过程中要求
C++ 引用计数技术及智能指针的简单实现
12-22
以下是一个简化的智能指针实现，使用辅助类策略： ```cpp class Point { // Point类的定义 }; class U_Ptr { int count; Point* ptr; public: U_Ptr(Point* p) : count(1), ptr(p) {} ~U_Ptr() { if (--...
智能指针的一个实现 中科大 面向对象课程
12-14
智能指针是C++编程中一个非常重要的概念，它是一种对象，可以自动管理动态分配的内存。...在文件"pointer"中，可能包含有关计数指针的具体实现代码或练习，这对于理解智能指针的工作机制和实践应用是非常有价值的。
智能指针的简单实现
05-03
在这个"智能指针的简单实现"项目中，开发者可能提供了一个自定义的智能指针类，用于演示或扩展C++智能指针的功能。描述中提到可以使用C++的标准容器，如`std::map`和`std::vector`，这表明该智能指针可能已经实现了...
C++智能指针实现（包含拷贝构造，赋值函数，引用解引用重载）
03-22
本主题将深入探讨如何实现一个简单的智能指针，包括拷贝构造函数、赋值运算符以及引用和解引用操作符的重载。我们将使用C++标准库中的`std::shared_ptr`作为参考，并在Visual Studio 2019环境下进行编译。 首先，...
智能指针以及代码实现
weixin_57722445的博客
06-16 211
C++ 11 标准中改用unique_ptr、shared_ptr、weak_ptr等智能指针来自动回收堆分配的对象。 unique_ptr与所指对象的内存绑定紧密，不能与其他unique_ptr类型的指针对象共享所指对象的内存。unique_ptr则是一个删除了拷贝构造函数、保留了移动构造函数的指针分装类型。 shared_ptr允许多个该智能指针共享同一堆分配对象的内存。 weak_ptr可以指向shared_ptr指针指向的对象内存，却并不拥有该内存。 普通智能指针： template &
常用智能指针使用源代码示例
lee353086的专栏
02-02 2916
boost常用智能指针使用示例。
C++智能指针的简单实现代码
perry_xiao的专栏
04-11 565
其中附带部分测试代码 #include #include #include template class SmartPointer { public: SmartPointer(T *p); SmartPointer(const SmartPointer &pointer); ~SmartPointer(); SmartPointer& operator=(const Sma
智能指针的代码实现——shared_ptr
Kevinonlie的博客
08-31 442
shared_ptr的适用场合 我们知道auto_ptr和unique_ptr的所有权唯一，释放权也唯一，但是shared_ptr是所有权不唯一，释放权是最后一个引用该资源的指针拥有，可以说所有权&释放权不唯一。同时 ...
详解C++11智能指针
爱自在的专栏
01-19 180
原文地址https://www.cnblogs.com/WindSun/p/11444429.html 前言 C++里面的四个智能指针: auto_ptr, unique_ptr,shared_ptr, weak_ptr 其中后三个是C++11支持，并且第一个已经被C++11弃用。 C++11智能指针介绍 智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。C++ 11中最常用的智能指针类型为sha..
C++智能指针代码诠释
flb269264570的专栏
01-14 328
#include <iostream> #include <string> #include <memory> using namespace std; class Test { public: Test() { cout << "Test()"<<endl; } ~Test() { cout << "~Test()"<<endl; } .
智能指针
fdoyy的专栏
03-27 459
智能指针Shared_ptr 智能指针用于管理在堆中申请的内存，允许使用者不需要显式调用delete释放内存，属于自动内存管理的一种实现。 C++11中存在着以下的智能指针，auto_ptr、unique_ptr、shared_ptr与weak_ptr。除了auto_ptr是C++03标准加入，其余皆是C++11标准开始加入。 类型 说明 auto_ptr
给我一份C++智能指针实现的代码
08-07
### 回答1： 好的，以下是一个简单的C++智能指针实现的代码示例： ``` #include <iostream> template <typename T> class SmartPointer { public: explicit SmartPointer(T* ptr = nullptr) : m_ptr(ptr) {} ~SmartPointer() { delete m_ptr; } // 禁止拷贝构造函数和赋值运算符 SmartPointer(const SmartPointer&) = delete; SmartPointer& operator=(const SmartPointer&) = delete; // 获取指针 T* get() const { return m_ptr; } // 重载解引用运算符 T& operator*() const { return *m_ptr; } // 重载箭头运算符 T* operator->() const { return m_ptr; } // 重载布尔运算符，用于判断是否为nullptr operator bool() const { return m_ptr != nullptr; } private: T* m_ptr; }; int main() { SmartPointer<int> p(new int(42)); std::cout << *p << std::endl; std::cout << p->size() << std::endl; if (p) { std::cout << "p is not null." << std::endl; } return 0; } ``` 这个智能指针类的实现中，通过封装原始指针来实现自动释放内存的功能。当智能指针被销毁时，其内部保存的指针会被自动释放，从而避免了内存泄漏的问题。此外，该实现还禁止了拷贝构造函数和赋值运算符的使用，以避免多个智能指针指向同一个内存块的问题。 ### 回答2： 以下是一个简单的C++智能指针的实现示例代码： ```cpp #include <iostream> template <typename T> class SmartPointer { public: SmartPointer(T* ptr) : ptr_(ptr) {} ~SmartPointer() { delete ptr_; } T& operator*() const { return *ptr_; } T* operator->() const { return ptr_; } private: T* ptr_; }; int main() { SmartPointer<int> sp(new int(5)); std::cout << *sp << std::endl; // 输出 5 std::cout << sp->get() << std::endl; // 输出 5 return 0; } ``` 这段代码中，我们定义了一个名为SmartPointer的模板类，用于实现智能指针。它接受一个指向任意类型对象的原始指针作为构造函数参数，并负责该指针对象的内存管理。 在类的实现中，我们重载了解引用运算符*和箭头运算符->，使得智能指针的使用方式与原始指针类似。在类的析构函数中，我们释放了指向的内存。 在main函数中，我们创建了一个int类型对象的智能指针sp，并将其包装在SmartPointer类中。我们可以通过*和->运算符来访问所指向的对象，就像原始指针一样。最后，我们通过输出流输出对象的值。 这个示例是一个简单的智能指针实现，仅用于演示基本原理。在实际应用中，我们可能需要更复杂的实现，例如引用计数、拷贝控制等机制，以确保内存的正确管理和多线程安全。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值