int**** array anstatt int array [a][b][c][d]

maddy87

Hey,
ich bin extrem neu was den Umgang mit C++ angeht. Ich habe eine Aufgabe, bei der ich ein 4d Array benötige dieses aber zu groß wird um es auf dem Stack anzulegen also so in der art

int array[a][b][c][d];

Mit anschließender Initalisierung via for-Schleifen (verschachtelt)

Jetzt wollte ich das Ganze auf den Heap bringen mit Pointern doch wie mache ich das nun um hier etwas ähnliches abbilden zu können
Ich habe ein Beispiel gefunden in dieser Art

int** f = new int*[101];
for (int i=0; i<101; i++)
{
 int a=4;
 f[i]= new int[a];
}

Wie kann ich aber dieses Beispiel jetzt auf meinen int**** Pointer übertragen? Wäre nett wenn mir jemand auf die Sprünge helfen könnte

TyRoXx

std::vector

cooky451

Du müsstest das halt in 3 Schleifen für jede Dimension durchziehen. Aber das zerstückelt den Speicher total. Müssen alle 4 Dimensionen dynamisch sein? Nein, offenbar nicht. Das Problem war ja nur die Größe.

Die Frage ist, wie soll der Speicher aufgebaut sein? Am besten am Stück, so wie auch bei einem Vierdimensionalen Array. Also:

std::vector<int> v(a * b * c * d);

Aber: Darauf kann man natürlich nur doof zugreifen, wenn das 4 Dimensionen sein sollen. Wie wird das denn berechnet?

v[i][j][k][l] == v[i * b * c * d + j * c * d + k * c + l];

Ok, das ist nervig zu schreiben. Aber man kann das kapseln:

#include <vector>

class my_4d_array
{
  std::vector<int> data_;
public:
  const std::size_t x, y, z, w;
  my_4d_array(std::size_t x, std::size_t y, std::size_t z, std::size_t w)
    : x(x)
    , y(y)
    , z(z)
    , w(w)
    , data_(x * y * z * w)
  {}
  int& operator () (std::size_t i, std::size_t j, std::size_t k, std::size_t l)
  {
    return data_[i * y * z * w + j * z * w + k * w + l];
  }
  const int& operator () (std::size_t i, std::size_t j, std::size_t k, std::size_t l) const
  {
    return data_[i * y * z * w + j * z * w + k * w + l];
  }
};

int main()
{
  my_4d_array a(50, 25, 45, 76);
  a(2, 7, 5, 3) = 42;
}

Dadaa!

Oder, wenn alles zur Compilezeit bekannt ist:

#include <vector>
#include <array>

int main()
{
	std::vector<std::array<std::array<std::array<int, 50>, 25>, 25>> v(5000);
	v[5][3][5][6] = 44;
}

SeppJ

Informier dich mal über den Begriff "three star programmer". Dein Programm hat einen gewaltigen Bedarf nach Abstraktion. Zum Glück kommt dir die Standardbibliothek mit zwei einfachen Arrayabstraktion entgegen: std::array (in tr1 und C++11, aber auch ganz einfach selber zu programmieren) für statische Arrays und std::vector für dynamische. Es ist aber gut möglich, dass du eine besser passende Abstraktion für dein konkretes Problem finden kannst, als diesen sehr allgemeinen Containern.

maddy87

Ich habe das mal wie folgt inizialisiert

int**** pointer = new int***[192];

		for (int a=0; a<192;a++)
		{
			pointer[a]*** = new int**[256];
			for (int b=0; b<256; b++)
			{
				pointer[a][b]** = new int*[24];
				for (int c=0; c<24; c++)
				{
					pointer[a][b][c]* =new int[10];
					for (int d=0; d<10; d++)
					{
						pointer[a][b][c][d]=-1;
					}

				}
			}
		}

Dich leider sagt er jetzt immer einen Syntaxfehler in den folgenden Zeilen
pointer[a]*** = new int**[256];
pointer[a][b]** = new int*[24];
pointer[a][b][c]* =new int[10];

Eigentlich wäre es schön wenn alle 4 "Dimensionen" dynamisch wären, aber zu Testzwecken reicht es momentan auch Fest. Es geht um Pixelkoordinaten in einem 3d Bild mit Parametern zu versehen.

cooky451

Du hast Dereferenzierungen nicht verstanden.

