L'operatore +, differenza tra tipi di classi e tipi built-in?

Question

Sono nuovo del C++. Il libro che ho letto mi dice che se l'operatore più (+) è stato sovraccaricato per qualche oggetto di classe, ad esempio la classe string, per rendere questo problema più concreto.

#include<iostream> 
#include<string> 
using namespace std; 

int main() 
{ 
    string s1("abc"); 
    string s2("def"); 

    string s3("def"); 

    cout<<(s1+s2=s3)<<endl; 

    int x=1; 
    int y=2 
    int z=3; 
    cout<<(x+y=z)<<endl; 

    return 0; 
} 

Come ci si potrebbe aspettare, la prima cout affermazione è corretta, mentre il secondo è sbagliato. Il reclamo del compilatore x+y non è un lvalue modificabile. La mia domanda è: perché l'operatore + restituisce un lvalue modificabile per gli oggetti string ma non per int?

Answer 1

Non restituisce un lvalue modificabile per la stringa. Restituisce un oggetto temporaneo e s1+s2 e x+y sono entrambi rvalues.

Tuttavia, gli oggetti di tipo classe potrebbero aver sovraccaricato operator=, che fa string. È consentito chiamare le funzioni membro su rvalue.

La differenza tra i due casi è in = (non +)

Answer 2

Per std::string, s1 + s2 = s3 è infatti:

(operator+(s1, s2)).operator =(s3) 

s1 + s2 restituisce un rvalue

metodi Stati possono essere applicati a anche temporaneo.
Poiché C++ 11, abbiamo la qualificazione lvalue/rvalue per il metodo,
in modo da può vietare o1 + o2 = o3 per il vostro tipo personalizzato con:

struct Object 
{ 
    Object& operator =(const Object& rhs) & ; // Note the & here 
}; 

così Object::operator = può essere applicato solo alle lvalue.