C++一些注意点之指针成员管理

      C++类中经常含有指针，但是如何处理这个问题，本文针对<<C++ Primer>>和<<C++沉思录>>的方法进行了一点小结。本文只是浅尝辄止，深了自己都不懂了，且本文的例子漏洞百出，本文旨在总结这几种处理方法。

 

类中含有指针带来的一些问题

     设计具有指针成员的类时，类设计者必须首先需要决定的是该指针应提供什么行为。将一个指针复制到另一个指针时，两个指针指向同一个对象。当两个指针指向同一对象时，可以使用任一指针改变对象。类似地，很可能一个指针了一个对象时，另一个指针的用户还没有发现。

      通过不同的复制控制策略，可以为指针成员实现不同的行为。通常有以下五种策略（个人之见）：

    （1）指针成员采取常规指针行为。这样的类具有所有指针缺限，但是不需要用户编写复制控制程序；

    （2）类采取值行为。复制的时候，另外分配空间，但是值与被复制对象一致；

    （3）采取拥有权转移。即被复制对象释放指针的引用。标准库的auto_ptr；

    （4）实现所谓的“智能指针”。共享对象，但是能防止“悬垂指针”；

    （5）“写时复制”技术。在修改的时候才去重新分配空间。

 

策略一：常规指针行为

      这种方式的赋值操作符/复制构造函数采用系统默认的，两个复制的对象共用相同的空间，这会带来一些析构时遇到的问题。

#include<iostream>using namespace std; class HasPtr{public:     HasPtr(int *p):ptr(p){}     int* getPtr()const     {return ptr;}     void setPtr(int *p)     {ptr = p;}     int& operator*()//返回引用可以对其赋值     {return *ptr;}     const int& operator*()const     {return *ptr;}     int* operator->()     {return ptr;}     const int* operator->()const     {return ptr;}     ~ HasPtr(){delete ptr;}private:     int *ptr;}; int main(){    HasPtr p1(new int(5));    HasPtr p2(p1);    *p1 = 12;    cout<<*p1<<endl;//12    cout<<*(p2.operator->())<<endl;//12    system("pause");    return 0;}

策略二：“值复制”行为

       这种方式在复制的时候，采用“值复制”的方式。即复制的时候不复制空间指针，而是重新分配空间，但是其“值”与被复制的对象“值”一样。一般笔试时，string可以采用这种类型。

/*copyright@ CNV && lsj*/ #include<iostream>using namespace std; class HasPtr{public:    HasPtr(int *p):ptr(p){}    HasPtr(const HasPtr& other):ptr(new int(*other))    {}    HasPtr& operator=(const HasPtr& other)    {      if(&other != this)           *ptr = *other;//如果是数组的话这里，要释放掉原来的值       return *this;    }    int& operator*()//返回引用可以对其赋值    {return *ptr;}    const int& operator*()const    {return *ptr;}    int* operator->()    {return ptr;}    const int* operator->()const    {return ptr;}    ~ HasPtr(){delete ptr;}private:    int *ptr;}; int main(){    HasPtr p1(new int(5));    HasPtr p2(p1);    *p2 = 13;    cout<<*p1<<endl;//5    cout<<*p2<<endl;//13    system("pause");    return 0;}

策略三：拥有权转移行为

      被复制的对象释放对指针的拥有权，由左边对象接管指针的拥有权。标准库auto_ptr采用了这种策略。

/*copyright@ CNV && lsj*/ #include<iostream>using namespace std; class HasPtr{public:   HasPtr(int *p):ptr(p){}   HasPtr(const HasPtr& other)   {      ptr = other.getPtr();      other.setPtr(NULL);   }    HasPtr& operator=(const HasPtr&other)   {      if(&other!=this){          ptr = other.getPtr();          other.setPtr(NULL);       }       return *this;   }   int getPtr()const   {return ptr;}    void setPtr(int *p)   {ptr = p;}   ~ HasPtr()   {       if(ptr)delete ptr;   }private:    int *ptr;};

策略四：智能指针行为

     这种策略虽然还是采用多个对象共享同一份地址空间，但是通过给类添加计数器，能够有效的防止“悬垂指针”。实现智能指针有两种方案（C++ Primer）：计数伙伴类和句柄类。

方案1：设计伙伴计数类。

/*copyright@ CNV && lsj*/ #include<iostream>using namespace std; class HasPtr;class Uptr{//计数伙伴类    friend class HasPtr;    int *ip;//本来应该包含这个指针    size_t use;    Uptr(int *p):ip(p),use(1)    {}    ~Uptr(){delete ip;}}; class HasPtr{public:    HasPtr(int *p):ptr(new Uptr(p))    {}    HasPtr(const HasPtr& other){       ptr = other.ptr;       ++ptr->use;    }    HasPtr operator=(const HasPtr&other){       ++other.ptr->use;       if(--ptr->use==0)          delete ptr;       ptr = other.ptr;       return *this;     }     int& operator *()     { return *(ptr->ip);}     ~ HasPtr(){          if(--ptr->use==0)              delete ptr; //将调用伙伴类的析构函数      }private:   Uptr *ptr;//将int类型的指针封装到伙伴类中}; int main(){    HasPtr p1(new int(3));    HasPtr p2 = p1;    *p2 = 5;    cout<<*p1<<endl;//5    system("pause");    return 0;}

方案2：计数器封装到当前类中,但是计数器use必须采用指针，这样各个指向同一个指针的对象共享同一份空间，都可以去改这个计数器

/*copyright@ CNV && lsj*/ #include<iostream>using namespace std; class HasPtr{public:    HasPtr(int*p):ptr(p),use(new int(1))    {}    HasPtr(constHasPtr& other)    {        ptr= other.ptr;             use= other.use;        ++*use;    }    HasPtr&operator=(const HasPtr& other){                   ++*other.use;        if(--*use==0){            delete ptr;            delete use;         }                         ptr= other.ptr;         use= other.use;         return*this;     }     int& operator *()     {         return *ptr;     }     ~HasPtr()     {         if(--*use==0)         {             delete ptr;             delete use;         }     }private:    int *ptr;//所包含元素的指针     //一定要用指针，这样大家共用一份空间，都可以改写    int *use;};

策略五：写时复制计数

     有时候用户需要对象与对象之间的空间独立，但是每次都复制开销又很大。采用的策略是先不急着复制空间，拖到当另一个类要改写共享空间的时候，复制出来一份改写。

/*copyright@ CNV && lsj*/ #include<iostream>using namespace std; class HasPtr{public:    HasPtr(int*p):ptr(p),use(new int(1))    {}    HasPtr(constHasPtr& other){       ptr= other.ptr;       use= other.use;       ++*use;    }    HasPtr& operator=(const HasPtr& other){       ++*other.use;       if(--*use==0){           delete ptr;           delete use;        }                        ptr= other.ptr;        use= other.use;        return *this;    }    int& operator *()    {        return*ptr;    }    ~HasPtr()    {        if(--*use==0)        {           delete ptr;           delete use;        }    }    //这个接口要改写共享空间，此时复制一份改写    void setValue(intval)    {        //判断是不是只有当前对象持有共享空间        //如果是，则不用复制，直接改        if(*use!=1){            --*use;            use= new int(1);            ptr= new int(val);        }        *ptr= val;    }private:    int *ptr;//所包含元素的指针    //一定要用指针，这样大家共用一份空间，都可以改写    int *use;}; int main(){    HasPtr p1(newint(3));    HasPtr p2= p1;    p2.setValue(5);    cout<<*p1<<endl;//5    system("pause");    return 0;}