RecordsetPtr智能指针

合集下载

qsharedpointer和deletelatter

qsharedpointer和deletelatter QSharedPointer是Qt框架中提供的一种智能指针类，它用于管理一块动态分配的内存，并在不再需要时自动释放该内存。

而DeleteLater()是QObject类中的一个槽函数，用于延迟删除一个QObject对象。

在这篇文章中，我将一步一步回答关于QSharedPointer和DeleteLater()的问题，并解释它们的作用和使用方法。

第一步：介绍QSharedPointerQSharedPointer是Qt框架中提供的智能指针类之一，它能够自动管理动态分配的内存，确保在不再使用时正确释放。

与传统的裸指针相比，QSharedPointer具有更高的安全性和易用性。

它的主要特点如下：1. 引用计数：QSharedPointer使用引用计数来跟踪有多少指针指向同一个对象。

当最后一个指针离开作用域时，引用计数将自动减少并且在没有其他指针引用时，对象将被自动删除。

2. 自动删除：当引用计数为零时，QSharedPointer会自动删除所管理的对象，无需手动调用delete操作。

3. 复制语义：QSharedPointer可以通过复制构造函数和赋值运算符进行复制，每次复制都会增加引用计数。

第二步：使用QSharedPointer使用QSharedPointer非常简单。

首先，您需要创建一个QSharedPointer 对象并用new操作符初始化它。

以下是一个示例：cppQSharedPointer<MyClass> sharedPtr(new MyClass);在这个示例中，我们使用MyClass作为被管理的对象类型，然后通过new 操作符在堆上分配一个新的MyClass对象，并将其指针传递给QSharedPointer的构造函数。

一旦创建了QSharedPointer对象，您可以像使用普通裸指针一样使用它。

例如，您可以通过箭头运算符访问MyClass对象的成员函数和成员变量：cppsharedPtr->doSomething();当您不再需要这个QSharedPointer对象时，它会自动释放所管理的对象。

智能指针内部实现原理

智能指针内部实现原理智能指针是一种能够在运行时自动管理动态分配的内存的指针。

它们可以跟踪资源的所有者，并确保在不再需要资源时正确释放它。

智能指针的内部实现原理主要有两个方面：资源管理和所有权转移。

一、资源管理：在使用智能指针时，需要确保动态分配的内存被正确释放，以避免内存泄漏。

为了实现这一点，智能指针通常会使用引用计数来跟踪资源的所有者数量。

每当一个智能指针指向一个资源时，它的引用计数就会增加；当这个智能指针不再指向资源时，引用计数就会减少。

当引用计数为零时，表示该资源没有任何所有者，可以安全地释放。

智能指针还可以通过重载析构函数来实现自动释放资源的功能。

在析构函数中，智能指针可以调用delete或delete[]来释放动态分配的内存。

这样，在智能指针超出作用域时，析构函数会自动被调用，从而实现自动释放资源的效果。

二、所有权转移：智能指针可以通过所有权转移来确保资源的唯一性。

当一个智能指针拥有资源的所有权时，其他智能指针无法访问该资源。

只有在所有权转移时，其他智能指针才能访问该资源。

为了实现所有权转移，智能指针通常会禁止拷贝构造函数和赋值运算符，只允许移动构造函数和移动赋值运算符。

这样，当一个智能指针被赋值给另一个智能指针时，所有权会从一个指针转移到另一个指针。

移动构造函数和移动赋值运算符会将资源的所有权从一个智能指针转移到另一个智能指针，并将源指针的引用计数置为零。

这样可以确保资源只有一个所有者，并且不会被错误地释放多次。

除了引用计数和所有权转移，智能指针的实现还需要考虑线程安全性。

由于智能指针的使用很容易涉及多线程操作，为了保证线程安全，需要使用原子操作来对引用计数进行增加和减少，以避免竞争条件。

综上所述，智能指针的内部实现原理包括资源管理（引用计数和析构函数）和所有权转移（禁止拷贝构造函数和赋值运算符，使用移动构造函数和移动赋值运算符）。

此外，为了保证线程安全性，还需要使用原子操作来对引用计数进行管理。

使用_ConnectionPtr接口开发ACCESS数据库

使用_ConnectionPtr接口开发ACCESS数据库2011-03-30 08:16:16| 分类：Visual C++ | 标签：使用_connectionptr 接口开发access数据库|字号大中小订阅ADO中最重要的对象有三个：Connection、Recordset和Command，分别表示连接对象、记录集对象和命令对象。

