Question

我对c ++并不了解。
我已经实现了智能指针，以防止由原始指针引起的问题。（内存泄漏）
下面是智能指针的代码。

#ifndef SMARTPOINTER
#define SMARTPOINTER
class RC
{
    private:
    int count; // Reference count
    public:
    RC(){            count = 0;        }
    void AddRef()
    {
        // Increment the reference count
        count++;
    }
    int Release()
    {
        // Decrement the reference count and
        // return the reference count.
        if(count==0) return 0;
        return --count;
    }
};

template < typename T > class SP
{
private:
    T*    pData;       // pointer
    RC* reference; // Reference count
public:
    SP() : pData(0), reference(0)
    {
        // Create a new reference
        reference = new RC();
        // Increment the reference count
        reference->AddRef();
    }
    SP(T* pValue) : pData(pValue), reference(0)
    {
        // Create a new reference
        reference = new RC();
        // Increment the reference count
        reference->AddRef();
    }
    SP(const SP<T>& sp) : pData(sp.pData), reference(sp.reference)
    {
        // Copy constructor
        // Copy the data and reference pointer
        // and increment the reference count
        reference->AddRef();
    }
    ~SP()
    {
        // Destructor
        // Decrement the reference count
        // if reference become zero delete the data
        if(reference->Release() == 0)
        {
            delete pData;
            delete reference;
        }
    }
    T& operator* ()
    {
        return *pData;
    }
    T* operator-> ()
    {
        return pData;
    }
    SP<T>& operator = (const SP<T>& sp)
    {
        // Assignment operator
        if (this != &sp) // Avoid self assignment
        {
            // Decrement the old reference count
            // if reference become zero delete the old data
            if(reference->Release() == 0)
            {
                delete pData;
                delete reference;
            }

            // Copy the data and reference pointer
            // and increment the reference count
            pData = sp.pData;
            reference = sp.reference;
            reference->AddRef();
        }
        return *this;
    }
};
#endif // SMARTPOINTER

我的问题正在关注..
如下使用此智能指针类

 SP<MyObject> ptrObject;  //MyObject class is the custom class.
 MyObject *ptr = new MyObject;
 ptrObject = ptr;  //This invokes the SP(T *) constructor.. why?
                   //Though operator = ( T*) is not defined.

这时，尽管未定义operator=(T*)函数，为什么要调用智能指针SP（T * pValue）的构造函数？我以为创建类对象时会调用构造函数。
请解释一下，谢谢。

Answer 1

每当在上下文中使用某种T1类型的表达式但不接受该类型但接受某种其他T2类型的表达式时，就会执行隐式转换；特别是：

当调用以T2作为参数声明的函数时，将表达式用作自变量时；
当表达式用作期望T2的运算符的操作数时；
初始化类型为T2的新对象时，包括返回T2的函数中的return语句；
在switch语句中使用表达式时（T2是整数类型）；
在if语句或循环（T2为bool）中使用表达式时。

这对您有帮助。
https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.3.0/com.ibm.zos.v2r3.cbclx01/implicit_conversion_sequences.htm

何时使用指针调用C ++类构造函数？

1 个答案: