Surcharge de l'opérateur >>

Question

Je suis très nouveau à la surcharge de l'opérateur C++ et j'ai des problèmes de démarrage.

J'ai défini:

vide opérateur Graph :: >> (const char * param)

La fonction ci-dessus a dû accepter une chaîne en entrée, puis effectuer certaines actions sur le chaîne. Comment appeler cette fonction? De quelles façons puis-je l'utiliser?

Answer 1

Graph myGraph; 
myGraph >> "bla"; 

Notez que le vôtre est une utilisation étrange de operator>>(). Normalement, il est utilisé comme ceci:

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

et

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

Answer 2

Si vous êtes nouveau à cela, vous avez choisi un problème assez intéressant (lire comme « pas simple ») pour tenter de résoudre.

Les surcharges de l'opérateur ne sont pas exactement des fonctions. Ils sont appelés indirectement lorsque le compilateur tente de résoudre le code qui ressemble à ceci:

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

Je vous recommande de ne le fait pas. La surcharge de l'opérateur peut entraîner des bogues très difficiles à résoudre, grâce aux effets secondaires. Ils sont également difficiles sur toute personne qui doit maintenir votre code (ce qui pourrait être vous après avoir oublié pourquoi vous l'avez fait).

Utilisez les surcharges de l'opérateur uniquement lorsque la signification et l'utilisation sont intuitives.

Answer 3

Je devine ce que vous en train d'essayer de faire est d'être en mesure d'écrire du code comme ceci:

cin >> myGraph; 
cout << myGraph; 

Notez que l'objet graphique n'est pas fait l'objet qui obtient sa méthode appelée.

Dans ce cas, ce que vous voulez vraiment faire est de surcharger l'opérateur global >> fonctions:

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

Answer 4

Si vous souhaitez définir l'opérateur de sorte que vous pouvez faire:

cin >> myGraph 
cout << myGraph 

Vous besoin de faire quelque chose comme cet exemple ci-dessous:

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); 

ensuite mettre en œuvre les opérateurs:

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; 
} 

Remarque: dans ce cas, l'entrée est structurée de façon à ce que ses membres soient publics. Si vous ne voulez pas les rendre publics, vous pouvez définir les méthodes de l'opérateur comme des amis afin qu'ils puissent accéder aux membres privés de Entry.

Voici comment l'entrée ressemblerait si elle les membres de ne sont pas publiques:

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); 
};