Si può scambiare la direzione di e sovraccarichi per definirli come membri della classe?

I sovraccarichi dell'operatore in C ++ sono zucchero sintattico , niente di più. Il tuo esempio funzionerà bene: tuttavia, considera due cose. In primo luogo, in che modo le persone si aspettano che gli operatori di streaming (operatori tecnicamente bitshift) funzionino? Si aspettano che possano essere incatenati : la seconda idea da considerare è come funziona il tuo esempio con il concatenamento?

Dato questo codice:

std::cout << obj1 << obj2 << std::endl;

Ciò che sta realmente succedendo è questo, una volta rimosso lo zucchero sintattico:

std::cout.operator<<(obj1).operator<<(obj2).operator<<(std::endl);

Ricorda che operator<<() restituisce un riferimento a *this per convenzione (true nella libreria standard e una buona idea in generale per consentire di concatenare gli operatori in questo modo). Ciò significa che tutte queste chiamate sono invocate su std::cout , il primo oggetto a cui si fa riferimento in quella dichiarazione.

Ora considera il tuo esempio:

obj >> std::cout;

Se lo estendi per concatenare più oggetti, potresti ottenere questo:

obj1 >> obj2 >> std::cout;

Che assomiglierebbe a questo se convertito in chiamate di funzioni appropriate:

obj1.operator>>(obj2).operator>>(std::cout);

Ciò significa che sì, è possibile invertire l'ordine, ma si romperà e non si comporterà come i programmatori C ++ si aspettano una volta che si concatenano più funzioni insieme.

Scambiare la direzione degli operatori I / O per spostare gli operandi sul lato sinistro sarebbe tecnicamente possibile, ma il "concatenamento" che viene spesso utilizzato per lo streaming I / O sarebbe quantomeno ingombrante. Invece di

std::cout << "The result is " << result << endl;

dovresti scrivere o

"The result is " >> std::cout;
result >> std::cout;
std::endl >> std::cout;

o

std::endl >> (result >> ("The result is " >> std::count));

che sembra innaturale.

Insieme con i problemi già citati (che per lo più si riducono alla mancanza di concatenamento), qui c'è un altro problema fondamentale. Considera cosa succede se provi a lavorare con un tipo integrato nel compilatore:

int x;

x << std::cin;

In mancanza di una funzione libera sovraccaricata per eseguire il lavoro, questo proverebbe a fare x.operator<<(std::cin); . Poiché x è di tipo int , non contiene e non può contenere operatori sovraccaricati.

Quindi, per tutti i tipi built-in, dovresti ancora implementare il sovraccarico come una funzione libera come fai adesso, oppure creare wrapper come Integer di Java solo per gestire questi sovraccarichi. Né sembra (almeno per me) fornire alcun significativo miglioramento rispetto alla situazione attuale.