Problem beim Überladen des << - Operators

Reyme

Grünschnabel
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:

Code:
//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

Code:
//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 :)
 
Hi

da gehört aber ein return.

In welcher Zeile wird er Fehler gezeigt?
ostream ist dreinmal mit std:: und einmal ohne.
 
Das std hab ich jetzt noch ergänzt, die Fehlermeldung bleibt aber :(

Die Fehlermeldung bezieht sich auf Z. 13 von rational.h
 
Da Teile rausgenommen sind: Was ist bei dir Zeile 13?
Komplette Datei wäre sowieso hilfreich.
 
Die Fehlermeldung sagt ofstream, überall sonst schreibst du aber ostream. Ist da ein f reingerutscht?
 
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):

Code:
//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

Code:
//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 :)
 
Hi.

Wenn du std::eek: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... :confused:

Übrigens ist "const" als Modifzierer bei Rückgabetypen unsinnig. Die get Methoden solltest du stattdessen als const markieren:
C++:
// nicht so:
const /* <-- hat keine Wirkung */ double getwert();

// sondern so:
double getwert() const;
Gruß
 
Hallo,

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

C++:
#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.
 
Zuletzt bearbeitet:
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?
 
Zurück