彻底搞清c/c++中的几个指针概念：悬垂指针和智能指针以及哑指针和野指针

先看看下面两段代码运行结果：

#include<iostream>
//#include <windows.h>
using namespace std;
int *p=NULL;
void fun()
{int i=10;p=&i;}
void main()
{
//fun();
 int i=10;p=&i;
//cout<<"*p= "<<*p<<endl;
//Sleep(1000);
//cout<<"一秒钟后，fun()中的i变量的存储空间被释放,p所指对象的值为:"<<endl<<"*p= "<<*p<<endl;
cout<<"*p= "<<*p<<endl;
cout<<"*p= "<<*p<<endl;
}

结果：

*p=10；

*p=10；

 

而

#include<iostream>
//#include <windows.h>
using namespace std;
int *p=NULL;
void fun()
{int i=10;p=&i;}
void main()
{
fun();
 //int i=10;p=&i;
//cout<<"*p= "<<*p<<endl;
//Sleep(1000);
//cout<<"一秒钟后，fun()中的i变量的存储空间被释放,p所指对象的值为:"<<endl<<"*p= "<<*p<<endl;
cout<<"*p= "<<*p<<endl;
cout<<"*p= "<<*p<<endl;
}

结果：

*p=10；

*p=13454657；

原因

一秒钟后，fun()中的i变量的存储空间被释放,p所指对象的值为:

　　*p= 13454657

这就是悬垂指针：

定义：指向曾经存在的对象，但该对象已经不再存在了，此类指针称为垂悬指针。结果未定义，往往导致程序错误，而且难以检测。

避免方法：

引入智能指针可以防止垂悬指针出现。一般是把指针封装到一个称之为智能指针类中，这个类中另外还封装了一个使用计数器，对指针的复制等操作将导致该计数器的值加1，对指针的delete操作则会减1，值为0时，指针为NULL

 哑指针：

1.哑指针指传统的C/C++指针，它只是一个指向，除此以外它不会有其他任何动作，所有的细节必须程序员来处理，比如指针初始化,释放等等

智能指针：

当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。

是指一种实现，能让指针在离开自己生命周期的时候自动销毁指向的内容（对象等），这往往用一个对象将指针包装起来来实现，例如标准库中的auto_ptr和boost中的智能指针都是智能指针的例子，但是缺点就是没有带引用参数。

　　智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。智能指针结合了栈的安全性和堆的灵活性，本质上将就是栈对象内部包装一个堆对象

　　每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。

　　实现引用计数有两种经典策略：一是引入辅助类，二是使用句柄类。下面分别介绍这些内容

　　问题描述　　

　　假设有一个名为TestPtr的类，里面有一个指针成员，简化为如下代码

　　class TestPtr

　　{

　　public:

　　TestPtr(int *p): ptr(p) { }

　　~TestPtr( ) { delete ptr; }

　　// other operations

　　private:

　　int *ptr;

　　// other data

　　};

　　在这种情况下，类TestPtr对象的任何拷贝、赋值操作都会使多个TestPtr对象共享相同的指针。但在一个对象发生析构时，指针指向的对象将被释放，从而可能引起悬垂指针。

　　现在我们使用引用计数来解决这个问题，一个新的问题是引用计数放在哪里。显然，不能放在TestPtr类中，因为多个对象共享指针时无法同步更新引用计数。

　　方案一

　　这里给出的解决方案是，定义一个单独的具体类（RefPtr）来封装指针和相应的引用计数。由于这个类只是用于对类TestPtr中的成员指针ptr进行了封装，无其它用途，所以把引用计数类RefPtr的所有成员均定义为private，并把类TestPtr声明为它的友元类，使TestPtr类可以访问RefPtr类。示例代码如下：

　　class RefPtr

　　{

　　friend class TestPtr;

　　int *ptr;

　　size_t count;

　　RefPtr (int *p): ptr(p), count(1) {}

　　~RefPtr () {

　　delete ptr;

　　}

　　};

　　class TestPtr

