Arraygröße aus Dateiangabe initialisieren

volkard

NDEBUG schrieb:

Wenn das bei dir zu Fehlern führt lösch, das CAST Makro.

quote gesichert und eingereicht für den preis "Kreative! Interpunktion 2009".

NDEBUG

Danke! Was kann ichn da gewinnen?!

TTP

Tim schrieb:

Bitte lesen.
http://www.c-plusplus.net/forum/viewtopic.php?t=206606

hab ich doch, stand doch im 3. post oder so -.-

@NDEBUG:
WOW das sieht gut aus, ich bin gerad über eine andere Version im www gestolpert, die auch funktioniert:

int main()
{
  int *Map;
  int mWidth=10;
  int mHeight=10;
  int x,y;
  Map = (int*)malloc(sizeof(int) * (mWidth * mHeight + 2));

  for(x = 0; x < mWidth; x++){
    for(y = 0; y < mHeight; y++){
      *(Map+x+y)= 5;
      printf("%d\t",Map[x+y]);
    }
    printf("\n");
  }

	system("PAUSE");
	return 0;
}

Die sieht mir kürzer aus.... ich guck mir aber erstmal deine Variante an

NDEBUG schrieb:

Für ein 2-dimensionales Array, das dynamisch erzeugt werden soll, allokierst du den Speicher in zwei Schritten.
1. Schritt: Allokiere zunächst die Zeilen
2. Schritt: Allokiere die Spalten

warum so umständlich? malloc (zeilen*spalten*sizeof(arrayelement)) reicht doch auch.

NDEBUG

Bei der von dir gefundenen Variante ist das ein Pseudo-2d-Array. Er rechnet sich die Positionen selber aus, wo die jeweiligen Werte stehen sollen. D.h. er wird einen Fehler erhalten, wenn er z.B. map[x][y] probiert.

EDIT:

~fricky schrieb:

NDEBUG schrieb:

Für ein 2-dimensionales Array, das dynamisch erzeugt werden soll, allokierst du den Speicher in zwei Schritten.
1. Schritt: Allokiere zunächst die Zeilen
2. Schritt: Allokiere die Spalten

warum so umständlich? malloc (zeilen*spalten*sizeof(arrayelement)) reicht doch auch.

Zeigst du mir ein Listing wo ich auf diese Weise mit der althergebrachten array[x][y] Notation auf das Array zugreifen kann? Das dürfte dann auch bei deiner Variante zu einem Fehler führen.

pointercrash**

NDEBUG schrieb:

Für ein 2-dimensionales Array, das dynamisch erzeugt werden soll, allokierst du den Speicher in zwei Schritten.
1. Schritt: Allokiere zunächst die Zeilen
2. Schritt: Allokiere die Spalten

Der Free läuft dann genau andersrum:
1. Schritt: Free die Spalten
2. Schritt: Free die Zeilen

Ist doch viel zu umständlich und auch gar nicht nötig, Du kannst problemlos mein_2D_array = malloc(sizeof(int) * zeilen * spalten) anfordern, reallocen usw. Deine Spalten/Zeileneinteilung interessiert den Compiler nicht die Bohne, der multipliziert nur die Indices aus, um die Elementadresse zu finden, die Du ansprechen magst.

pointercrash**

NDEBUG schrieb:

Zeigst du mir ein Listing wo ich auf diese Weise mit der althergebrachten array[x][y] Notation auf das Array zugreifen kann? Das dürfte dann auch bei deiner Variante zu einem Fehler führen.

Ah, fricky war schneller, aber das kannst Du selber auch, probier's einfach mal aus!

Ich war übrigens selber mal platt, daß das wirklich so geht ...

NDEBUG

Hmm, keine Ahnung wie ihr das anstellt. Bei mir führt das zu Laufzeitfehlern...

TTP

ähm, die variante von NDEBUG is aber sauberer, weil sie den speicher wieder frei gibt oder nicht?

Also ist es aus Compiler sicht egal, welche Variante ich benutzte?

TTP

NDEBUG schrieb:

Hmm, keine Ahnung wie ihr das anstellt. Bei mir führt das zu Laufzeitfehlern...

benutz einfach winzigweichtools, die bügeln alles glatt, weil die coder von denen auch so viel mist einbauen und kein bock auf fehlersuche haben *hehe*

Getestet mit VS2008 unter C++: Testurteil läuft

