ich möchte eine mehrdimensionale objektstruktur aufbauen, habe jedoch das problem, das die zuweisung nicht funktioniert.

class GraphEntry;

class MatrixGraph {

  public:
    /* constructor, destructor, ... */

    void init();
    void addGraphEntry(GraphEntry *entry, int row, int col);

  private:
    GraphEntry **matrix;
    int maxSize = 3;
}

void MatrixGraph::init() 
{
  if (maxSize > 0) {
    matrix = new GraphEntry*[maxSize];
    for (int i = 0; i < maxSize; i++)
      matrix[i] = new GraphEntry[maxSize];
  }
}

void MatrixGraph::addGraphEntry(GraphEntry *entry, int row, int col)
{
  if (row < maxSize && col < maxSize) {
    matrix[row][col] = entry;
  }
}

In der methode addGraphEntry möchte ich einen eintrag einer bestimmten position in der matrix zuweisen, jedoch bemängelt der compiler das mit der meldung:

no match for ‘operator=’ (operand types are ‘GraphEntry’ and ‘GraphEntry*’)

In der klasse GraphEntry habe ich den zuweisungsoperator überschrieben.

Kann mir jemand sagen, wo ich einen fehler gemacht habe?

Weiters ist mir bewusst, das es stl container gibt, aber ich muss mit arrays arbeiten.

Danke.

matrix[row][col] = *entry;

Was kann ich machen, damit ich den zeiger nicht dereferenzieren muss, sondern direkt speichern kann?

Was kann ich machen, damit ich den zeiger nicht dereferenzieren muss, sondern direkt speichern kann?

Ein 2d GraphEntry-Pointer array, aktuell hast du ein 2d GraphEntry array.

Ein 2d GraphEntry-Pointer array, aktuell hast du ein 2d GraphEntry array.

Ok, danke, und wie?

Was ich möchte ist, ich bekomme einen zeiger auf ein GraphEntry, das irgendwo außerhalb erstellt wurde. Ich möchte jetzt diese adresse an kreuzungspunkt von zeile und spalte in der matrix speichern.

Danke, das ergibt jetzt sinn.

Was kann ich machen, damit ich den zeiger nicht dereferenzieren muss, sondern direkt speichern kann?

Du könntest deine Methode addGraphEntry() dahingehend ändern, dass sie keinen Pointer erwartet, sondern ein "Value", bzw. für deinen derzeitigen Code sinnvoll eine konstante Referenz darauf:

void MatrixGraph::addGraphEntry(const GraphEntry& entry, int row, int col)
{
    ...
    matrix[row][col] = entry;
}

Finnegan

void addGraphEntry(GraphEntry *entry, int row, int col);

Aber danke für den tipp!

Danke, das ergibt jetzt sinn.

Was kann ich machen, damit ich den zeiger nicht dereferenzieren muss, sondern direkt speichern kann?

Deine matrix entsprechend definieren. Im Moment speichert die GraphEntry-Objekte und keine Zeiger auf Graphentry-Objekte.

Der Compiler wäre mit

GraphEntry ***matrix;

zufriedengestellt.

Schön ist aber anders.

Und löschen kann ich das ganze im destrukter wie folgt?

for (int i = 0; i < maxSize; i++) {
    delete[] matrix[i];
  }
  delete[] matrix;

Oder habe ich da wieder einen denkfehler?

GrapEntry*[3][3]

Deine Init-Methode passt dann nicht mehr und abräumen tust du nur den für die Zeiger angeforderten Speicher.
Die GraphEntry-Objekte selber räumst Du nicht ab.
Normalerweise räumt der die GraphEntry-Objekte auf, der sie auch angelegt hat.
Außer das Design ist so dass die nur angelegt werden und Du die dann selber verwalten musst.
Fragen über Fragen.

Du bist wirklich sicher keine STL-Container und Smartpointer verwenden zu wollen?

Ich habe das jetzt folgendermaßen geändert:

GraphEntry ***matrix;

void MatrixGraph::init() 
{
  if (maxSize > 0) {
    matrix = new GraphEntry**[maxSize];
    for (int i = 0; i < maxSize; i++)
      matrix[i] = new GraphEntry*[maxSize];
  }
}

Nur um sicher zu gehen, ich habe hier einen zeiger, der auf ein array zeigt, in welchem wieder zeiger sind die auf ein array zeigen? Hab ich das jetzt so richtig verstanden?

Wenn ich das jetzt wieder alles sauber löschen möchte

for (int i = 0; i < maxSize; i++) {
    delete[] matrix[i]; //hier entferne ich die arrays in den arrays
  }
  delete[] matrix; //hier entferne ich die arrays

Lieg ich soweit richtig? Die klasse MatrixGraph soll mehr oder weniger die ownership der GraphEntry objekte übernehmen, unabhängig davon, ob das im der realität wirklich so gemacht wird. Daher soll auch alles sauber wieder gelöscht werden.

####
########
##
#########
######

zu

####
####
####
####

?

Dir ist schon klar, dass deine Matrix sich zu einer "richtigen" 2D-Matrix verhält wie

####
########
##
#########
######

Manch einer hat da sogar folgendes Bild vor Augen:

#########

                        ##                    ####                                    

                         ######

SCNR,
Finnegan

################