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,

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

#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;

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é

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

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

@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);

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

@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

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)

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é