Prä- und Postfix-Increment sowie Umwandlungsoperator

1.)

class X() {};
X obj;

wenn ich schreibe

int s = obj;

Wie kann ich da überladen, damit obj auch einen int zurückliefert?
Oder geht das nur mit get()-Methode?

2.) Wie muss der operator++ überladen werden? Mit

int operator++() {
   return v++;
}

bekomm ich bei der Anwendung obj++ eine Warnung.

[ 05.10.2001: Beitrag editiert von: HumeSikkins ]

HumeSikkins

Hallo,

class X
{
    int x;
    public:
        X(int i = 0) : x(i) {}
        operator int() {return x;}  // Umwandlungsoperator X ->int
        // pre-Increment
        X& operator++()
        {
            ++x;
            return *this;
        }

        // post-Increment
        const X operator++(int)
        {
            X Temp(x);
            ++*this;
            return Temp;
        }

};

Für 1) benötigst du einen Umwandlungsoperator von deiner Klasse X nach int.

Zu 2). Du definierst nur den Prefix-Increment-Operator. In meinem Beispiel siehst du die Syntax für den Postfix-Increment. Es ist generell eine gute Idee den Postfix-Increment über den Prefix-Increment-Operator zu implementieren (auch wenn das hier nicht nötig ist). Beachte auch die Rückgabewerte. Einmal eine Referenz auf das Objekt und einmal ein const X. Letzteres verhindert Ausdrücke wie z.B. x++++.

[ 05.10.2001: Beitrag editiert von: HumeSikkins ]

Fux

zu 1)
Man kann einen Cast-Operator in der Klasse definieren:

class X {
  operator int() { return __blub__; }
};

Mein Tipp, schreib eine spezielle Funktion, Cast-Funktionen haben seiteneffekte und machen den Code nicht unbedingt lesbarer nur kürzer:

class X {
  int to_int() { return __blub__; } // oder as_int, oder einen besseren Namen
};

X obj;
int s = obj.to_int();

Den Operator definiert man am besten auch in der Klasse:

class X {
  X& operator++() { ++was_weiss_ich; return *this; } // für ++x
  X operator++(int) { // für x++
    X tmp = *this; // Kopie anlegen
    ++*this; // erhöhen mit der anderen Funktion
    return tmp;
  }
};

Hier sieht man auch, warum bei eigenen Typen man ++x (statts x++) nehmen sollte, diese Variante kommt ohne temporäre Objekte aus und ist deshalb schneller.

cu