Question

所以我为整数创建了一个容器类，我想重载=运算符，以便我可以返回该对象的深层副本。我的代码正常工作，但这两个对象指向同一个地址。这是main.cpp文件：

int main (int argc, const char * argv[]) {
    IntList cArray(5);

    for (int i = 0; i < cArray.getLength(); i++) {
        cArray[i] = (i + 1) * 10;
    }

    using namespace std;

    for (int i = 0; i < cArray.getLength(); i++)
        cout << cArray[i] << " ";
    cout << endl << popped << endl;

    IntList cArray2(4);

    for (int i = 0; i < cArray2.getLength(); i++)
        cArray2[i] = i * 5;

    cArray2 = cArray;
    cArray2[2] = 1000;

    for (int i = 0; i < cArray.getLength(); i++)
        cout << cArray[i] << " ";
    cout << endl;
    for (int i = 0; i < cArray2.getLength(); i++)
        cout << cArray2[i] << " ";
    cout << endl;

    return 0;
}

这是IntList类的头文件：

class IntList {
private:
    int _length;
    int* _data;

public:
    IntList(int length);
    ~IntList();

    void erase();
    void reallocate(int length);    //  Faster way to call erase() and resize()
    void resize(int length);
    void insert(int value, int index);
    void prepend(int value);
    void append(int value);
    int pop(int index);
    void removeBefore(int index);    //  Exclusive
    void removeAfter(int index);    //  Exclusive
    int getLength();
    int indexOf(int value);

    int& operator[](int index);
    IntList operator=(IntList* source);
};

这是IntClass的{{1}}方法的实现：

operator=()

Answer 1

您没有使用指向IntList的指针 - operator=通常需要const &并返回对所分配实例的引用。

IntList & IntList::operator=(IntList const & source) {
  ...
  return *this;
}

请记住，您还需要一个复制构造函数：IntList(IntList const & source)

你可以创建一个operator =，它接受一个指向IntList的指针 - 只有当你做了类似这样的事情时才会有效：

IntList l1;
IntList l2;
l1 = &l2;

这不是典型用法，如果您需要，请务必明确，例如使用在这种情况下void IntList::copyFrom(IntList const *)。

您应该做出的其他更改：

添加：

int operator[](int index) const;

制作这些const：

int getLength() const;
int indexOf(int value) const;

Answer 2

因为赋值运算符接受一个指向IntList的指针，所以你需要像这样调用它：

cArray2 = &cArray;

您的示例代码使用编译器生成的默认赋值运算符。您的赋值运算符应该具有此声明：

IntList& IntList::operator=(IntList const& source)

Answer 3

您的运营商需要签名IntList& operator=(const IntList& source);。请注意引用而不是指针，并且您必须通过引用返回以允许分配链接。当您通过指针传递它时，需要使用隐式赋值，将使用编译器生成的浅拷贝赋值运算符。

编辑：你还需要制作getLength const，以便能够在赋值运算符中调用它。

Answer 4

IntList IntList::operator=(IntList* source)

operator=的签名错误，因为它的参数类型是指针到IntList

正确签名是这样的：

IntList & IntList::operator=(const IntList & source) //reference of source!
     //^^^ note this                      ^^^ note this as well!

即，同时使用参数类型以及返回类型引用。

重载=运算符时返回对象的深层副本

4 个答案: