重载副本分配运算符

Question

我最近一直在学习重载运算符，并很快来到重载复制运算符。 我尝试了一些示例，但无法真正理解其格式及其功能。 好吧，如果您可以用更简单的方式向我解释代码，这将很有帮助，因为因为我是C ++的初学者。 无论如何，这是我的代码：

#include <iostream>
using namespace std;

class Point{
private:
    int* lobster;
public:
    Point(const int somelobster){
        lobster = new int;
        *lobster = somelobster;
    }
    //deep copy 
    Point(const Point& cpy){ //copy of somelobster(just to make sure that it does not do shallow copy)
        lobster = new int;
        *lobster = *cpy.lobster;
    }
    //assingment operator
    Point& operator=(const Point& cpy){ //used to copy value
        lobster = new int; //same thing as the original overloaded constructor
        *lobster = *cpy.lobster; //making sure that it does not makes a shallow copy when assigning value
        return *this;
    }

    void display_ma_lobster(){ //display nunber
        cout << "The number you stored is: " << *lobster << endl;
    }
    ~Point(){ //deallocating memory
        cout << "Deallocating memory" << endl;
        delete lobster;
    }
};

int main(){
    Point pnt(125);
    cout << "pnt: ";
    pnt.display_ma_lobster();
    cout << "assigning pnt value to tnp" << endl;
    Point tnp(225);
    tnp = pnt;
    tnp.display_ma_lobster();
    return 0;
}

但是真正需要解释的主要部分是：

//deep copy 
        Point(const Point& cpy){ //copy of somelobster(just to make sure that it does not do shallow copy)
            lobster = new int;
            *lobster = *cpy.lobster;
        }
        //assingment operator
        Point& operator=(const Point& cpy){ //used to copy value
            lobster = new int; //same thing as the original overloaded constructor
            *lobster = *cpy.lobster; //making sure that it does not makes a shallow copy when assigning value
            return *this;
        }

感谢您的时间

Answer 1

副本分配运算符可以使用对象已拥有的现有资源。 它不像构造函数。 （您的副本构造函数是正确的。）

//assingment operator
Point& operator=(const Point& cpy){ //used to copy value
    // Do not allocate anything here.
    // If you were to allocate something, that would require deallocating yer shit too.

    *crap = *cpy.crap; //making sure that it does not makes a shallow copy when assigning value
    return *this;
}

Answer 2

关于该主题的不错的阅读是： 什么是复制和交换惯用法？

对象包含已分配的内存，因此，每次复制对象时，还需要执行新的内存分配，并复制分配的内容。 这就是为什么在复制构造函数中需要这些东西的原因。 当编译器尝试复制您的对象（例如跨函数调用）并将其放置在容器中时，将自动调用复制构造函数。

赋值运算符有缺陷，因为它需要做的更多或更少。 它用于

tnp = pnt;

因为它正在处理将一个对象分配给另一个对象，所以它需要使用现有的已分配内存，或者在复制pnt内存之前处理旧tnp对象中的内存释放。