c++ - 对这两个赋值运算符之间的不同感到困惑

Question

我有以下名为 CoordinatesList 的类。它包含一个动态坐标数组，其中每个坐标有3个整数； x、y 和 z。在 CoordinatesList 类中，我有两个不同的成员 operator=，我有点困惑它们之间有什么区别？

如果我继承类CoordinatesList中的类坐标，它会不会一样呢

class Coordinates {//this is a complete class, do not modify it.
public:
    Coordinates() {
        x = new int; y = new int; z = new int;
        *x = *z = *y = 0;
    }
    Coordinates(int _x, int _y, int _z) {
        x = new int; y = new int; z = new int;
        *x = _x;
        *z = _y;
        *y = _z;
    }
    Coordinates(const Coordinates& rhs) { // copy constructor
        x = new int; y = new int; z = new int;
        *x = *(rhs.x);
        *y = *(rhs.y);
        *z = *(rhs.z);
    }
    ~Coordinates() {
        delete x; delete y; delete z;
    }
    void operator=(const Coordinates& rhs) {//simplified operator=
        *x = *(rhs.x);
        *y = *(rhs.y);
        *z = *(rhs.z);
    }
    int getx() const { return *x; }
    int gety() const { return *y; }
    int getz() const { return *z; }
    void setx(int _x) { *x = _x; }
    void sety(int _y) { *y = _y; }
    void setz(int _z) { *z = _z; }
    friend ostream& operator<< (ostream& out, const Coordinates& rhs) {
    out << "[" << *(rhs.x) << "," << *(rhs.y) << "," << *(rhs.z) << "]" << endl;
    return out;
    }

private:
    int *x, *y, *z;
}; //--------------------------------------------------------------



class CoordinatesList {
public:

    /*CoordinatesList &  operator=(const CoordinatesList &rhs)
    {

        if (size != rhs.size)
        {
            delete[] list;
            size = rhs.size;
            list = new Coordinates[size];
        }
        for (int i = 0; i < size; i++)
        {
            list[i].Coordinates::operator=(rhs.list[i]);
        }
        return *this;

    } */

    CoordinatesList operator=(const CoordinatesList & rhs) 
    {

        //check if sizes are differernt
        if (size != rhs.size) 
        {   
            delete[] list; //this calls ~coordinates 
            size = rhs.size; 
            list = new Coordinates[size]; 
        }
        //copy content      
        for (int i = 0; i < size; i++) {
            //list[i] = rhs.list[i]; 
//will work as operator= is defined for Coordinates
            list[i].setx(rhs.list[i].getx());
            list[i].sety(rhs.list[i].gety());
            list[i].setz(rhs.list[i].getz());
        }
        return *this; 
    }
    private:
    Coordinates * list;
    int size;
};

Answer 1

using CL = CoordinatesList;以节省打字时间。

区别在于一个返回一个引用，一个返回一个拷贝。惯用的方法是返回对 *this 的引用。 ，所以使用这个: CL& operator=(const CL& rhs){/*...*/ return *this;}请注意，定义两个版本将导致编译器错误，因为函数不能仅在返回值上有所不同。

operator= 的用法:

CL a = CL(<args>);// (1)
CL b,c;
b = a; // (2)
b.operator=(a); //(3)
c = b = a; // (4)
c.operator=(b.operator=(a)); // (5)

(1) 不调用任何CL::operator=但是一个构造函数 CL::CL(<args>) .正在创建对象，因此无论等号是什么，都必须调用构造函数。

(2) 只是 (3) 的语法糖。来电CL::operator=并丢弃任何返回值。

(4) 同样，它是 (5) 的唯一语法糖。先右operator=被评估并将返回值传递给左侧operator=作为它的论据。在这种情况下有 operator=返回拷贝确实会制作拷贝。这就是为什么第二种选择是首选的原因，因为它不会产生这种额外的和不必要的成本。这也应该很好地解释为什么函数返回任何东西，如果它返回 void那么这种语法是不可能的。