智能指针上

最新推荐文章于 2025-05-13 18:28:53 发布
最新推荐文章于 2025-05-13 18:28:53 发布
阅读量238 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yu876876/article/details/81474455
本文深入探讨了C++中智能指针的概念与应用，包括引入智能指针的原因、不同类型的智能指针及其工作原理。通过具体实例，展示了如何利用智能指针有效管理动态内存，避免内存泄漏等问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

为什么引入智能指针？

C++的动态内存需要用户自己维护，动态开辟空间，在出函数作用域或者程序退出时释放内存，否则会造成内存泄漏。当代码教长或者复杂时，我们会忘记释放空间。

void Fun1()
{
    int*p = new int[10];
    FILE* pFile = fopen("1.txt", "r");
    if (pFile == NULL)
    {
        return;    //如果打开失败，返回，造成内存泄漏
    }
    if (p != NULL)
    {
        delete[]p;
        p = NULL;
    }
}

void Fun2()
{
    int *p = new int[10];
    try
    {
        //dosomething();
    }
    catch (...)
    {
        return; //返回之前忘记释放内存，导致内存泄漏
    }
    delete[] p;
}

智能指针的基本情况

1 RAII（资源分配即初始化）

    定义一个类封装资源的分配和释放，在构造函数完成资源的分配和初始化
在析构函数完成资源的清理，可用保证资源正确初始化和释放。

2 像指针一样 operator* operator->
3 赋值和拷贝

Boost库的智能指针
（ps:新的C++11标准中已经引入了unique_ptr/shared_ptr/weak_ptr）
scoped_ptr
scoped_array
shared_ptr
shared_array
weak_ptr
intrusive_ptr
模拟实现库中的部分智能指针
1 auto_ptr
思想：采用的是资源转移的方式，在拷贝和赋值后，原有对象对资源无访问权。

template<typename T>
class AutoPtr
{
public:
    AutoPtr(T* ptr)
        :_ptr(ptr)
    {
        ptr = NULL;//与动态申请的空间脱离
        cout << "AutoPtr()" << endl;
    }
    ~AutoPtr()
    {
        if (NULL != _ptr)
        {
            cout << "~AutoPtr()" << endl;
            delete _ptr;
            _ptr = NULL;
        }
    }
private:
    T* _ptr;
};
void Funtest()
{
    AutoPtr<int> p = new int;
    AutoPtr<int>p1(p); ///p资源被转移到p1，p无法进行访问

}

int main()
{
    Funtest();
    system("pause");
    return 0;
}

这里写图片描述
不写拷贝构造函数默认浅拷贝，同一块被释放了两次，导致程序崩溃。

改进：添加拷贝构造函数

template<typename T>
class AutoPtr
{
public:
    AutoPtr(T* ptr)
        :_ptr(ptr)
    {
        ptr = NULL;//与动态申请的空间脱离
        cout << "AutoPtr()" << endl;
    }
    AutoPtr(AutoPtr<T>& ptr)  //由于内部要改变ptr的值，所以去掉const
        :_ptr(ptr._ptr)
    {
        ptr = NULL;    //让ptr与动态申请的空间脱离关系
    }
    ~AutoPtr()
    {
        if (NULL != _ptr)
        {
            cout << "~AutoPtr()" << endl;
            delete _ptr;
            _ptr = NULL;
        }
    }
private:
    T* _ptr;
};
void Funtest()
{
    AutoPtr<int> p = new int;
    AutoPtr<int>p1(p); //拷贝构造
}

int main()
{
    Funtest();
    system("pause");
    return 0;
}

这里写图片描述

智能指针管理权转移：资源被转移，原来的对象无法进行访问，所以只调用了一次析构函数

构造函数的参数要给缺省值

template<typename T>
class AutoPtr
{
public:
    AutoPtr(T* ptr=NULL)
        :_ptr(ptr)
    {
        ptr = NULL;//与动态申请的空间脱离
        cout << "AutoPtr()" << endl;
    }
    AutoPtr(AutoPtr<T>& ptr)  //由于内部要改变ptr的值，所以去掉const
        :_ptr(ptr._ptr)
    {
        ptr = NULL;    //让ptr与动态申请的空间脱离关系
    }
    ~AutoPtr()
    {
        if (NULL != _ptr)
        {
            cout << "~AutoPtr()" << endl;
            delete _ptr;
            _ptr = NULL;
        }
    }
private:
    T* _ptr;
};
void Funtest()
{
    AutoPtr<int> p = new int;
    AutoPtr<int>p1(p); //拷贝构造
    AutoPtr<int> p2;
}

