第61课 智能指针类模板

最新推荐文章于 2022-08-29 00:07:29 发布
最新推荐文章于 2022-08-29 00:07:29 发布
阅读量223 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35604488/article/details/79187431
版权

1、智能指针的意义

    1.1、 现代C++开发库中最重要的类模板之一
    1.2、 C++中 自动内存管理 的主要手段
    1.3、 能够在很大程度上 避开内存相关的问题 （如 内存泄漏、内存的多次释放 等）

2、STL中的智能指针

    2.1、 auto_ptr智能指针
        2.1.1、 生命周期结束时，销毁指向的内存空间
        2.1.2、只能用来管理单个动态创建的对象，   而不能管理动态创建的数组。即 不能指向堆数组，只能指向指针堆对象 （变量）        
int  *pn = new int[100];
        auto_ptr<int> ap(pn);//用一个pn初始化ap对象， auto_ptr指向堆数组，释放时，相当于delete  pn，而不是delete []，只释放了数组第一个元素，会造成内存泄漏。
        2.1.3、一片堆空间 只属于一个 智能指针对象， 多个智能指针对象不能指向同一片堆空间

/***********      auto_ptr使用初探         ********/
#include <iostream>
#include <string>
#include <memory>
using namespace std;
class Test
{
    string m_name;
public:
    Test()
    {
        m_name = "DT.SoftWare";
        cout << "Hello, " << m_name << "." << endl;
    }

    Test(const char* name)  //字符串常量
    {
        m_name = name;
        cout << "Hello, " << m_name << "." << endl;
    }

    void print()
    {
        cout << "I'am, " << m_name << ". " << endl;
    }

    ~Test()
    {
        cout << "Good Bye, " << m_name << ". " << endl;
    }
};
int main()
{
    //智能指针，会自动销毁堆空间,即一片堆空间只能属于一个智能指针对象。只能被一个智能指针指向。
    //解析意思：auto_ptr这个智能指针类模板<>泛型中是智能指针指向的类型，用一个类地址去初始化智能指针的指向。pt重载了->仔细体会。
    auto_ptr<Test> pt(new Test("DT.SoftWare!!"));  //pt本质上是一个对象，但是重载了->操作符，就相当于pt对象指向的地址是从堆空间申请来的，string字符串被初始化
    cout << "pt = " << pt.get() << endl;//pt指针所指向的内存地址

    pt->print();

    cout << endl;

    //同一个堆空间, 每次只能有一个auto_ptr指针指向它
    auto_ptr<Test> pt1(pt);     //让pt1指向pt所指向的空间，会发生所有权的转移。
    cout << "pt = " << pt.get() << endl;  //所有权转移， pt == 0；
    cout << "pt1 = " << pt1.get() << endl;  //pt1指向原来的堆空间；

    //pt->print();  //因为你访问了转换所有权对象指针的私有变量，段错误，成员方法是可以访问的，因为成员方法是对象共享的。
    pt1->print();

    cout << endl;

    //其内部实现的机理。
    //auto_ptr<Test> ptArray(new Test[10]); //auto_ptr指向堆数组，会发生内存泄漏，auto_ptr内部实现是当释放时相当于delete ptArray而不是delete[] ptArray

    return 0;
}


    2.2、其它智能指针
        2.2.1、shared_ptr：带有引用计数机制，支持多个指针对象指向同一片内存
        2.2.2、weak_ptr: 配合shared_ptr而引入的一种智能指针来协助shared_ptr工作，它可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr不能直接访问资源，它的构造和析构不会引起指针引用计数的增加或减少。
        2.2.3、unique_ptr：是auto_ptr的进化版，也是一个指针对象指向一片内存空间，但不能拷贝构造和赋值。

3、Qt中的智能指针

    3.1、QPointer
        3.1.1、当其指向的对象被销毁时，这个指针会被自动置空。
        3.1.2、析构时不会自动销毁所指向的对象
        3.1.3、这种指针主要是用来解决手动释放对象时造成的多次释放的问题。因为当删除一个对象时，所有指向该对象的QPointer指针都会被置空。
    3.2、QSharedPointer
        3.2.1、引用计数型智能指针
        3.2.2、可以被自由地拷贝和赋值
        3.2.3、当引用计数为0时才删除指向的对象，即会自动释放所指向的对象。

#include <QPointer>
#include <QSharedPointer>
#include <QDebug>

class Test:public QObject
{
    QString m_name;
public:
    Test(const char* name)
    {
        m_name = name;
        qDebug() << "Hello, " << m_name << ".";
    }