　　{

　　public:

　　TestPtr(int *p): ptr(new RefPtr(p)) { }

　　TestPtr(const TestPtr& src): ptr(src.ptr) {

　　++ptr->count;

　　}

　　TestPtr& operator= (const TestPtr& rhs) {

　　// self-assigning is also right

　　++rhs.ptr->count;

　　if (--ptr->count == 0)

　　delete ptr;

　　ptr = rhs.ptr;

　　return *this;

　　}

　　~TestPtr() {

　　if (--ptr->count == 0)

　　delete ptr;

　　}

　　private:

　　RefPtr *ptr;

　　};

　　当希望每个TestPtr对象中的指针所指向的内容改变而不影响其它对象的指针所指向的内容时，可以在发生修改时，创建新的对象，并修改相应的引用计数。这种技术的一个实例就是写时拷贝（Copy-On-Write）。

　　这种方案的缺点是每个含有指针的类的实现代码中都要自己控制引用计数，比较繁琐。特别是当有多个这类指针时，维护引用计数比较困难。

　　方案二

　　为了避免上面方案中每个使用指针的类自己去控制引用计数，可以用一个类把指针封装起来。封装好后，这个类对象可以出现在用户类使用指针的任何地方，表现为一个指针的行为。我们可以像指针一样使用它，而不用担心普通成员指针所带来的问题，我们把这样的类叫句柄类。在封装句柄类时，需要申请一个动态分配的引用计数空间，指针与引用计数分开存储。实现示例如下

　　#include <iostream>

　　#include <stdexcept>

　　using namespace std;

　　#define TEST_SMARTPTR

　　class Stub

　　{

　　public:

　　void print() {

　　cout<<"Stub: print"<<endl;

　　}

　　~Stub(){

　　cout<<"Stub: Destructor"<<endl;

　　}

　　};

　　template <typename T>

　　class SmartPtr

　　{

　　public:

　　SmartPtr(T *p = 0): ptr(p), pUse(new size_t(1)) { }

　　SmartPtr(const SmartPtr& src): ptr(src.ptr), pUse(src.pUse) {

　　++*pUse;

　　}

　　SmartPtr& operator= (const SmartPtr& rhs) {

　　// self-assigning is also right

　　++*rhs.pUse;

　　decrUse();

　　ptr = rhs.ptr;

　　pUse = rhs.pUse;

　　return *this;

　　}

　　T *operator->() {

　　if (ptr)

　　return ptr;

　　throw std::runtime_error("access through NULL pointer");

　　}

　　const T *operator->() const {

　　if (ptr)

　　return ptr;

　　throw std::runtime_error("access through NULL pointer");

　　}

　　T &operator*() {

　　if (ptr)

　　return *ptr;

　　throw std::runtime_error("dereference of NULL pointer");

　　}

　　const T &operator*() const {

　　if (ptr)

　　return *ptr;

　　throw std::runtime_error("dereference of NULL pointer");

　　}

　　~SmartPtr() {

　　decrUse();

　　#ifdef TEST_SMARTPTR

　　std::cout<<"SmartPtr: Destructor"<<std::endl; // for testing

　　#endif

　　}

　　private:

　　void decrUse() {

　　if (--*pUse == 0) {

　　delete ptr;

　　delete pUse;

　　}

　　}

　　T *ptr;

　　size_t *pUse;

　　};

　　int main()

　　{

　　try {

　　SmartPtr<Stub> t;

　　t->print();

　　} catch (const exception& err) {

　　cout<<err.what()<<endl;

　　}

　　SmartPtr<Stub> t1(new Stub);

　　SmartPtr<Stub> t2(t1);

　　SmartPtr<Stub> t3(new Stub);

　　t3 = t2;

　　t1->print();

　　(*t3).print();

　　return 0;

　　}

STL中auto_ptr的实现：

  Stl  中 auto_ptr只是众多可能的智能指针之一，auto_ptr所做的事情，就是动态分配对象以及当对象不再需要时自动执行清理。
    这里是一个简单的代码示例，如果没有auto_ptr,