三个对象对应的智能指针分别是：_ConnectionPtr、_RecordsetPtr、_CommandPtr。

ADO使用_ConnectionPtr这个指针来操纵Connection 对象，类似地，后面用到的_CommandPtr和_RecordsetPtr分别表示命令对象指针和记录集对象指针。

Connection对象是这三个对象的基础，它的主要作用是建立与数据库的连接，建立了与数据库的连接后，才能进行其它有关数据库的访问和操作。

也就是说，使用ADO操作数据库，通常先用Connection对象的Open方法打开一个库连接，然后才能进行数据库的操作。

操作完成后，要关闭这个库连接。

本文只讲述Connection对象最常用的Open方法和Execute方法。

Open方法用于打开一个库连接，而Execute方法一般用于执行一条SQL语句。

_ConnectionPtr智能指针的用法：首先定义一个Connection类型的指针，然后调用CreateInstance()来创建一个连接对象的实例，再调用Open函数建立与数据源的连接。

在建立连接对象后，可以使用连接对象的Execute()函数来执行SQL命令。

_ConnectionPtr智能指针Open方法的原型：Open(_bstr_t ConnectionString,_bstr_t UserID,_bstr_tPassword,long Options)ConnectionString为连接字串，UserID是用户名，Password是登陆密码Options是连接选项，可以是如下几个常量：adModeUnknown 缺省，当前的许可权未设置adModeRead 只读adModeWrite 只写adModeReadWrite 可以读写adModeShareDenyRead 阻止其它Connection对象以读权限打开连接adModeShareDenyWrite 阻止其它Connection对象以写权限打开连接adModeShareExclusive 阻止其它Connection对象打开连接adModeShareDenyNone 阻止其它程序或对象以任何权限建立连接_ConnectionPtr智能指针Execute方法的原型：_RecordsetPtr Connection15::Execute(_bstr_t CommandText,VARIANT* RecordsAffected,long Options)其中CommandText是命令字串，通常是SQL命令，参数RecordsAffected是操作完成后所影响的行数参数Options表示CommandText中内容的类型，可以取下列值之一：adCmdText 表明CommandText是文本命令adCmdTable 表明CommandText是一个表名adCmdProc 表明CommandText是一个存储过程adCmdUnknown 未知Execute执行完后返回一个指向记录集的指针。

_RecordsetPtr使用方详解

_RecordsetPtr使用方法variant_t vUsername,vID,vname; //变量声明_RecordsetPtr m_pRecordset; //记录集CString strid;_ConnectionPtr connection;m_pRecordset.CreateInstance(__uuidof( Recordset )); //创建实例m_pRecordset->Open("SELECT * FROM users",connection.GetInterfacePtr(),adOpenStatic,adLockOptimistic,adCmdText);//执行SQL语句，得到记录集, connection必须已和数据库连接/*************原型*****************/Open方法的原型是这样的:HRESULT Recordset15::Open ( const _variant_t & Source, const _variant_t & ActiveConnection,enum CursorTypeEnum CursorType, enum LockTypeEnum LockType, long Options )/***********************************//************************************************/①Source是数据查询字符串②ActiveConnection是已经建立好的连接（我们需要用Connection对象指针来构造一个_variant_t对象)③CursorType光标类型，它可以是以下值之一,请看这个枚举结构:enum CursorTypeEnum{adOpenUnspecified = -1,///不作特别指定adOpenForwardOnly = 0,///前滚静态光标。

ADO三个基本接口

_ConnectionPtr接口、_CommandPtr接口和_RecordsetPtr接口ADO库包含三个基本接口：_ConnectionPtr接口、_CommandPtr接口和_RecordsetPtr接口Connection、Recordset和Command，分别表示连接对象、记录集对象和命令对象。

三个对象对应的智能指针分别是：_ConnectionPtr、_RecordsetPtr、_CommandPtr。

ADO使用_ConnectionPtr这个指针来操纵Connection对象，类似地，后面用到的_CommandPtr和_RecordsetPtr分别表示命令对象指针和记录集对象指针。

参考：svn中文网_ConnectionPtr接口返回一个记录集或一个空指针。

通常使用它来创建一个数据连接或执行一条不返回任何结果的SQL语句，如一个存储过程。

使用 _ConnectionPtr接口返回一个记录集不是一个好的使用方法。

