智能指针知识点归纳

最新推荐文章于 2024-07-13 21:27:21 发布
最新推荐文章于 2024-07-13 21:27:21 发布
阅读量512 收藏 8
点赞数 19
分类专栏： cpp 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47549429/article/details/136378109
版权
3.3 智能指针
3.3.1 RAII 和 智能指针实现

智能指针使用RAII 技术将普通的指针封装为一个栈对象，当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。

智能指针的实现：

template <typename T>
class SharedPtr {
public:
    explicit SharedPtr(T* ptr = nullptr) : data(ptr), refCount(new int(1)) {}

    SharedPtr(const SharedPtr<T>& other) : data(other.data), refCount(other.refCount) {
        (*refCount)++;
    }

    ~SharedPtr() {
        if (--(*refCount) == 0) {
            delete data;
            delete refCount;
        }
    }

    SharedPtr<T>& operator=(const SharedPtr<T>& other) {
        if (this != &other) {
            if (--(*refCount) == 0) {
                delete data;
                delete refCount;
            }
            data = other.data;
            refCount = other.refCount;
            (*refCount)++;
        }
        return *this;
    }

    T& operator*() const {
        return *data;
    }

    T* operator->() const {
        return data;
    }

private:
    T* data;
    int* refCount;
};
3.3.2 shared_ptr

shared_ptr 除了内置的常见属性，常见的有两种用法：一种是使用std::shared_ptr＜void＞用于线程池、任务队列封装任务；另一种用于类成员智能指针；

（1）shared_ptr

​ shared_ptr 共享指针主要有个用法：reset，get, use_count;创建使用std::make_shared

std::vector<double> vec = {2, 3, 1, 4, 6, 8, 9, 7, 5, 0};
std::shared_ptr<std::vector<double>>sharePtr = std::make_shared<std::vector<double>>(vec);
std::cout << "use_count is: " << sharePtr.use_count() << std::endl;
std::vector<double> *ptr = sharePtr.get();
for(int i = 0; i<ptr->size(); i++){
  std::cout << (*ptr)[i] << ", ";
}
std::cout << std::endl;
sharePtr.reset(); // sharePtr 现在为空指针，原来的对象被释放

（2）std::shared_ptr＜void＞

泛型数据结构或者函数都可以被std::shared_ptr接管，并且在离开其作用域，会自动调用其析构函数。常见的使用方式：

#include <iostream>
#include <memory>
#include <functional>

// 定义任务接口
using Task = std::function<void()>;

// 任务执行函数
void executeTask(const std::shared_ptr<Task>& taskPtr) {
    if (taskPtr) {
        (*taskPtr)();
    } else {
        std::cerr << "Invalid task!\n";
    }
}

int main() {
    // 创建一个任务并封装在std::shared_ptr中
    auto taskPtr = std::make_shared<Task>([]() {
        std::cout << "Task executed!\n";
    }); 
    // 执行任务
    executeTask(taskPtr);
    return 0;
}

（3）类成员智能指针

请注意类成员智能指针是在类外进行初始化，在类内部仅声明了，在构造函数也没有任何显示；

示例代码：

#include <iostream>
#include <memory>

class Resource {
public:
    Resource(int id) : mId(id) {
        std::cout << "Resource " << mId << " created!" << std::endl;
    }

    ~Resource() {
        std::cout << "Resource " << mId << " destroyed!" << std::endl;
    }

    void doSomething() {
        std::cout << "Resource " << mId << " doing something..." << std::endl;
    }

private:
    int mId;
};

class Owner {
public:
    std::shared_ptr<Resource> mResource;

    Owner() {
        std::cout << "Owner created!" << std::endl;
    }

    ~Owner() {
        std::cout << "Owner destroyed!" << std::endl;
    }

    void useResource() {
        if (mResource) {
            mResource->doSomething();
        } else {
            std::cout << "No resource available!" << std::endl;
        }
    }
};

int main() {
    // 创建 Resource 对象并初始化 shared_ptr
    std::shared_ptr<Resource> resource = std::make_shared<Resource>(1);
    // 创建 Owner 对象并将 resource 分配给 mResource
    Owner owner;
    owner.mResource = resource;
    // 使用 Owner 对象拥有的 Resource 对象
    owner.useResource();
    // Owner 对象在 main() 函数结束时被销毁，同时 Resource 对象也会被正确地释放
    return 0;
}
3.3.3 weak_ptr

weak_ptr在指向一个对象的时候不会增加其引用计数，weak_ptr 除了内置函数，主要应用于解决shared_ptr 循环使用

（1）weak_ptr

