Wie Überladen + = Operator, um eine Zeichenfolge zurückzugeben?

Question

Ich habe nur eine kurze Frage: Wie kann ich den Operator + = überladen, um eine Zeichenfolge zurückzugeben. Hier ist, was ich versucht habe, aber ohne Erfolg.

// 'Student' is the class that this function is in 
// 'get_name()' returns the name of the student 
// 'get_grade()' returns the grade of the student 
// Description: 
// Ultimately I will be creating a list of students and their grades in 
// the format of (Student1, Grade1) (Student2, Name2) ... (StudentN, GradeN) 
// in a higher level class, and thus I need an overloaded += function. 
Student& Student::operator+=(const Student& RHS) 
{ 
    string temp_string; 
    temp_string = "(" + RHS.get_name() + ", " + RHS.get_grade() + ") "; 
    return temp_string; 
} 

Answer 1

Rein technisch:

// v NO reference here! 
std::string Student::operator+=(const Student& rhs) 
{ 
    string temp_string; 
    temp_string = "(" + rhs.get_name() + ", " + rhs.get_grade() + ") "; 
    return temp_string; 
} 

ABER:

Was soll die Bedeutung dieses sein? Erstens, was ist das Ergebnis der Summe von zwei Studenten im Allgemeinen? Ein anderer Schüler? Wie würdest du das in der menschlichen Sprache interpretieren? Fängt schon verwirrend an. Dann werfen Sie einen Blick auf die folgenden:

int x = 10; 
x += 12; 

Sie erwarten x danach den Wert zu halten, 22. Insbesondere: x wurde geändert (es sei denn, Sie hinzugefügt Null ...). Ihr Operator ändert im Gegensatz this in keiner Weise - es sieht nicht einmal ... Wie würden Sie das Hinzufügen eines anderen Schülers zu thisjetzt interpretieren? Vor allem: Mit einem Operator + akzeptieren zwei Studenten, könnten Sie eine Art von Paar oder Familie zurückgegeben haben, aber mit + =, Ändern der Ergebnisart ??? Was ist, wenn x += 7 x nicht geändert hat, aber ein Double zurückgegeben hat? Siehst du, wie verwirrend das alles wird?

Auf der anderen Seite, könnte ich mir vorstellen, aber, dass Sie tatsächlich für die explizite Cast-Operator statt suchen:

operator std::string() 
{ 
    std::string temp_string; 
    temp_string = "(" + this->get_name() + ", " + this->get_grade() + ") "; 
    return temp_string; 
} 

Auf diese Weise Sie einen Schüler in eine Zeichenfolge, e hinzufügen könnte. G. wie folgt:

Student s; 
std::string str; 
str += s; 

Oder möchten Sie Schüler an Ausgangsströme übergeben? Dann folgt aus:

std::ostream& operator<<(std::ostream& stream, Student const& s) 
{ 
    stream << "(" << s.get_name() << ", " << s.get_grade() << ") "; 
    return stream; 
} 

Mit oben, könnten Sie Cast-Operator zu reduzieren:

operator std::string() 
{ 
    std::ostringstream s; 
    s << *this; 
    return s.str(); 
} 

Es ist sogar möglich, ein Motto zu haben:

operator std::string() 
{ 
    return static_cast < std::ostringstream& >(std::ostringstream() << *this).str(); 
} 

Nun, zugegeben, wenn es wirklich netter mit dieser Besetzung notwendig ist diskutierbar ...