Wie funktioniert RHS?

Question

Ich versuche C++ zu lernen und hier feststecken. Hier verstehe ich, dass rhs rechte Seite bedeutet, aber ich verstehe nicht, wie der Compiler versteht, dass "rhs" sich auf die rechte Seite bezieht. Und ich wäre mehr als froh, wenn jemand erklären könnte, in welchem ​​Fall diese Überladung notwendig ist.

MyArray<T>& operator=(const MyArray<T>& rhs); 

Vielen Dank an alle, euch die besten sind.

Answer 1

Der Compiler weiß nicht, dass rhs für "rechte Seite" steht, und in der Tat kann der Name dieser Variablen alles sein, was Sie möchten.

Der Compiler "weiß", wie dies zu formatieren ist, da die Syntax von operator= dies erfordert.

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

Die Sprache definiert die Verwendung dieser Bediener die Form anzunehmen:

A a, b; 
a = b; 

Der obige Code ruft A::operator=(const &other) gegen die Instanz von Aa genannt, und nutzt die Instanz von A namens b als other .

Answer 2

rhs ist nur ein Name, den Leute normalerweise für diesen Operator verwenden, er hat keine besondere Bedeutung. Die Art, wie der Operator definiert ist, macht das Argument immer zum rechten Element.

Answer 3

Wenn Sie etwas tun:

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

Der Zuweisungsteil ist eigentlich nur ein Funktionsaufruf:

a.operator=(b); 

nichts Besonderes los. Der Parametername spielt keine Rolle, nur die Signatur, die aus dem Rückgabetyp und den Parametertypen besteht, nicht aus Namen.

Answer 4

Wie bei jeder Funktion können Sie das Argument alles was Sie wollen nennen.

Arbeiten mit dem Beispiel mit dem Zuweisungsoperator, wenn Sie etwas haben, wie

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

, die auf

entsprechen

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

Die „rechte Seite“ einfach als Argument an einem normalen weitergegeben Mitgliedsfunktion.

Answer 5

Der Standardzuweisungsoperator auf eine Instanz desselben Typs hat den Prototyp

MyArray<T>& operator=(const MyArray<T>&);

Der Namen rhs normalerweise an die Funktionsparameter gegeben ist, da er auf der rechten Seite einer Zuweisung erscheint, wenn die Operator wird aufgerufen. Es verbessert die Lesbarkeit Ihres Quellcodes, das ist alles.

Answer 6

Ich gehe davon aus, dass MyArray eine solche Struktur haben wird.

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

Jetzt ein Szenario, wo es 2 Objekt von 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} 

Wenn wir nun ob1 = ob2 tun; Der Compiler würde arr1 auf arr2 zeigen, also wenn Ob2 geändert wird, um {4,5,6} zu sagen, dann wird Ob1 auch zu {4,5,6}, dies wird flache Kopie genannt. Um dieses Szenario zu vermeiden, müssen wir dieses Add

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

Nun, wenn oB 2 geändert wird ob1 nicht betroffen, weil wir das Array auf unseren eigenen nicht der Zeiger copy.So diese aufgerufen wird tiefe Kopie kopiert haben. Dies ist eines der wichtigsten Szenarien, in denen = überlastet ist.