Problem beim Überladen des << - Operators

[Reyme]

Hallo
Ich hab mal wieder ein Problem:
Da in meinem "C++-Programmierer" gerade das Überladen von Operatoren durchgenommen wird, dachte ich mir, ich programmiere eine kleine Klasse für rationale Zahlen. Hier ein kleiner Codeausschnitt:

//rational.h

#ifndef RATIONAL_H
#define RATIONAL_H

class rational {
       [...]
}

[...]

rational operator+ (rational& r1, rational& r2);
std::ostream& operator<< (std::ostream& os, rational& r);

#endif //RATIONAL_H

//rational.cpp

#include "rational.h"

rational operator+ (rational& r1, rational& r2) {
     [...]
}

std::ostream& operator<< (ostream& os, rational& r) {
    return os << r.getzaehler() << " / " << r.getnenner();
}

Das Überladen des +-Operators funktioniert, aber beim compilieren des <<-Operators erhalte ich die Fehlermeldung

Fehler: "ofstream" im Namensbereich "std" bezeichnet keinen Typ

PS: Wenn das etwas helfen sollte: Ich arbeite mit Code::Blocks

Wäre schön wenn jemand eine Antwort für mich hätte

Oh ich habe mich verschrieben

bei rational.cpp das "return" weglassen

 

[sheel]

Hi

da gehört aber ein return.

In welcher Zeile wird er Fehler gezeigt?
ostream ist dreinmal mit std:: und einmal ohne.

 

[Reyme]

Das std hab ich jetzt noch ergänzt, die Fehlermeldung bleibt aber

Die Fehlermeldung bezieht sich auf Z. 13 von rational.h

 

[sheel]

Da Teile rausgenommen sind: Was ist bei dir Zeile 13?
Komplette Datei wäre sowieso hilfreich.

 

[Endurion]

Die Fehlermeldung sagt ofstream, überall sonst schreibst du aber ostream. Ist da ein f reingerutscht?

 

[Reyme]

Nein, da ist mir bei der Fehlermeldung ein f reingerutscht

Z. 13 bezieht sich auf den Code oben

Hier aber mal der komplette Code(weil er gewünscht ist):

//rational.h

#ifndef RATIONAL_H
#define RATIONAL_H

class rational {
    public:
        rational(int z, int n);
        rational(rational& r);

        void setzaehler(int z);
        void setnenner(int n);

        const int getzaehler();
        const int getnenner();

        const double getwert();

        bool operator>= (rational& r);
        bool operator<= (rational& r);
        bool operator<  (rational& r);
        bool operator>  (rational& r);
        bool operator== (rational& r);

        rational& operator= (rational& r);
    private:
        int zaehler;
        int nenner;
};

inline rational::rational(int z = 0, int n = 0)
    : zaehler(z), nenner(n) {};

inline rational::rational(rational& r)
    : zaehler(r.zaehler), nenner(r.nenner) {};

inline void rational::setzaehler(int z) {
    zaehler = z;
}

inline void rational::setnenner(int n) {
    nenner = n;
}

inline const int rational::getnenner() {
    return nenner;
}

inline const int rational::getzaehler() {
    return zaehler;
}

inline const double rational::getwert() {
    return static_cast<double> (zaehler) / static_cast<double>(nenner);
}

rational operator+ (rational& r1, rational& r2);
std::ostream& operator<< (std::ostream& os, rational& r);

#endif //RATIONAL_H

und

//rational.cpp

#include "rational.h"

rational operator+ (rational& r1, rational& r2) {
    rational temp(0, 0);
    temp.setzaehler(r1.getzaehler() * r2.getnenner() + r2.getzaehler() * r1.getnenner());
    temp.setnenner(r1.getnenner() * r2.getnenner());

    return temp;
}

inline bool rational::operator>=(rational& r) {
    return getwert() >= r.getwert();
}

inline bool rational::operator<=(rational& r) {
    return getwert() <= r.getwert();
}

inline bool rational::operator< (rational& r) {
    return getwert() < r.getwert();
}

inline bool rational::operator> (rational& r) {
    return getwert() > r.getwert();
}

inline bool rational::operator== (rational& r) {
    return getwert() == r.getwert();
}

rational& rational::operator= (rational& r) {
    zaehler = r.getzaehler();
    nenner = r.getnenner();

    return *this;
}

std::ostream& operator<< (std::ostream& os, rational& r) {
    return os << r.getzaehler() << '/' << r.getnenner();
}

Jetzt bezieht sich die Fehlermeldung auf Z. 58 der "rational.h" Datei

 

[deepthroat]

Hi.

Wenn du std:stream in einer Datei verwenden willst, mußt du natürlich auch die entsprechende Headerdatei einbinden welche diesen Typ deklariert. Da ist die Fehlermeldung doch eigentlich hinreichend deutlich...

Übrigens ist "const" als Modifzierer bei Rückgabetypen unsinnig. Die get Methoden solltest du stattdessen als const markieren:

// nicht so:
const /* <-- hat keine Wirkung */ double getwert();

// sondern so:
double getwert() const;

Gruß

 

[Matthias Reitinger]

Hallo,

du hast vergessen, in rational.h den Header <ostream> einzubinden:

#include <ostream>

Grüße,
Matthias

\edit: Zu langsam…

Um doch noch was Neues beizutragen: an allen Stellen in deinem Code, an denen du eine Referenz als Argument übergibst, kannst du genauso gut auch eine Const-Referenz übergeben. Du modifizierst die übergebenen Instanzen schließlich nicht. Ansonsten kannst du z.B. kein const rational addieren oder ausgeben.

 

[Reyme]

Vielen Dank für die Hilfe

 

[Reyme]

Aber wenn wir schonmal dabei sind über überladene Operatoren zu reden:

Gibt es eigentlich eine feste Regel, wann man die Übergabe per Referenz oder per Wert verwendet oder muss man sich in jedem einzelnen Fall Gedanken dazu machen?