ich bekomme einen Fehler, den ich nicht verstehe:

// Privates Attr. in einer Klasse
float	_mesh[4][3];

// Öffentlicher Zugriff
void	getMesh(float* mesh)	{ mesh = _mesh; };

Mein Compiler (VC8.0) sagt dazu:

error C2440: '=' : cannot convert from 'float [4][3]' to 'float *'

Bisher dachte ich, dass eine Feldvariable ohne Indizes immer einen Zeiger auf das Feld zurückgibt, was mit eindimensionalen Feldern auch klappt. Wieso funktioniert das nicht bei mehrdimensionalen Feldern?

BTW: Mit dem folgendem Kode läuft's:

void	getMesh(float* mesh)	{ mesh = &_mesh[0][0]; };

Grüße,
don_basto. :xmas1:

Bisher dachte ich, dass eine Feldvariable ohne Indizes immer einen Zeiger auf das Feld zurückgibt, was mit eindimensionalen Feldern auch klappt. Wieso funktioniert das nicht bei mehrdimensionalen Feldern?

Weil diese Umwandlung Array -> Pointer nur eindimensional verläuft - _mesh kann höchstens umgewandelt werden in einen float* mesh[4] (Zeiger auf float-Array), aber nicht in einen float*

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!

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

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

float **mesh

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)

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

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.

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.

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.