智能指针 野指针

一般的指针再释放的时候需要程序员自己调用Release进行最后的释放，智能指针不需要

智能指针的原理及实现方案
 
 

     
     
 
         
 
             
 
              
 
               
   本文主要讨论C++程序设计的一种常用技术——智能指针（smart pointer），主要内容包括引用计数（reference count）和句柄类(handle class)。如果文中有错误或遗漏之处，敬请指出，谢谢！  
               
 
               
   作者： tyc611, 2007-02-01 
               
 
              
 
              

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

                  
              
 
              

                   智能指针(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;
}
 
              
 
             

野指针，也就是指向不可用内存区域的指针。通常对这种指针进行操作的话，将会使程序发生不可预知的错误。 
 
 

  
  

   
   “野指针”不是NULL指针，是指向“垃圾”内存的指针。人们一般不会错用NULL指针，因为用if语句很容易判断。但是“野指针”是很危险的，if语句对它不起作用。野指针的成因主要有两种： 

一、指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。 

二、 指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。别看free和delete的名字恶狠狠的（尤其是 delete），它们只是把指针所指的内存给释放掉，但并没有把指针本身干掉。通常会用语句if (p != NULL)进行防错处理。很遗憾，此时if语句起不到防错作用，因为即便p不是NULL指针，它也不指向合法的内存块。例： 

char *p = (char *) malloc(100); 

strcpy(p, “hello”); 

free(p); // p 所指的内存被释放，但是p所指的地址仍然不变 

if(p != NULL) // 没有起到防错作用 

strcpy(p, “world”); // 出错 

另外一个要注意的问题：不要返回指向栈内存的指针或引用，因为栈内存在函数结束时会被释放。
  
  
  
  

   
   野指针，也就是指向不可用内存区域的指针。通常对这种指针进行操作的话，将会使程序发生不可预知的错误。首先请诸位看以下一段“危险”的C++代码： 

void function( void ) 
{ 
char* str = new char[100]; 
delete[] str; 
// Do something 
strcpy( str, "Dangerous!!" ); 
} 


之 所以说其危险，是因为这是一段完全合乎语法的代码，编译的时候完美得一点错误也不会有，然而当运行到strcpy一句的时候，问题就会出现，因为在这之 前，str的空间已经被delete掉了，所以strcpy当然不会成功。对于这种类似的情况，在林锐博士的书中有过介绍，称其为“野指针”。 

那么，诸位有没有见过安全的“野指针”呢？下面请看我的一段C++程序，灵感来自CSDN上的一次讨论。在此，我只需要C++的“类”，C++的其余一概不需要，因此我没有使用任何的C++标准库，连输出都是用printf完成的。 

#include <stdio.h> 

class CTestClass 
{ 
public: 
CTestClass( void ); 
int m_nInteger; 
void Function( void ); 
}; 

CTestClass::CTestClass( void ) 
{ 
m_nInteger = 0; 
} 

void CTestClass::Function( void ) 
{ 
printf( "This is a test function.\n" ); 
} 

void main( void ) 
{ 
CTestClass* p = new CTestClass; 
delete p; 
p->Function(); 
} 


OK，程序到此为止，诸位可以编译运行一下看看结果如何。你也许会惊异地发现：没有任何的出错信息，屏幕上竟然乖乖地出现了这么一行字符串： 

This is a test function. 

奇怪吗？不要急，还有更奇怪的呢，你可以把主函数中加上一句更不可理喻的： 

((CTestClass*)NULL)->Function(); 


这仍然没有问题！！ 

我这还有呢，哈哈。现在你在主函数中这么写，倘说上一句不可理喻，那么以下可以叫做无法无天了： 

int i = 888; 
CTestClass* p2 = (CTestClass*)&i; 
p2->Function(); 


你看到了什么？是的，“This is a test function.”如约而至，没有任何的错误。 

你也许要问为什么，但是在我解答你之前，请你在主函数中加入如下代码： 

printf( "%d, %d", sizeof( CTestClass ), sizeof( int ) ); 


这 时你就会看到真相了：输出结果是——得到的两个十进制数相等。对，由sizeof得到的CTestClass的大小其实就是它的成员m_nInteger 的大小。亦即是说，对于CTestClass的一个实例化的对象（设为a）而言，只有a.m_nInteger是属于a这个对象的，而 a.Function()却是属于CTestClass这个类的。所以以上看似危险的操作其实都是可行且无误的。 

现在你明白为什么我的“野指针”是安全的了，那么以下我所列出的，就是在什么情况下，我的“野指针”不安全： 

在成员函数Function中对成员变量m_nInteger进行操作； 
将成员函数Function声明为虚函数（virtual）。 
以上的两种情况，目的就是强迫野指针使用属于自己的东西导致不安全，比如第一种情况中操作本身的m_nInteger，第二种情况中变为虚函数的Function成为了属于对象的函数（这一点可以从sizeof看出来）。 

其 实，安全的野指针在实际的程序设计中是几乎毫无用处的。我写这一篇文章，意图并不是像孔乙己一样去琢磨回字有几种写法，而是想通过这个小例子向诸位写明白 C++的对象实例化本质，希望大家不但要明白what和how，更要明白why。李马二零零三年二月二十日作于自宅。 


关于成员函数CTestClass::Function的补充说明 



这个函数是一个普通的成员函数，它在编译器的处理下，会成为类似如下的代码： 

void Function( const CTestClass * this ) // ① 
{ 
printf("This is a test function.\n"); 
} 

那么p->Function();一句将被编译器解释为： 

Function( p ); 

这 就是说，普通的成员函数必须经由一个对象来调用（经由this指针激活②）。那么由上例的delete之后，p指针将会指向一个无效的地址，然而p本身是 一个有效的变量，因此编译能够通过。并且在编译通过之后，由于CTestClass::Function的函数体内并未对这个传入的this指针进行任何 的操作，所以在这里，“野指针”便成了一个看似安全的东西。 

然而若这样改写CTestClass::Function： 

void CTestClass::Function( void ) 
{ 
m_nInteger = 0; 
} 

那么它将会被编译器解释为： 

void Function( const CTestClass * this ) 
{ 
this->m_nInteger = 0; 
} 

你看到了，在p->Function();的时候，系统将会尝试在传入的这个无效地址中寻找m_nInteger成员并将其赋值为0，剩下的我不用说了——非法操作出现了。 

至于virtual虚函数，如果在类定义之中将CTestClass声明为虚函数： 

class CTestClass 
{ 
public: 
// ... 
virtual void Function( void ); 
}; 


那 么C++在构建CTestClass类的对象模型时，将会为之分配一个虚函数表vptr（可以从sizeof看出来）。vptr是一个指针，它指向一个函 数指针的数组，数组中的成员即是在CTestClass中声明的所有虚函数。在调用虚函数的时候，必须经由这个vptr，这也就是为什么虚函数较之普通成 员函数要消耗一些成本的缘故。以本例而言，p->Function();一句将被编译器解释为： 

(*p->vptr[1])( p ); // 调用vptr表中索引号为1的函数（即Function）③ 


上面的代码已经说明了，如果p指向一个无效的地址，那么必然会有非法操作。 

备注： 

①关于函数的命名，我采用了原名而没有变化。事实上编译器为了避免函数重载造成的重名情况，会对函数的名字进行处理，使之成为独一无二的名称。 
②将成员函数声明为static，可以使成员函数不经由this指针便可调用。 
③vptr表中，索引号0为类的type_info。