Zeiger auf mehrdimensionales Array

Deine Lösung funktioniert zwar CStoll, aber als elegant würde ich sie nicht bezeichnen, weil die Funktion dann nur mit Feldern arbeitet deren 2.Dimension 4 Werte umfasst.

Kennst du nicht noch eine andere Lösung, welche universeller ist?
Irgendsoetwas wie:

vector<verctor<float> >

oder so?

PS: War kein Vorschlag -> Keine Ahnung ob das funktioniert!

David_pb

Oder boost::multi_array!

CStoll

@M: Das war kein Vorschlag, sondern eher eine Erklärung zur Array-Arithmetik

Und bessere Möglichkeiten wären u.a. dein verschachtelter vector, boost::multi_array oder im Ernstfall auch Doppelzeiger (oder man verwendet ein 1D-Feld und rechnet die Dimensionen von Hand um).

Jaja, siehs nicht als kritik!
Ich hab schin gemerkt das du was drauf hast.

Könntest du das mit dem Doppelzeiger mal genauer erklären?
Meinst du so was wie:

float **mesh

CStoll

Ja, sowas meinte ich.

Zusatzbemerkung: Das zweidimensionale Array lässt sich übrigens nicht implizit in so einen Doppelzeiger umwandeln. Das heißt, du müsstest da selber eine Indirektionsebene dazwischenbauen:

float mesh[4][3];
float (*mdata)[3]={mesh[0],...};
getMesh(mdata);

(Achtung Pseudocode - die ganze Syntax mit Pointern, Arrays und Kombinationen IST grauenhaft)

Danke, ich weis nicht ob das don_basto hilft, aber ich bin zumindest wieder etwas klüger.

don_basto

Danke für die Antworten. Es geht also grundsätzlich nicht. Was ist eigentlich der Grund?

Denn der Unterschied zwischen einem einem eindimensionalen und einem Mehrdimesionale Feld ist doch nur der Zugriff. Es wird doch immer der gleiche Speicher allokiert.

const int X = 4;
const int Y = 3; 

float mesh1[X*Y];
float mesh2[X][Y];

// Versteht der Compiler unter mehrdimensionalem Array sowas ???
typedef float[Y] vertex_type;
vertex_type mesh3[X];

Also laut meinem bisschen Wissen:

Bei

float mesh1[X*Y];

wird zwar genausoviel Speicher reserviert wie bei

float mesh2[X][Y];

allerdings hast du die logische trennung übergangen und dein Quelltext ist ein Stück Verständlichkeit verlorengegangen.

Kann dir allerdings nicht sagen ob

float[Y]

überhaupt funktioniert.

don_basto

|M| schrieb:

Kann dir allerdings nicht sagen ob
float[Y]
überhaupt funktioniert.

Der Unsinn ist mir auch gerade aufgefallen. Aber ich wollte damit fragen, ob ein 2-dimensionales Feld aus einem einem Feld mit Zeigern auf ein eindimensionales Feld besteht.

don_basto

Der Speicher von ein- und mehrdimensionalen Feld ist gleich:

int main()
{
	const int X = 4;
	const int Y = 3;

	float mesh1[X*Y];
	float mesh2[X][Y];
	int count = 0;

	for (int i=0; i<X*Y; ++i)       mesh1[i] = (float) i;
	for (int i=0; i<X; ++i)
		for (int j=0; j<Y; ++j)     mesh2[i][j] = (float) count++ ;

	float* mesh1_ptr = mesh1;
	float* mesh2_ptr = &mesh2[0][0];  // mesh2_ptr = mesh2 geht ja nicht

	for (int i=0; i<X*Y; ++i) 
		std::cout << *mesh1_ptr++ << "\t" << *mesh2_ptr++ << std::endl;

	return 0;
}

ergibt:

0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
11 11

Weil damit abgesehen von der Verwendung Indizes alles identisch ist, wundert's mich, dass der Compiler meckert, wenn ich einfach nur den Zeiger auf den Feldanfang haben will.