int main()
{
    Funtest();
    system("pause");
    return 0;
}

这里写图片描述

赋值运算符重载

template<typename T>
class AutoPtr
{
public:
    AutoPtr(T* ptr=NULL)
        :_ptr(ptr)
    {
        cout << "AutoPtr()" << endl;
    }

    AutoPtr(AutoPtr<T>& ptr)  //由于内部要改变ptr的值，所以去掉const
        :_ptr(ptr._ptr)
    {
        ptr._ptr = NULL;    //让ptr与动态申请的空间脱离关系
    }

    AutoPtr<T>& operator=(AutoPtr<T>& ptr)
    {
        if (this != &ptr)
        {
            if (NULL != _ptr) //防止空对象进行引用导致程序崩溃
            {
                delete _ptr;
                _ptr = ptr._ptr;  //如果_ptr为空，则崩溃
                ptr._ptr = NULL;
            }
        }
        return *this;
    }
    ~AutoPtr()
    {
        if (NULL != _ptr)
        {
            cout << "~AutoPtr()" << endl;
            delete _ptr;
            _ptr = NULL;
        }
    }
private:
    T* _ptr;
};
void Funtest()
{
    AutoPtr<int> p = new int;
    AutoPtr<int>p1(p); //拷贝构造
    AutoPtr<int> p2;
    p2 = p1;  //赋值运算符重载 
}

int main()
{
    Funtest();
    system("pause");
    return 0;
}

这里写图片描述

获取原生指针 重载* 和->

template <typename T>
class AutoPtr
{
public:
    AutoPtr(T* ap = NULL)
        :_p(ap)
    {
        cout << "AutoPtr()" << endl;
    }

    AutoPtr(AutoPtr<T>& ap)//由于内部要改变ap的值，所以去掉const修饰
        :_p(ap._p)
    {
        ap._p = NULL;//让ap与动态申请的空间脱离关系
    }

    AutoPtr<T>& operator=(AutoPtr<T>& ap)
    {
        if (this != &ap)
        {
            if (NULL != _p)//防止对空对象进行引用导致程序崩溃
            {
                delete _p;
                _p = ap._p;//如果_p为空，则崩溃
                ap._p = NULL;//脱离关系
            }
        }
        return *this;
    }

    ~AutoPtr()
    {
        if (NULL != _p)
        {
            cout << "~AutoPtr()" << endl;
            delete _p;
            _p = NULL;
        }
    }
    T* Get()
    {
        return _p;
    }
    T* operator*()
    {
        return *_p;
    }
    T* operator->()
    {
        return _p;
    }
private:
    T* _p;
};
void Funtest()
{
    AutoPtr<int> p = new int;
    AutoPtr<int> p1(p);
    AutoPtr<int> p2;
    p2 = p1;
    AutoPtr<int>* p3 = &p1;
    cout << *(p3->Get)() << endl;
}
int main()
{
    Funtest();
    system("pause");
    return 0;
}

这里写图片描述

auto_ptr

特点:带有缺陷的设计
方式：管理权转移防止一块空间被多次释放（即资源被转移，原对象无法进行访问）

scoped_ptr
思想：让单个对象独占空间，避免对象被多次释放的问题
一个类要防止被拷贝要做两件事情
1》将拷贝构造函数和赋值运算符重载函数的访问权设置为私有
2》将拷贝构造函数和赋值运算符重载函数只声明不定义

template <typename T>
class scopted_ptr
{
public:
    scopted_ptr(T* ptr = NULL)
        :_ptr(ptr)
    {
        cout << "scopted_ptr()" << endl;
    }

    ~scopted_ptr()
    {
        if (NULL != _ptr)
        {
            cout << "~scopted_ptr()" << endl;
            delete _ptr;
            _ptr = NULL;
        }
    }
    T* Get()
    {
        return _ptr;
    }
    T* operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
private:
    scopted_ptr(const scopted_ptr<T>& ptr);
    scopted_ptr<T>& operator=(const scopted_ptr<T>& ptr);
private:
    T* _ptr;
};
void Funtest()
{
    scopted_ptr<int> p1= new int;
    scopted_ptr<int> *p2= &p1;
    cout << *(p2->Get)() << endl;

}
int main()
{
    Funtest();
    system("pause");
    return 0;
}

这里写图片描述

注意：避免出错，不要进行赋值和对象拷贝

引用计数版本的智能指针—->shared_ptr
之前我们学习string类时，运用了写诗拷贝的方法解决浅拷贝存在的问题，同样我们借助它的原理来实现shared_ptr

