2 dimensionales, dynamisches array

Radiation2K5

wie kann ich ein 2 dinemsionales und dynamisches array per new erzeugen?
es sollten alles integer variablen sein. habe schon zig seiten durchsucht, hab aber immer nur 1 dimensionale felder gesehen. eine notdürftige lösung hab ich so gelöst:
zuerst mit struct einen eigenen datentyp der ein array enthält erzeugen und diesen dann wiederrum als array per new erzeugen.
aber es muss doch auch anders gehen.

thx im voraus

MfG Radiation 2K5

Dasd

Eine Möglichkeit wäre mit reinen C-Mitteln:

int w = ... // Breite
int h = ... // Höhe

int *array = (int*) calloc(w * h, sizeof(int)); // anlegen

// zugriff auf x,y:
int wert = *(array + x * h + y);

Ungetestet.

Per VCL kannst du verschachtelte DynamicArrays nehmen. Gibt's auch ein Beispiel in der Hilfe dafür.

Radiation2K5

ich progge mit C++ erst seit knapp nem halben jahr
könntest du mir da bitte das ganze mal genauer erklären was calloc genau macht und wie der zugriff so funktioniert.

aber danke für deine schnelle antwort

Dasd

Zu calloc siehe BCB-Hilfe.
Zu Zeigern ebenfalls. Und C-Grundlagen lernen.

Der Grundgedanke ist schlicht, alle Werte hintereinader in den Speicher zu schreiben. Und jedes h-te Element ist eine Spalte vorbei und die nächste beginnt. Deswegen die Formel.

Falls dir das zu kompliziert ist :p, kann ich dir nur weiterhin DynamicArray empfehlen.

akari

Hallo

wenn du schon im BCB-Forum fragst, kannst du wenigstens DynamicArray nehmen, denn dann must du dich nicht um die Auflösung des Arrays kümmern

int w = ... // Breite
int h = ... // Höhe

DynamicArray<int *> array;
array.Length = w * h;

// zugriff auf x,y:
int wert = *(array[x * h + y]);

/Edit : Um die Auflösung der int-Instanzen must du dich wegen der Pointer aber trotzdem selber kümmern

bis bald
akari

Dasd

akari schrieb:

wenn du schon im BCB-Forum fragst, kannst du wenigstens DynamicArray nehmen

Hatte darauf hingewiesen. In manchen Fällen sind reine Pointer einfach nur effizienter.

Aber warum nicht gleich DynamicArray verschachteln?

int w = ... // Breite
int h = ... // Höhe

DynamicArray<DynamicArray<int>> array;
array.Length = w;
for (int i = 0; i < w; i++)
   array[i].Length = h;

// zugriff auf x,y:
int wert = array[x][y];

Dann brauch man sich um gar nichts mehr zu kümmern...

Edit: @akari: Wozu um alles in der Welt int*****? Er wollte doch nur einfache Integervariablen? Ist das nicht ein wenig übertrieben?

akari

Hallo

Hatte darauf hingewiesen. In manchen Fällen sind reine Pointer einfach nur effizienter.

Den Hinweis im ersten Post hatte ich übersehen, der zweite kamm zu spät...

Hatte darauf hingewiesen. In manchen Fällen sind reine Pointer einfach nur effizienter.

Leider auch fehleranfälliger, da das Freigeben selber gemacht werden muß.

Aber warum nicht gleich DynamicArray verschachteln?

Dadurch ergibt sich das Problem, das unterschiedliche Zeilenlänge oder Spaltenhöhen entstehen können. In so einen Fall nehme ich immer eindimensionale Arrays, deren Zugriff ich in einer Klasse kapsele.

Wozu um alles in der Welt int*? Er wollte doch nur einfache Integervariablen? Ist das nicht ein wenig übertrieben?

Stimmt natürlich, hatte das irgendwie mißverstanden.

bis bald
akari

epidemic

Es geht auch einfacher, ohne unnötig mit zeigern zu handeln.

#include <vector>

std::vector< std::pair<int,int> > ArrayPair;
std::pair<int,int> Pair(1,2);

ArrayPair.push_back(Pair);
ShowMessage(ArrayPair.at(0).first);//1
ShowMessage(ArrayPair.at(0).second);//2

Radiation2K5

wenn ich ehrlich bin würde ich eher diese form hier verwenden, die sieht für mich am einfachsten aus, und nachdem ich die jetzt fast schon zum 100-mal angeguckt hab, wird es mir auch klarer was ihr damit meint.

int w = ... // Breite
int h = ... // Höhe

int *array = (int*) calloc(w * h, sizeof(int)); // anlegen

// zugriff auf x,y:
int wert = *(array + x * h + y);

aber btw: wo gibt es gute tut's um sein wissen in pointern zu erweitern wäre nämlich sehr hilfreich. link würde mir schon reichen.

thx im voraus
MfG Radiation 2K5

Dasd

akari schrieb:

Dadurch ergibt sich das Problem, das unterschiedliche Zeilenlänge oder Spaltenhöhen entstehen können.

