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

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;
}

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.

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?

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

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

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.

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.

Ä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.

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.

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.

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.

#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.

produziert fehler.

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