    void print()
    {
        qDebug()<< "Good bye11" << m_name << ".";
    }

    ~Test()
    {
        qDebug() << "Good bye" << m_name << ".";
    }
};

int main()
{
    QPointer<Test> pt(new Test("DT.SoftWare!"));//pt = new Test("DT.SoftWare!")
    QPointer<Test> pt1 = pt;   //所有权不会转让，与pt指向同一个堆空间
    QPointer<Test> pt2(pt);     //所有权不会转让，与pt指向同一个堆空间

    pt->print();
    pt1->print();
    pt2->print();

    delete pt;  //删除一个对象时，pt，pt1，pt2会同时被置空。注意，任意删除一个，这个QPointer智能指针的最大特色。

    qDebug()<< "pt = " << pt;
    qDebug()<< "pt1 = " << pt1;
    qDebug()<< "pt2 = " << pt2;

    qDebug()<<endl;

    //带有引用计数
    QSharedPointer<Test> spt(new Test("Demo"));
    QSharedPointer<Test> spt1(spt);
    QSharedPointer<Test> spt2(spt);

    spt->print();
    spt1->print();
    spt2->print();

    spt.clear();
    spt1.clear();
    //spt2.clear();

    qDebug()<< "spt = " << spt;
    qDebug()<< "spt1 = " << spt1;
    qDebug()<< "spt2 = " << spt2;
    //spt->print();//错误，不能使用已经释放的对象。


    return 0;
}

    
3.3、QT中的其它智能指针
    3.3.1、①QWeakPointer；②QScopedPointer③QScopedArrayPointer；④QSharedDataPointer；⑤QExplicitlySharedDataPointer

4、自定义的智能指针类模板

                    编程智能指针类模板1（仿auto_ptr）

#ifndef _SMARTPOINTER_H_
#define _SMARTPOINTER_H_
#include <iostream>
using namespace std;
                          //仿auto_ptr：同一堆空间对象只能有一个智能指针指向。
/*
    创建智能指针类模板的步骤：
        1类中创建一个成员变量，为模板类的类型，
        2构造函数中初始化这个类的指向。
        3定义拷贝构造函数。
        4重载赋值操作符，4要素
        5重载-> *操作符。返回智能指针指向的类对象。
*/
template<typename T>
class SmartPointer
{
    T* mp;
public:
    SmartPointer(T* p = NULL)//构造函数(T* p = NULL)这是默认类型。
    {
        mp = p;
    }

    //拷贝构造函数
    SmartPointer(const SmartPointer<T>& obj) //类的引用
    {cout << "saf拷贝构造函数f" << endl;
        mp = obj.mp;    //堆空间的所有权转让

        //去掉const属性，obj放弃所有权，同时自己置空。
        const_cast<SmartPointer<T>&>(obj).mp = NULL;
    }

    //重载赋值操作符
    SmartPointer<T>& operator=(const SmartPointer<T>& obj)
    {cout << "saf重载赋值操作符f" << endl;
        if(this != &obj)//避免自赋值
        {
            delete mp;  //删除原先指向的堆空间
            mp = obj.mp;//obj转让堆空间所有权
            const_cast<SmartPointer<T>&>(obj).mp = NULL;  //类的地址
        }
        return *this;
    }

    //重载->操作符
    T* operator->()
    {
        return mp;//返回指向对象的指针。
    }

    //重载解引用操作符*
    T& operator*()
    {
        return *mp;
    }

    //判断所指向堆空间是否为NULL
    bool isNULL()
    {
        return (mp == NULL);
    }

    //返回对象的堆空间指针（仿auto_ptr智能指针）
    T* get()
    {
        return mp;
    }

    ~SmartPointer()
    {
        delete mp;
    }
};
#endif

#include <iostream>
#include <string>
#include "test.h"
using namespace std;
class Test
{
    string m_name;
public:
    Test()
    {
        m_name = "DT.SoftWate!";
        cout << "Hello, " << m_name << "." << endl;
    }

    Test(const char* name)
    {
        m_name = name;
        cout << "Helllo, " << m_name << "." << endl;
    }

    void print()
    {
        cout << "I'm" << m_name << "." << endl;
    }