对于要返回记录的操作通常用_RecordserPtr来实现。

而用 _ConnectionPtr操作时要想得到记录条数得遍历所有记录，而用_RecordserPtr时不需要。

_CommandPtr接口返回一个记录集。

它提供了一种简单的方法来执行返回记录集的存储过程和SQL语句。

在使用_CommandPtr接口时，你可以利用全局 _ConnectionPtr接口，也可以在_CommandPtr接口里直接使用连接串。

如果你只执行一次或几次数据访问操作，后者是比较好的选择。

但如果你要频繁访问数据库，并要返回很多记录集，那么，你应该使用全局_ConnectionPtr接口创建一个数据连接，然后使用_CommandPtr 接口执行存储过程和SQL语句。

_RecordsetPtr是一个记录集对象。

与以上两种对象相比，它对记录集提供了更多的控制功能，如记录锁定，游标控制等。

同_CommandPtr接口一样，它不一定要使用一个已经创建的数据连接，可以用一个连接串代替连接指针赋给 _RecordsetPtr的connection成员变量，让它自己创建数据连接。

sharedptr作为函数参数

sharedptr作为函数参数（实用版）目录1.智能指针的概念与作用2.sharedptr 的定义与实现3.sharedptr 作为函数参数的优点4.sharedptr 作为函数参数的注意事项5.示例代码及解析正文一、智能指针的概念与作用在 C++中，智能指针是一种自动管理内存的指针，它能够自动地分配和释放内存，避免了内存泄漏和悬挂指针的问题。

智能指针主要用于解决动态内存分配和释放的管理问题，提高了程序的稳定性和安全性。

二、sharedptr 的定义与实现sharedptr 是 C++11 标准库中引入的一种智能指针，它通过引用计数来管理内存。

当一个对象被多个 sharedptr 引用时，它们的引用计数会相应地增加和减少。

当引用计数为零时，sharedptr 会自动释放该对象的内存。

sharedptr 的定义如下：```cpptemplate <class T>class sharedptr {public:sharedptr(T* ptr) : ptr_(ptr) {}sharedptr(sharedptr<T> const& other) : ptr_(other.ptr_) {}// 其他成员函数private:T* ptr_;std::atomic_count<1> count_;};```三、sharedptr 作为函数参数的优点sharedptr 作为函数参数具有以下优点：1.避免了内存泄漏：由于 sharedptr 能够自动管理内存，因此当函数返回时，不再需要手动释放动态分配的内存。

2.提高了代码的可读性和可维护性：使用 sharedptr 作为函数参数，可以使代码更加简洁明了，易于理解。

3.支持传值和引用：sharedptr 作为函数参数时，既可以传递值（拷贝构造），也可以传递引用（赋值操作符重载）。

四、sharedptr 作为函数参数的注意事项虽然 sharedptr 作为函数参数具有很多优点，但在使用过程中还需要注意以下几点：1.不要在多个地方创建对同一个对象的 sharedptr 引用，这会导致内存泄漏。

智能指针的实现原理

智能指针的实现原理智能指针是C++语言中的一个重要的概念，是一种用于自动管理内存的技术。

它的实现原理基于C++的RAII（Resource Acquisition Is Initialization）机制，即资源获取即初始化的理念。

智能指针可以帮助我们防止内存泄漏和空指针错误，提高程序的安全性和稳定性。

智能指针的实现主要包括两个关键点：引用计数和所有权转移。

引用计数指的是智能指针中存储了一个计数器，用来记录有多少个智能指针共享同一块堆内存。

每当有一个新的智能指针指向该内存时，计数器就会加一。

每当一个智能指针被销毁时，计数器就会减一。

当计数器变为零时，就说明没有任何智能指针指向该内存，此时就可以将该内存释放回操作系统。

所有权转移指的是智能指针可以通过移动构造函数和移动赋值运算符实现所有权的传递。

所有权是指在同一时间内，只有一个智能指针拥有对某个内存块的操作权限。

当一个智能指针转移所有权时，它将负责内存的释放和管理。

这种机制使得智能指针能够实现资源的高效管理，同时保证内存的安全使用。

当我们使用智能指针时，可以选择使用标准库中提供的shared_ptr和unique_ptr。

shared_ptr使用引用计数来管理内存，可以实现多个智能指针共享同一块内存，并且能够自动释放内存。

unique_ptr则只能拥有独占的所有权，不能共享内存，但由于不需要实时的引用计数处理，因此更加轻量级，也更加高效。

