所以，使用 std::auto_ptr 时，不能使用“operator=”操作符。作为一个库，不允许用户使用，确没有明确拒绝[1]，多少会觉得有点出乎预料。
　　看完 std::auto_ptr 好景不长的第一个例子后，让我们再来看一个：
　　void TestAutoPtr3() {
　　std::auto_ptr<Simple> my_memory(new Simple(1));
　　if (my_memory.get()) {
　　my_memory.release();
　　}
　　}
　　执行结果为：
　　Simple: 1
　　看到什么异常了吗？我们创建出来的对象没有被析构，没有输出“~Simple: 1”，导致内存泄露。当我们不想让 my_memory 继续生存下去，我们调用 release() 函数释放内存，结果却导致内存泄露（在内存受限系统中，如果my_memory占用太多内存，我们会考虑在使用完成后，立刻归还，而不是等到 my_memory 结束生命期后才归还）。
　　正确的代码应该为：
void TestAutoPtr3() {
std::auto_ptr<Simple> my_memory(new Simple(1));
if (my_memory.get()) {
Simple* temp_memory = my_memory.release();
delete temp_memory;
}
}
或
void TestAutoPtr3() {
std::auto_ptr<Simple> my_memory(new Simple(1));
if (my_memory.get()) {
my_memory.reset();  // 释放 my_memory 内部管理的内存
}
}
　　原来 std::auto_ptr 的 release() 函数只是让出内存所有权，这显然也不符合 C++ 编程思想。
　　总结：std::auto_ptr 可用来管理单个对象的对内存，但是，请注意如下几点：
　　（1）    尽量不要使用“operator=”。如果使用了，请不要再使用先前对象。
　　（2）    记住 release() 函数不会释放对象，仅仅归还所有权。
　　（3）    std::auto_ptr 好不要当成参数传递（读者可以自行写代码确定为什么不能）。
　　（4）    由于 std::auto_ptr 的“operator=”问题，由其管理的对象不能放入 std::vector 等容器中。
　　（5）    ……
　　使用一个 std::auto_ptr 的限制还真多，还不能用来管理堆内存数组，这应该是你目前在想的事情吧，我也觉得限制挺多的，哪天一个不小心，导致问题了。
　　由于 std::auto_ptr 引发了诸多问题，一些设计并不是非常符合 C++ 编程思想，所以引发了下面 boost 的智能指针，boost 智能指针可以解决如上问题。
　　让我们继续向下看。
　　3、boost::scoped_ptr
　　boost::scoped_ptr 属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。boost::scoped_ptr 跟 std::auto_ptr 一样，可以方便的管理单个堆内存对象，特别的是，boost::scoped_ptr 独享所有权，避免了 std::auto_ptr 恼人的几个问题。
　　我们还是从代码开始分析：
void TestScopedPtr() {
boost::scoped_ptr<Simple> my_memory(new Simple(1));
if (my_memory.get()) {
my_memory->PrintSomething();
my_memory.get()->info_extend = "Addition";
my_memory->PrintSomething();
(*my_memory).info_extend += " other";
my_memory->PrintSomething();
my_memory.release();           // 编译 error: scoped_ptr 没有 release 函数
std::auto_ptr<Simple> my_memory2;
my_memory2 = my_memory;        // 编译 error: scoped_ptr 没有重载 operator=，不会导致所有权转移
}
}
　　首先，我们可以看到，boost::scoped_ptr 也可以像 auto_ptr 一样正常使用。但其没有 release() 函数，不会导致先前的内存泄露问题。其次，由于 boost::scoped_ptr 是独享所有权的，所以明确拒绝用户写“my_memory2 = my_memory”之类的语句，可以缓解 std::auto_ptr 几个恼人的问题。
　　由于 boost::scoped_ptr 独享所有权，当我们真真需要复制智能指针时，需求便满足不了了，如此我们再引入一个智能指针，专门用于处理复制，参数传递的情况，这便是如下的 boost::shared_ptr。
　　4、boost::shared_ptr
　　boost::shared_ptr 属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。在上面我们看到 boost::scoped_ptr 独享所有权，不允许赋值、拷贝，boost::shared_ptr 是专门用于共享所有权的，由于要共享所有权，其在内部使用了引用计数。boost::shared_ptr 也是用于管理单个堆内存对象的。
　　我们还是从代码开始分析：
void TestSharedPtr(boost::shared_ptr<Simple> memory) {  // 注意：无需使用 reference (或 const reference)
memory->PrintSomething();
std::cout << "TestSharedPtr UseCount: " << memory.use_count() << std::endl;
}
void TestSharedPtr2() {
boost::shared_ptr<Simple> my_memory(new Simple(1));
if (my_memory.get()) {
my_memory->PrintSomething();
my_memory.get()->info_extend = "Addition";
my_memory->PrintSomething();
(*my_memory).info_extend += " other";
my_memory->PrintSomething();
}
std::cout << "TestSharedPtr2 UseCount: " << my_memory.use_count() << std::endl;
TestSharedPtr(my_memory);
std::cout << "TestSharedPtr2 UseCount: " << my_memory.use_count() << std::endl;
//my_memory.release();// 编译 error: 同样，shared_ptr 也没有 release 函数
}
　　执行结果为：
　　Simple: 1
　　PrintSomething:
　　PrintSomething: Addition
　　PrintSomething: Addition other
　　TestSharedPtr2 UseCount: 1
　　PrintSomething: Addition other
　　TestSharedPtr UseCount: 2
　　TestSharedPtr2 UseCount: 1
　　~Simple: 1
　　boost::shared_ptr 也可以很方便的使用。并且没有 release() 函数。关键的一点，boost::shared_ptr 内部维护了一个引用计数，由此可以支持复制、参数传递等。boost::shared_ptr 提供了一个函数 use_count() ，此函数返回 boost::shared_ptr 内部的引用计数。查看执行结果，我们可以看到在 TestSharedPtr2 函数中，引用计数为 1，传递参数后（此处进行了一次复制），在函数TestSharedPtr 内部，引用计数为2，在 TestSharedPtr 返回后，引用计数又降低为 1。当我们需要使用一个共享对象的时候，boost::shared_ptr 是再好不过的了。
　　在此，我们已经看完单个对象的智能指针管理，关于智能指针管理数组，我们接下来讲到。
　　5、boost::scoped_array
　　boost::scoped_array 属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。
　　boost::scoped_array 便是用于管理动态数组的。跟 boost::scoped_ptr 一样，也是独享所有权的。
　　我们还是从代码开始分析：
void TestScopedArray() {
boost::scoped_array<Simple> my_memory(new Simple[2]); // 使用内存数组来初始化
if (my_memory.get()) {
my_memory[0].PrintSomething();
my_memory.get()[0].info_extend = "Addition";
my_memory[0].PrintSomething();
(*my_memory)[0].info_extend += " other";            // 编译 error，scoped_ptr 没有重载 operator*
my_memory[0].release();                             // 同上，没有 release 函数
boost::scoped_array<Simple> my_memory2;
my_memory2 = my_memory;                             // 编译 error，同上，没有重载 operator=
}
}
　　boost::scoped_array 的使用跟 boost::scoped_ptr 差不多，不支持复制，并且初始化的时候需要使用动态数组。另外，boost::scoped_array 没有重载“operator*”，其实这并无大碍，一般情况下，我们使用 get() 函数更明确些。
　　下面肯定应该讲 boost::shared_array 了，一个用引用计数解决复制、参数传递的智能指针类。
　　6、boost::shared_array
　　boost::shared_array 属于 boost 库，定义在 namespace boost 中，包含头文件 #include<boost/smart_ptr.hpp> 便可以使用。
　　由于 boost::scoped_array 独享所有权，显然在很多情况下（参数传递、对象赋值等）不满足需求，由此我们引入 boost::shared_array。跟 boost::shared_ptr 一样，内部使用了引用计数。
　　我们还是从代码开始分析：
void TestSharedArray(boost::shared_array<Simple> memory) {  // 注意：无需使用 reference (或 const reference)
std::cout << "TestSharedArray UseCount: " << memory.use_count() << std::endl;
}
void TestSharedArray2() {
boost::shared_array<Simple> my_memory(new Simple[2]);
if (my_memory.get()) {
my_memory[0].PrintSomething();
my_memory.get()[0].info_extend = "Addition 00";
my_memory[0].PrintSomething();
my_memory[1].PrintSomething();
my_memory.get()[1].info_extend = "Addition 11";
my_memory[1].PrintSomething();
//(*my_memory)[0].info_extend += " other";  // 编译 error，scoped_ptr 没有重载 operator*
}
std::cout << "TestSharedArray2 UseCount: " << my_memory.use_count() << std::endl;
TestSharedArray(my_memory);
std::cout << "TestSharedArray2 UseCount: " << my_memory.use_count() << std::endl;
}
　　执行结果为：
　　Simple: 0
　　Simple: 0
　　PrintSomething:
　　PrintSomething: Addition 00
　　PrintSomething:
　　PrintSomething: Addition 11
　　TestSharedArray2 UseCount: 1
　　TestSharedArray UseCount: 2
　　TestSharedArray2 UseCount: 1
　　~Simple: 0
　　~Simple: 0
　　跟 boost::shared_ptr 一样，使用了引用计数，可以复制，通过参数来传递。
　　至此，我们讲过的智能指针有 std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array。这几个智能指针已经基本够我们使用了，90% 的使用过标准智能指针的代码这 5 种。可如下还有两种智能指针，它们肯定有用，但有什么用处呢，一起看看吧。