《泛型》篇中提到的某个IT项目的辩论会，

一派坚持智能指针和裸指针可以“离婚”，它们是std::auto_ptr的支持者，

一派认为智能指针和裸指针不可以“离婚”，boost::scoped_ptr体现了他们的观点：

boost::scoped_ptr基本用法：

void testScopePtr()
{
    boost::scoped_ptr <S> ss (new S);
    if(ss) ///判断是否不空
    {
        ss->SetA(99);
        cout << ss->a << endl;
        (* ss).SetA(100); //和裸指针一样，也可以先用*取值
        cout << (*ss).a << endl;
    }
}

同样模拟了裸指针的功能（重载了“->”和“*”操作符）；

还提供了是否为空的判断（重载了“!”操作符）；

禁止了裸指针的偏移计算，比如：p++、p--、p+=5、p-=2等。

既然是智能指针，正如代码所演示的，不需要手工delete。

scoped_ptr明确禁用拷贝构造和赋值操作（回忆一下boost::noncopyable），所以智能通过指针或引用的方式将scoped_ptr对象传给一个函数：

void foo4(boost::scoped_ptr<S> const& csp)
{
    csp->SetA(100);

//    delete csp.get(); //代码阻止不了某些程序原的猥琐
}

正如52行代码注释说明的，程序员有权力强行释放智能指针返回(而非release)的裸指针，这让人欲哭无泪。公司的管理人员很大一部分工作，就是发现这样的程序员，然后劝退

现在scoped_ptr身上犯错，哪怕是新手，可能性也挺小的，你看：

scoped_ptr <S> sp1(new int);

scoped_ptr <S> sp2 = sp1; //这样不OK啦
scoped_ptr <S> sp3(sp1); //这样也不OK啦

甚至在构造时都不允许使用‘=’操作了，比如

scoped_ptr <S> sp4 = new int; //编译失败，简直是道德洁癖

scoped_ptr中的“scoped”意为“区域，范围”，所以它不仅信奉“从一而终”，而且信奉“老子”的“鸡犬之声相闻，民至老死不相往来”。

因为无法复制，所以当需要传递给函数时，只能以引用或指针形式传入真身，无法传值；用作函数返回值也一样。

scoped_ptr不支持在对象间复制，转移裸指针，但如果它对裸指针不满意，那它可以“谋杀”这个裸指针，然后自行换个新的，这个“谋杀”函数就是“reset()”:

scoped_ptr sp1(new int);
sp1.reset();//所拥有的指针被内部delete掉了
assert(!sp1);

调用reset()之后，sp1又恢复了自由身，现在它不拥有任何裸指针了，直到它看上新的：

boost::scoped_ptr <int> sp1 (new int);
*sp1 = 38;
sp1.reset(); //释放原有裸指针，恢复自由身
sp1.reset(new int(22)); //改为拥有传入的新指针
cout << *sp1 << endl;

甚至可以在“在谋杀的同时，娶的新人”：

boost::scoped_ptr <int> sp1(new int);
*sp1 = 38;
sp1.reset(new int(22)); //释放原有，改拥新指针

两个scoped_ptr可以交换所拥有的裸指针，方法是通过成员函数swap()；

boost::scoped_ptr<int> sp1(new int(0));
boost::scoped_ptr<int> sp2(new int(1));
cout << *sp1 << endl;
cout << *sp2 << endl;
sp1.swap(sp2);
cout << *sp1 << endl;
cout << *sp2 << endl;

从一个指针管理的功能来看，释放指针(reset)，释放指针并替换为新指针(reset(newPtr))、高效地交换两个指针都是必要的，这些功能也都不容易使用出错。

boost::scoped_ptr最本质的改进，就是不允许拥有权的“潜式”转移，也不提供直接交出所有权的操作（类似auto_ptr的release()函数）。

有关scoped_ptr最后也是最重要的问题是：一个变量只在一定范围(scope)内私用，可以自动释放，那不就是“栈”变量吗？为什么一定要使用scoped_ptr?对比一下代码：

使用栈变量	使用“scoped_ptr”
void foo() {         int a = 10;         cout << a << endl;         ... }	void foo() {         scoped_ptr <int> a (new int(10));         cout << *a << endl;         ... }

很明显，右边使用的“scoped_ptr”方式纯属折腾，看不出任何必要性。

“面向对象”编程时，经常需要使用基类类型的指针，指向或创建派生类；如果有多种派生类，往往需要在运行期才能决定创建哪类对象，此时通常需要使用new操作以动态创建。如果这个堆对象正好符合“此处用完就删除”的特性，就可以使用scoped_ptr加以管理：

Foo函数中事先并不知道将创建AirPlane或Duck的对象，因此需要使用基类指针从堆中动态创建对象，而为了管理该堆对象，可以使用scoped_ptr。