"Freund" -Funktionen und & lt; & lt; Überladen des Operators: Was ist der richtige Weg, um einen Operator für eine Klasse zu überlasten?

In einem Projekt an dem ich arbeite, ich habe eine Score Klasse, unten in score.h. Ich bin versucht zu überlasten es so, wenn ein << operation durchgeführt wird, _points + " " + _name gedruckt wird.

Hier ist, was ich versuchte zu tun:

ostream & Score::operator<< (ostream & os, Score right)
{
    os << right.getPoints() << " " << right.scoreGetName();
    return os;
}

Hier sind die Fehler zurückgegeben:

score.h(30) : error C2804: binary 'operator <<' has too many parameters

(Dieser Fehler erscheint 4-mal, eigentlich)

Habe ich es geschafft es zum laufen zu bringen, indem er die überlastung als friend-Funktion:

friend ostream & operator<< (ostream & os, Score right);

Und entfernen der Score:: von der Deklaration der Funktion in score.cpp (effektiv nicht deklarieren, es als Mitglied).

Warum funktioniert das, aber die erstere Stück code nicht?

Vielen Dank für Ihre Zeit!

BEARBEITEN

Löschte ich alle Erwähnungen der überlastung, die auf der header-Datei... aber ich bekomme die folgenden (und nur die) Fehler. binary '<<' : no operator found which takes a right-hand operand of type 'Score' (or there is no acceptable conversion)
Wie kommt mein test in der main(), kann nicht finden die passenden überlastung? (es ist nicht das zählen, das habe ich überprüft)

Unten ist die volle Punktzahl.h

#ifndef SCORE_H_
#define SCORE_H_

#include <string>
#include <iostream>
#include <iostream>

using std::string;
using std::ostream;

class Score
{

public:
    Score(string name);
    Score();
    virtual ~Score();
    void addPoints(int n);
    string scoreGetName() const;
    int getPoints() const;
    void scoreSetName(string name);
    bool operator>(const Score right) const;

private:
    string _name;
    int _points;

};
#endif

InformationsquelleAutor der Frage Francisco P. | 2010-05-13

  1. 54

    Hinweis: vielleicht möchten Sie sich an der operator überladen FAQ.

    Binäre Operatoren können entweder Mitglieder der linken-hand-argument der Klasse oder Kostenlose Funktionen. (Einige Betreiber, wie Zuordnung, müssen Mitglieder sein.) Da die stream-Operatoren' linken-hand-argument ist ein stream, stream-Operatoren müssen entweder Mitglieder der stream-Klasse oder Kostenlose Funktionen. Die kanonische Implementierung der operator<< für jede Art ist diese: 

    std::ostream& operator<<(std::ostream& os, const T& obj)
{
   //stream obj's data into os
   return os;
}

    Beachten Sie, dass es nicht eine member-Funktion. Beachten Sie auch, dass es dauert, das Objekt stream pro const Referenz. Das ist, weil Sie nicht wollen, um das Objekt zu kopieren, um zu streamen, und Sie nicht möchten, dass das streaming zu ändern.

    Manchmal werden Sie wollen, um stream-Objekte, deren Einbauten nicht zugänglich sind, die durch Ihre Klasse " öffentliche Schnittstelle, so kann der Betreiber nicht an. Dann haben Sie zwei Möglichkeiten: Entweder setzen Sie eine öffentliche member in der Klasse, die die streaming -

    class T {
  public:
    void stream_to(std::ostream&) const {os << obj.data_;}
  private:
    int data_;
};

    und rufen, dass vom Betreiber: 

    inline std::ostream& operator<<(std::ostream& os, const T& obj)
{
   obj.stream_to(os);
   return os;
}

    oder den Betreiber einer friend 

    class T {
  public:
    friend std::ostream& operator<<(std::ostream&, const T&);
  private:
    int data_;
};

    so, dass es Zugriff auf die Klasse' private parts: 

    inline std::ostream& operator<<(std::ostream& os, const T& obj)
{
   os << obj.data_;
   return os;
}

    InformationsquelleAutor der Antwort sbi

  2. 9

    Lassen Sie uns sagen, Sie wollten schreiben Sie eine operator-überladung für + so könnte man hinzufügen, zwei Score Objekte zu einander, und die anderen, so könnte man hinzufügen, eine int zu einem Scoreund eine Dritte, so könnte man hinzufügen, eine Score zu einem int. Diejenigen, bei denen eine Score ist der erste parameter können member-Funktionen der Partitur. Aber bei dem ein int ist der erste parameter kann nicht Mitglied werden Funktionen von intrichtig? Helfen Sie mit, dass Sie erlaubt sind, um Ihnen zu schreiben, als freie Funktionen. Das ist das, was passiert mit diesem << Betreiber, Sie können nicht fügen Sie eine Mitglied-Funktion zum ostream so schreiben Sie eine freie Funktion. Das ist, was es bedeutet, wenn Sie nehmen die Score:: Teil.

    Nun, warum es eine friend? Tut es das nicht. Du bist nur den Aufruf von öffentlichen Methoden (getPoints und scoreGetName). Sie sehen, viele Freund-Operatoren, weil Sie gerne sprechen Sie direkt mit den privaten Variablen. Es ist ok von mir, das zu tun, weil Sie sind, geschrieben und verwaltet von der person maintaing die Klasse. Nur nicht den Freund Teil konfus mit der member-Funktion-vs-free-Funktion Teil.

    InformationsquelleAutor der Antwort Kate Gregory

  3. 6

    Du bist immer Kompilierungsfehler, wenn operator<< ist eine member-Funktion in das Beispiel, weil Sie erstellen ein operator<< nimmt Score als der erste parameter (das Objekt die Methode aufgerufen wird), und dann gibt es einen zusätzlichen parameter am Ende.

    Wenn Sie anrufen ein binärer operator, der erklärte, wie eine member-Funktion, die linke Seite des Ausdrucks ist das Objekt die Methode aufgerufen wird. z.B. a + b könnte, wie das funktioniert:

    A a;
B b

a.operator+(b)

    Es ist in der Regel vorzuziehen, die nicht Mitglied sind binäre Operatoren (und in einigen Fällen-z.B. operator<<für ostream ist der einzige Weg, es zu tun. In diesem Fall a + b funktionieren könnte wie dieser:

    A a;
B b

operator+(a, b);

    Hier ist ein vollständiges Beispiel zeigt beide Möglichkeiten, es zu tun; main() wird der Ausgabe - '55' drei Zeiten:

    #include <iostream>

struct B
{
    B(int b) : value(b) {}
    int value;
};


struct A
{
    A(int a) : value(a) {}
    int value;

    int operator+(const B& b) 
    {
        return this->value + b.value;
    }
};

int operator+(const A& a, const B& b)
{
    return a.value + b.value;
}

int main(int argc, char** argv)
{
    A a(22);
    B b(33);

    std::cout << a + b << std::endl;
    std::cout << operator+(a, b) << std::endl;
    std::cout << a.operator+(b) << std::endl;

    return 0;
}

    InformationsquelleAutor der Antwort pkh

Schreibe einen Kommentar