Ordine di risoluzione di sovraccarico dell'operatore che coinvolge provvisori

Question

consideri il seguente esempio minimale:

#include <iostream> 

using namespace std; 

class myostream : public ostream { 
    public: 
     myostream(ostream const &other) : 
      ostream(other.rdbuf()) 
     { } 
}; 

int main() { 
    cout << "hello world" << endl; 

    myostream s(cout); 
    s << "hello world" << endl; 

    myostream(cout) << "hello world" << endl; 
} 

L'uscita, sia sul g ++ e Visual C++, è

hello world 
hello world 
0x4012a4 

La versione che scrive ad un oggetto temporaneo , myostream(cout), sembra preferire l'operatore membro ostream::operator<<(void *), anziché l'operatore libero operator<<(ostream &, char *). Sembra fare la differenza se l'oggetto ha o meno un nome.

Perché succede? E come posso prevenire questo comportamento?

Edit: Perché succede è ormai chiaro da varie risposte. Per quanto riguarda come evitare ciò, sembra interessante quanto segue:

class myostream : public ostream { 
    public: 
     // ... 
     myostream &operator<<(char const *str) { 
      std::operator<<(*this, str); 
      return *this; 
     } 
}; 

Tuttavia, questo si traduce in tutti i tipi di ambiguità.

Answer 1

rvalues ​​non possono essere tenuti a riferimento non-const. Quindi nel tuo esempio il temporaneo di tipo ostream non può essere il primo argomento dell'operatore libero < < (std :: ostream &, char const *) e ciò che viene utilizzato è l'operatore membro < < (void *).

Se ne avete bisogno, è possibile aggiungere una chiamata come

myostream(cout).flush() << "foo"; 

che trasformerà il rvalue in un punto di riferimento.

Si noti che in C++ 0X, l'introduzione del riferimento di rvalue consentirà di sovraccaricare l'operatore < < prendendo come riferimento i riferimenti rvalue, risolvendo la causa principale del problema.

Answer 2

Ho appena realizzato parte della risposta. Il temporaneo non è un lvalue, quindi non può essere utilizzato come argomento di tipo ostream &.

La domanda "come posso fare questo lavoro" rimane ...

Answer 3

Se un oggetto non ha un nome (cioè si tratta di un temporaneo), non può essere associato a un riferimento non-const. In particolare, non può essere vincolata al primo parametro di:

operator<<(ostream &, char *) 

Answer 4

Beh, non so le specifiche C++ che causa questo, ma è facile da suss fuori perché succede.

Una vita temporanea in pila, in genere da passare a un'altra funzione o per far eseguire un'unica operazione su di essa. Quindi, se si chiama l'operatore libero su di esso:

operatore < < (myostream (cout))

Si è distrutto al termine di questa operazione e il secondo operatore "< <" per aggiungere l'endl sarebbe fare riferimento a un oggetto non valido. Il valore restituito dall'operatore "" libero sarebbe un riferimento a un oggetto temporaneo destructed. Le specifiche del C++ probabilmente definiscono le regole sugli operatori gratuiti per evitare che questo scenario possa frustrare e confondere i programmatori C++.

Ora, nel caso di un "< < (void *)" operatore membro sul temporaneo, il valore restituito è l'oggetto stesso, che è ancora in pila e non distrutto, quindi il compilatore sa di non distruggere ma per passarlo al prossimo operatore membro, quello che prende il file. L'operatore che concatena sui temporari è una caratteristica utile per il codice C++ succinto, quindi sono sicuro che i progettisti di specifiche C++ lo hanno considerato e implementato il compilatore per supportarlo intenzionalmente.

modificare

Alcuni hanno detto che è a che fare con un riferimento non-const.Questo codice viene compilato:

#include <iostream> 
using namespace std; 
class myostream : public ostream { 
    public: 
     myostream(ostream const &other) : 
      ostream(other.rdbuf()) 
     { } 
      ~myostream() { cout << " destructing "; } 
    }; 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    basic_ostream<char>& result = std::operator << (myostream(cout), "This works"); 
    std::operator << (result, "illegal"); 
     return 0; 
} 

e restituisce

This works destructing illegal 

Answer 5

Poiché nessuna delle risposte finora sembra dare una soluzione pulita, mi accontenterò della soluzione sporca:

myostream operator<<(myostream stream, char const *str) { 
    std::operator<<(stream, str); 
    return stream; 
} 

Questo è possibile solo perché myostream ha un costruttore di copia. (Internamente, è supportato da un conteggio std::stringbuf.)

Answer 6

Mentre C++ 11 risolve questo problema poiché ci sono riferimenti di rvalue, penso che questo potrebbe essere una soluzione alternativa per il pre-C++ 11.

La soluzione è quella di avere una funzione di membro < < operatore dove possiamo lanciare a un riferimento non const alla classe di base:

class myostream : public ostream { 
    public: 
     // ... 
     template<typename T> 
     ostream &operator<<(const T &t) { 
      //now the first operand is no longer a temporary, 
      //so the non-member operators will overload correctly 
      return static_cast<ostream &>(*this) << t; 
     } 
};