它在底层多申请了一块空间保存引用计数，用来检测当前对象所管理的空间是否还被其他智能指针使用，在构造函数中，若该智能指针所指空间非空，将其引用计数初始化为1，析构时，先对其引用计数-1，若减为0，就可释放空间，否则不能释放

template<class T>
class SharedPtr
{
public:
    SharedPtr(T* ptr = NULL)
        :_ptr(ptr)
        , _pCount(NULL)
    {
        if (_ptr != NULL)
        {
            _pCount = new int(1);
        }
    }
    SharedPtr(const SharedPtr<T>& sp)
        :_ptr(sp._ptr)
        , _pCount(sp._pCount)
    {
        ++GetRef();
    }

    SharedPtr<T>& operator=(const SharedPtr<T>& sp)
    {
        if (this != &sp)
        {
            Release();
            _ptr = sp._ptr;
            _pCount = sp._pCount;
            ++GetRef();
        }
        return *this;
    }

    T* operator->()
    {
        return _ptr;
    }
    T& operator*()
    {
        return *_ptr;
    }
    int UseCount()
    {
        return GetRef();
    }
    ~SharedPtr()
    {
        Release();
    }
private:
    void Release()
    {
        if (_ptr && 0 == --GetRef())
        {
            delete _ptr;
            delete _pCount;
        }
    }
    int& GetRef()
    {
        return *_pCount;
    }
private:
    T* _ptr;
    int* _pCount;
};

void TestSharedPtr()
{
    SharedPtr<int> sp1(new int(10));
    SharedPtr<int> sp2(sp1);

    *sp1 = 20;
    *sp2 = 30;
    cout << sp1.UseCount() << endl;//2
    cout << sp2.UseCount() << endl;//2

    SharedPtr<int> sp3(new int(50));
    SharedPtr<int> sp4(sp3);

    sp1 = sp3;
    sp2 = sp4;
    cout << sp1.UseCount() << endl;//4
    cout << sp2.UseCount() << endl;//4
}

int main()
{
    TestSharedPtr();
    return 0;
}

这种方式看似完美，但是也有一个问题
试想有一个双向链表，每个节点的next和prev都是SharedPtr类型的智能指针，则此时的p1,p2引用计数都为2，但函数结束时要销毁p1,p2，p1的引用计数先减1后为1，说明还有其他指针使用这块空间，因此不能释放，P2也是如此，它的引用计数减1后也为1，无法释放，二者相互制约，最终都无法释放导致内存泄漏。

