理解面向对象设计2（操作符重载和智能指针）

//Define a big enough global table.


void *operator new(size_t size)

{

            void *p = malloc(size);

            record p in the global table; //If multithreads, mutex needed


            return p;

}

void operator delete(void *p)

{

            remove the record from global table; //If multithreads, mutex needed


            free(p);

}

class Target;

/** This class represents a smart pointer to Target. */
class SmartPtr
{
public:

    /** Default constructor */
    SmartPtr();
    
    /** Copy Constructor */
    SmartPtr( const SmartPtr& tg);
    
    
    /** Construct smart pointer from a new target */
    SmartPtr(Target* target);
    
    
    /** Destructor */
    ~SmartPtr();
    
    // Assignment operator

    SmartPtr& operator=(const SmartPtr& p);
    
    // Assignment operator

    SmartPtr& operator=(Target* p);

    /** Returns true if the smart pointer has not been initialized with
     * a target.
     */
    bool isNil();

    /** Make the smart pointer uninitialized (i.e., the smart pointer is no longer pointing
     * to any target object.
     */
    void nil();
    
    Target* operator->() const;
    
    private:
    // Pointer to actual object

    Target* m_tgtPtr;

};

#include "/Target.h"
#include "SmartPtr.h"

SmartPtr::SmartPtr()
{
        // This initializes the object pointer to null.

        m_tgtPtr = (Target *)0L;
}

SmartPtr::SmartPtr(const SmartPtr& dp )
{
    m_tgtPtr = (Target *)0L;     

    /* This next statement uses the overloaded operator=(SmartPtr&) defined below
     * to decrement the reference count for the
     * old Target object used by this class and increment the
     * usage count for the new Target object.
     */
    *this = dp;
}

SmartPtr::SmartPtr( Target *dp )
{
    m_tgtPtr = (Target *)0L;

    /* This next statement uses the overloaded operator=(Target *) defined below
     * to decrement the reference count for the
     * old Target object used by this class and increment the
     * usage count for the new Target object.
     */
    *this = dp;
}

SmartPtr::~SmartPtr()
{
    // This will cause a decrement of the Target reference count

    // via the operator=(Target *) defined below


    *this = (Target *) 0L;
}

SmartPtr& SmartPtr::operator= (const SmartPtr& newPtr)
{
    // This has the effect of calling the overloaded operator=(Target *)

    // method which adjusts the Target reference count

    *this = newPtr.m_tgtPtr;

    return *this;
}


bool SmartPtr::isNil()
{
    return( ( dPtr == 0L ) );
}

void SmartPtr::nil()
{
    // This will cause a decrement of the Target reference count

    // via the operator=(Target *) defined below


    *this = 0L;

}


// This overloading will allow the user of this handle to access public

// methods and data members of Target, as though they were members of SmartPtr.

// For example, where you might do a req->setX() you can do a reqPtr->setX() with the same

// effect

Target *SmartPtr::operator-> () const
{
    return(m_tgtPtr);
}

SmartPtr& SmartPtr::operator= (Target *newTgt)
{
    /* This method is the main method keeping track of the
     * reference count for the associated Target object.
     */

    // If the pointer passed is not null then bump up the reference

    // count for the source Target.

    if(newTgt != 0L )
    {
        newTgt->incrRefCount();
    }

    // If the pointer this object is currently using is not null

    // then decrement the count for that pointer.

    if(m_tgtPtr != 0L ) {

        // If the count has reached zero, then it is time to delete this

        // object

        if(m_tgtPtr->decrRefCount() == 0 )
        {
            delete m_tgtPtr;
        }
    }

    // Have this smart pointer now point to the new Target object.

    m_tgtPtr = newTgt;

    return(*this);
}

#include “SmartPtr.h”
class Target
{
public:
    Target()
    {
        m_refCount = 0;
    }

    virtual ~Target();
    void DoSth();
protected:
    friend class SmartPtr;
    int incrRefCount()
    {
        return ++m_refCount; //Mutex protection needed for multi-threads

    }

int decrRefCount()
{
    if(--m_refCount < 0) //Mutex protection needed for multi-threads

        m_refCount = 0;
    return m_refCount;
}

int m_refCount;
//Add mutex for multi-threads

};

Target::~Target()
{
    m_refCount = 0;
}

void Foo()
{
Target *p = new Target();
SmartPtr sp(p);
SmartPtr sp2 = p; //p’s reference count is 2

sp->DoSth();
sp2->DoSth();        // p will be destroyed automatically after function returns

}