下载文档原格式
智能指针std ：：unique_ptrstd::unique_ptr1.特性1） 任意时刻unique_ptr 只能指向某⼀个对象，指针销毁时，指向的对象也会被删除（通过内置删除器，通过调⽤析构函数实现删除对象）2）禁⽌拷贝和赋值（底层实现拷贝构造函数和复制构造函数 = delete ），可以使⽤std::move()、unique_ptr.reset(...) 转移对象指针控制权。
（由1决定，指针发⽣了拷贝就违反了第⼀条）2.怎么实现禁⽌拷贝构造和赋值构造？拷贝构造 和 赋值符‘=’ 对应函数 被删除了，所以⽤不了。
（看下⾯的构造函数表）可以在IDE/编辑器中查看详细实现：(下⾯是 GNU g++的实现)我们可以看到，拷贝和赋值函数被禁⽌实现（禁⽤）了。
更加详细的内容参阅cppreference：① 构造②3. 使⽤default (1)constexpr unique_ptr() noexcept;from null pointer (2)constexpr unique_ptr (nullptr_t) noexcept : unique_ptr() {}from pointer (3)explicit unique_ptr (pointer p) noexcept;from pointer + lvalue deleter (4)unique_ptr (pointer p,typename conditional<is_reference<D>::value,D,const D&> del) noexcept;from pointer + rvalue deleter (5)unique_ptr (pointer p,typename remove_reference<D>::type&& del) noexcept;move (6)unique_ptr (unique_ptr&& x) noexcept;move-cast (7)template <class U, class E>unique_ptr (unique_ptr<U,E>&& x) noexcept;move from auto_ptr (8)template <class U>unique_ptr (auto_ptr<U>&& x) noexcept;拷贝构造拷贝构造copy (deleted!) (9)unique_ptr (const unique_ptr&)= delete;复制作业（删除！）（4）unique_ptr ＆operator =（const unique_ptr ＆）= delete;1 #include <iostream>2 #include <memory>3 using namespace std;45 // unique_ptr::get vs unique_ptr::release6 int main()7 {8 std::unique_ptr<int > foo; //foo - null9 std::unique_ptr<int > bar; //bar - null10 int * p = nullptr;11 foo = std::unique_ptr<int >(new int (100));// foo - 10012 bar = std::move(foo); // foo 转移给bar bar - 100 foo - null13 p = bar.get (); // p - 100 smart pointer.get （）返回⼀个指向该对象的内置指针14 foo.reset(bar.release()); // bar 放弃指针控制权，返回指针给foo foo - 100, bar 已经不存在1516 cout << "foo : " << *foo << endl;17 cout << "p : " << *p << endl;18delete p; //记得删除，这也是使⽤智能指针的初衷之⼀---防⽌内存泄漏1920if (bar)21 cout << "bar : " << *bar << endl;22else23 cout << "bar已经被释放" << endl; //这⾥bar已经销毁了，可能会报错。
智能指针weakptr原理
智能指针是C++中用于管理动态内存的一种工具，它可以帮助
程序员避免内存泄漏和悬空指针等问题。
智能指针中的weak_ptr是
一种特殊的智能指针，它用于解决shared_ptr的循环引用问题。
weak_ptr是一种弱引用，它允许你观察shared_ptr指向的对象，但并不拥有对象的所有权。
当最后一个shared_ptr指向的对象
被销毁时，即使还有weak_ptr指向该对象，weak_ptr也会自动失效，避免悬空指针的问题。
weak_ptr的实现原理涉及到引用计数。
当我们使用shared_ptr 时，每个指向对象的shared_ptr都会维护一个引用计数，记录有多
少个shared_ptr指向该对象。
而weak_ptr则不会增加引用计数，
它只是观察shared_ptr的引用计数。
当对象的引用计数变为0时，
对象会被销毁，这时所有指向该对象的weak_ptr都会自动失效。
另外，为了确保在使用weak_ptr时不会访问已经被销毁的对象，我们可以通过调用weak_ptr的lock()方法来获得一个指向对象的shared_ptr，如果对象还存在的话。
通过这种方式，我们可以安全
地访问对象，而不用担心对象已经被销毁。
总的来说，weak_ptr通过观察shared_ptr的引用计数，避免循环引用导致的内存泄漏问题，同时提供了一种安全的方式来访问被shared_ptr管理的对象。
这种设计在C++中的动态内存管理中起到了非常重要的作用。
智能指针内部实现原理智能指针是一种能够在运行时自动管理动态分配的内存的指针。
它们可以跟踪资源的所有者，并确保在不再需要资源时正确释放它。
智能指针的内部实现原理主要有两个方面：资源管理和所有权转移。
一、资源管理：在使用智能指针时，需要确保动态分配的内存被正确释放，以避免内存泄漏。
为了实现这一点，智能指针通常会使用引用计数来跟踪资源的所有者数量。
每当一个智能指针指向一个资源时，它的引用计数就会增加；当这个智能指针不再指向资源时，引用计数就会减少。
当引用计数为零时，表示该资源没有任何所有者，可以安全地释放。
智能指针还可以通过重载析构函数来实现自动释放资源的功能。
在析构函数中，智能指针可以调用delete或delete[]来释放动态分配的内存。
这样，在智能指针超出作用域时，析构函数会自动被调用，从而实现自动释放资源的效果。
二、所有权转移：智能指针可以通过所有权转移来确保资源的唯一性。
当一个智能指针拥有资源的所有权时，其他智能指针无法访问该资源。
只有在所有权转移时，其他智能指针才能访问该资源。
为了实现所有权转移，智能指针通常会禁止拷贝构造函数和赋值运算符，只允许移动构造函数和移动赋值运算符。
这样，当一个智能指针被赋值给另一个智能指针时，所有权会从一个指针转移到另一个指针。
移动构造函数和移动赋值运算符会将资源的所有权从一个智能指针转移到另一个智能指针，并将源指针的引用计数置为零。
这样可以确保资源只有一个所有者，并且不会被错误地释放多次。
除了引用计数和所有权转移，智能指针的实现还需要考虑线程安全性。
由于智能指针的使用很容易涉及多线程操作，为了保证线程安全，需要使用原子操作来对引用计数进行增加和减少，以避免竞争条件。
综上所述，智能指针的内部实现原理包括资源管理（引用计数和析构函数）和所有权转移（禁止拷贝构造函数和赋值运算符，使用移动构造函数和移动赋值运算符）。
此外，为了保证线程安全性，还需要使用原子操作来对引用计数进行管理。
智能指针的应用原理1. 什么是智能指针智能指针是C++中的一个特性，用于管理动态分配的内存。
与原始指针（raw pointer）不同的是，智能指针有能力自动管理所指的内存，避免内存泄漏和野指针的问题。
智能指针通过在析构函数中释放所引用的内存来确保资源的正确释放，从而减少错误和内存泄露的风险。
2. 智能指针的优点•自动释放内存：智能指针可以自动释放所管理的内存，避免了手动释放内存的繁琐工作，并减少了内存泄漏的风险。
•简化内存管理：智能指针可以方便地共享和传递资源所有权，减少了手动处理内存所有权的复杂性。
•防止野指针：智能指针会在指针不再需要时自动将其置为nullptr，避免了野指针的问题。
•可定制性：C++提供了多个智能指针类型，如unique_ptr、shared_ptr和weak_ptr，每种智能指针类型都有自己的适用场景，开发人员可以根据需要选择使用不同类型的智能指针。
3. 智能指针的应用场景智能指针在以下情况下特别有用：1.动态内存分配：当需要动态分配内存时，使用智能指针可以方便地管理所分配的内存，避免内存泄漏和野指针的问题。
2.资源管理：智能指针可以用于管理其他类型的资源，如文件句柄、数据库连接等，通过在析构函数中释放资源，确保资源的正确释放。
3.避免循环引用：shared_ptr和weak_ptr可以用于解决循环引用的问题。
当存在互相引用的对象时，如果使用普通指针，则这些对象无法被正确释放，而使用shared_ptr和weak_ptr可以解决这个问题。
4. 智能指针的工作原理智能指针通过维护一个引用计数（reference count）来管理内存。
引用计数表示有多少个指针共享同一块内存。
•unique_ptr使用独占的方式管理内存，即同一时间只能有一个指针指向该内存。
•shared_ptr可以共享内存，通过维护一个引用计数，当引用计数为0时，释放内存。
•weak_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++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 个整数的堆存储空间。
智能指针是C++语言中一种非常重要的数据类型，它可以帮助程序员管理动态内存分配，并且能够自动释放内存，有效避免内存泄漏的问题。
在实际的编程工作中，有时我们会需要将智能指针变量存储到数组中，以便于对多个指针进行统一管理和操作。
本文将介绍如何将智能指针变量存储到数组中的方法。
1. 使用std::vectorstd::vector是C++标准库中的一个容器类模板，它可以存储各种类型的数据，并且能够动态调整大小。
我们可以利用std::vector来存储智能指针变量，实现对多个指针的统一管理。
我们需要包含< vector>头文件：```cpp#include <vector>```我们定义一个std::vector对象，存储智能指针变量：```cppstd::vector<std::shared_ptr<int>> ptrArray;```在这个例子中，我们使用了std::shared_ptr作为智能指针的类型，存储了int类型的数据。
当然，你也可以选择其他类型的智能指针，如std::unique_ptr或者std::weak_ptr，根据实际情况来选择。
接下来，我们可以向ptrArray中添加智能指针变量：```cppptrArray.push_back(std::make_shared<int>(10));ptrArray.push_back(std::make_shared<int>(20));```通过调用push_back方法，我们可以将智能指针变量添加到ptrArray 中。
这样，我们就实现了将多个智能指针变量存储到数组中的目的。
2. 使用普通指针数组除了使用std::vector外，我们还可以使用普通指针数组来存储智能指针变量。
在实际编程中，这种方法可能会更加高效。
我们定义一个指针数组：```cppstd::shared_ptr<int>* ptrArray = new std::shared_ptr<int>[10]; ```在这个例子中，我们定义了一个含有10个std::shared_ptr<int>类型的指针数组。
智能指针swap用法智能指针是现代C++编程中不可或缺的一个工具。
在C++11中引入的智能指针，尤其是std::unique_ptr和std::shared_ptr，为我们处理动态内存分配提供了更加安全和方便的方式。
在使用智能指针时，我们有时需要将指针对象的所有权转移给另一个对象。
这时我们可以使用swap函数。
本文将介绍智能指针swap 用法，并为读者提供一些实际应用场景。
一、swap函数概述swap函数是C++ STL库中的一个重要函数，它用于交换两个对象的值。
使用swap函数可以避免对象复制带来的额外开销。
STL中的标准容器和迭代器都提供了swap函数的实现。
当我们使用智能指针时，swap函数可以将两个智能指针所指对象的所有权交换。
这意味着，swap函数可以将一个智能指针指向的对象的所有权转移给另一个智能指针对象。
二、智能指针swap用法std::unique_ptr和std::shared_ptr都提供了swap函数。
具体用法如下：// std::unique_ptr swapstd::unique_ptr<int> ptr1(new int(10));std::unique_ptr<int> ptr2(new int(20));ptr1.swap(ptr2);// std::shared_ptr swapstd::shared_ptr<int> ptr3(new int(30));std::shared_ptr<int> ptr4(new int(40));ptr3.swap(ptr4);在上述代码中，ptr1和ptr2是两个std::unique_ptr对象，它们所指向的对象的所有权可以通过swap函数互相传递。
ptr3和ptr4是两个std::shared_ptr对象，它们所指向的对象同样可以通过swap函数进行所有权交换。
值得注意的是，智能指针swap函数并不进行内存复制或移动。
shared pointer用法（原创版）目录1.智能指针的概念2.共享指针的定义和特点3.共享指针的初始化和销毁4.共享指针的优缺点5.共享指针的实际应用正文一、智能指针的概念在 C++中，智能指针是一种能够自动管理内存的指针，它能够在指针所指向的对象被销毁时自动释放内存。
智能指针的出现，大大降低了内存泄漏的风险，提高了程序的稳定性。
二、共享指针的定义和特点共享指针，又称为 shared pointer，是一种特殊的智能指针，它的主要特点是可以共享对象。
当一个对象被多个共享指针指向时，只有当所有共享指针都被销毁，该对象才会被销毁。
共享指针的定义如下：```cpp#include <shared_ptr>using namespace std;shared_ptr<class> pointer;```三、共享指针的初始化和销毁1.初始化：可以使用构造函数或赋值操作符初始化共享指针。
```cppshared_ptr<class> pointer(new class()); // 使用构造函数初始化shared_ptr<class> pointer2(pointer); // 使用赋值操作符初始化```2.销毁：当共享指针被销毁时，它所指向的对象也会被销毁。
销毁共享指针的方法是使用析构函数。
```cpppointer.~shared_ptr(); // 销毁共享指针```四、共享指针的优缺点1.优点：共享指针可以有效地避免内存泄漏，提高程序的稳定性。
同时，它也提供了灵活的接口，方便程序员使用。
2.缺点：共享指针在使用过程中，可能会出现悬挂指针的问题。
当一个共享指针被销毁，但仍有其他共享指针指向该对象时，就会出现悬挂指针。
这种情况下，该对象的内存无法被释放，会导致内存泄漏。
五、共享指针的实际应用共享指针在实际编程中被广泛应用，特别是在大型项目中。
它不仅可以避免内存泄漏，还可以提高程序的运行效率。
智能指针get函数智能指针是一种可以自动管理内存的指针，它可以自动释放内存，避免了手动管理内存带来的许多问题。
其中，get函数是智能指针中一个非常重要的函数，它用于获取指向所管理对象的原始指针。
本文将详细介绍智能指针中的get函数。
一、什么是智能指针在C++中，我们通常使用new关键字来申请堆上的内存空间，并通过返回一个指向该空间的指针来使用该空间。
但是，在使用完这个空间后我们也需要手动释放这个空间，否则就会出现内存泄漏等问题。
而智能指针则可以自动管理这些问题。
智能指针是一种模板类，它将一个原始指针封装在一个对象中，并提供了一些成员函数来自动管理这个原始指针。
智能指针最常见的两种实现方式是shared_ptr和unique_ptr。
二、shared_ptr和unique_ptrshared_ptr和unique_ptr都实现了RAII（资源获取即初始化）技术，即在构造函数中获取资源，在析构函数中释放资源。
二者之间最大的区别在于所有权。
1. shared_ptrshared_ptr是共享所有权的智能指针。
多个shared_ptr对象可以同时拥有同一个原始指针，当最后一个shared_ptr对象析构时，它会自动释放所管理的内存空间。
shared_ptr的构造函数和析构函数非常简单，使用起来也非常方便。
例如：```std::shared_ptr<int> p(new int(10)); //创建一个指向int类型的共享指针```2. unique_ptrunique_ptr是独占所有权的智能指针。
每个unique_ptr对象都拥有它所管理的内存空间的唯一所有权，不能被复制或共享。
当unique_ptr对象被销毁时，它会自动释放所管理的内存空间。
unique_ptr也非常简单易用。
例如：```std::unique_ptr<int> p(new int(10)); //创建一个指向int类型的独占指针```三、智能指针中的get函数get函数是智能指针中一个非常重要的函数，它用于获取指向所管理对象的原始指针。
在你的代码中使用Boost智能指针Smart Pointers to boost your code（By peterchen）翻译 masterleeDownload source files - 45.3kb正文智能指针能够使C++的开发简单化，主要是它能够像其它限制性语言（如C#、VB）自动管理内存的释放，而且能够做更多的事情。
1、什么是智能指针智能指针是一种像指针的C++对象，但它能够在对象不使用的时候自己销毁掉。
我们知道在C++中的对象不再使用是很难定义的，因此C++中的资源管理是很复杂的。
各种智能指针能够操作不同的情况。
当然，智能指针能够在任务结束的时候删除对象，除了在程序之外。
许多库都提供了智能指针的操作，但都有自己的优点和缺点。
Boost库是一个高质量的开源的C++模板库，很多人都考虑将其加入下一个C++标准库的版本中。
下面让我们看一个简单的例子：2、首先介绍：boost::scoped_ptr<T>scoped_ptr 是 Boost 提供的一个简单的智能指针，它能够保证在离开作用域后对象被释放。
例子说明：本例子使用了一个帮助我们理解的类： CSample, 在类的构造函数、赋值函数、析构函数中都加入了打印调试语句。
因此在程序执行的每一步都会打印调试信息。
在例子的目录里已经包含了程序中需要的Boost库的部分内容，不需要下载其它内容（查看Boost的安装指南）。
使用普通普通指针的时候，我们必须记住在函数退出的时候要释放在这个函数内创建的对象。
当我们使用例外的时候处理指针是特别烦人的事情（容易忘记销毁它）。
使用scoped_ptr 指针就能够在函数结束的时候自动销毁它，但对于函数外创建的指针就无能为力了。
优点：对于在复杂的函数种，使用scoped_ptr 指针能够帮助我们处理那些容易忘记释放的对象。
也因此在调试模式下如果使用了空指针，就会出现一个断言。
3、引用指针计数器引用指针计数器记录有多少个引用指针指向同一个对象，如果最后一个引用指针被销毁的时候，那么就销毁对象本身。
shared_ptr 就是Boost中普通的引用指针计数器，它表示可以有多个指针指向同一个对象，看下面的例子：void Sample2_Shared(){// (A)创建Csample类的一个实例和一个引用。
boost::shared_ptr<CSample> mySample(new CSample);printf("The Sample now has %i references\n", e_count()); // TheSample now has 1 references// (B)付第二个指针给它。
boost::shared_ptr<CSample> mySample2 = mySample; // 现在是两个引用指针。
printf("The Sample now has %i references\n", e_count());// (C) 设置第一个指针为空。
mySample.reset();printf("The Sample now has %i references\n", e_count()); // 一个引用// 当mySample2离开作用域的时候，对象只有一个引用的时候自动被删除。
}在（A）中在堆栈重创建了CSample类的一个实例，并且分配了一个shared_ptr指针。
对象mySample入下图所示：然后我们分配了第二个指针mySample2，现在有两个指针访问同一个数据。
我们重置第一个指针（将mySample设置为空），程序中仍然有一个Csample实例，mySample2有一个引用指针。
只要当最有一个引用指针mySample2退出了它的作用域之外，Csample这个实例才被销毁。
当然，并不仅限于单个Csample这个实例，或者是两个指针，一个函数，下面是用shared_ptr的实例：用作容器中。
∙用在PIMPL的惯用手法（the pointer-to-implementation idiom ）。
∙RAII（Resource-Acquisition-Is-Initialization）的惯用手法中。
∙执行分割接口。
注意：如果你没有听说过PIMPL (a.k.a. handle/body) 和 RAII，可以找一个好的C++书，在C++中处于重要的内容，一般C++程序员都应该知道（不过我就是第一次看到这个写法）。
智能指针只是一中方便的他们的方法，本文中不讨论他们的内容。
PIMPL：如果必须包容一个可能抛异常的子对象，但仍然不想从你自己的构造函数中抛出异常，考虑使用被叫做Handle Class或Pimpl的方法（“Pimpl”个双关语：pImpl或“pointer to implementation”）4、主要特点boost::shared_ptr 有一些重要的特征必须建立在其它操作之上。
∙shared_ptr<T>作用在一个未知类型上当声明或定义一个shared_ptr<T>，T可能是一个未知的类型。
例如你仅仅在前面声明了class T，但并没有定义class T。
当我们要释放这个指针的时候我们需要知道这个T具体是一个声明类型。
∙shared_ptr<T>作用在任意类型上在这里本质上不需要制定T的类型（如从一个基类继承下来的）∙shared_ptr<T>支持自己定义释放对象的操作如果你的类中自己写了释放方法，也可以使用。
具体参照Boost文档。
∙强制转换如果你定义了一个U*能够强制转换到T*（因为T是U的基类），那么shared_ptr<U>也能够强制转换到shared_ptr<T>。
∙shared_ptr 是线程安全的（这种设计的选择超过它的优点，在多线程情况下是非常必要的）∙已经作为一种惯例，用在很多平台上，被证明和认同的。
5、例子：在容器中使用shared_ptr许多容器类，包括STL，都需要拷贝操作（例如，我们插入一个存在的元素到list,vector,或者container。
）当拷贝操作是非常销毁资源的时候（这些操作时必须的），典型的操作就是使用容器指针。
std::vector<CMyLargeClass *> vec;vec.push_back( new CMyLargeClass("bigString") );将内存管理的任务抛给调用者，我们能够使用shared_ptr来实现。
typedef boost::shared_ptr<CMyLargeClass> CMyLargeClassPtr;std::vector<CMyLargeClassPtr> vec;vec.push_back( CMyLargeClassPtr(new CMyLargeClass("bigString")) );当vector被销毁的时候，这个元素自动被销毁了。
当然，除非有另一个智能指针引用了它，则还本能被销毁。
让我们看Sample3中的使用：void Sample3_Container(){typedef boost::shared_ptr<CSample> CSamplePtr;// (A) create a container of CSample pointers:std::vector<CSamplePtr> vec;// (B) add three elementsvec.push_back(CSamplePtr(new CSample));vec.push_back(CSamplePtr(new CSample));vec.push_back(CSamplePtr(new CSample));// (C) "keep" a pointer to the second:CSamplePtr anElement = vec[1];// (D) destroy the vector:vec.clear();// (E) the second element still existsanElement->Use();printf("done. cleanup is automatic\n");// (F) anElement goes out of scope, deleting the last CSample instance}6、使用Boost中的智能指针，什么是正确的使用方法使用智能指针的一些操作会产生错误（突出的事那些不可用的引用计数器，一些对象太容易释放，或者根本释放不掉）。
Boost增强了这种安全性，处理了所有潜在存在的危险，所以我们要遵循以下几条规则使我们的代码更加安全。
下面几条规则是你应该必须遵守的：规则一：赋值和保存——对于智能指针来说，赋值是立即创建一个实例，并且保存在那里。
现在智能指针拥有一个对象，你不能手动释放它，或者取走它，这将帮助你避免意外地释放了一个对象，但你还在引用它，或者结束一个不可用的引用计数器。
规则二：_ptr<T>不是T*——恰当地说，不能盲目地将一个T* 和一个智能指针类型T相互转换。
意思是：∙当创建一个智能指针的时候需要明确写出__ptr<T> myPtr<new T>。
∙不能将T*赋值给一个智能指针。
∙不能写ptr = NULL，应该使用ptr.reset()。
∙重新找回原始指针，使用ptr.get()，不必释放这个指针，智能指针会去释放、重置、赋值。
使用get()仅仅通过函数指针来获取原始指针。
∙不能通过T*指向函数指针来代表一个__ptr<T>，需要明确构造一个智能指针，或者说将一个原始指针的所有权给一个指针指针。
（见规则三）∙这是一种特殊的方法来认定这个智能指针拥有的原始指针。
不过在Boost:smart pointerprogramming techniques举例说明了许多通用的情况。
规则三：非循环引用——如果有两个对象引用，而他们彼此都通过一个一个引用指针计数器，那么它们不能释放，Boost 提供了weak_ptr来打破这种循环引用（下面介绍）。
规则四：非临时的share_ptr ——不能够造一个临时的share_ptr来指向它们的函数，应该命名一个局部变量来实现。
（这可以使处理以外更安全，Boost share_ptr best practices有详细解说）。
