Ich versuche dir das ganze mit Zeigern zu erklären, ich hoffe ich mache jetzt keinen Bockmist xD
keine angst. das was du erklärt hast ist richtig
kann mir jemand die unterschiede folgender zeilen erkären?
|
C-/C++-Quelltext
|
1
2
|
const char& operator[](size_t pos) const
{ return pos; }
|
das const nach der parameterliste zeichnet die ganze funktion als const aus. sowas ist nur gültig bei memberfuntionen einer klasse. es bedeutet, dass diese funktion das objekt für das sie aufgerufen wird nicht verändert. hast du ein konstantes objekt, kannst du nur const funktionen darauf aufrufen. kurzes bsp:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
class foo
{
public:
void func1();
void func2() const;
};
//...
foo obj1;
obj1.func1(); // ok
obj1.func2(); // ok
const foo obj2;
obj2.func2(); // ok
obj2.func1(); // nicht ok, die funktion foo1 ist nicht const, das objekt aber schon
|
im allgemeinen kannst du in einer solchen funktion keine member des objektes verändern (außer diese sind als mutable deklariert).
|
C-/C++-Quelltext
|
1
2
|
char& operator[](size_t pos) const
{ return pos; }
|
fast das gleiche wie die vorige funktion, nur mit dem unterschied, dass der rückgabewert nicht const ist. diese deklaration ist ziemlich widersprüchlich, denn jetzt bekommt der aufrufer dieser funktion eine referenz auf die membervariable (non-const) und kann diese nach lust und laune verändern.
|
C-/C++-Quelltext
|
1
2
|
char& operator[](size_t pos)
{ return pos; }
|
das deklariert den operator[] nochmal, jetzt non const. da das const hinter der parameterliste teil der signatur ist, wird es auch beim overloading berücksichtigt.
folgendes bsp:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
class foo
{
private:
int x[10];
public:
int operator [](int index) const { return x[index]; } // const version
const int& operator [](int index) { return x[index]; }
};
// ...
foo obj1;
obj1[8] = 10; // geht, objekt ist non-const daher
// wird der non-const operator aufgerufen
// dieser liefert eine referenz auf das
// arrayelement und daher funktioniert die
// zuweisung
const foo obj2;
obj2[8] = 10; // geht nicht. es wird der operator [] const
// aufgerufen. der liefert aber keinen wert
// an den man etwas zuweisen kann (kein "L-value")
int a = obj1[2]; // geht beides, da beide varianten von operator []
int b = obj2[3]; // einen wert der gelesen werden kann liefern
|