const Counter& Counter::operator++()
{
++itsVal;
return *this;
}

Hier wurde der ++-Präfix-Operator überladen, wobei eine
konstante Referenz auf das aktuelle Objekt (*this) zurückgegeben wird.
Meine Frage ist jetzt, warum eine konstante Referenz zurückgegeben wird
und nicht einfach eine normale bzw. eine nicht-konstante Referenz
zurückgegeben wird.
Was bewirkt man also damit, eine konstante Referenz zurückzugeben?
Würde mich freuen, wenn mir das jemand erklären könnte.
Danke schon mal an alle Tippfreudigen, die mir helfen möchten :)!

Edit: ich sehe grade, ich habe mich verlesen, du implementierst ja die Präfix-Version. In dem Fall ist die konstante Referenz unintuitiv, die verwendet man bei der Postfix-Version.

MyClass myobj;
(myobj++) = 3; // wäre bei dir nicht möglich, da op++ ein const MyClass& liefert

MfG SideWinder

Function(++myObject); // Function() nimmt Referenz

Datax schrieb:

eine nicht-konstante Referenz

Sowas existiert in C++ nicht. Jede Referenz ist konstant.

Was du meinst, ist das referenzierte Objekt, das über die Referenz verändert werden kann oder nicht. Ich ziehe es daher vor, von Referenz auf const oder Const-Referenz zu sprechen. Das nur so am Rande...

vector<typ> & func(); (2)

Das da oben seien jetzt mal Methoden einer Klasse.

(1)
typ val = obj->func()[3]; // ok
obj->func().push_back(wert) // fehler

(2)
typ val = obj->func()[3]; // ok
obj->func().push_back(wert) // ok

Auch wenn ich der Meinung bin,
dass es in der Regel keine Gute Idee ist Referenzen aus Funktionen zurückzugeben,
verdeutlicht dieses Beispiel doch sehr Gut den Unterschied in der Funktionalität.

In beiden fällen gibst du eine Referenz zurück, doch mit dem const sagst du dazu,
dass diese nicht verändert werden darf.

Aber mal von diesr Funktionalität abgesehen gibst du den Compiler noch den Hinweis, das diese Referenz von außen auf keinen Fall geändert wird,
was wohl auch für die ein oder andere Optimierung nützlich ist ( auch wenn ich davon keine Ahnung habe wie der Compiler so arbeitet).

const Counter& Counter::operator++()
{
   ++itsVal;
   return *this;
}

Hier wurde der ++-Präfix-Operator überladen, wobei eine
konstante Referenz auf das aktuelle Objekt (*this) zurückgegeben wird.
Meine Frage ist jetzt, warum eine konstante Referenz zurückgegeben wird
und nicht einfach eine normale bzw. eine nicht-konstante Referenz
zurückgegeben wird.

Keine Ahnung. Frag den Autor, was er sich dabei gedacht hat. Das entspricht jedenfalls nicht dem Verhalten von anderen Typen wie int .

void haha(int&);
void haha(Counter&);

int main() {
  Counter c = ...;
  int     i = ...;
  ++++c; // funzt nicht
  ++++i; // funzt
  haha(++c); // funzt nicht
  haha(++i); // funzt
}

Datax schrieb:

Was bewirkt man also damit, eine konstante Referenz zurückzugeben?

Das übliche. Du kannst auf dem Ergebnis keine nicht-const Elementfunktionen aufrufen und auch nicht an Funktionen weitergeben, die eine nicht-const Referenz haben wollen.

kk