Während eindimensionale Arrays schlecht erweiterbar sind. Der Ansatz mit einer eigenen Klasse scheint wirklich der günstigste zu sein.

epidemic

Radiation2K5 schrieb:

wenn ich ehrlich bin würde ich eher diese form hier verwenden, die sieht für mich am einfachsten aus, und nachdem ich die jetzt fast schon zum 100-mal angeguckt hab, wird es mir auch klarer was ihr damit meint.
int w = ... // Breite
int h = ... // Höhe

int *array = (int*) calloc(w * h, sizeof(int)); // anlegen

// zugriff auf x,y:
int wert = *(array + x * h + y);
aber btw: wo gibt es gute tut's um sein wissen in pointern zu erweitern wäre nämlich sehr hilfreich. link würde mir schon reichen.

thx im voraus
MfG Radiation 2K5

hmhm,
was verstehst Du bei meinem Lösungsansatz nicht??

Was hier oben in dem Beispiel produziert wird ist kein c++, meiner meinung nach

Radiation2K5

wie kommst du auf sowas?

int wert = *(array + x * h + y);

ich wäre da net so schnell draufgekommen, obwohl ich gut programmieren kann (eben andere sprachen)
ich bin eben davon ausgegangen, das die daten irgendwo im ram rumliegen und net direkt hintereinander. deswegen kam ich durcheinander. aber mittlerweile blick ich schon durch. da calloc ja den ram für sich reserviert.

aber ich hätt trotzdem noch gerne ein tut für zeiger/pointer bidddee, es würde ja auch anderen helfen (meinen kollegen)

MfG Radiation 2k5

akari

Hallo

auf dieser Seite oben rechts ist ein Menüpunkt namens Tutorials, das jede Mende davon anbietet. Da wird sicher auch das Thema behandelt.

bis bald
akari

Dasd

epidemic schrieb:

Was hier oben in dem Beispiel produziert wird ist kein c++, meiner meinung nach

Ich hatte zu Beginn auch geschrieben, dass es sich hierbei um reines C handelt. VCL-typisch wäre meiner Meinung wie gesagt DynamicArray oder Set. std::vector ist ok, aber doch auch nicht BCB-spezifisch, oder?

Edit:

Radiation2K5 schrieb:

wie kommst du auf sowas?

Jahrelange Erfahrung... dann kommen auch die Tricks und Kniffe.

junix

std::vector ist nicht BCB-Spezifisch... und anstelle des calloc wäre vielleicht ein new ganz witzig. Und von Pointerarithmetik in Dingen die der Compiler erledigen könnte halte ich nur beschränkt viel...

-junix

Dasd

junix schrieb:

Und von Pointerarithmetik in Dingen die der Compiler erledigen könnte halte ich nur beschränkt viel...

Könntest du das etwas genauer beschreiben? Ich arbeite an der Uni an einem Projekt mit in dem die von mir gezeigte "Technik" recht intensiv genutzt wird.

epidemic

junix schrieb:

std::vector ist nicht BCB-Spezifisch...
-junix

Ja, das ist richtig.

Dann gehört aber der ganze Thread auch woanders hin
Außerdem ist eine Lösung, die aus dem C++ standard kommt(STL) eher zu bevorzugen als eine Frameworkabhängige, oder?

Ich bevorzuge schon eine Standard Lösung, frameworkunabhängig, wo es nur geht. Dann ist es egal ob ich MVC++ oder den C++ Builder verwende...
Das nur als Argument.

epidemic

Dasd schrieb:

junix schrieb:

Und von Pointerarithmetik in Dingen die der Compiler erledigen könnte halte ich nur beschränkt viel...

Könntest du das etwas genauer beschreiben? Ich arbeite an der Uni an einem Projekt mit in dem die von mir gezeigte "Technik" recht intensiv genutzt wird.

Dann ist es aber ein C Projekt.
bei C++ ist allotieren mit new zu verwenden.

Oder Deine Kollegen an der Uni kennen nur diese Technik

epidemic

Dasd schrieb:

junix schrieb:

Und von Pointerarithmetik in Dingen die der Compiler erledigen könnte halte ich nur beschränkt viel...

Könntest du das etwas genauer beschreiben? Ich arbeite an der Uni an einem Projekt mit in dem die von mir gezeigte "Technik" recht intensiv genutzt wird.

Dann ist es aber ein C Projekt.
In C++ allokiert man mit new.

Oder Deine Kollegen an der Uni kennen nur diese Technik

Nighthero

schon mal so versucht?

int m = 3;                               // ANZAHL DER ZEILEN.
int n = 5;                               // ANZAHL DER SPALTEN.
int **int_array;

int_array = new int*[m];                 // SCHRITT 1: ZEILEN EINRICHTEN

for (int j = 0; j < m; ++j)
   int_array[j] = new int[n];            // SCHRITT 2: SPALTEN EINRICHTEN.

// löschen
for (int i = 0; i < m; ++i)
   delete[] int_array[i];                // SCHRITT 1: SPALTEN LÖSCHEN

delete[] int_array;                      // SCHRITT 2: ZEILEN LÖSCHEN

aus der BCB-Hilfe

Nighthero