与shared_ptr类似，weak_ptr用法主要是：lock()，expired()；lock()函数类似shared_ptr的get函数，expired()类似于use_count()==0

（2）weak_ptr 无法直接访问资源，使用lock方法才能访问资源

(3）防止循环引用，weak_ptr 主要用于解决shared_ptr 循环使用

示例：

class CTxxx {
public:    
	CTxxx() {printf( "CTxxx cst\n" );}
	~CTxxx() {printf( "CTxxx dst\n" );};
};
    
int main() {
    std::shared_ptr<CTxxx> sp_ct(new CTxxx);
    std::weak_ptr<CTxxx> wk_ct = sp_ct;
    std::weak_ptr<CTxxx> wka1;
    {
        std::cout << "wk_ct.expired()=" << wk_ct.expired() << std::endl;
        std::shared_ptr<CTxxx> tmpP = wk_ct.lock();
        if (tmpP) {
            std::cout << "tmpP usecount=" << tmpP.use_count() << std::endl;
        } else {
            std::cout << "tmpP invalid" << std::endl;
        }
        std::shared_ptr<CTxxx> a1(new CTxxx);
        wka1 = (a1);
    }
    std::cout << "wka1.expired()=" << wka1.expired() << std::endl;
    std::cout << "wka1.lock()=" << wka1.lock() << std::endl;
 
    std::shared_ptr<CTxxx> cpySp = wka1.lock();
    if (cpySp) std::cout << "cpySp is ok" << std::endl;
    else std::cout << "cpySp is destroyed" << std::endl;
    return 1;
}

（2）weak_ptr循环引用

请注意强弱智能指针的一个重要应用规则：定义对象时，用强智能指针shared_ptr，在其它地方引用对象时，使用弱智能指针weak_ptr

class B; // 前置声明类B
class A
{
public:
	A() { cout << "A()" << endl; }
	~A() { cout << "~A()" << endl; }
	weak_ptr<B> _ptrb; // 指向B对象的弱智能指针。引用对象时，用弱智能指针
};
class B
{
public:
	B() { cout << "B()" << endl; }
	~B() { cout << "~B()" << endl; }
	weak_ptr<A> _ptra; // 指向A对象的弱智能指针。引用对象时，用弱智能指针
};
int main()
{
    // 定义对象时，用强智能指针
	shared_ptr<A> ptra(new A());// ptra指向A对象，A的引用计数为1
	shared_ptr<B> ptrb(new B());// ptrb指向B对象，B的引用计数为1
	
    // A对象的成员变量_ptrb也指向B对象，B的引用计数为1，因为是弱智能指针，引用计数没有改变
	ptra->_ptrb = ptrb;
	// B对象的成员变量_ptra也指向A对象，A的引用计数为1，因为是弱智能指针，引用计数没有改变
	ptrb->_ptra = ptra;

	cout << ptra.use_count() << endl; // 打印结果:1
	cout << ptrb.use_count() << endl; // 打印结果:1

	/*
	出main函数作用域，ptra和ptrb两个局部对象析构，分别给A对象和
	B对象的引用计数从1减到0，达到释放A和B的条件，因此new出来的A和B对象
	被析构掉，解决了“强智能指针的交叉引用(循环引用)问题”
	*/
	return 0;
}

（3）weak_ptr弱回调

​ 弱回调的作用是实现了一种在事件处理器对象销毁后不再调用回调函数的机制。

​ 具体来说，假设有一个事件处理器对象 handler，它持有一个回调函数对象的弱指针 mCallback。当事件发生时，事件处理器会调用 triggerEvent() 函数，该函数会尝试将弱指针转换为 std::shared_ptr，如果成功则说明回调函数对象仍然存在，可以调用；如果失败则说明回调函数对象已经被销毁，无法调用。

#include <iostream>
#include <memory>
#include <functional>

// 定义一个事件处理器类，它持有一个弱指针
class EventHandler {
public:
    EventHandler() {}

    void setCallback(std::weak_ptr<std::function<void()>> callback) {
        mCallback = callback;
    }

    void triggerEvent() {
        // 检查弱指针是否已经过期
        if (auto callback = mCallback.lock()) {
            (*callback)();
        } else {
            std::cout << "Callback is expired!" << std::endl;
        }
    }

private:
    std::weak_ptr<std::function<void()>> mCallback;
};

int main() {
    // 创建一个事件处理器对象
    EventHandler handler;
    // 创建一个 shared_ptr，用于保存回调函数
    auto callback = std::make_shared<std::function<void()>>([]() {
        std::cout << "Event triggered!" << std::endl;
    });
    // 将回调函数传递给事件处理器
    handler.setCallback(callback);
    // 触发事件
    handler.triggerEvent();
    // 释放回调函数
    callback.reset();
    // 再次触发事件，此时因为回调函数已经被释放，会输出 "Callback is expired!"
    handler.triggerEvent();
    return 0;
}
3.3.4 unique_ptr

unique_ptr的特点是： （1）管理的资源只能有一个，不能进行拷贝，只能进行移动。（2）轻量：没有引用计数；unique_ptr 常用于vector容器组合使用，用于互斥锁之中；

**（1）unique_ptr **

​ unique_ptr 和share_ptr内置函数类似：reset，get，move ，创建函数std::make_unique

#include <iostream>
#include <memory>

int main() {
  //创建
    std::unique_ptr<int> ptr1 = std::make_unique<int>(42);
		std::unique_ptr<int> ptr2(new int(42));
  //转移所有权
  std::unique_ptr<int> ptr3 = std::move(ptr1); // ptr1 失去了对资源的所有权
  //获取原始指针
  int* rawPtr = ptr.get();
  ptr.reset(); // 释放所有权并删除对象
}

**（2）std::vector<std::unique_ptr> **

通常情况下，需要把类放入一个容器中，常采用std::unique_ptr 与 std::vector 结合使用;

示例代码：

#include <iostream>
#include <memory>
#include <vector>

class MyClass {
public:
    MyClass(int data) : mData(data) {
        std::cout << "MyClass Constructor, Data: " << mData << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass Destructor, Data: " << mData << std::endl;
    }
    void doSomething() {
        std::cout << "MyClass doing something with data: " << mData << std::endl;
    }
private:
    int mData;
};

int main() {
    std::vector<std::unique_ptr<MyClass>> vec;

    // 向 vector 中添加元素
    vec.push_back(std::make_unique<MyClass>(1));
    vec.push_back(std::make_unique<MyClass>(2));
    vec.push_back(std::make_unique<MyClass>(3));

    // 访问 vector 中的元素
    for (const auto& ptr : vec) {
        ptr->doSomething();
    }

    // vector 结束生命周期时，所有元素的内存会自动释放

    return 0;
}

示例2:

#include <iostream>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>

class Resource {
public:
    Resource(int data) : mData(data) {}

    void doSomething() {
        std::cout << "Resource " << mData << " is being used." << std::endl;
    }

private:
    int mData;
};

class ResourceManager {
public:
    void addResource(int data) {
        std::lock_guard<std::mutex> lock(mMutex);
        mResources.push_back(std::make_unique<Resource>(data));
    }

    void useResources() {
        std::lock_guard<std::mutex> lock(mMutex);
        for (const auto& resource : mResources) {
            resource->doSomething();
        }
    }

private:
    std::mutex mMutex;
    std::vector<std::unique_ptr<Resource>> mResources;
};

int main() {
    ResourceManager manager;

    // 创建两个线程分别添加资源和使用资源
    std::thread addThread([&]() {
        for (int i = 0; i < 5; ++i) {
            manager.addResource(i);
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    });

    std::thread useThread([&]() {
        for (int i = 0; i < 5; ++i) {
            manager.useResources();
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
        }
    });

    addThread.join();
    useThread.join();

    return 0;
}
3.3.5 智能指针转换

static_pointer_cast

作用：改函数主要是将继承类的父类指针转换成子类指针；

示例代码：

#include <iostream>
#include <memory>

struct BaseClass {};

struct DerivedClass : BaseClass {
   void f() const {
      std::cout << "Sample word!\n";
   }
};
 
int main() {
   std::shared_ptr<BaseClass> ptr_to_base(std::make_shared<DerivedClass>());

   std::static_pointer_cast<DerivedClass>(ptr_to_base)->f();

   static_cast<DerivedClass*>(ptr_to_base.get())->f();

}
熊明之
关注
  • 19
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++_动态内存与智能指针知识点总结
Maple的博客
07-12 902
C++动态内存与智能指针     为了更容易同时也更安全地使用动态内存，新的标准库提供了两种智能指针（smart pointer）类型来管理对象。智能指针的行为类似于常规指针，重要的区别是它负责自动释放内存。      新标准库提供的这两种智能指针的区别在于管理底层指针的方式：shared_ptr允许多个指针指向同一个对象；unique_ptr则“独占”所指向的对象。标准库还定义了一个名为weak...
智能指针的初步认识
New_learner55的博客
10-22 198
开辟了内存空间，必定要释放内存空间，如果不释放就会造成内存泄漏，引发安全问题。 如果代码量很少的时候，我们会记得释放掉开辟的空间，但是如果代码量过大，我们会忘记开辟的空间，那么就需要智能指针来帮助我们自动释放空间。 例如： #include<memory> int main() { int* tmp = new int[10]; auto_ptr<int> ap(tmp); cout << *ap <<endl; //delete []tmp; re
c++知识点总结--智能指针
qq_1169789866的博客
08-20 250
智能指针 引入智能指针目的：为了解决:一种是忘记释放内存,如new完,忘记delete,另外是尚有指针引用内存的情况下释放指针,就会产生引用非法内存的指针。 1 shared_ptr:允许多个指针指向同一个对象, 默认初始化的智能指针中保存着一个空指针。 make_shared函数: 最安全的分配和使用动态内存的方法就是调用一个名为make_shared的标准库函数,此函数在动态内存中分配一个对象并初始化它,返回指向此对象的 shared_ptr。头文件和share_ptr相同,在memory中 必须指定想
实现智能指针
春风来不来的博客
08-06 400
AutoPtr资源的转移不推荐使用。 旧库使用拥有者会导致野指针实现代码template <class T> class AutoPtr { public: AutoPtr(T* p = NULL) : _ptr(p) {} AutoPtr(AutoPtr<T>& ap) :_ptr(ap._ptr) { ap._ptr
c++智能指针最全知识点即面试题目总结
02-27
本文讲解4个智能指针的基本概念和特性，以及其他设计到的知识点。讲解的过程中，如果此部分内容涉及到面试题目，会在旁边以这个题目的序号来标注出，方便大家对着题目序号来寻找问题的答案。文章整理了近两年来10个...
C++结构体与类指针知识点总结
08-25
C++结构体与类指针知识点总结 在C++编程语言中，结构体和类是两种常用的数据类型，它们可以用来定义复杂的数据结构和对象。本文总结了C++结构体和类指针的知识点，并提供了相关的代码示例和注释，旨在帮助读者更好...
C++面试知识点总结
09-25
C++是一种强大的、通用的编程语言，被广泛应用于...通过阅读《C++知识点总结.docx》文档，你将能深入理解并巩固这些概念。在学习过程中，实践和不断的代码编写是必不可少的，理论与实践相结合，才能真正提升C++技能。
配置文件操作类封装及智能指针实现
12-13
总结来说，本主题的核心是通过封装配置文件操作类提供便捷的配置文件读写接口，并结合智能指针确保内存资源的正确管理。这样的实现方式既提高了代码的可读性和可维护性，又降低了内存管理的风险，是软件开发中的良好...
C++面试常问知识点总结
03-29
c++常用知识点总结，包含c++基础知识、c++内存、c++面向对象、c++stl、c++ 新特性、c++操作系统、c++计算机网络、c++数据库、c++设计模式。 C++在C语言基础上引入了面对对象的机制，同时也兼容C语言。 C++有三大特性...
初始C++
2302_81016149的博客
07-08 809
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
C++初探究（2）
Frenemy__的博客
07-09 1480
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 1015
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
05day--C++日期类的实现与取地址运算符的重载
weixin_73863912的博客
07-13 235
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动。⽣成的就可以够我们⽤了，不需要去显⽰实现。
C++客户端Qt开发——QT初识
最新发布
m0_63596031的博客
07-13 524
②中的代码创建，是在堆上new出来的一块空间，当把对象改成在栈上创建，此时就可以看到运行起来的程序无法显示出helloworld，此时label对象随着构造函数的结束，就销毁了，所以应该把它交给对象树进行管理。在QT Designer中创建一个控件的时候，此时会给这个控件分配一个objectName属性，这个属性的值，要求是在界面中是唯一的，不能和别人重复。Qt的对象树模型是一种递归的结构，其中一个对象可以拥有多个子对象，而每个子对象又可以拥有自己的子对象，以此类推。坐标体系：以左上角为原点（0,0），
C语言操作符详解
z317920的博客
07-11 605
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
C++：哈希表
m0_61088872的博客
07-12 485
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
深入解析【C++ list 容器】：高效数据管理的秘密武器
小李很执着的博客
07-09 941
C++ 中的 list 容器是一个基于双向链表的序列式容器，适用于需要频繁插入和删除操作的场景，但不支持随机访问。list 提供了多种构造方法和丰富的操作接口，包括插入、删除、访问等。与 vector 相比，list 在插入和删除操作上更高效，但在随机访问和空间利用率上较差。
Python的异常处理（与C++对比学习）
2302_76941579的博客
07-09 959
通过C++的基础来学习Python的异常处理

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值