Jetzt habe ich folgendes Problem:

//bm ist das argument des AssignmentOps
if(bm.matrix_[i][j] != NULL)
    *matrix_[i][j]=*bm.matrix_[i][j]; //BOOM!
else
    matrix_[i][j]=NULL;

In der markierten Zeile knallts, weil natuerlich in einigen Faellen auf der linken Seite der Zuweisung verusucht wird ein NULL-Pointer zu dereferenzieren.
Aber wie koennte ich die Werte aus der anderen Klasse sonst kopieren?
Wie kann ich dieses Problem ohne eine dynamische Allokation loesen?

thx in advance

class Foo { };

class Bar
{
    Foo *f[10][10];
    //...
    Bar operator=(const Bar& src);
    //...
};

Bar operator=(const Bar& src)
{
    for(int i=0; i<10; ++i)
        for(int j=0; j<10; ++j)
            if(src.f[i][j] != NULL)
                *f[i][j]=*src.f[i][j];    //BOOM!
            else
                f[i][j]=NULL;
}

Das Array Bar::f enthaelt auch NULL Pointer.
Wie angedeutet knallts gelegentlich in der markierten Zeile, weil this->f[i][j]==NULL ist.
Wie kann ich den operator= vernuenftig implementieren, ohne dass versucht wird NULL-Pointer zu dereferenzieren?

MfG

*f[i][j]=*src.f[i][j];

*f[i][j]=*src.f[i][j];

Btw. Wenn du platz für einen pointer hast, hast du noch lange nicht platz für ein objekt!

Hier resultiert das Problem eher daher das die linke seite auf irgendwas zeigt, aber nicht auf einen Speicherplatz ( den er benutzen darf ).

*f[i][j]=*src.f[i][j];

Wir reden hier vom operator= und nicht dem CopyCtor. Warum sollten die Pointer nicht auf einen Speicherplatz zeigen?

Falls du jetzt meinst, dass einige auf NULL zeigen, dann hast du genau das wiederholt, was ich in meinem vorherigen Post geschrieben habe.

MfG

evilissimo schrieb:

Hier resultiert das Problem eher daher das die linke seite auf irgendwas zeigt, aber nicht auf einen Speicherplatz ( den er benutzen darf ).

*f[i][j]=*src.f[i][j];

Wir reden hier vom operator= und nicht dem CopyCtor. Warum sollten die Pointer nicht auf einen Speicherplatz zeigen?

Falls du jetzt meinst, dass einige auf NULL zeigen, dann hast du genau das wiederholt, was ich in meinem vorherigen Post geschrieben habe.

Das Topic ging ja ursprünglich in der Tat um den CopyCtor, und der sah/sieht genau so aus. Dein Code für den op= ist fast wie er sein sollte (lieber *this zurück als Referenz zurückgeben), aber falsch für den CopyCtor.

Also wo kommen die Foo Objekte her? Und setzt du die gesamte Matrix auf 0 in deinen Konstruktoren, oder Default-Foos oder sowas?

setElement(int x,int y, Foo* f)

setze ich dann die jeweiligen Elemente.
Die Foos, die ich als Parameter benutze, kommen aus main(), wo ich sie statisch auf dem stack definiert habe.

Ich setze die gesamte Matrix im Ctor auf NULL.
Mittels eines setters

setElement(int x,int y, Foo* f)

setze ich dann die jeweiligen Elemente.
Die Foos, die ich als Parameter benutze, kommen aus main(), wo ich sie statisch auf dem stack definiert habe.

Ok.

mal angenommen du hast ein einen Pointer p der zeigt auf 0 ( das ist dein Array in der klasse )
und nun kommt ein pointer o der auf 4 Byte zeigt an der adresse 0x24234FFA ( Das sind deine daten aus Main )

und DU machst dann *p (ups du dereferenzierst NULL ? ) = *o;

Verstanden? Du hast keinen Speicherplatz für deine Daten!!!

Ich setze die gesamte Matrix im Ctor auf NULL.
Mittels eines setters

setElement(int x,int y, Foo* f)