总之，智能指针的实现原理是基于C++的RAII机制和引用计数、所有权转移机制。

它可以有效地防止内存泄漏和空指针错误，提高程序的安全性和稳定性。

我们在编写代码时，应该养成使用智能指针的好习惯，从而使我们的程序更加高效、可靠。

关于智能指针类型shared_ptr的计数问题

关于智能指针类型shared_ptr的计数问题⼀、关键每个shared_ptr所指向的对象都有⼀个引⽤计数，它记录了有多少个shared_ptr指向⾃⼰shared_ptr的析构函数：递减它所指向的对象的引⽤计数，如果引⽤计数变为0，就会销毁对象并释放相应的内存引⽤计数的变化：决定权在shared_ptr，⽽与对象本⾝⽆关⼆、引⽤计数初步shared_ptr<int> sp; //空智能指针shared_ptr<int> sp2 = make_shared<int>(3);shared_ptr<int> sp3(sp2);cout << e_count() << endl; //输出0cout << e_count() << endl; //输出2注：e_count()函数返回sp所指对象的引⽤计数三、引⽤计数增加的情况拷贝⼀个shared_ptr，其所指对象的引⽤计数会递增，如：⽤⼀个shared_ptr初始化另⼀个shared_ptr⽤⼀个shared_ptr给另⼀个shared_ptr赋值将shared_ptr作为参数传递给⼀个函数shared_ptr作为函数的返回值四、引⽤计数减少的情况给shared_ptr赋予⼀个新值shared_ptr被销毁（如离开作⽤域）五、迷途返航1. 局部的shared_ptr离开其作⽤域，它所指对象的引⽤计数会递减(-1)假设：没有全局的shared_ptr，那么正确的结果应该是该shared_ptr所指的对象被销毁我之前错误的想法：多个局部shared_ptr共同指向同⼀个对象，那么该对象的引⽤计数就>1，该函数结束时对象的引⽤计数减1（但仍>0），那么该对象不应该被销毁。