    ~Test()
    {
        cout << "Good bye, " << m_name << "." << endl;
    }
};
int main()
{
    //本质上智能指针是个对象（而不是指针，只是重载了->操作符）
    SmartPointer<Test> pt(new Test("DT>Software!!"));

    cout << "pt = " << pt.get() << endl; //获得pt指向的堆空间

    pt->print();

    cout << endl;

    SmartPointer<Test> pt1(pt);   //转让所有权//pt1是智能指针类的对象。

    cout << "pt = " << pt.get() << endl;//为0NULL，说明转让了。
    cout << "pt1 = " << pt1.get() << endl;

    pt1->print();

    return 0;
}


创建智能指针类模板2（仿sharead_ptr）

#ifndef _SMARTPOINTER_H
#define _SMARTPOINTER_H
#include <iostream>
//引用计数类
class SmartCount
{
    int useCount;    //计数变量
public:
    SmartCount(int c):useCount(c)
    {
    
    }
    ~SmartCount()
    {
    
    }
    
    //增加引用计数
    int addRef()
    {
        return ++useCount;
    }
    //减少引用计数
    int release()
    {
        return --useCount;
    }
    //获取当前引用次数
    int getCount()
    {
        return useCount;
    }
};
//具有引用计数功能的智能指针类
template<typename T>
class SmartPointer
{
    T* m_pointer;
    SmartCount* m_pSmartCount;  //计数类
public:
    //构造空指针（形如SmartPointer<int> pi的空指针时）
    explicit SmartPointer();
    
    //构造函数
    SmartPointer(const T* pointer);
    
    //拷贝构造函数
    SmartPointer(const SmartPointer<T>& obj);
    
    //析构函数
    ~SmartPointer();
    
    //重载指针操作符->
    T* operator->();
    
    //重载解引用操作符
    T& operator*();
    
    //重载赋值操作符//SmartPointer<Test>&返回引用也是可以的
    void operator=(const SmartPointer<T>& obj);        //返回的不是引用吗？
    
    
    //重载相等判断操作符
    bool operator==(const SmartPointer<T>& obj);
    
};
//构造空指针(形如SmartPointer<int> pi的空指针时)
template <typename T>
SmartPointer<T>::SmartPointer():m_pointer(NULL),m_pSmartCount(NULL)
{
    //无参构造函数初始化列表
}
//构造函数(当创建形如SmartPointer<int> pi(new int)或
//         SmartPointer<int> pi=new int)
template <typename T>
SmartPointer<T>::SmartPointer(const T* pointer)
{
    m_pointer = const_cast<T*>(pointer);   //去const属性
    m_pSmartCount = new SmartCount(1);  //给useCount赋值为1
}
//拷贝构造函数
template <typename T>
SmartPointer<T>::SmartPointer(const SmartPointer<T>& obj)
{
    m_pointer = obj.m_pointer;
    m_pSmartCount = obj.m_pSmartCount;
    if(m_pSmartCount)
    {
        m_pSmartCount->addRef();   //调用这个方法，增加1 计数。
    }
}
//析构函数
template <typename T>
SmartPointer<T>::~SmartPointer()
{
    if(m_pointer && m_pSmartCount->release()<= 0)
    {
        delete m_pointer;
        delete m_pSmartCount;
        m_pointer = NULL;
    }
}
//重载指针操作符->
template <typename T>
T* SmartPointer<T>::operator->()
{
    return m_pointer;
}
//重载解引用操作符
template <typename T>
T& SmartPointer<T>::operator*()
{
    return *m_pointer;
}
//重载赋值操作符
template <typename T>
void SmartPointer<T>::operator=(const SmartPointer<T>& obj)//SmartPointer<Test>& 返回引用也是可以的
{
    //判断旧对象是否可删除（如果引用计数release仍大于0，说明
    //    原来的堆空间被其它对象所引用，就不删除旧的堆空间，
    //    留给那个引用它的对象去删除）
    if(m_pointer && m_pSmartCount->release()<= 0)
    {
        delete m_pointer;
        delete m_pSmartCount;
        m_pointer = NULL;
    }
    m_pointer = obj.m_pointer;
    m_pSmartCount = obj.m_pSmartCount;
    //增加新对象的引用计数
    if(m_pSmartCount)
        m_pSmartCount->addRef();    
}
//重载相等判断操作符
template <typename T>
bool SmartPointer<T>::operator==(const SmartPointer<T>& obj)
{
    return m_pointer == obj.m_pointer;//本身对象的指针和要比对的对象的指针是否相同。
}
#endif

#include <iostream>
#include <string>
#include "SmartPointer.h"
using namespace std;
class Test
{
    string m_name;
public:
    Test()
    {
        m_name = "DT_SoftWare!!";
        cout << "Hello, " << m_name << ". " << endl;
    }
    
