Operator Overloading



  • Hallo,

    ich möchte eine Methode und eine Funktion "operator+(int)" implementieren für die Klasse Time,

    der operator soll die Minuten zur aktuellen Zeit hinzuzählen,

    Kann mir da jemand helfen?

    lg und vielen Dank,



  • Time operator+(int minuten) {
        // bla
    }
    

    Du musst schon sagen, wie du deine Klasse aufgebaut hast!



  • So schaut meine Klasse aus:

    #include <iostream>
    using namespace std;
    class Time {
    public:
    Time(int _h, int _m) : h(_h), m(_m) {}
    void print() {
    cout << h << ":" << m << endl:
    int h, m;
    


  • PollerCPP schrieb:

    So schaut meine Klasse aus:...

    Zum einen C++ Codetags verwenden (und bitte lesbar formatieren), zum anderen ist die Klasse abgeschnitten.

    Und ansonsten ist ein Operator wie schon gezeigt eine einfache Methode, oder besser: eine Funktion (dann können Minuten auch das linke Argument sein, ansonsten muß die Klasse immer links stehen).

    Übliche Implementierung ist das man sowohl einen += als auch + Operator definiert, und den + Operator über zuhilfename des += Operators schreibt:

    class Time
    {
        // ...
        Time& operator+=(int minuten)
        {
            // <-- Deine Implementierung
            return *this;
        }
    
        Time operator+(int minuten)
        {
            Time temp = *this;
            temp += minuten;
            return temp;
        }
        // ...
    };
    
    // Alternativ +Operator aus der Klasse ziehen:
    Time operator+(const Time& time, int minuten)
    {
        Time temp = time;
        temp += minuten;
        return temp;
    }
    

    cu André



  • rein zum verständnis:

    Time& operator+=(int minuten)
    {
    // <-- Deine Implementierung
    return *this;
    }

    hier übergebe ich ja eine referenz vom typ Time...
    da dies einer adresse entspricht, ist der rückgabewert ein zeiger, der im
    eigentlichen sinne auch nur einer adresse entspricht...

    könnte ich auch einfach:

    Time* operator+=(int minuten)
    {
    // <-- Deine Implementierung
    return *this;
    }

    schreiben?! bzw. warum muss ich unbedingt eine referenz übergeben?!

    im 2. fall:

    Time operator+(const Time& time, int minuten)
    {
    Time temp = time;
    temp += minuten;
    return temp;
    }

    erzeuge ich ja ein objekt des types temp (im block)...
    von variablen weiss ich, das sie bei beenden des blockes ihre
    gültigkeit verlieren, wenn sie erst dort angelegt sind.
    bei objekten scheint das ja dann anders zu sein?!

    ein beispiel zu den beiden methoden wäre schön 🙂

    gruss pete



  • asc schrieb:

    den + Operator über zuhilfename des += Operators schreibt:

    [cpp]class Time
    {
    // ...
    Time& operator+=(int minuten)
    {
    // <-- Deine Implementierung
    return *this;
    }

    Die Implementierung wäre noch interessant, mir ist nichtganz klar, wie ich nur die minuten dazuzählen kann, damit das Ergebnis auch gültig bleibt (0 <= h < 24, 0 <= m < 60)

    Vielen Dank,

    lg



  • @PollerCPP:
    Na, da ist aber ein bisschen Eigeninitiative gefragt. Du erhöhst die Minuten, wenn die über 60 gehen, ziehst Du 60 ab und erhöhst die Stunden um eins. Das in einer Schleife bis min < 60.

    @petedeluxe2k:
    Quark, Referenzen sind keine Zeiger. Und der Sinn von Referenzen an dieser Stelle (wie von Referenzen überhaupt) ist die natürlichere Lesbarkeit. Oder sieht folgendes natürlich aus 😉

    Time a;
    cout << *(&a + 1);
    


  • Sollte nich auch die Variante vorhanden sein:

    // Alternativ +Operator aus der Klasse ziehen: 
    Time operator+(const Time& ltime, const Time& rtime) 
    { 
    ..........
    }
    


  • LordJaxom schrieb:

    @PollerCPP:
    Na, da ist aber ein bisschen Eigeninitiative gefragt. Du erhöhst die Minuten, wenn die über 60 gehen, ziehst Du 60 ab und erhöhst die Stunden um eins. Das in einer Schleife bis min < 60.

    Warum einfach, wenn's auch kompliziert geht? Es gibt doch einen Modulo- und Divisions-Operator dafür 😉



  • CStoll schrieb:

    Warum einfach, wenn's auch kompliziert geht? Es gibt doch einen Modulo- und Divisions-Operator dafür 😉

    Klar, aber ich wollte erstmal die naivste Lösung vorschlagen (wenn er schon nicht selbst auf irgendeine mögliche Implementierung kommt) 😉



  • petedeluxe2k schrieb:

    rein zum verständnis:
    ...
    hier übergebe ich ja eine referenz vom typ Time...
    da dies einer adresse entspricht, ist der rückgabewert ein zeiger, der im
    eigentlichen sinne auch nur einer adresse entspricht...

    Nein, eine Referenz ist ein Aliasname kein Zeiger (Und egal wie es der Compiler intern macht, ob er dies mittels Zeiger auflöst oder - und das glaube ich eher - anders ist erst einmal egal).

    Ich möchte Operatoren wie folgt nutzen können:

    Time t1(12, 15);
    Time t2 = t1 + 135;
    t2 += 20;
    t1 = t1 + t2 + 123 + 234;
    

    Und nicht erst Zeigerumwandlungen anstellen.

    cu André


Log in to reply