一、什么是智能指针在C++中没有垃圾回收机制,必须自己释放分配的内存,否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针(smart pointer)。智能指针是存储指向动态分配(堆)对象指针的类,用于生存期的控制,能够确保在离开指针所在作用域时,自动地销毁动态分配的对象,防止内存泄露。随着C++的发展,有三个解决方案,一个方案对应着一种智能指针。将指针的管理权转移给另外一个对象。对应C            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-25 17:42:41
                            
                                126阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            OpenCV Mat类及像素操作(持续更新)01 Mat类及与其相关的类1.1 Mat简介在opencv刚出来的时候,库都是围绕C接口构建的,当时使用名为IplImage C 的结构在内存中存储图像,大多数老旧教材中经常看到。这个结构把C的缺点暴露无疑,最大的问题是需要手动管理,当代码非常大的时候就会特别难顶。后来,c++问世了,引入了类的概念,于是产生了新的管理方式,Mat类,但也有弊端,就是一            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-24 16:44:34
                            
                                977阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            智能指针是为了解决内存泄漏的问题!unique_ptr 独占所指向的对象, 同一时刻只能有一个 unique_ptr 指向给定对象(通过禁止拷贝语义, 只有移动语义来实现), 定义于 memory (非memory.h)中, 命名空间为 std. 标准库早期版本中定义了 auto_ptr, 它具有 unique_ptr 的部分特征, 但不是全部, 例如, 不能在容器中保存 auto_ptr, 也不            
                
         
            
            
            
            C++11标准引入了boost库中的智能指针,给C++开发时的内存管理提供了极大的方便。接下来这篇文件介绍shared_ptr/weak_ptr内部实现原理及使用细节。C++不像java有内存回收机制,每次程序员new出来的对象需要手动delete,流程复杂时可能会漏掉delete,导致内存泄漏。于是C++引入智能指针,可用于动态资源管理,资源即对象的管理策略。C++中的shared_ptr/we            
                
         
            
            
            
            Smart Pointers - What, Why, Which?  http://ootips.org/yonat/4dev/smart-pointers.htmlauto_ptr  C++98中,智能指针通过一个模板类型auto_ptr实现,缺点:拷贝时返回一个左值,不能调用delete[](只能针对单个对象使用,不能针对数组使用),所以在C++11标志中被废弃了。  a            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-07 14:46:19
                            
                                198阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            cv::Ptr类就看成一个cv的一个智能指针,在适当的时间能自动删除指向的对象;工作机制很像C++的内置指针cv::Ptr<cv::Matx33f> p = new cv::Matx33f;  //创建一个智能指针p,空构造    //cv::Ptr<cv::Matx33f> pp =makePtr<cv::Matx33f>();  这种格式在3.0版本可以,在            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-01-25 15:02:18
                            
                                3164阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            智能指针            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2016-04-14 11:20:13
                            
                                606阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            智能指针:是存储指向动态分配对象指针的类。能够在适当的时间自动删除指向的对象。下面是它的三种实现://autoptr
template<class T>
class Autoptr
{
public:
	Autoptr(T* ptr)
		:_ptr(ptr)
	{}
	~Autoptr()
	{
		if(_ptr)
		{
			delete             
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2016-04-19 21:02:13
                            
                                797阅读
                            
                                                                             
                 
                
                             
         
            
            
            
                   智能指针是能够智能化的动态开辟空间和内存释放。C++中引入智能指针,是防止我们在动态开辟空间是,由于疏忽大意,导致内存的释放出现问题,最终致使内存泄漏。智能指针的基本特点:(1)智能指针管理的是一块内存的释放。(2)智能指针是一个类,有类似指针的功能。AutoPtr:#include<iostream>using namespace            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2016-04-25 11:09:30
                            
                                585阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            说起指针相信大家一定不陌生,那么智能指针呢?首先,我们来看看,为什么要有智能指针?例如void Test2 ()
{
     int* p1 = new int(2);
     bool isEnd = t            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2016-05-12 22:41:51
                            
                                550阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            智能指针            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2020-10-27 21:14:56
                            
                                812阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            unique_ptr独享被管理对象,同一时刻只能有一个unique_ptr拥有对象的所有权,当其被赋值时对象的所有权也发生转移,当其被销毁时被管理对象也自动被销毁 shared_ptr共享被管理对象,同一时刻可以有多个shared_ptr拥有对象的所有权,当最后一个shared_ptr对象销毁时,被            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-07-14 16:31:34
                            
                                10000+阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            #include <bits/stdc++.h> using namespace std; //智能指针 int main(){ //unique_ptr,保证同一时间内只有一个智能指针可以指向该对象 unique_ptr<string> p3(new string("auto")); unique ...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-07-16 21:37:00
                            
                                168阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
                   C++中智能指针能够防止出现野指针、内存泄露等情况,智能指针的类中包括4个函数:构造函数、拷贝构造函数、重载复制操作符、析构函数。构造函数须要对引用计数和指针进行初始化,引用计数初始化为1,拷贝构造函数完毕对象之间的拷贝,要注意引用计数的变化和推断两个指针是否指向同样的内存。
重载复制操作符。须要推断的情况是左值代表的指针假设引用计数减为0。要释放对应的内存,避免发生内存泄露。析            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2016-01-10 12:30:00
                            
                                117阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            RAII 问题:申请资源使用释放资源 通常遗忘 内存泄漏 fd 使用对象的自动析构的方式,进行所申请资源的自动释放 auto_ptr 禁止隐式构造	允许拷贝构造	允许等号运算符 不能让多个智能指针指向同一块空间 不能用auto_ptr直接传参,否则会直接崩溃	传引用可以 显式构造带有类型	隐式的不带 ...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-07-23 20:01:00
                            
                                113阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            1.reset的作用: reset() 相当于释放当前所控制的对象reset(T* p) 相当于释放当前所控制的对象,然后接管p所指的对象reset(T*, Deleter) 和上面一样 2.get: 获取对象指针            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2019-09-30 22:02:00
                            
                                135阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            1、头文件 #include <memory> 2、类型 auto_ptr share_ptr weak_ptr unique_ptr            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2019-03-05 11:16:00
                            
                                59阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            使用c++,除了c++的语法外,指针是我们面临的最的大一个问题,由于使用不当就会导致程序意外退出,或着内存的占用越来越多,总结起来这些错误由以下三个原因造成。       1 野指针:指针指向的内存已经被释放,但是我们还在使用该指针,或者还在使用之前指向的指针,此时程序会崩溃,也有可能导致已经释放的内存被重新分配给程序使用,造成意想不到的后果。             
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-06-02 11:00:30
                            
                                72阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            RAII(Resource Acquisition Is Initialization):资源分配即初始化,定义封装一个类,用来实            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2022-09-02 14:24:45
                            
                                99阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            #include <iostream> using namespace std; template<class T> class SmartPtr{ public: explicit SmartPtr():ptr(nullptr), count(new int(0)){} explicit Smar
                    
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-07-02 00:00:21
                            
                                27阅读