    Test(const char* name)
    {
        m_name = name;
        cout << "Hello" << m_name << ". " << endl;
    }
    
    void print()
    {
        cout << "I'm" << m_name << ". " << endl;
    }
    
    ~Test()
    {
        cout << "Goodbye , " << m_name << ". " << endl;
    }
};
int main()
{
    //本质上智能指针是个对象（而不是指针，只是重载了->操作符）
    SmartPointer<int> pi = new int(5);//pi指向的地址上面是5。
    SmartPointer<float> pf(new float(10.0f));
    
    cout <<"*pi=" << *pi <<", *pf="<<*pf<<endl;
    
    SmartPointer<Test> pt(new Test("SantaClaus")); //pt = new Test("SantaClaus")
    pt->print();
    
    SmartPointer<Test> ppt(pt);  //指向同一片内存空间  ,,赋值的效果。
    
    if (ppt == pt)
       cout <<"ppt == pt" << endl;
       
       return 0;
}


5、小结

    5.1、智能指针是C++中自动内存管理的主要手段
    5.2、智能指针在各种平台上都有不同的表现形式
    5.3、智能指针能够尽可能的避开内存相关的问题
    5.4、STL和Qt中提供了对智能指针的支持
























































































 

码农小李。x17355150737
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++智能指针内存管理std::auto_ptr、 std::shared_ptr、std::weak_ptr make_shared
usstmiracle的博客
04-26 582
由于C++语言没有自动内存回收机制，程序员每次new出来的内存都要手动delete。程序员忘记delete，流程太复杂，最终导致没有delete，异常导致程序过早退出，没有执行delete的情况并不罕见。 用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、...
C++ 面试宝典——基础知识（一）
hang_1994的博客
07-23 331
C++ 面试宝典——基础语言（一） 一、static关键字的作用 全局静态变量 在全局变量前加上关键字static，全局变量就定义成一个全局静态变量. 静态存储区，在整个程序运行期间一直存在。 初始化：未经初始化的全局静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显式初始化）； 作用域：全局静态变量在声明他的文件之外是不可见的，准确地说是从定义之处开始，到文件结尾。 局部静态变量 在局部变量之前加上关键字static，局部变量就成为一个局部静态变量。 内存中的位置：静态存储区 初始化：未
模板类与类模板、函数模板与模板函数等的区别
sunxx1986的专栏
07-20 2万+
在C++中有好几个这样的术语，但是我们很多时候用的并不正确，几乎是互相替换混淆使用。下面我想彻底辨清几个术语，这样就可以避免很多概念上的混淆和使用上的错误。 这几个词是： 函数指针——指针函数 数组指针——指针数组 类模板——模板类 函数模板——模板函数 最终在使用中，我们就可以
用类模板做的智能指针
谢绝留言与私信
12-26 1232
前言 做一个类模板的准备工作. 先准备一个普通类, 她的关联类都调试过.  将准备改到类模板的类声明为template, 一个类模板放在一个.h中 加入关联类的前向声明 在类模板中加入友元类模板的声明 为了维护方便, 将所有类实现都内联实现. 不要再放到类外部, 防止该类模板进行类特例时, 看的眼花~ 测试代码 // SmartPtrD.cpp : Defines the entr
用类模板实现C++智能指针
o707191418的博客
01-03 443
  首先是一段错误的代码 #include&lt;iostream&gt; using namespace std; template&lt;class T&gt; class autoPtr { public: //构造函数，创建一个T类型的指针并赋值n autoPtr(T n) { T *ptr = new T; *ptr = n; cout &lt;&lt; "n...
