Operatorüberladung diesmal []

double Vektor::operator [](int index)
{
  if (index < 0 || index > 1)
  {
    throw out_of_range("index");
  }
  else

  {
    return wert[index];
  }
}

Hallo, hab diesen Quelltext da oben und dieser soll den Operator []
überladen, aber irgendwie verstehe ich dass nicht, was es bringen soll.
Wenn ich z. B. ne Klasse "Vektor" hab und einige Operatoren dafür übeladen hab wie + - * / dann kann ich ja schon mit diesen Vektoren rechnen...
Genauso kann ich ja ein Array von Vektoren erstellen Vektor MeinArray[10]
so, wieso muss ich jetzt den [] Operator überhaupt überladen, wo liegt der Sinn darin?

if (index < 0 || index > 1)

Diese Zeile ist für mich irgendwie auch unlogisch
wenn (index kleiner wie 0) oder (index größer wie 1)
da darf index ja nur 0 oder 1 sein ???
was soll dass den bringen?

Gruß Giovanni

otze

wie benutzt man denn arrays?

//zuerst erstellen
char a[10];

//jetzt kommts
a[0]='a';
a[1]='b';
a[2]='c';

weist es jetzt?

zu der sache mit dem index: ok, das finde ich auch komsich, kleiner als 0 ist ok,muss auch so sein, die sache mit der 1...hmm vielleicht ist das ja ne Klasse die nur 0/1 unterstützt...ka

virtuell Realisticer

Hallo,

wenn ich das richtig sehe, dann ist das Zuweisen von Werten an ein Objekt mit
obigem []-op nicht moeglich, dafuer muesstest du eine Refernez auf ein double
zurueckgeben:

double &Vektor::operator [](int index)
{
  if (index < 0 || index > 1)
      throw out_of_range("index");
  else
      return wert[index];
}

= bar' moeglich sein.

mfg
v R

Shlo

Normalerweise definiert man zwei Versionen des operator[] - eine const und die andere non-const:

double& Vektor::operator [](int index)
{
	if (index < 0 || index >= size) //<< Größe des Vectors
		throw out_of_range("index");

	return wert[index];
}

double Vektor::operator [](int index) const
{
	if (index < 0 || index >= size)
		throw out_of_range("index");

	return wert[index];
}

otze

wie kann man denn zwischen const und nonconst aktiv wechseln?

Shlo

otze schrieb:

wie kann man denn zwischen const und nonconst aktiv drankommen?

Bei einem konstanten Objekt wird die const-Version aufgerufen, anderfalls die non-const. Falls nur die const-Version definiert worden ist, wird in beiden Fällen auch diese aufgerufen.

Okay, bei der Operatorüberladung [] weiße ich keinen wert zu, sondern hole mir lediglich nen bestimmten (index) wert aus dem Vektor.

Irritiert mich jetzt ein bißchen, weil otze folgendes geschrieben hat:

//jetzt kommts
a[0]='a';
a[1]='b';
a[2]='c';

und dass ist ja eindeutig ne zuweisung! was ist denn jetzt richtig?

otze

geht beides.
wenn man ne referenz übergibt, kann man der einen Wert zuweisen.

Shlo schrieb:

Bei einem konstanten Objekt wird die const-Version aufgerufen, anderfalls die non-const. Falls nur die const-Version definiert worden ist, wird in beiden Fällen auch diese aufgerufen.

Okay, bis auf das hab ich jetzt alles begriff, aber was ist ein konstantes Objekt? Habe z. B. diesen Quellcode, und weise von einem Vektor dem anderen die Werte zu, wie kann ich das jetzt konstanz machen?
Vektor1[0] = Vektor3.GetValue1();
Vektor1[1] = Vektor3.GetValue2();

Gruß Giovanni

Shlo

const Vector vector;
//...

aha, und wenn ich so einen Konstanten Vektor habe (const Vektor1) dann wird automatisch die Überladung [] mit const aufgerufen
und wenn ich ne "normale" Variable oder nen normalen Vektor habe, dann wird die Methode ohne const aufgerufen:

const int Zahl = Vektor[0]; // const Überladung
int Zahl = Vektor[0] // normale Überladung

oder?

PS: danke euch allen für die Hilfe, wird mir am Montag in der Klassenarbeit bestimmt viel helfen und hoffentlich auch in der Zukunft! Hab mir auch das Forum heut noch mal näher angesehen, es hat wirklich sehr viel zu bieten (auch Matheforum) also mal ein großes Kompliment an alle die da mitwirken!

Shlo

Giovanni Rena schrieb:

aha, und wenn ich so einen Konstanten Vektor habe (const Vektor1) dann wird automatisch die Überladung [] mit const aufgerufen
und wenn ich ne "normale" Variable oder nen normalen Vektor habe, dann wird die Methode ohne const aufgerufen:
const int Zahl = Vektor[0]; // const Überladung
int Zahl = Vektor[0] // normale Überladung
oder?

Ob die Variable die den Returnwert des operator[] zugewiesen bekommt, const oder non-const, ist irrelevant. Es geht nur um das Vector-Objekt:

const Vector v1;

v1[0] = 0; //Fehler, konstant, int Vector::operator[] (int) const
const int a = v1[0]; //OK, int Vector::operator[] (int) const

Vector v2;
v2[0] = 0; //OK, int& Vector::operator[](int)
const int b = v2[0]; //OK