编译器并不知道rhs代表“右手边”，实际上该变量的名称可以是任何您喜欢的名称。
编译器“知道”如何格式化它，因为operator=的语法要求它这样做。

class A
{
public:
   A& operator=(const A& other);
};

该语言将此运算符的用法定义为以下形式：

A a, b;
a = b;

上面的代码针对名为a的A示例调用A::operator=(const &other)，并将名为b的A示例用作other。

相同类型示例的标准赋值运算符具有原型
MyArray<T>& operator=(const MyArray<T>&);
函数参数通常被命名为rhs，因为当操作符被调用时，它出现在赋值语句的右边，它提高了源代码的可读性，仅此而已。

rhs只是人们通常对该运算符使用的名称，它没有特殊含义。该运算符的定义方式总是使参数成为右边的元素。

如果您执行以下操作：

int a = 5;
int b = 3;
a = b;

赋值部分实际上只是一个函数调用：

a.operator=(b);

没有什么特别的，参数名不重要，只有返回类型和参数类型组成的签名，而不是名字。

与任何函数一样，您可以根据需要调用参数。
使用带有赋值运算符的示例，如果您有类似

MyArray<int> arr1, arr2;
arr1 = arr2;

这相当于

MyArray<int> arr1, arr2;
arr1.operator=(arr2);

“右边”只是作为参数传递给普通成员函数。

我是在这样的假设下假设的，MyArray会有这样的结构。

class MyArray{
public:
       int* arr;
       int len;
       MyArray( int l ){
          arr = new int[l];
          len = l;
       }
       ~MyArray(){
          delete [] arr;
       }
    };

现在考虑有2个MyArray对象的场景

MyArray ob1(3); 
for( int i=0; i<3; i++ )
   ob1[i]=i*i; // ob1 = {0, 1, 4}
MyArray ob2(3);
for( int i=0; i<3; i++ )
   ob2[i]=i+1; // ob2 = {1, 2, 3}

现在如果我们做ob1 = ob2编译器会让arr 1指向arr 2，所以如果Ob 2变成{4，5，6} Ob 1也会变成{4，5，6}，这叫做浅拷贝。

MyArray& operator=(const MyArray& rhs){
     for( int i=0; i<rhs.len; i++ ) this.arr[i] = rhs[i];
 }

现在如果ob 2被改变了，ob 1不会受到影响，因为我们已经复制了数组，而不是指针副本，所以这叫做深度复制，这是重载=的主要情况之一。