ich möchte die Werte eines mehrdimensionalen Arrays an eine Funktion übergeben (call by value), die wiederum einzelne Werte des Arrays an eine andere Funktion übergibt. Das Ganze soll in etwa so laufen:

float array[3][3];
void funktion1(float array[]);
void funktion2(float wert);

void funktion1(float array[])
{
   for(int i=0; i<3; i++)
   {
      for(int j=0; j<3; j++)
      {
          funktion2(array[i][j]);
      }
   }
}

Der Code ist so natürlich falsch. Ich habe schon versucht die Funktion mit "void funktion1(float array[][3])" zu deklarieren, weil eine Dimension fest ist. Daraufhin sind nicht alle Werte an funktion2 übermittelt worden.

Hoffe mir kann jemand helfen!

Danke schonmal und Gruß,
Nico

Aber wie du daran schon siehst, machst du dich mit mehrdimensionalen Arrays nicht glücklich. Nimm lieber eindimensionale und tu einfach so als seien sie mehrdimensional. Der Compiler macht das nämlich intern auch so.

ich möchte die Werte eines mehrdimensionalen Arrays an eine Funktion übergeben (call by value)

Call by value ist mit Arrays nicht möglich.

Nimm aber einen Array-Wrapper wie std::tr1::array (und wenn du keine TR1-Unterstützung hast, boost::array ), dann kannst du Arrays wie ganz normale Klasseninstanzen behandeln.

#include <array>

// Verschachteltes Array
typedef std::tr1::array<std::tr1::array<float, 3>, 3> FloatMultiArray;

void Function1(FloatMultiArray a);        // call by value
void Function2(const FloatMultiArray& a); // call by reference

int main()
{
    FloatMultiArray Array = {{1,2,3}, {4,5,6}, {7,8,9}}; // Initialisierungsliste
    Function1(Array);
    Function2(Array);
}

Oder bilde die zwei Dimensionen auf eine ab. Du kannst auch std::vector verwenden, dann hast du einfach dynamische Speicherverwaltung.

int A[5][5];
// Die Speicherzellen sind nicht gleich!
	cout << (&A[3][0] == &A[0][1]) << endl;

Woher hast du denn diese Weisheiten? So ist das nicht!

int A[5][5];
// Die Speicherzellen sind nicht gleich!
	cout << (&A[3][0] == &A[0][1]) << endl;

Bei A[2][5] schon.

Bei A[2][5] schon.

A[2][5] ist RAM Dschungel, undefiniert. Aber das weisst du bestimmt selbst.

float array[3][3];
void funktion1(float array[]);
void funktion2(float wert);

void funktion1(float array[])
{
   for(int i=0; i<3; i++)
   {
      for(int j=0; j<3; j++)
      {
          funktion2(array[i][j]);
      }
   }
}

Der Code ist so natürlich falsch.

float array[3][3];
void funktion1(float (*array)[3]);
void funktion2(float wert);
void funktion2(float wert)
{}
void funktion1(float(*array)[3])
{
   for(int i=0; i<3; i++)
   {
      for(int j=0; j<3; j++)
      {
          funktion2(array[i][j]);
      }
   }
}  

int main()
{

	funktion1(array); //!
	return 0;
}

SeppJ schrieb:

Bei A[2][5] schon.

A[2][5] ist RAM Dschungel, undefiniert. Aber das weisst du bestimmt selbst.

Verstehst du mich eigentlich absichtlich falsch?

float A[2][5];
assert(&A[3][0] == &A[0][1]);

Verstehst du mich eigentlich absichtlich falsch?

Nö, warum sollte ich.

SeppJ schrieb:

float A[2][5];
assert(&A[3][0] == &A[0][1]);

Hätte ja gern 'knapp daneben ist auch vorbei' geschreiben, aber das ist ja weit gefehlt!
Du meinst wohl sowas:

char A[2][5]; 
	cout << (&A[0][5] == &A[1][0]);

const int X = 5, Y = 4;
int U = 5, V = 4;
void f2 ( float a )
{}

void f1 ( float* B )
{
	for ( int y = 0; y < Y; y++ )
		for ( int x = 0; x < X; x++ )
			f2 (B[y*X+x]);
// X,Y  müssen hier nicht mehr const sein!
for ( int y = 0; y < V; y++ )
		for ( int x = 0; x < U; x++ )
			f2 (B[y*U+x]);
}

int main()
{	

	float A[Y][X] = {0};
	A[2][1] = 88.88;
	f1 ( ( float* )&A );