int ****v; // Typ: int****
*v; // Typ: int***
**v; // Typ: int**
***v; // Typ: int*
****v; // Typ: int

Aber bitte lies meinen Beitrag von oben. Und erzähl uns mal etwas mehr. Attribute über ein 3D Bild?

cooky451 schrieb:

std::vector<std::array<std::array<std::array<int, 50>, 25>, 25>>

Und wer garantiert dir da, dass das hintereinander im Speicher liegt?

cooky451

lazycoder schrieb:

Und wer garantiert dir da, dass das hintereinander im Speicher liegt?

Es ist nicht garantiert, aber recht wahrscheinlich. Und da es um Performance und nicht um Fehler geht, kann man das problemlos machen denke ich.

lazycoder schrieb:

cooky451 schrieb:

std::vector<std::array<std::array<std::array<int, 50>, 25>, 25>>

Und wer garantiert dir da, dass das hintereinander im Speicher liegt?

Äh...der Standard. std::array hat alles lokal und std::vector alles direkt hintereinander im Speicher.

Trotzdem lasse ich mal einen Link zu Boost.Multi-Array hier.

cooky451

seldon schrieb:

Äh...der Standard. std::array hat alles lokal und std::vector alles direkt hintereinander im Speicher.

std::array darf hinter den Daten aber so viel stehen haben wie es will. Wie oben gesagt: Wahrscheinlich, aber meines Wissens nach nicht garantiert.

TyRoXx

cooky451 schrieb:

Und da es um Performance und nicht um Fehler geht, kann man das problemlos machen denke ich.

Hat er nie gesagt. Außerdem ist er Programmieranfänger, kann das also nicht einschätzen.

Noch einmal zum Mitschreiben: Was du suchst, ist vector . Das ist das eindimensionale dynamische Array in C++. Damit lässt sich leicht ein vierdimensionales bauen, wie schon hinreichend beschrieben.
Ob das in der Größe veränderbar ist, kann dir solange egal sein, bis du das Konzept gut verstanden hast. Mit Zeigergefrickel würde das länger dauern.

cooky451

TyRoXx schrieb:

Hat er nie gesagt. Außerdem ist er Programmieranfänger, kann das also nicht einschätzen.

lol, die Aussage dass es performanter ist alles am Stück zu haben kommt doch von mir, der TE hat diese Forderung nie aufgestellt.

lazycoder schrieb:

cooky451 schrieb:

std::vector<std::array<std::array<std::array<int, 50>, 25>, 25>>

Und wer garantiert dir da, dass das hintereinander im Speicher liegt?

Das verstehe ich nicht. [] ist doch ein überladener Operator. Wenn std::array das intern nicht richtig machte, wäre das ja fatal, dann könnte ja genausogut

std::array<int,5> ar;
ar[4]=4; // Ist an der Stelle auch wirklich das 5te Element...

schiefgehen. Oder verstehe ich da gerade etwas falsch, falls ja, klär mich bitte auf.

cooky451

Edit: -

maddy87

Hey ich bin es nochmal,
also es geht in erster Linie nicht um performance.

cooky451

Wo ist dein Problem? Hast du die Beiträge gelesen?

maddy87

Ja ich habe die Beiträge gelesen, und habe es mal mit den verschiedenen vorgeschlagenen Ansätzen versucht, erstes Problem auf das ich gestoßen bin

#include <array>

produziert fehler. Somit kann ich auch den Ansatz mit dem Vektor der mehrere Array enthält nicht testen (ich glaube der war von dir cooky).
Deswegen habe ich jetzt 4 "verschachtelte" Vektoren genutzt. Dies funktioiert

std::vector<int> pHelpV1 (192,0);
std::vector< std::vector<int> > pHelpV2 (256, pHelpV1);
std::vector< std::vector< std::vector<int> > >pHelpV3 (24, pHelpV2);
std::vector< std::vector< std::vector< std::vector<int> > > >pMeshPointMap (10, pHelpV3);

So etwas ähnliches hatte ich hier gefunden.

cooky451

maddy87 schrieb:

produziert fehler.

Welchen Compiler / Version nutzt du?
Das mit den geschachteteln Vektoren ist kein Problem, ist halt nur nicht so flott.

314159265358979

Dann eben std::tr1::array aus <tr1/array>. Oder so.