pointercrash**

TTP schrieb:

ähm, die variante von NDEBUG is aber sauberer, weil sie den speicher wieder frei gibt oder nicht?

Je mehr Einzelpointer Du hast, desto größer die Gefahr, mal ein free zu vergessen Nicht jetzt in der Schnuckelversion, aber wenn's mal etwas unübersichtlicher wird, schon.

Hauptsache, Du vergißt kein free!

NDEBUG

Deine gefundene Variante ist auch fürn Hintern. Er macht in der Schleife einen Fehler ... er müßte eigentlich einen Offset einbauen.

TTP

Okay dann nehm ich auf jeden fall deine

EDIT: ist mir auch sympatischer das ding wie n richtigen array behandeln zu könn

TTP schrieb:

Tim schrieb:

Bitte lesen.
http://www.c-plusplus.net/forum/viewtopic.php?t=206606

hab ich doch, stand doch im 3. post oder so -.-

O.K. wenn du es schon gelesen hast, kannst du mit dem Punkt "Verstehen" weitermachen

NDEBUG

Wie wir ja schon in dem anderen Thread festgestellt haben wird array[x][y] -> ((array + x) + y) und durch die Dereferenzierung muß *(array + x) selber auf eine Adresse zeigen, da y nur der Offset ist. Ich weiß nicht wie ihr das macht, aber das ist mit einem malloc Aufruf nicht umsetzbar. Also ~fricky und pointercrash() zeigt mir, wie ihr das anstellt. Würde mich interessieren, denn ich denke, daß das nicht geht.

TTP

Tim schrieb:

O.K. wenn du es schon gelesen hast, kannst du mit dem Punkt "Verstehen" weitermachen

Danke, ich bin gerad bei Verstehen und umschreiben so wie ich es brauche
Ich denke bis ich die Funktion Präsentieren muss, muss ich mir nochmal Pointer genauer durchlesen, also ich weiß das ein Pointer auf einen anderen zeigt und so weiter, aber hab es bisher nur zu 75% verstanden glaubig.

NDEBUG schrieb:

Wie wir ja schon in dem anderen Thread festgestellt haben wird array[x][y] -> ((array + x) + y) und durch die Dereferenzierung muß *(array + x) selber auf eine Adresse zeigen, da y nur der Offset ist. Ich weiß nicht wie ihr das macht, aber das ist mit einem malloc Aufruf nicht umsetzbar. Also ~fricky und pointercrash() zeigt mir, wie ihr das anstellt. Würde mich interessieren, denn ich denke, daß das nicht geht.

Also ich brauch wirklich nur den Code in mein VS kopieren (den ich gepostet hab), dann läuft´s...

Das heißt es ist eigentlich ein Array im Array, da ein Array ja nur ein Teilelement aufnehmen kann... ahh jetzt hab ich´s gepeilt...
Vereinfacht gesagt:
Array(Array(Wert1, Wert2), Array(Wert1, Wert2), Array(Wert1, Wert2), ...) richtig?

pointercrash**

NDEBUG schrieb:

Wie wir ja schon in dem anderen Thread festgestellt haben wird array[x][y] -> ((array + x) + y) und durch die Dereferenzierung muß *(array + x) selber auf eine Adresse zeigen, da y nur der Offset ist.

void sacramento(void)
{	
	int far *feld;
	int i = 20;
	int *spalten;

	*spalten = 20;

	feld = malloc( sizeof(int) * i * *spalten);
	for (i = 0; i < 20; i ++)
		for (*spalten = 0; *spalten < 20; *spalten++)
		 feld[i][spalten] = i * *spalten;
}

Ich überprüf' jetzt aber nix mehr, Schnellschuß mit Problemchengefahr - das Prinzip ist aber klar?

NDEBUG

spalten ist n Pointer der ins Nirvana zeigt und du willst da einfach mal 20 drunter speichern?!
Die Auflösung von array[x][y] funktioniert auch hier nicht!
Läuft das bei dir?! Welchen Compieler verwendest du?
Hast du das selber geschrieben?

Quarkish dein Listing.

TTP

also mir bleibt da jedes prinzip verborgen

NDEBUG schrieb:

Wie wir ja schon in dem anderen Thread festgestellt haben wird array[x][y] -> ((array + x) + y)

nee, array[x][y] ist doch (array + x + y*hoehe) oder *(array +xbreite + y).