Fragen zu const bei Referenz

Hallo,
ich habe folgenden Code:

#include <iostream>

class Counter{
public:
	Counter();
	~Counter(){}
	int GetItsVal(){return itsVal}; 
	void SetItsVal(int x) {itsVal=x;}
	const Counter& operator++ ();
	const Counter operator++ (int);

private:
	int itsVal;
};

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

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

int main(){
//blabla
	return 0;
}

Wozu wird hier das
"const" vor "Counter& operator++ ();" gesetzt ?

Wenn ich dann sowas habe wie

const Counter  &Function(const Counter & input){
//bla bla
}

wo ist da der Unterschied zu

const Counter & const Function(const Counter & input){
//bla bla
}

const Counter  &Function(const Counter & input) const {
//bla bla
}

[/cpp]

newcomer

Wo ist der Unterschied ob ich

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

oder

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

verwende bei:

int main(){ 
Counter i;
 Counter j=i++ ;
}

Durch die Zuweisung Counter j=i++ ; wird doch der Wert i angeguckt und eine entsprechende Kopie erstellt, die dann j zugewiesen wird. Um einen Vorteil zu erhalten, müsste ich doch dann schreiben

Counter &j=i++ ;

da hierbei j nur auf das Objekt i zeigt. Daher verstehe ich das Beispiel nicht, welches ich aus einem Buch hab. Dort wird nämlich die erste Variante benutzt. Und wie gesagt, warum in der Def der Methode ein const davor stehen soll ich mir auch nicht klar.

Es wird eine Referenz zurückgegeben, welche ein weiteres, unnötiges Kopieren erspart. Konstant deshalb, damit man mit dem Ausdruck nicht das Objekt verändern kann.

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

Es wird *this zurückgegeben, also das Objekt, für welches die Operatorfunktion aufgerufen wird, aber eben nicht als Kopie (langsamer) sondern als konstante Referenz (Lerne, was eine Referenz ist, falls du es nicht weißt).

Wenn es keine Referenz auf ein konstantes Objekt wäre, könnte man das...

Counter a, b;
(a + b).schreibendeMethodeVonA();

...machen. Und das ist böse!
Außerdem wäre die Operatorfunktion dann nicht für konstante Counter-Objekte geeignet.

MfG :xmas1:

camper

ceplusplus@loggedoff schrieb:

Und das ist böse!

So böse wie der Weihnachtsmann. Aber ich hoffe, dass irgendwann auch noch der Letzte kapiert, dass const eine Bedeutung hat und nicht bloß der Dekoration dient. mehr != besser