Operator überladen >>

Question

Ich bin sehr neu zu C++ Operator Überladung und einige Kinderkrankheiten Probleme.

Ich habe definiert:

Leere Graph :: operator >> (const char * param)

Die obige Funktion eine Zeichenkette als Eingabe akzeptieren musste und führen Sie dann bestimmte Aktionen auf der Zeichenfolge. Wie rufe ich diese Funktion auf? Wie kann ich es benutzen?

Answer 1

Graph myGraph; 
myGraph >> "bla"; 

Beachten Sie, dass Ihre eine seltsame Verwendung von operator>>() ist. Normalerweise ist es so benutzten:

NumericObject NumericObject::operator>>(NumericObject const& operand) const; 
// bitshifts to the right 

und

std::istream& operator>>(istream& in, StreamableObject& obj); 
// parses a string representation of obj 

Answer 2

Wenn Sie diese neu sind, können Sie eine recht interessante gepflückt (gelesen als „nicht einfach“) Problem zu lösen zu versuchen.

Die Überladungen des Operators sind nicht genau Funktionen. Sie werden indirekt aufgerufen, wenn der Compiler Code zu lösen versucht, die etwa wie folgt aussieht:

Graph g = new Graph(); 
g >> "do something"; 

empfehle ich Ihnen dies nicht tun. Überladung des Operators kann zu SEHR schwierigen Bugs führen, dank der Nebenwirkungen. Sie sind auch schwer auf jemanden, der Ihren Code pflegen muss (was vielleicht der Fall ist, nachdem Sie vergessen haben, warum Sie das getan haben).

Verwenden Sie Operator-Überladungen nur, wenn deren Bedeutung und Verwendung intuitiv ist.

Answer 3

Ich vermute, was Sie wirklich zu tun versuchen, ist in der Lage sein, Code zu schreiben, wie folgt aus:

cin >> myGraph; 
cout << myGraph; 

Beachten Sie, dass das Diagrammobjekt ist nicht wirklich das Objekt, das seine Methode aufgerufen wird.

In diesem Fall, was Sie wirklich wollen, ist zu tun, um die globalen Operator >> Funktionen überlasten:

std::istream& operator>> (std::istream&, graph&); 
std::ostream& operator<< (std::ostream&, const graph&); 

Answer 4

Wenn Sie Operator definieren wollen, so dass Sie tun können:

cin >> myGraph 
cout << myGraph 

Sie so etwas wie dieses Beispiel müssen unten tun:

struct Entry 
{ 
    string symbol; 
    string original; 
    string currency; 

    Entry() {} 
    ~Entry() {} 
    Entry(string& symbol, string& original, string& currency) 
     : symbol(symbol), original(original), currency(currency) 
    {} 
    Entry(const Entry& e) 
     : symbol(e.symbol), original(e.original), currency(e.currency) 
    {} 
}; 


istream& operator>>(istream& is, Entry& en); 
ostream& operator<<(ostream& os, const Entry& en); 

Dann Betreiber implementieren:

istream& operator>>(istream& is, Entry& en) 
{ 
    is >> en.symbol; 
    is >> en.original; 
    is >> en.currency; 
    return is; 
} 

ostream& operator<<(ostream& os, const Entry& en) 
{ 
    os << en.symbol << " " << en.original << " " << en.currency; 
    return os; 
} 

Hinweis: In diesem Fall ist der Eintrag struct so dass seine Mitglieder öffentlich sind. Wenn Sie sie nicht veröffentlichen möchten, können Sie die Operatormethoden als Freunde definieren, damit sie auf private Mitglieder von Entry zugreifen können.

Hier ist, wie Eintrag aussehen würde, wenn es den Mitgliedern nicht öffentlich waren:

struct Entry 
{ 
    private: 
     string symbol; 
     string original; 
     string currency; 

    public: 
     Entry() {} 
     ~Entry() {} 
     Entry(string& symbol, string& original, string& currency) 
      : symbol(symbol), original(original), currency(currency) 
     {} 
     Entry(const Entry& e) 
      : symbol(e.symbol), original(e.original), currency(e.currency) 
     {} 

     friend istream& operator>>(istream& is, Entry& en); 
     friend ostream& operator<<(ostream& os, const Entry& en); 
};