Operatorüberladung

Hi,
ist es möglich den Indexoperator für mehrdimensionale Arrays zu überladen?
Mein Versuch:

T& operator[][](int firstIndex, int secondIndex) {
		assert(firstIndex < zeilen && secondIndex < spalten);
		return ptr[firstIndex*spalten + secondIndex];
	}
	const T& operator[][](int firstIndex, int secondIndex) const {
		assert(firstIndex < zeilen && secondIndex < spalten);
		return ptr[firstIndex*spalten + secondIndex];
	}

Konstruktor etc. der Klasse sind so weit inordnung. Wenn ich die Klasse in main instanziiere:

Array2d<int> arr(2, 5);

und anschließend die Indexoperatoren verwenden will:

for (size_t i = 0; i < arr.getZeilen(); ++i) {
		for (size_t j = 0; j < arr.getSpalten(); ++j) {
			arr[i][j] = i*j;
		}
	}

wirft der Compiler folgende Fehlermeldung:

Severity	Code	Description	Project	File	Line
Error		IntelliSense: no operator "[]" matches these operands
            operand types are: Array2d<int> [ size_t ]

SG1

Einen operator[][] gibt es nicht. Bau Dir einen operator[], der ein Proxy-Objekt, also eine Sicht auf eine Zeile Deiner Matrix zurückgibt. Und die Zeile hat dann wieder einen operator[]

Nein du kannst keinen operator[][] überladen. Es gibt aber eine Reihe von anderen Möglichkeiten. Du überlädst normal den operator[], der dann ein Objekt zurückgibt für das es wieder einen operator[] gibt. Das einfachste wäre einfach einen Pointer zu nehmen, es kann aber auch irgendeine Helper Klasse sein. Mit dem Pointer würde es dann so aussehen:

T* operator[] (int firstIndex) {
  assert(firstIndex < zeilen);
  return &ptr[firstIndex*spalten];
}

Du verlierst aber dadurch aber die Möglichkeit ein assert für den zweiten Index einzubauen. Dafür müsstest du eine Helper Klasse nutzen.

Nice, dankö

DocShoe

Du kannst den operator() überladen und ihm beliebig viele Argumente mitgeben.

T& Array2D::operator()( std::size_t RowIndex, std::size_t ColIndex )
{
   ...
}

int main()
{
   Array2D<double> arr;
   ...
   double v = arr( 0,1 );
}