c++ - 什么时候用指针调用C++类构造函数？

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

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

• 当调用以 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