纠正想法：既然是多个局部shared_ptr指向该对象，那么函数结束时对象的引⽤计数就不应该只减1啊！！shared_ptr<int> init(){shared_ptr<int> sp2 = make_shared<int>(3);shared_ptr<int> sp3(sp2);cout << e_count() << endl; //输出2return sp2; //返回sp2，故引⽤计数递增，变为3} //sp2和sp3离开作⽤域，引⽤计数减2，变为1int main(){auto p = init(); //此处赋值的拷贝与return处的拷贝是⼀致的cout << e_count() << endl; //输出1return 0;}由代码证实，函数结束时，引⽤计数减2，⽽⾮减1！。

VTKvtkSmartPointer智能指针详解

VTKvtkSmartPointer智能指针详解智能指针则⽤来解决这个问题。

使⽤智能指针，⽤户不必考虑何时进⾏内存释放，⽽是由智能指针进⾏控制。

智能指针 VTK中的智能指针类为vtkSmartPointer，是⼀个模板类，继承⾃vtkSmartPointerSmart类。

vtkSmartPointer类中定义⼀个vtkObjectBase类型的指针对象Object，⽤于存储智能指针中实际⽣成的对象。

vtkSmartPointer<vtkLight> light1 = vtkSmartPointer<vtkLight>::New(); vtkSmartPointer中定义了静态函数New()来⽣成⼀个智能指针对象。

该函数根据模板参数类型来⽣成⼀个对象，并将其保存在基类vtkSmartPoitnerBase的成员变量Object中。

vtkSmartPointer重载了‘->’操作符，返回实际的模板类型的的对象，因此可以⽅便的访问对象的成员函数。

如light->SetColor()vtkSmartPointer<vtkLight> light1 = vtkSmartPointer<vtkLight>::New();vtkSmartPointer<vtkLight> light2 = light1 ; vtkSmartPointer重载了赋值操作符，可以在vtkSmartPointer对象之间进⾏赋值。

在赋值过程中，vtkSmartPointer会⾃动控制其内部对象指针Object的引⽤计数加1；上⾯代码中， light1和light2的引⽤计数最终都等于2。

⾸先light1的vtkLight对象Object调⽤Register()⾃动将引⽤计数加1；然后将light2的object指向light1的Object对象。

vtkLight* light3 = vtkLight::New();vtkSmartPointer<vtkLight> light4 = light3;可以将⼀个对象指针赋值给⼀个智能指针。

_recordsetptr duplicate values -回复

_recordsetptr duplicate values -回复Recordsetptr是一个特定的数据类型，可以在编程中使用。

它是一个指向记录集对象的指针。

在本文中，我们将探讨duplicate values（重复值），以及如何在recordsetptr中处理它们。

第1步：介绍recordsetptr和duplicate values在编程中，recordsetptr是一个常用的数据类型，用于处理和操作数据库中的数据。

它允许我们访问和操作记录集中的数据。

而duplicate values 是指在数据集中存在重复的值。

这可以导致数据的冗余，影响查询和数据处理的效率。

第2步：解释recordsetptr中如何出现duplicate valuesduplicate values可以出现在recordsetptr中的两个主要原因是数据输入错误或者数据被多次插入到数据库中。

这种情况可能会导致数据不一致性和重复性，需要我们进行处理和清理。

第3步：讨论不同的处理duplicate values的方法有多种方法可以处理recordsetptr中的duplicate values。

以下是一些常见的方法：1. 使用SQL语句去重可以使用SQL语句，例如"SELECT DISTINCT"或者"GROUP BY"来检索不重复的数据。

这些语句可以去除重复的值，返回一个没有重复值的记录集。

我们可以通过执行这些语句将结果存储到一个新的recordsetptr中，即为处理后的数据集。

2. 编写自定义代码去重也可以通过编写自定义的代码来处理duplicate values。

我们可以使用循环和条件语句遍历整个recordsetptr，检查每一个值是否已经存在于另一个数据结构中。

如果某个值已经存在，我们可以选择删除或者跳过这个值。

这样我们就可以得到一份没有duplicate values的新的recordsetptr。

shared_ptr reset函数

shared_ptr reset函数
shared_ptrreset函数是一种在C++中用于重置智能指针的方法。

这个函数有两种重载形式：一种是没有参数的形式，另一种是带有一个参数的形式。

在没有参数的形式中，reset函数将当前智能指针置为空指针。

这意味着它不再拥有任何资源。

使用该函数将释放当前智能指针持有的任何资源，并将其设为一个空指针，以防止悬挂指针或内存泄漏。

在带有一个参数的形式中，reset函数将当前智能指针重置为指向给定的对象。

这意味着它将放弃其原来的资源，并获得一个新的资源。

使用该函数可以实现智能指针对象的复用，从而提高内存利用率。

需要注意的是，在使用reset函数时，需要注意避免出现多个智能指针同时引用同一个资源的情况，以免出现竞争条件。

因此，在使用reset函数时，应该谨慎考虑其用法，以确保程序的正确性和安全性。

- 1 -。

智能指针shared_ptr用法

智能指针shared_ptr用法1. 嘿，你知道吗？智能指针 shared_ptr 就像是一个魔法棒！比如说，当我们多个地方都需要使用同一份资源时，就像大家都想玩同一个玩具，shared_ptr 能确保资源不会莫名其妙地消失。

就像你和朋友抢玩具，有了它就不会争抢出问题啦！2. 哇塞，想想看呀，shared_ptr 用法真的超厉害呢！就好比一个团队里的队长，能把大家都组织好，让一切都井井有条。

你看在处理动态分配的内存时，它就能牢牢地掌控局面，不会让内存泄漏之类的麻烦出现。

这不是超棒的吗？3. 嘿呀，智能指针 shared_ptr 啊，可千万别小看它！它就像一个贴心小助手，时刻守护着资源。

比如说有个很复杂的程序里面，很多地方都要用到同一块内存，那 shared_ptr 就能确保大家都能好好使用，不会乱套。

这可不是一般的厉害呀，你难道不想深入了解一下？4. 呀，智能指针 shared_ptr 简直就是编程中的利器呀！它就如同一个高明的指挥家，让资源的使用变得和谐有序。

想想看，当我们在不同的代码块里来回穿梭时，它能保证资源始终都在，不会弄丢。

这能省掉我们多少麻烦呀，是不是很神奇？5. 哇哦，智能指针 shared_ptr 的用法真的很值得研究呢！好比是航行中的指南针，指引着我们正确地使用资源。

在面对复杂的数据结构和多级指针时，它能轻松应对，就像英雄拯救世界一样帅气。

这难道不让你心动吗？6. 嘿！智能指针 shared_ptr 可是个宝贝呢！就像游戏中的超级道具，能帮我们轻松解决难题。

当我们需要共享一些重要的数据时，它就能大显身手，让数据安全又可靠。

你还不赶紧去试试它的强大威力吗？结论：智能指针 shared_ptr 真的太好用啦，对于管理资源有着不可或缺的作用，大家一定要熟练掌握它的用法呀！。

详解C++中shared_ptr的使用教程

详解C++中shared_ptr的使⽤教程shared_ptr是⼀种智能指针（smart pointer）。

shared_ptr的作⽤有如同指针，但会记录有多少个shared_ptrs共同指向⼀个对象。

这便是所谓的引⽤计数（reference counting）。

⼀旦最后⼀个这样的指针被销毁，也就是⼀旦某个对象的引⽤计数变为0，这个对象会被⾃动删除。

这在⾮环形数据结构中防⽌资源泄露很有帮助。

auto_ptr由于它的破坏性复制语义，⽆法满⾜标准容器对元素的要求，因⽽不能放在标准容器中；如果我们希望当容器析构时能⾃动把它容纳的指针元素所指的对象删除时，通常采⽤⼀些间接的⽅式来实现，显得⽐较繁琐。

boost库中提供了⼀种新型的智能指针shared_ptr，它解决了在多个指针间共享对象所有权的问题，同时也满⾜容器对元素的要求，因⽽可以安全地放⼊容器中。

总结下⼏个使⽤shared_ptr需要注意的问题:⼀. 相互引⽤链class C;class B : public std::enable_shared_from_this{public:~B(){ cout << "~B" << endl; }void SetPC(std::shared_ptr<C>& pc){ _pc = pc; }private:std::shared_ptr<C> _pc;};class C : public std::enable_shared_from_this<C>{public:~C(){ cout << "~C" << endl; }void SetPB(std::shared_ptr& pb){ _pb = pb; }private:std::shared_ptr _pb;};int main(){std::shared_ptr<C> pc = std::make_shared<C>();std::shared_ptr pb = std::make_shared();pc->SetPB(pb);pb->SetPC(pc);return 0;}上⾯的代码中，B和C均不能正确析构，正确的做法是，在B和C的释放函数，如Close中，将其包含的shared_ptr置空。

sharedptr作为函数参数

shared_ptr作为函数参数的特定函数1. 定义shared_ptr是C++11标准库中的一个智能指针，用于管理动态分配的内存资源。

它提供了自动的内存管理，能够自动释放资源，避免了手动管理内存的麻烦和容易引发的内存泄漏问题。

shared_ptr采用引用计数的方式来管理内存资源。

每个shared_ptr对象都包含一个指向动态分配内存的指针，以及一个引用计数器。

当一个shared_ptr对象被创建时，引用计数器初始化为1。

每当该对象被拷贝构造或拷贝赋值给另一个shared_ptr对象时，引用计数器加1。

当一个shared_ptr对象被析构时，引用计数器减1。

当引用计数器为0时，表示没有任何对象引用该内存资源，此时shared_ptr会自动释放该内存资源。

2. 用途shared_ptr作为函数参数的特定函数是指将shared_ptr对象作为函数参数传递的函数。

它的主要用途是在函数中对动态分配的内存资源进行操作，并确保资源的正确释放。

使用shared_ptr作为函数参数的特定函数有以下几个常见的用途：2.1 传递动态分配的内存资源当我们需要在函数中对动态分配的内存资源进行操作时，我们可以将shared_ptr 作为函数参数传递给函数。

这样可以确保在函数执行完毕后，动态分配的内存资源会被正确释放，避免了内存泄漏的问题。

2.2 传递资源的所有权shared_ptr可以在多个地方共享同一块内存资源，通过传递shared_ptr对象，可以将资源的所有权从一个地方转移到另一个地方。

这样可以避免资源被重复释放或者忘记释放的问题。

2.3 传递资源的状态shared_ptr对象不仅包含指向动态分配内存的指针，还包含了一个引用计数器。

通过传递shared_ptr对象，可以传递资源的状态信息，比如引用计数器的值，从而可以在函数中判断资源是否被其他地方引用。

2.4 传递资源的共享权限shared_ptr对象可以通过控制块（control block）来共享对同一块内存资源的访问权限。

sharedptr的用法

sharedptr的用法shared_ptr是C++11中的一个智能指针类，用于管理动态分配的内存。

它可以自动释放指向同一对象的所有shared_ptr实例，并且在对象不再需要时自动释放内存。

使用shared_ptr需要包含<memory>头文件。

下面是shared_ptr的基本用法：1. 创建一个shared_ptr实例```c++std::shared_ptr<int> sp(new int(10));```上面的代码创建了一个int类型的智能指针sp，它指向一个值为10的整数。

2. 使用智能指针访问对象```c++int value = *sp;```可以通过*运算符来访问智能指针所指向的对象。

3. 重置智能指针```c++sp.reset(new int(20));```可以通过reset()函数来重置智能指针所指向的对象。

上面的代码将sp 重新设置为一个值为20的整数。

4. 获取智能指针引用计数```c++int count = e_count();```可以通过use_count()函数获取当前共享该对象的所有智能指针实例数量。

上面的代码将count设置为当前共享该对象的所有智能指针实例数量。

5. 将普通指针转换为智能指针```c++std::unique_ptr<int> uptr(new int(30));std::shared_ptr<int> sptr = std::move(uptr);```可以使用std::move()函数将一个unique_ptr实例转换为shared_ptr 实例。

上面的代码将uptr所指向的对象转换为一个shared_ptr实例。

6. 使用自定义删除器```c++void my_deleter(int* p) {delete[] p;}std::shared_ptr<int> sp(new int[10], my_deleter);```可以使用自定义删除器来管理动态分配的内存。

qsharedpointer和deletelatter

qsharedpointer和deletelatter【实用版】目录1.智能指针的概念2.智能指针的优点3.std::shared_ptr 和 std::delete_later 的介绍4.std::shared_ptr 和 std::delete_later 的使用方法5.std::shared_ptr 和 std::delete_later 的比较正文智能指针是 C++11 中引入的一种新型指针，它能够自动管理动态内存，有效地避免了内存泄漏和野指针的问题。

智能指针的优点在于，它们可以在适当的时候自动地删除所指向的对象，这样就不需要程序员手动地进行内存管理。

在智能指针中，std::shared_ptr 和 std::delete_later 是两种常用的智能指针。

std::shared_ptr 是一种引用计数的智能指针，它通过计数对象的引用数量来决定对象的生存时间。

当最后一个引用被销毁时，std::shared_ptr 会自动地删除所指向的对象。

而 std::delete_later 则是一种特殊的智能指针，它主要用于在栈上分配的对象。

当对象被销毁时，std::delete_later 会自动地将其从栈上移动到堆上，以便进行垃圾回收。

在使用 std::shared_ptr 和 std::delete_later 时，需要遵循一定的使用方法。

对于 std::shared_ptr，我们需要在类中实现析构函数，并在析构函数中删除所指向的对象。

对于 std::delete_later，我们需要在类中实现一个虚函数，并在该函数中删除所指向的对象。

尽管 std::shared_ptr 和 std::delete_later 都是智能指针，但它们有着本质的不同。

std::shared_ptr 是一种引用计数的智能指针，它需要对所指向的对象进行初始化和销毁。

而 std::delete_later 则是一种特殊的智能指针，它主要用于在栈上分配的对象，并且不需要对所指向的对象进行初始化和销毁。

智能指针（shared_ptr,unique_ptr）作为函数参数或者返回值时的一些注意事项

智能指针（shared_ptr,unique_ptr）作为函数参数或者返回值时的⼀些注意事项智能指针(shared_ptr,unique_ptr)作为函数参数或者返回值时的⼀些注意事项当智能指针作为函数的参数或者返回值时，⼀直在纠结到底是⽤智能指针对象本⾝还是⽤原始指针。

Herb Sutter⼤师的⽂章很好的解决了这个疑惑，参见⽹址：总结起来如下1、不要传递shared_ptr本⾝，⽽是⽤原始指针。

因为会有性能损失，原⼦操作的⾃增⾃减等。

使⽤f(widget *w)不使⽤f(shared_ptr< widget > w)函数的返回值也是同样的道理。

2当表⽰所有权的转移时，⽤unique_ptr作为函数参数。

Guideline: Don’t pass a smart pointer as a function parameter unless you want to use or manipulate the smart pointer itself, such as to share or transfer ownership.Guideline: Prefer passing objects by value, *, or &, not by smart pointer.Guideline: Express a “sink” function using a by-value unique_ptr parameter.Guideline: Use a non-const unique_ptr& parameter only to modify the unique_ptr.Guideline: Don’t use a const unique_ptr& as a parameter; use widget* instead.Guideline: Express that a function will store and share ownership of a heap object using a by-value shared_ptr parameter.Guideline: Use a non-const shared_ptr& parameter only to modify the shared_ptr. Use a const shared_ptr& as a parameter only if you’re not sure whether or not you’ll take a copy and share ownership; otherwise use widget* instead (or if not nullable, a widget&).。

智能指针shared_ptr的用法

智能指针shared_ptr的⽤法为了解决C++内存泄漏的问题，C++11引⼊了智能指针（Smart Pointer）。

智能指针的原理是，接受⼀个申请好的内存地址，构造⼀个保存在栈上的智能指针对象，当程序退出栈的作⽤域范围后，由于栈上的变量⾃动被销毁，智能指针内部保存的内存也就被释放掉了（除⾮将智能指针保存起来）。

C++11提供了三种智能指针：std::shared_ptr, std::unique_ptr, std::weak_ptr，使⽤时需添加头⽂件<memory>。

shared_ptr使⽤引⽤计数，每⼀个shared_ptr的拷贝都指向相同的内存。

每使⽤他⼀次，内部的引⽤计数加1，每析构⼀次，内部的引⽤计数减1，减为0时，删除所指向的堆内存。

shared_ptr内部的引⽤计数是安全的，但是对象的读取需要加锁。

1. shared_ptr的基本⽤法初始化可以通过构造函数、std::make_shared<T>辅助函数和reset⽅法来初始化shared_ptr：#include "stdafx.h"#include <iostream>#include <future>#include <thread>using namespace std;class Person{public:Person(int v) {value = v;std::cout << "Cons" <<value<< std::endl;}~Person() {std::cout << "Des" <<value<< std::endl;}int value;};int main(){std::shared_ptr<Person> p1(new Person(1));// Person(1)的引⽤计数为1std::shared_ptr<Person> p2 = std::make_shared<Person>(2);p1.reset(new Person(3));// ⾸先⽣成新对象，然后引⽤计数减1，引⽤计数为0，故析构Person(1)// 最后将新对象的指针交给智能指针std::shared_ptr<Person> p3 = p1;//现在p1和p3同时指向Person(3)，Person(3)的引⽤计数为2p1.reset();//Person(3)的引⽤计数为1p3.reset();//Person(3)的引⽤计数为0，析构Person(3)return0;} 注意，不能将⼀个原始指针直接赋值给⼀个智能指针，如下所⽰，原因是⼀个是类，⼀个是指针。

C++11unique_ptr智能指针详解

C++11unique_ptr智能指针详解在《》的基础上，本节继续讲解 C++11 标准提供的另⼀种智能指针，即 unique_ptr 智能指针。

作为智能指针的⼀种，unique_ptr 指针⾃然也具备“在适当时机⾃动释放堆内存空间”的能⼒。

和 shared_ptr 指针最⼤的不同之处在于，unique_ptr 指针指向的堆内存⽆法同其它 unique_ptr 共享，也就是说，每个 unique_ptr 指针都独⾃拥有对其所指堆内存空间的所有权。

这也就意味着，每个 unique_ptr 指针指向的堆内存空间的引⽤计数，都只能为 1，⼀旦该 unique_ptr 指针放弃对所指堆内存空间的所有权，则该空间会被⽴即释放回收。

unique_ptr 智能指针是以模板类的形式提供的，unique_ptr<T>（T 为指针所指数据的类型）定义在<memory>头⽂件，并位于 std 命名空间中。

因此，要想使⽤ unique_ptr 类型指针，程序中应⾸先包含如下 2 条语句：1. #include <memory>2. using namespace std;第 2 句并不是必须的，可以不添加，则后续在使⽤ unique_ptr 指针时，必须标注std::。

unique_ptr智能指针的创建考虑到不同实际场景的需要，unique_ptr<T> 模板类提供了多个实⽤的构造函数，这⾥给读者列举了⼏种常⽤的构造 unique_ptr 智能指针的⽅式。

1) 通过以下 2 种⽅式，可以创建出空的 unique_ptr 指针：1. std::unique_ptr<int> p1();2. std::unique_ptr<int> p2(nullptr);2) 创建 unique_ptr 指针的同时，也可以明确其指向。

例如：1. std::unique_ptr<int> p3(new int);由此就创建出了⼀个 p3 智能指针，其指向的是可容纳 1 个整数的堆存储空间。