Allokieren von 2D-Array in Funktion

maxinagl

Das hatte ich mir selber gebaut. Habe erst vor kurzem mit C++ angefangen, daher noch wenig Erfahrung damit.
Werds mit dem Vektor mal versuchen.
Danke für die Antwort.

*Rewind*

Dein Ansatz ist schon mal nicht schlecht. Kurzer Hinweis: die Zählvariablen in den Schleifen (also ii bzw. jj) solltest du erst bei der Initialisierung anlegen, wenn sie nach der Schleife in der Funktion nicht weiter leben sollten (so wie's hier der Fall ist).

Dein C/C++-Hybrid sollte eher so aussehen (nicht getestet), aber wie gesagt, das ist alles andere als schön oder sicher:

#include <iostream>

//using namespace std;    Wegen ein paar couts sollte man das nie global angeben

int allocate(int *** dynArr, unsigned firstDim, unsigned secondDim);

int main()
{
  int ** dynArr;

  unsigned firstDim = 50;
  unsigned secondDim = 100;
  int errFlag = allocate(&dynArr, firstDim, secondDim);

  for (unsigned ii = 0; ii < firstDim; ii++)
    for (unsigned jj = 0; jj < secondDim; jj++)
      std::cout << "dynArr[" << ii << "][" << jj << "]=" << dynArr[ii][jj] << std::endl;

  //Aufräumen:
  for (unsigned i = 0; i < firstDim; i++)
    delete [] (dynArr[i]);
  delete [] dynArr;
}

int allocate(int *** dynArr, unsigned firstDim, unsigned secondDim) {

  *dynArr = new int*[firstDim];
  for (unsigned ii = 0; ii < firstDim; ii++)   //hier hattest du den gültigen Speicherbereich verlassen
    (*dynArr)[ii] = new int[secondDim];

  for (unsigned ii = 0; ii < firstDim; ii++)
	  for (unsigned jj=0; jj < secondDim; jj++) 
      (*dynArr)[ii][jj] = secondDim * ii + jj; //counter;

  return 0;   //Überflüssig, wenn keine anderen Fälle abgefangen werden
}

[Rewind] schrieb:

Dein C/C++-Hybrid sollte eher so aussehen (nicht getestet), aber wie gesagt, das ist alles andere als schön oder sicher:

Si tacuisses...

Oder: Was ist denn an dem Beispiel besser als am Original?

*Rewind*

Wenn du keinen Unterschied siehst, dann kann ich dir nicht helfen.

Shade Of Mine

Oft macht es auch Sinn ein 2 dimensionales Array als 1 dimensionales anzulegen.

Statt arr[i][j] kann man dann zB per arr[size*i+j] darauf zugreifen. Das erleichtert die Verwaltung oft enorm.

[Rewind] schrieb:

int allocate(int ** array, unsigned firstDim, unsigned secondDim) {
 
  array = new int*[firstDim];

Das ist nicht dein Ernst, oder?

maxinagl

for (int i = 0; i < firstDim; i++)
  delete [] array[i];
delete [] array;

Was ist denn der Vorteil wenn ich die Variablen der Schleifen in der Schleife direkt deklariere? Bin Fortran Muttersprachler und kenne das daher nicht anders.
Gibt es da einen wesentlichen Vorteil gegenüber der Deklaration am Anfang der Funktion?

Fellhuhn

Variablen dort zu deklarieren wo man sie benötigt macht es übersichtlicher. Auch ist in diesem Fall "i" nur innerhalb der Schleife gültig und kann somit zB in einer zweiten Schleife erneut verwendet werden ohne Gefahr zu laufen aus Versehen den Wert der vorherigen Verwendung zu übernehmen.

maxinagl

Ok, das hat aber dann nur Vorteile hinsichtlich der Übersichtlichkeit. Performancevorteile erhalte ich dadurch nicht?

Kellerautomat

Reicht das nicht?

*Rewind*

maxinagl schrieb:

Ok, das hat aber dann nur Vorteile hinsichtlich der Übersichtlichkeit. Performancevorteile erhalte ich dadurch nicht?

Performance - nein. Aber lies dir nochmal den Beitrag von Fellhuhn genauer durch. Im Prinzip bedeutet bessere Übersichtlichkeit gleich eine niedrigere Wahrscheinlichkeit, dass du Fehler machst, und einen geringeren Aufwand bei der Fehlersuche. Kennst du noch den Spaghetti-Code mit goto's..? Dann weißt du, was ich meine.