Ich bin relativ neu und habe eine Frage bzgl. Operator[]. Ich komme aus der Welt von Delphi und möchte gerne fragen, ob es in C++ auch möglich ist, beim *Schreibzugriff* auf [] eine Funktion ausführen zu lassen.

Also so ein Szenario:
test = new MyClass();
test[5] = 100;

Dabei soll test[5] nicht eine Referenz auf die entsprechende Speicherstelle zurückliefern. Ich möchte, dass dabei eine Funktion ausgeführt wird, die die Zahl "100" z.B. in eine MySQL-Tabelle schreibt (ist nur ein Beispiel).
Bei "test[5] = 100" soll also eine Funktion wie "void MyClass::writeValue(int index, int value)" ausgeführt werden.

Danke für eure Hilfe!

//Edit:
In Delphi würde das etwa so gehen:

TMyClass = class
private
 function readItem(Index: Integer): Integer;
 procedure writeItem(Index: Integer; Value: Integer);
public
 property Item[Index: Integer]: Integer read readItem write writeItem; default;
end;

Okay, das würde gehen. Dann müsste man aber zusätzlich noch eine Referenz auf die ursprüngliche Klasse mitgeben; da sonst die "zusätzliche kleine Klasse" keine Ahnung hat, für welche Klasse er das jetzt erledigen muss.

an sich richtig erkannt. nur tricksen wir und machen diese referenz zum attribut der kleinen klasse und setzen sie im ctor der kleinen klasse.

die anderen attribute der kleinen klasse sind wohl die sachen, die dem op[] übergeben wurden.

seeplusplus schrieb:

Das heisst ich muss im Operator eine Klasse instanzieren und diese per Referenz zurückgeben.

Referenz auf lokales Objekt ist Unsinn.
So wie ich es verstanden hab meinte volkard die haupklasse hat eine Instanz der hilfsklasse als member und diese hat eine referenz auf die hauptklasse als member ( müsste dann eh referenz oder zeiger sein, da es sonst nicht kompiliert) und initialisiert diese im ctor der hilfklasse...
// er kann mich hier gern korrigieren.

also alles in allem sollte die klasse mit dem op[] ne instanz der hilfklasse haben, diese auch initialisiert haben und dann im op[] zurückgeben.

Meine frage wäre, könntest du das design so ändern, dass die hilfsklasse nichts von der, die sie aufruft wissen braucht? wenn ja reich wenn sie member der anderen ist und ne referenz auf sie zurückgegeben wird.
sie macht quasi dann mittels op= den funktionsaufruf , also quasi die arbeit.
was muss denn die klasse mit op[] können ? eigentlich nichts, wenn die mit dem op= alles verwalten kann. naja wie gesagt ich kann das design und die klasse nicht, aber vll passt meine idee ja, ansonsten spricht natürlich nichts gegen volkards vorschlag, im gegenteil.

Hmmm, bin jetzt fast etwas enttäuscht, dass das nicht besser geht. Und wenns schlussendlich doch irgendwie geht, wird es performance-mässig nicht top sein..

Das ist was ich bis jetzt hab...

#include "stdafx.h"
#include <iostream>
#include <stdio.h>

using namespace std;

class MyArray; 

// Hilfsklasse
class WriteItemHelpClass {
private:
	int index_;
	MyArray* myArray_;
public:
	int operator= (const int &rhs);
	WriteItemHelpClass(MyArray *myArray, const int index) : myArray_(myArray), index_(index) { };
};

// Hauptklasse
class MyArray {
	void writeItem(int index, int value) {
		cout << "write [" << index << "] = " << value << endl;
	}
	int readItem(int index) const {
		cout << "read [" << index << "]" << endl;
		return 0;
	}
public:
	const int
		operator[](const int index) const {
		return readItem(index);
	}
	WriteItemHelpClass& operator[](const int index) {
		return *(new WriteItemHelpClass(this, index));
	}
	friend class WriteItemHelpClass;
};

WriteItemHelpClass::operator =(const int &rhs) {
	myArray_->writeItem(index_, rhs);
	delete this;
	return rhs;
}

int _tmain(int argc, _TCHAR* argv[])
{
	MyArray test;
	test[3] = 123; // schreiben
	int i = test[4]; // cannot convert from 'WriteItemHelpClass' to 'int'
	return 0;
}

@shapeless: Ich möchte eigentlich, dass die Hilfsklasse möglichst nichts tut, und dass sie möglicherweise sogar von mehreren Klassen gebraucht werden kann.. Sie soll so allgemein wie möglich sein. (Natürlich, wenn's nicht anders geht, werd ich's schlussendlich schon so lösen müssen, wie du es vorschlägst)

int i = test[4]; // cannot convert from 'WriteItemHelpClass' to 'int'

Für sowas musst du deiner Proxyklasse noch einen operator int spendieren. Dieser übernimmt dann das Lesen, während op= fürs Schreiben zuständig ist.

Und deine Funktionssignaturen für op[] solltest du generell nochmal überarbeiten.

int operator [](int index) const
// oder
const int& operator [](int index) const
// und entsprechend
WriteItemHelpClass operator [](int index)

Und da es nunmal keinen Sinn macht, dass index einen negativen Wert hat, ist es sinnvoll, hierfür einen unsigned Typ zu verwenden, zB size_t.

#include "stdafx.h"
#include <iostream>
#include <stdio.h>

using namespace std;

template <class T>
class BracketAux {
public:
	class BracketAuxOp {
		BracketAux& object_;
		const int index_;
	public:
		BracketAuxOp(BracketAux& object, const int index) : object_(object), index_(index) {}
		operator T() const {
			return object_.readBracket(index_);
		}
		void operator=(T value) {
			object_.writeBracket(index_, value);
		}
	}; // class BracketAuxOp

	virtual T readBracket( const int index ) const = 0;
	virtual void writeBracket( const int index, const T value ) = 0;
};

class MyClass: public BracketAux<int> {
private:
	int readBracket(const int index) const {
		cout << "read [" << index << "]" << endl;
		return 0;
	}
	void writeBracket(const int index, const int value) {
		cout << "write [" << index << "] = " << value << endl;
	}
public:
	BracketAuxOp operator[](const int index);
};

inline MyClass::BracketAuxOp MyClass::operator[](const int index) {
	return BracketAuxOp(*this, index);
}

int _tmain(int argc, _TCHAR* argv[])
{
...
}