Was bedeutet & - operator bedeutet überlastung

Lese ich ein C++ Buch.
Das Programm versucht, einen Vektor von Objekten.
Hier ist der Teil den ich nicht verstehe

class X {
public:
    X();
    X(int m) {
        temp = x;
    }

    int temp;


    X &operator =(int z) {
        temp = z;
        return *this;
    }

private :
    //           Some functions here
}

Was bedeutet die obige Zeile bedeutet?
Ist dies eine Art der überlastung?
Dann, wie?

Bitte überprüfen Sie Ihren code. Ich bin mir sicher, dass das Programm in diesem Buch nicht so Aussehen, weil es nicht immer kompilieren.
Ich befestigte den code bis gerade genug, um schmackhaft

InformationsquelleAutor | 2012-02-06

c++class overloading stl vector

6

Ich nehme an, Sie haben einen Tippfehler und das die Zeile eigentlich lautet:
```
X &operator =(int z) {
```
Den & bedeutet, dass der Rückgabetyp ist ein Verweis; Sie sollten dies Lesen als Funktion operator = gibt eine Art von X &.
- bedeutet Es eine form von operator überladen !!
- Soweit ich sehen kann, eine überlastung nicht beteiligt ist, in diesem code, überall.
- Es heißt "operator überladen" sowieso, da Sie die überlastung der fundamentalen Bedeutung von x = y für Ihre Klasse geben.
InformationsquelleAutor Mark Ransom
4

Die Bedeutung vielleicht klarer, wenn du den Abstand etwas:
```
X& operator= (int z)
```
Dass ein überladen des zuweisungsoperators, operator= nimmt, die eine int argument, und liefert eine Referenz auf class X.

Können Sie es verwenden zum zuweisen einer integer-Wert in ein Objekt:
```
X x;
x = 42; //calls the overloaded operator
```
Den Rückgabewert können Sie kettenbelegung:
```
X x1,x2;
x1 = x2 = 42;   //equivalent to `x2 = 42; x1 = x2;`
(x1 = x2) = 42; //equivalent to `x1 = x2; x1 = 42;`
```
- Natürlich Recht, aber diese Art der Verkettung würde auch funktionieren, wenn operator= zurückgegebenen Wert.
- Ja, wenn die Klasse kopierbar.
- Eine nicht-kopierbaren-Klasse mit einer Kopie Zuweisungsoperator wäre seltsam.
- In der Tat, aber dies ist nicht ein copy-Zuweisungsoperator; es ist die Zuweisung von einem anderen Typ. Trotzdem, der Vollständigkeit halber habe ich die Art der Verkettung, der braucht eine nicht-const Referenz.
InformationsquelleAutor Mike Seymour

Wohl, Ihr code sollte wie folgt Aussehen:

class X {
public:
    int temp;
private :
    //Some functions here 
    X &operator =(int z) 
    {
        temp = z; 
        return *this ;
    }
};

Und als Sie sich mit operator=, nicht &operator

Ihre operator = gibt Referenz auf das Objekt angewendet.

InformationsquelleAutor Lol4t0

1

Bedeutet dies: C^* und C++ erlauben, Sie an die Kette Zuordnungen wie diese
```
((x = 4) = 3) = 2;
```
das Ergebnis davon ist, dass x haben den Wert 2: x ist, den ersten Satz zu 4, dann 3, dann auf 2 (nicht sehr nützlich, wie es scheint, aber Variationen dieses machen große Kurzschrift-Ausdrücke). Für diese Arbeit, die folgenden Anforderungen zu passieren, darunter:
```
x = 4;
X& x2 = x;  //reference to x, so that it can be modified without explicitly writing x
x2 = 3;     //since x2 is just an alias, the variable that's actually changed is x
X& x3 = x2; //again, x2 just refers to x, so now x3 also does
x3 = 2;     //yet again, modifies x
```
*in C, es tut natürlich nicht mit Referenzen arbeiten, aber das Ergebnis ist das gleiche.

InformationsquelleAutor leftaroundabout
0

Es ist X& operator= (int z) ich denke, dass ist zu sagen, dass eine überlastung der = - operator nimmt eine int und eine Referenz auf X.

InformationsquelleAutor Geoffroy
0

Es ist die definition der Zuweisungsoperator: Es könnte besser Aussehen, formatiert wie in dieser (out-of-line-definition):
```
X & X::operator=(int z)
{
    temp = z;
    return *this;
}
```
Ermöglicht es Ihnen zu schreiben, so etwas wie dieses:
```
X a, b, c(10);
a = b = c;
```
Den Wert jeder Zuordnung Teilausdruck ist eine Referenz an den Zessionar.

Können, muss der Anwender sein erklärt innerhalb der definition der Klasse natürlich:
```
class X
{
public:
    X & operator=(int);
    //...
};
```
InformationsquelleAutor Kerrek SB

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.