setze ich dann die jeweiligen Elemente.
Die Foos, die ich als Parameter benutze, kommen aus main(), wo ich sie statisch auf dem stack definiert habe.

Auf dem Stack? Dann könnte die Lösung knifflig werden. Du musst nämlich nicht nur bei src, sondern auch bei *this auf != 0 achten.

Mit jeweils einmaligen Foos auf dem Heap könnte die Lösung ungefähr so aussehen:

inline bool Bar::hasElement( std::size_t row, std::size_t col ) const
{
  return matrix_[row][col] != 0;
}

void Bar::setElement( std::size_t row, std::size_t col, Foo* f )
{
  if (f != 0) {
    if (hasElement(row, col)) {
      *matrix_[row][col] = *f;
    } else {
      matrix_[row][col] = new Foo(*f);
    }
  } else if (hasElement(row, col)) {
    delete matrix_[row][col];
    matrix_[row][col] = 0;
  }
}

Bar& Bar::operator=( Bar const& src )
{
  for (int row = 0; row < 10; ++row) {
    for (int col = 0; col < 10; ++col) {
      setElement(row, col, src.matrix_[row][col]);
    }
  }
  return *this;
}

Könnte ungefähr sein was du suchst, aber auch komplett daneben.
Schwer zu sagen ohne zu wissen was Foo & Bar eigentlich sind, wieso unbedingt Pointer und nicht schlicht Objekte wenn du jene ohnehin immer kopierst/zuweist, es offensichtlich nicht wirklich "Referenzen" sind...

int main()
{
    char* arr = "abcdefghijklm";

    return 0;
}

Ich glaube euch ja, dass ich keinen Speicher habe, aber warum?
Warum muss ich bei meinem Problem extra welchen anfordern?
Die Array-Groessen sind doch bekannt.

Ich glaube euch ja, dass ich keinen Speicher habe, aber warum?
Warum muss ich bei meinem Problem extra welchen anfordern?
Die Array-Groessen sind doch bekannt.

Es sind nicht die Pointer in deiner Matrix denen Speicher fehlt. Es sind die Objekte auf die sie zeigen sollen.

Es sind nicht die Pointer in deiner Matrix denen Speicher fehlt. Es sind die Objekte auf die sie zeigen sollen.

huh?

evilissimo schrieb:

Verstanden? Du hast keinen Speicherplatz für deine Daten!!!

Es sind nicht die Pointer in deiner Matrix denen Speicher fehlt. Es sind die Objekte auf die sie zeigen sollen.

huh?

evilissimo schrieb:

Verstanden? Du hast keinen Speicherplatz für deine Daten!!!

Wird das ein ASW-Experiment?

for(int i=0; i<10; ++i)
        for(int j=0; j<10; ++j)
            if(src.f[i][j] != NULL)
                *f[i][j]=*src.f[i][j]; //...dann wird hier doch der inhalt von
                                       // *src.f[i][j] kopiert - damit waeren doch 
                                       // schonmal Objekte vorhanden

Warum meinst du trotzdem, die Objekte wuerden fehlen?

{ { x, x, x },            { { y, y, y },
  { 0, x, x },      =       { y, y, 0 },
  { 0, 0, x } }             { y, 0, 0 } }

int main()
{
    //dass es mit NULL net funktioniert weiss ich ja schon
    /*int arr00[][3] = { { 1, 1, 1 },
                       { NULL, 1, 1 },
                       { NULL, NULL, 1 } };

    int arr11[][3] = { { 2, 2, 2 },
                       { 2, 2, NULL },
                       { 2, NULL, NULL } };*/

    int arr0[][3] = { { 1, 1, 1 },
                      { 42, 1, 1 },
                      { 42, 42, 1} };

    int arr1[][3] = { { 2, 2, 2 },
                      { 2, 2, 42 },
                      { 2, 42, 42 } };

    for(int i=0; i<3; ++i)
        for(int j=0; j<3; ++j)
            arr0[i][j]=arr1[i][j];     

    return 0;
}

Funktioniert soweit wunderbar.