Question

我是超载的新手所以请耐心等待。在我的对象中，我定义了一个operator =，一个拷贝构造函数和一个像我读过的析构函数。一切都指向它应该工作，但它没有。我的对象看起来像这样

class myObject
{
    public:
    myObject()
    {
        internalPtr = NULL;
    }

    myObject(const myObject& rhs)
    {
        internalPtr = rhs.internalPtr;
    }

    ~myObject()
    {
        delete[] internalPtr;
    }

    myObject& operator= (const myObject& rhs)
    {
        this->empty(); //this will delete[] internalPtr
        internalPtr = rhs.internalPtr;
        return *this;
    }

    //Other methods are used to allocate internalPtr with new when needed

    private:
    double* internalPtr;
}

myObject add(myObject A, myObject B)
{
    myObject C;
    //simple code to add A and B together and store it back into C.internalPtr
    return C;
}

当我运行一个调用

的测试函数时

C = add(A,B);   //A,B,and C are myObject

C将为空，不包含add（）

返回的对象

我在这里做错了什么？

提前感谢您的帮助！

Answer 1

如果您不想使用<vector>，则必须通过克隆阵列来处理深层复制。但为此你需要跟踪它的大小（让我们假设它是一个私人成员）。

我希望您可以使用<algorithm>，因为它也适用于数组。

您的构造函数将如下所示：

myObject() : internalPtr(nullptr), size(0) { }  // init size  

myObject(const myObject& rhs) : internalPtr(nullptr), size(rhs.size)  // init 
{
    if (rhs.size) {  // if there is something to copy, clone the table:  
        internalPtr = new double[rhs.size];
        std::copy(rhs.internalPtr, rhs.internalPtr + rhs.size, internalPtr);
    }
}

您当然要调整empty（）来重新调整大小。

然后分配看起来像：

myObject& operator= (const myObject& rhs)
{
    if (this != &rhs) {         //  ATTENTION:  Check that's not a copy on one self bbefore deallocaing !! 
        empty(); //this will delete[] internalPtr
        internalPtr = new double[rhs.size];
        size = rhs.size; 
        std::copy(rhs.internalPtr, rhs.internalPtr + rhs.size, internalPtr);
    }
    return *this;
}

如果将对象分配给自己，您的原始代码就是一个很好的例子。看看上面的评论，关于如何避免这种情况。

add()看起来像是：

myObject add(myObject A, myObject B)
{
    myObject C = A;   // create C by cloning object A 
    //simple code to add B to C 
    return C;
}

顺便说一句，如果你让这个函数成为你班级的朋友，简单的代码看起来很简单，如：

    int sz = min(C.size, B.size);  // avoid out of bounds if B is bigger or smaller than C
    std::transform (C.internalPtr, C.internalPtr + sz, B.internalPtr, C.internalPtr, std::plus<double>());

C ++中重载的赋值运算符

1 个答案: