operator << überladen *help*



  • hallo;
    ich habe ein problem;
    cih willd en operator der klasse cout ü+berladen (<<)
    da der aber alles nach hinten durchschiebt geht das nicht so einfach.
    könnt ihr mir sagen, wie ich die funktion programmieren muss?
    meine klasse:

    private:
      	int tag, std, min, sec;
    
     public:
             tUhrzeit(int std, int min, int sec);
    	void normalisiere();
             void set_std(int std);
    	void set_min(int min);
    	void set_sec(int sec);
             int get_std(){return std;};
    	int get_min(){return min;};
    	int get_sec(){return sec;};
    .
    .
    .
    
             ostream &operator << (tUhrzeit h); // ist das auch richtig deklariert?
    
    };
    
    ostream tUhrzeit::&operator <<(tUhrzeit h)
    {
     /*
     // 1:05:03 als besipiel ausgabe;
    */
    }
    

    ich wil dan in main() zum beispiel einfach schreiben können:

    void main()
    {
     tUhrzeit t1;
     cout << t1;
    }
    

    könnt ihr mir da vielleicht helfen?
    das wäre super lieb.
    danke



  • den mußt du als globale Funktion überladen:

    ostream& operator<<(ostream& in,const tUhrzeit& zeit)
    {
      //..
      return in;
    }
    


  • CStoll schrieb:

    den mußt du als globale Funktion überladen:

    ostream& operator<<(ostream& in,const tUhrzeit& zeit)
    {
      //..
      return in;
    }
    

    ähm joa;
    also was schreibe ich denn dann in der funktion?

    in+=zeit.get_std();
    in+= ":";
    in+=zeit.get_min();
    in+=":";
    in+=zeit.get_sec();

    oder wie?
    hättest da mal kot? :p



  • Dieser Thread wurde von Moderator/in Jansen aus dem Forum VCL/CLX (Borland C++ Builder) in das Forum C++ verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.



  • Du musst zunächst die Funktion als friend innerhalb Deiner Klasse deklarieren, damit der Compiler das auch als Funktion erkennt.

    class tUhrzeit
    {
        ...
        friend ostream& operator<<( ostream& out, const tUhrzeit& zeit );
    };
    

    innerhalb der Funktion kannst Du dann auf die private Member zugreifen. z.B.:

    ostream& operator<<( ostream& out, const tUhrzeit& zeit )
    {
        const char* tage[] = {"Mo", "Di", "Mi", "Do", "Fr", "Sa", "So" };
        return out << tage[zeit.tag] << " " << zeit.std << ":" << zeit.min << ":" << zeit.sec;
    }
    

    Gruß
    Werner



  • Ich kann diesen Artikel sehr empfehlen, da er genau das Thema behandelt (auch wenn es zu Anfang nicht so ausschaut):
    http://www.artima.com/cppsource/streamstrings.html



  • Es gibt keinen Grund, die Funktion als friend zu deklarieren. Solange du über das öffentliche Interface an die Daten kommst, was ja bei tUhrzeit der Fall ist, sollte dieses verwendet werden.

    Gruß

    Tommi



  • Es gibt auch keinen Grund, die Funktion nicht als friend zu deklarieren - zumindest wenn du per Direktzugriff schneller an deine Daten kommst als über das Interface, ist das von Vorteil 😉



  • CStoll schrieb:

    Es gibt auch keinen Grund, die Funktion nicht als friend zu deklarieren - zumindest wenn du per Direktzugriff schneller an deine Daten kommst als über das Interface, ist das von Vorteil 😉

    Grund



  • Der "Grund" ist Käse - auch friend-Funktionen gehören zum Interface der Klasse (siehe z.B. C++ FAQ).



  • CStoll (off) schrieb:

    Der "Grund" ist Käse - auch friend-Funktionen gehören zum Interface der Klasse (siehe z.B. C++ FAQ).

    Ich stimme mit dem von dir verlinkten Text vollkommen überein. Könntest du mir kurz erläutern wie er deiner Ansicht nach ein Gegenargument zu dem von mir genannten Grund darstellt?

    Und bezüglich "auch friend-Funktionen gehören zum Interface der Klasse": was genau willst du damit aussagen? Dass friend-Funktionen zum Interface der Klasse gehören? Schön, und weiter?



  • Kurz gesagt - friend-Funktionen sind ein Teil der Klasse, gehören also auch zur Implementation. Und normalerweise schreibst du die Funktionen/Klassen auch selber, denen du friend-Zugriff geben willst. Also kannst du auch kontrollieren, was sie mit deinen Daten machen -> friend-Zugriff beeinflußt die Datenkapselung überhaupt nicht.



  • Ich glaube, das Gengenargument besteht darin, dass dern00b den Operator als Member definieren wollte, dies aber nicht erlaubt ist.
    Es besteht für ihn der Zwang das gewünschte Interface der Klasse aufzusplitten. Der << Operator soll oft Dinge, die privat bleiben sollen, zu Serialisierungszwecken auslesen dürfen. Wenn es sowieso öffentliche Ausleseschnittstellen für alle benötigten Daten gibt, sollte man den Operator aber nur zum friend machen, falls er sich der Zugriffskontrolle der Ausleseschnittstellen (und somit der vorgesehenen Kapselung) entziehen, und selbst eine spezielle, direkte Schnittstelle auf die privaten Daten bilden soll.



  • danke für eure hilfe - werde es ausprobieren was so empfohlen wurde wenn es nciht klappt melde ich mich wieder

    T I M



  • die ganze kacke eght icht, weil der compiler sagt das ich die funktion << nur mit einer übergabevariable deklarieren darf.

    nun habe ich alles ausprobiert.
    mir kommt es nicht wirklich auf die funktion mit inhalt an - aber bei jeder deklaration geht das nicht.
    bsp
    ...
    main()
    tUhrzeit t1;
    cout << t1;

    dann sagt er immer illegal structur glaube ich.... ich kriege das kotzen. meine genialen lehrer wissen das nicht mal... voll die n00bs

    help me... probiert es mal selber kurz aus - voll der shit

    T I M



  • komisch. bei mir geht's:

    #include <iostream>
    #include <iomanip>
    #include <ctime>
    
    using namespace std;
    
    class Uhrzeit
    {
    private:
          int m_std, m_min, m_sek;
    
    public:
        Uhrzeit(int std, int min, int sek)
            : m_std(std), m_min(min), m_sek(sek)
        {}
        Uhrzeit()
        {
            time_t sekSeit1970 = time(0);
            tm *datum = localtime(&sekSeit1970);
    
            m_sek = datum->tm_sec;
            m_min = datum->tm_min;
            m_std = datum->tm_hour;
        }
    
        friend ostream &operator<<(ostream & output, const Uhrzeit &zeit);
    };
    
    ostream &operator<<(ostream & output, const Uhrzeit &zeit)
    {
        return output << zeit.m_std << ":"
            << setw(2) << setfill('0') << zeit.m_min << ":"
            << setw(2) << setfill('0') << zeit.m_sek << " Uhr";
    }
    
    int main()
    {
        Uhrzeit jetzt;
        cout << "Es ist " << jetzt << endl;
        cin.get();
    }
    

Log in to reply