struct前向声明和复制构造函数

Question

My abstract Reference counter class:

template<class T>
class ReferenceCounter
{
public:

    ReferenceCounter();
    ~ReferenceCounter();

    void addRef();
    void release();

    uint32 getCountReferences() const;

protected:
    int32* pCountReferences;

    virtual void destroyObject() = 0;
    virtual void shallowCopy(const T& rhs) = 0;
};

template<class T>
inline ReferenceCounter<T>::ReferenceCounter() 
{
    pCountReferences = new int32;
    *pCountReferences = 1;
}

template<class T>
inline ReferenceCounter<T>::~ReferenceCounter() 
{
    if(pCountReferences != NULL && *pCountReferences == 0)
    {
        delete pCountReferences;
        pCountReferences = NULL;
    }
}

template<class T>
inline void ReferenceCounter<T>::addRef()
{
    debug_assert((*pCountReferences) >= 0, "Incorrect value of count references");
    ++(*pCountReferences);
}

template<class T>
inline void ReferenceCounter<T>::release()
{
    debug_assert((*pCountReferences) > 0, "Incorrect value of count references");
    (*pCountReferences)--;

    if(pCountReferences != NULL && *pCountReferences == 0)
    {
        destroyObject();
    }
}

template<class T>
inline uint32 ReferenceCounter<T>::getCountReferences() const
{
    return *pCountReferences;
}

This is my smart pointer :

template<class T>
class SmartPtr
{
public:
    SmartPtr();
    SmartPtr(T* pInst);
    SmartPtr(const SmartPtr<T>& rhs);
    ~SmartPtr();

    void operator = (const SmartPtr<T>& rhs);
    T* operator -> () const;
    T* getData() const;

    bool isNULL() const;

private:
    T* pInst;
};

template<class T>
SmartPtr<T>::SmartPtr() : pInst(NULL) {}

template<class T>
SmartPtr<T>::SmartPtr(T* pInst) : pInst(pInst) {}

template<class T>
SmartPtr<T>::~SmartPtr() 
{
    if(pInst != NULL)
    {
        pInst->release();
    }
}

template<class T>
SmartPtr<T>::SmartPtr(const SmartPtr<T>& rhs)
{
    this->pInst = rhs.pInst;
    if(pInst != NULL)
    {
        pInst->addRef();
    }
}

template<class T>
void SmartPtr<T>::operator= (const SmartPtr<T>& rhs)
{
    this->pInst = rhs.pInst;
    if(pInst != NULL)
    {
        pInst->addRef();
    }
}

template<class T>
T* SmartPtr<T>::operator->() const
{
    return pInst;
}

template<class T>
T* SmartPtr<T>::getData() const
{
    return pInst;
}

template<class T>
bool SmartPtr<T>::isNULL() const
{
    return pInst == NULL;
}

There are test of code :

#include <iostream>
#include "ReferenceCounter.h"
#include "SmartPtr.h"

using namespace std;

class B;

class A : public ReferenceCounter<A>
{
public:
    A();
    A(const A& rhs);
    ~A();

    SmartPtr<B> getB();
    void operator = (const A& rhs);

    private:
    void destroyObject();
    void shallowCopy(const A& rhs);
 };

class B : public ReferenceCounter<B>
{
private:
    void destroyObject() {} ;
    void shallowCopy(const B& rhs) {};
};

A::A()
{
    cout << "Create object" << endl;
}

A::A(const A& rhs)
{
    shallowCopy(rhs);
    addRef();
    cout << "copy constructor " << endl;
}

A::~A()
{
    release();
}

void A::destroyObject()
{
    cout << "destroy" << endl;
}

void A::shallowCopy(const A& rhs)
{
    this->pCountReferences = rhs.pCountReferences;
}

void A::operator = (const A& rhs)
{
    shallowCopy(rhs);
    addRef();
    cout << "operator = " << endl;
}

SmartPtr<B> A::getB()
{
    return SmartPtr<B>(new B());
}

SmartPtr<A> getA()
{
    SmartPtr<A> a(new A());
    return a;
}

int main()
{
    getA();
    return 0;
}

This code is worked but below not called copy constructor of smart pointer when i debug this code . What problems happens below ??

int main()
{
   A a;
   a.getB();
}

Answer 1

See here for Return value optimization .

The compiler is allowed, to eliminate the copy of a temporary object being returned.

With C++11, there's also the possibility of moving an object. See What are move semantics? for an explanation.

Update :

This is not a problem at all, just a compiler optimization.

As long as there's nothing special going on in your constructor and destructor, there's no need to prevent this optimization. You should allow this instead, because it makes your program run faster by skipping one constructor and one destructor call.