[C++] Operatoren überladen

G

Green Mamba

Gast
Tagchen,

ich hab hier ne Klasse Matrix, die unter anderem ein beliebig große 2d-Array an floats beinhaltet. Dieses float[][] wird auf dem Heap mit new erzeugt, der Datentyp dieses Arrays ist folglich float**.
Jetzt möchte ich bei einem Objekt dieser Klasse mit matrix_objekt [j]=17.f; zugreifen können, sowohl lesend als auch schreibend. Wie kann ich das bewerkstelligen?
Mit diesem Operator hier gehts zumindest nicht:
Code:
    float* operator [] (int i)  { return m_mat [i];};
Obwohl bei einem Zugriff der Form:
Code:
myMatrix[3][5]=7.f;
meiner Meinung nach der Operator nur beim ersten Array-Zugriff verwendung findet. Also myMatrix[3] liefert einen Pointer (float*) auf eine Matrixzeile zurück, und der zweite Array-Operator liefert dann das float an sich. Wo liegt mein Denkfehler?

Viele Grüße,
Green Mamba
 
Der Datentyp ist nicht float** sondern float*. Denn die Dimension des Arrays hat nichts mit der Pointerverschachtelung zu tun.

Den Pointer den dir new zurückliefert, kannst du mit void* (dann gehts leider nicht mit [] zu referenzieren) deklarieren, oder mit:

float (*cp)[25];
cp = new float[10][25];

am überladenen Operator bin ich noch dran.
 
Zuletzt bearbeitet:
Doch, in meinem Fall schon. Ich benutze eben einen Doppelpointer, und aloziiere den Speicher folgendermaßen:
Code:
float ** m_mat;
m_mat = new float*[x];
  for (int k = 0; k < x; k++) {
    m_mat[k] = new float[x];
  }
Ok, hätte ich auch in einem 1d-Array speichern können, aber dann müsste ich jetzt meine ganzen Algorithmen umschreiben. :evillol:
 
Code:
class Matrix  
{
private:
	float m_mat[10][10];

public:
	float* operator[] (int i)  { return m_mat [i];};
};


int main()
{
	Matrix myMatrix;

	myMatrix[3][5] = 7.f;

	return 0;
}
Und was klappt da nicht?
In m_mat wird das Element [3][5] auf 7.00000 gesetzt, sagt zumindest mein VC++ 6 Debugger.

Ach ja:
Feldgrenzen nicht vergessen zu prüfen.
 
Args, ich Trottel. :D
Ich habe versucht den Operator bei der Benutzung auf einen Pointer vom Typ Matrix anzuwenden, und habe nicht dereferenziert. Alles klar, das funktioniert jetzt soweit. Danke euch schonmal! :)

Um das ganze nochmal in meine Referenz zu bringen hier der Beispielcode:
Code:
#include <iostream>
using namespace std;

class Matrix  
{
private:
  float** m_mat;


public:
  Matrix (int x)
  {
  m_mat = new float*[x];
  for (int k = 0; k < x; k++) {
    m_mat[k] = new float[x];
  }
  }
  float* operator[] (int i)  { return m_mat [i];};
};


int main()
{
  Matrix myMatrix (10);

  myMatrix[3][5] = 7.f;
  cout << myMatrix [3][5] << endl;

  return 0;
}

Ich möchte dann gleich noch eine Frage anknüpfen:
Du hast ja angesprochen dass es sinnvoll ist die Array-Grenzen zu checken. Aber ich bei der Operatorüberladung in dieser Form lediglich den ersten Index checken, da der 2 verborgen bleibt. Gibts auch ne Möglichkeit beide Array-Operatoren zu überladen?
 
Wenn die Matrix immer quadratisch ist:
Code:
#include <iostream>
using namespace std;

class Matrix  
{
private:
  float** m_mat;
  [B]unsigned int size;[/B]

public:
  Matrix (int x)
  {
    m_mat = new float*[x];
    [B]size = k;[/B]
    for (int k = 0; k < x; k++) {
      m_mat[k] = new float[x];
    }
  }

  float* operator[] (int i)
  {
    [B]if( (i>=0) && (i<size)  )
      return m_mat [i];
    else
      // jetzt haben wir ein Problem[/B]
  }
};


int main()
{
  Matrix myMatrix (10);

  myMatrix[3][5] = 7.f;
  cout << myMatrix [3][5] << endl;

  return 0;
}
Da die Matrix genau so viele Elemente in X-Richtung enthält wie in Y-Richtung reicht es in der Matrix die Größe zu speichern, und bei Zugriffen auf >=0 und <size abzufragen.

Wie du im Fehlerfall vorgehen kannst?
- Fehlerwert im Rückgabewert (not very C++ like)
- Exception (very C++ like, aber schon ein bissl aufwändiger)

[edit]
Fehler: nicht auf >0 abfragen, sondern auf >=0
 
Zuletzt bearbeitet:
Zurück
Oben