thx im voraus

MfG Radiation 2K5

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.

aber danke für deine schnelle antwort

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.

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

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?

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

#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

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

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.

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

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

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

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

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.

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.

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

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

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

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

Ich glaube nicht daß bei diesem Konstrukt der delete sauber durchgeführt wird

Vielleicht überlegst Du es nochmal in Ruhe

Ist schon richtig.
Trotzdem würde ich von solchen Konstrukten abraten.

STL gibt doch alles erdenkliche her, oder?
Selbst Meyers(und er muß es schließlich wissen) empfiehlt Zeiger dort zu meiden wo es nur geht.

Nighthero