C++智能指针的使用
的博客
02-10 994
1. 下面的程序中，new了以后，我们也delete了，但是因为抛异常导致后面的delete没有得到执行，所以就内存泄漏了，所以我们需要new以后捕获异常，捕获到异常后delete内存，再把异常抛出。，它是一种管理资源的类的设计思想，本质是一种利用对象生命周期来管理获取到的动态资源，避免资源泄漏，这里的资源可以是内存、文件指针、网络连接、互斥锁等等。4、weak_ptr弱（辅助解决shared_ptr的一个问题）指针，它不同于上面的指针，它不支持RAII，也就意味着不能用它直接管理资源，
c++智能指针最全知识点即面试题目总结
02-27
本篇文章收集了近一年来所有关于智能指针的面试相关内容。以智能指针的面试题线索，穿插讲解完最常用的四种智能指针的各个方面。本文讲解4个智能指针的基本概念和特性，以及其他设计到的知识点。讲解的过程中，如果...
C++智能指针上
qq_44816790的博客
04-24 1714
裸指针”是最基础的，直接存储内存地址的指针类型。特点：①它本身没有自动的内存管理机制：如它不会自动释放内存，也不会检查是否指向有效的内存区域；②直接操作内存地址，不进行任何的边界检查：如空指针解引用。int*p = &x;//裸指针p指向x//输出x的值，10return 0;
C++ 智能指针 - 全部用法详解
热门推荐
cpp_learner的博客
08-02 10万+
血的教训？不学智能指针，本人丢了一份工作。
C++智能指针
Edward2022的博客
03-22 1217
unique_ptr、shared_ptr、weak_ptr
C++ 智能指针使用方法
最新发布
zxy_ZXY123的博客
05-13 1104
本文主要针对智能指针的使用是原理进行总结。
C++ STL 四种智能指针
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
C++智能指针详解
qq_61635026的博客
10-02 2219
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
c++智能指针详解
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
C++——智能指针详解及实现
小拉拉的博客
04-06 1113
在 C++ 的早期版本中，程序员主要使用原生指针来管理动态内存。例如，使用 new 关键字分配内存，使用 delete 释放内存。然而，这种方式很容易出错。例如，当程序员忘记释放内存时，就会导致内存泄漏；当释放内存后仍然使用指向该内存的指针时，就会产生悬空指针问题。智能指针的出现就是为了解决这些问题，它通过自动管理内存，让程序员可以更安全、更方便地使用动态内存。所谓的智能指针本质就是一个类模板，它可以创建任意的类型的指针对象，当智能指针对象使用完后，对象就会自动调用析构函数去释放该指针所指向的空间。
c++ | 智能指针
qq_42278275的博客
03-31 1155
将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。 auto_ptr（已经弃用） auto_ptr<string> p1 (new string ("aaa)); auto_ptr<string> p2; p2 = p1; // 不报错 unique_ptr “独占”所指向的对象 是auto的改进 unique_ptr<string> p1 (new string ("aaa")); uniqu
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
C++ 引用计数技术及智能指针的简单实现
12-22
智能指针是C++编程中用来自动管理动态内存的一种机制，它的主要目标是解决C++中手动内存管理带来的问题，如内存泄漏和悬垂指针。引用计数是智能指针实现中的关键技术之一，用于追踪对象被引用的次数，从而决定何时...
指针 - 智能指针 - 智能指针知识点
11-19
除了C++中的智能指针，其他一些编程语言也有自己独特的智能指针实现，例如Python中的垃圾回收机制和引用计数，以及Rust语言中的所有权系统和借用检查器，这些机制在不同程度上提供了类似于智能指针的功能，使得内存...
c++11&14-智能指针要点汇总
12-17
但像java等其他一些语言则不会有这样的问题，为什么呢，因为它们有很好的处理内存的方法，比如java的垃圾回收机制，现在，我们c++终于也有了智能指针。 1. 什么是智能指针 简单地说，智能指针是用对象去管理一个...
STL中list的使用
HiMark
08-15 2万+
list的底层结构 list底层是一个带头节点的双向循环链表，任意位置插入和删除时间复杂度0(1) list迭代器 由于list底层是带头节点的双向循环链表，因此list的迭代器需要list的实现者自己提供 迭代器怎么实现呢？ 迭代器的本质是指针，将指针封装出新的类型，指针有的操作，迭代器也视情况支持这些操作，比如：指针++，–，*，-&gt; 等操作。迭代器在类中将这些操作重载出来...
vector和list有什么区别？分别在什么场景下应用？
HiMark
08-15 1万+
Vector:顺序表 优点：和数组类似开辟一段连续的空间，并且支持随机访问，所以它的查找效率高其时间复杂度O(1)。 缺点：由于开辟一段连续的空间，所以插入删除会需要对数据进行移动比较麻烦，时间复杂度O（n），另外当空间不足时还需要进行扩容。 List：链表 优点：底层实现是循环双链表，当对大量数据进行插入删除时，其时间复杂度O(1) 缺点：底层没有连续的空间，只能通过指针来访问，所以查...
内存泄漏&悬挂指针（野指针）的危害及避免
HiMark
08-20 3291
内存泄漏&amp;悬挂指针（野指针）的危害及避免 什么是内存泄漏？ 内存泄漏：动态申请的内存空间没有正常释放，但是也不能正确使用的情况。 内存泄漏的危害？ 一般用户感觉不到内存泄漏的危害，真正有危害的是内存泄漏的堆积，最终会耗尽系统所有的内存。 如果程序内存泄漏正好写到了系统使用的内存或其他程序使用的内存地址，那么会导致系统异常或程序崩溃。 如何检测内存泄漏？ 使用工具 val...
剑指offer面试题1-10
HiMark
10-12 1414
1二维数组中的查找 在一个二维数组中，每一行元素都按照从这里写代码片左到右递增的顺序排序，每一列元素都按照从上到下递增的顺序排序。实现一个查找功能的函数，函数的输入为二维数组和一个整数，判断数组中是否含有该整数。 //例如查找元素7 //二位数组的规律是从左往右依次递增，从下往上依次递增 //可以根据待查元素，与起点位置比较，起点位置暂设为右上角（也可以选左下角） //如果待查元素...
C++智能指针简易实现教程
随着现代编程语言的发展，为了简化内存管理，提高程序的可靠性和效率，智能指针的概念应运而生。智能指针是一种资源管理类，用来模拟原始指针的行为，但同时又能够自动管理资源的生命周期。在C++中，智能指针类主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值