Liste als Element eines Zeiger arrays

Zacher

Hallo!

Ich bin neuling auf dem Gebiet der C Programmierung.
Und habe folgendes Problem.

ich habe eine structur definiert und diese als Zeiger array formuliert

typedef struct part_struct
{
real x_pos;
real y_pos;
real z_pos;
real diam;

struct part_struct *next;
}part_struct;

und diese Struktur als mehrdimensionales Zeigerarray

part_struct *Bereich[256][256];

nun möchte ich 256x256 beliebig erweiterbare Listen erzeugen
also 256x256 Datensätze, die ich beliebig groß machen möchte

wie reserviere ich den Speicher oder verschiebe diesen damit ich keine Probleme habe

kann ich mein Problem so überhaupt lösen.
Oder weiss jemand einen anderen Weg, wie 256x256 Listen bekomme, die sich durch zeiger der struktur auf sich selbst erzeugen....

bitte helft mir, bin echt am verzweifeln

danke

Shine

also ganz verstanden hab ich dein problem noch nicht

du möchtest ein zweidimensionales Array von Pointern auf die struct part_struct erzeugen

Das hast du eh schon, allerdings ist da im endeffekt nur speicherplatz reserviert für die pointer also 256x 256 pointer auf strukt part_struct, die inhalte legst du anders wo an etwa mit

part_struct ps1;
ps.x_pos = 0;
ps.y_pos = 0;
ps.z_pos = 0;
ps.diam = 10;

und das kannst du dann zum bsp auf die erste position schreiben von deinem array
Bereich[0][0] = &ps1;
also genau genommen wird nur die adresse reingeschrieben

aber wozu hast du jetzt eigentlich den zeiger auf next?

vielleicht kannst du nochmal genauer beschreiben, was du eigentlich erreichen willst.

mfg Shine

Zacher

Den Zeiger next möchte ich nutzen , um eine lineare Liste zu erzeugen.

In der Praxsis sieht das Problem folgendermaßen aus.
Ich habe einen Filter, auf dem ich Staubpartikel speichern möchte.

Verwende ich eine lineare Liste wird diese irgendwann zu groß, da bei jedem Iterationsschritt tausende von Partikel verglichen werden müssen, ob diese in Stoßreichweite sind.
Auß diesem Grund möchte ich die Partikel in einer Art Matrix speichern.
Aber jedes Feld der Matrix muss beliebig viele Partikel speichern können.
Deswegen das Struct mit next. Ich muss an ein Matrixelement weitere Elemente dranhängen können.

Bildhaft vielleicht so vorgestellt.

Ich habe ein Schachbrett, bei dem ich auf jedes Feld Steinchen legen kann.
Ich kann die Steinchen beliebig hoch Stapeln.
Und jedes Steinchen beinhaltet die Position eines Partikels.
Über next erzeuge ich mit malloc ein neues Steinchen im entsprechenden Feld und schaffe eine Verbindung, so dass ich über den Zeiger next die Information dieser Steinchen auf entsprechendem Feld abrufen kann.

Das war so mein Gedanke. Die Frage ist nur, wie sich das mit dem Speicher usw. verhält. Ist das überhaupt möglich?

Paulchen

grundsätzlich würd ich das ganze mal so schreiben:

Code

struct part_struct {
	double x_pos;
	double y_pos;
	double z_pos;
	double diam;
	struct part_struct *next;
};


struct part_struct *Bereich[256][256];

dann hast du mal die strukturen, die du haben willst. dynamische speicherverwaltung in C funktioniert mit malloc() sowie free() (#include <stdlib.h>, siehe linux-manpages bzw. google). bevor du nun Bereich verwenden kannst, musst du die notwendigen pointer initialisieren, also z.B.

Code

Bereich[0][0]=(struct part_struct *)malloc(sizeof(struct part_struct));

willst du den speicher wieder freigeben, machst du

Code

(void)free(Bereich[0][0]);

und nun zu den verketteten listen: zu deren implementierung findest du sicher ausreichend material über google; auch hier musst du wieder mit malloc() bzw. free() arbeiten; um beispielsweise einem "feld" auf deinem "schachbrett" ein "steinchen" hinzuzufügen, schreibst du:

Code

Bereich[a][b]->next=(struct part_struct *)malloc(sizeof(struct part_struct));

zum loswerden dient dir wieder free().

hal

Zitat von Zacher

Ist das überhaupt möglich?

Möglich ist es, wie Paulchen schon beschrieben hat. Ich persönlich würde bei sowas allerdings keine verkettete Liste verwenden, nachdem diese ca. 25% Overhead hat (ein pointer pro 4[?] floats).
Eine gute Lösung hier ist, Punkte in zB 100er [1000er?] Blöcken zu allozieren, und wenn mehr/viel weniger gebraucht werden, ein realloc zu machen (Achtung: das kann auch fehlschlagen, dann muss man ein bisschen herumbasteln mit malloc/memcpy/free). Man muss natürlich genau aufpassen, wie viel vom Speicherblock schon belegt ist, es ist sicher nicht die unaufwändigste Methode. Falls du C++ verwendest, könntest du std::vector einsetzen, der macht das auch so.

Zacher

vielen Dank!
ich werds mal versuchen und mich bei Fehlschlag ggf. nochmal melden

Jetzt mitmachen!