指针模板
weixin_30892889的博客
07-06 486
1//main.cpp2#include<iostream>3#include<cstdlib>4#include<ctime>5#include"stcktp1.h"678constintNum=10;9intmain()10{11std::srand(std::time(0));12...
区分类模板与模板类的概念类模板与模板类的特点，类模板的继承方式以及的继承特点
随意的风的专栏
03-22 354
　　一个类模板(类生成类)允许用户为类定义个一种模式，使得类中的某些数据成员、默认成员函数的参数，某些成员函数的返回值，能够取任意类型(包括系统预定义的和用户自定义的)。 　　如果一个类中的数据成员的数据类型不能确定，或者是某个成员函数的参数或返回值的类型不能确定，就必须将此类声明为模板，它的存在不是代表一个具体的、实际的类，而是代表一类类。 　　类模板定义： 定义一个类模板，一般有两方面的...
C++ 深度解析教程（十六）函数模板的概念和意义、深入理解函数模板、类模板的概念和意义、类模板深度剖析、数组类模板、智能指针类模板、单例类模板
Exp.Joker
06-16 555
C++中有几种交换变量的方法？定义宏代码块 VS 定义函数C++中有没有解决方案集合两种方法的优点？对于Swap函数可以考虑下面的泛型写法Swap泛型写法中的T不是一个具体的数据类型，而是泛指任意的数据类型。当函数重载遇见函数模板会发生什么？在C++中是否能够将泛型的思想应用于类？类模板特化与重定义有区别吗？函数模板可以特化吗？当需要重载函数模板时，优先考虑使用模板特化；当模板特化无法满足需求，再使用函数重载！......
智能指针和函数模板
weixin_52995261的博客
03-08 338
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38...
【C++】鱼的一生， 智能指针的实现
海洋饼干叔叔
08-29 293
本节将实现一个名为SmartPointer的简化版本的shared_ptr模板类。
类模板-实例为指针 vc6.0编译通过
artmcu的专栏
09-07 805
/////////////////////////////////////////// // // stcktp1.h -- modified Stack template // ///////////////////////////////////////// #ifndef STCKTP1_H_ #define STCKTP1_H_ template class Stack
c++ 函数指针与类模板的使用(二)
tianyexing2008的博客
08-15 343
介绍了函数指针与模板的使用，下面是一个改进版本，以前的项目中基本就是这个用法了。c++ 普通函数指针与类模板的使用(一)
c++ 普通函数指针与类模板的使用(一)
tianyexing2008的博客
08-13 539
这里声明了一个类模板，一共 3 个参数，这 3 个参数用来声明一个函数指针，一个参数作为函数的返回值，其他为函数参数。函数指针与类的使用在实际项目中经常会使用，但更多的情况是在类里声明一个类模板的变量，这个类模板实现了包含某种类型的函数指针，同时这个类模板可以进行多个函数指针的注册，这样就可以实现了一对多的调用情况，这个类似于设计模式中的“观察者模式”，即一个动作的发生可以有多个响应。这个类很简单，只能支持一种类型的函数指针的注册，如果是不同的类型则需要用到模板了。.........
【C/C++】 类模板与模板类详解|函数指针\指针函数|函数模板和类模板|普通参数模板、类参数模板
bandaoyu的note
12-14 1930
在C++的Template中很多地方都用到了typename与class这两个关键字，有时候这两者可以替换，那么这两个关键字是否完全一样呢？ 　　事实上class用于定义类，在模板引入c++后，最初定义模板的方法为:template&lt;class T&gt;,这里class关键字表明T是一个类型，后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键字，.........
C++模板——智能指针类模板
食梦者
06-01 2428
本文参照于狄泰软件学院——《C++深度剖析课程》
C++解析(27)：数组、智能指针与单例类模板
weixin_30787531的博客
12-09 146
0.目录 1.数组类模板 1.1 类模板高效率求和 1.2 数组类模板 1.3 堆数组类模板 2.智能指针类模板 2.1 使用智能指针 2.2 智能指针类模板 3.单例类模板 3.1 实现单例模式 3.2 单例类模板 4.小结 1.数组类模板 模板参数可以是数值型参数（非类型参数）： 数值型模板参数的限制： 变量不能作为模板参数 浮点数不能作为模板参数 类对象不能作为模板参数 。。。...
C++:共享指针shared_ptr的理解与应用
热门推荐
weixin_41504987的博客
04-28 3万+
文章目录前言一、shared_ptr的理解二、shared_ptr的初始化2.1.构造函数构造2.2.make_shared辅助函数三、shared_ptr常用函数四 、注意4.1.常见错误(注意以下代码全是错误代码)五、文章分享 前言 大家好，我是不会编程的程序猿，下面我将分享C++中的一个重要知识点，共享指针shared_ptr的理解和应用 一、shared_ptr的理解 智能指针shared_ptr 是存储动态创建对象的指针，其主要功能是管理动态创建对象的销毁，从而帮助彻底消除内存泄漏和悬空指针
现代C++设计：Loki库深度解析与模板新思维
第二部分（第十三章至第十六章）着重于Loki库的设计和实现，这是一个基于模板的库，包含了一系列实用的设计模式，如Small-Object Allocation（小对象分配）优化内存管理，Generalization Functors（泛化函数对象）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值