multidimensionales Array von Klassen

gnasen

Hallo Leute,

ich möchte ein mehrdimensionales Array einer Klasse erstellen. Dafür benutze ich für den 1D Fall folgenden Code (Die Klasse und größe des Arrays ist der einfachheit halber festgelegt):

class anyClass {
public:
  int x[9876];
};

void initArray1D(anyClass **blub)
{

  blub = new anyClass*[10];

  for (int i=0;i<10;i++)
    blub[i] = new anyClass;

}

int main(void)
{

  anyClass **blub;

  // why does this fail ...
    initArray1D(blub);

  // while this works?
//   blub = new anyClass*[10];
//   for (int i=0;i<10;i++)
//     blub[i] = new anyClass;

  blub[3]->x[17] = 5;
  cout << blub[3]->x[18] << endl;

  return 0;

}

Allerdings führt der selbe Code einmal direkt ausgeführt und einmal als Funktion (initArray1D) zu unterschiedlichen Ergebnissen (als Funktion crasht es).
Kann mir jemand sagen warum und wo mein Denkfehler ist?

Schonmal vielen Dank

Stichwort: Call-By-Value vs. Call-By-Reference

Du manipulierst eine Kopie von anyClass **blub innerhalb der Funktion.

du machst es dir viel zu kompliziert.

einen pointer von einen pointer nutzt man nicht.
arbeite mit einem return Wert.

anyClass* initArray1D( void )
{

return new(std::nothrow)anyClass;

}

und ich habe noch nie einen Array aus Pointern genutzt. Das führt nur zu undefiniertem verhalten wenn jemand deinen Code weiter verwendet.

std::vector<anyClass*> vVector;
vVector.push_back( initARray1D() );
vVector.push_back( initARray1D() );
vVector.push_back( initARray1D() );
vVector.push_back( initARray1D() );
vVector.push_back( initARray1D() );

und irgendwann dann den Inhalt löschen bevor der Scope vom Vector zuende ist. Auch das würde ich nicht machen wollen weil es zu unsicher ist ( was die weitere Verwendung angeht ).

machs also so:

void initArray1D(anyClass& **blub)

@ichhoffeesistrichtig

nein. entweder macht man es komplett "richtig" und verzichtet auf manuelle speicherverwaltung, oder man lässt den OP die grundlagen austüfteln und erfahrung im 2-3-sterne-programmieren machen.
diese halbgare zwischenlösung von dir hilft niemandem.

gnasen

qweasdyxc schrieb:

Stichwort: Call-By-Value vs. Call-By-Reference

Du manipulierst eine Kopie von anyClass **blub innerhalb der Funktion.

Das verstehe ich noch nicht ganz, könntest du ein Beispiel geben wie es richtig wäre?

Was ich letztendlich will ist das folgende:
Mehrdimensionale Arrays einer bestimmten Klasse (anyClass) die man wie jedes "normale" array auch nutzen kann.
In allen Sprachen die ich bisher benutzt habe war dies trivial, in c scheint dies allerdings nicht so einfach zu sein...

Ein Beispiel würde mir schon viel helfen.

Mehrdimensionale Arrays einer bestimmten Klasse (anyClass) die man wie jedes "normale" array auch nutzen kann.
In allen Sprachen die ich bisher benutzt habe war dies trivial, in c scheint dies allerdings nicht so einfach zu sein...

class CInformations
{
double dValue;
}

Funktion()
{

// anlegen
CInformations cInformations[100][100][100];
// zugriff
double dValue = cInformations[0][0][0].dValue;
}

1D Fall:

vector<anyClass> vec

for( size_t i=0; i<10; ++i)
{
    vec.emplace_back(anyClass());
}

// Zugriff
anyClass& myVec = vec[2];

2D Fall (eine 2D Matrix von anyClass Objekten)

size_t rows = 4711;
size_t columns = 42;

for( size_t r=0; r<10; ++r)
{
    for( size_t c=0; c<columns; ++c)
    {
        vec.emplace_back(anyClass());
    }
}
// Zugriff
anyClass& myVec = vec[2][3]; // row, column

Wenn die Groessen statisch bekannt sind, kannst Du statt std::vector<> auch std::array<> nehmen.

gnasen

ichhoffeesistrichtig schrieb:

Mehrdimensionale Arrays einer bestimmten Klasse (anyClass) die man wie jedes "normale" array auch nutzen kann.
In allen Sprachen die ich bisher benutzt habe war dies trivial, in c scheint dies allerdings nicht so einfach zu sein...
class CInformations
{
double dValue;
}

Funktion()
{

// anlegen
CInformations cInformations[100][100][100];
// zugriff
double dValue = cInformations[0][0][0].dValue;
}

Sorry ich habe vergessen zu erwähnen, aber die größe des Arrays ist erst zur Laufzeit bekannt. Es muss also ersteinmal leer definiert werden, bevor es später befüllt wird. Deswegen der Ansatz mit den Poinern.

Die Vector Klasse habe ich jetzt schon öfters mal gesehen, finde die Syntax aber um ehrlich zu sein ziemlich überladen und unübersichtlich. Ich meine das Problem selbst ist doch so einfach, dafür muss es doch auch eine schicke Lösung geben
Ich bin überhaupt nicht fit in c++, aber warum geht sowas nicht:

anyClass **blub;
blub = new anyClass[x][y];

Es steht doch oben wie Du Dein Problem lösen kannst. Übergib den Zeiger per Referenz an die Funktion

qwertzui schrieb:

machs also so:

void initArray1D(anyClass& **blub)

Andersrum sorry

void initArray1D(anyClass** &blub)