Importer:Error:WasEmpty

Hey,

Ich versuche gerade ein 2-dim Array an eine unterfunktion zu geben. Ich habe schon mal gehört dass es dabei zu Problemen kommen kann und dies lieber mit Zeigern gelöst werden soll.
Leider glaube ich etwas falsch verstanden zu haben.
Meine Unterfunktion ist:

double initialE(int &state,double J,double h) //calculation of energy for random state
{
 int first=0,second=0;
 double E;
  for (int k=0;k<L;k++){
      state[k][L]=state[k][0];
      state[L][k]=state[0][k];
      }
 for (int j=0;j<L;j++){
   for (int i=0;i<(L-1);i++)
     {
       first=first+state[i][j]*state[i+1][j];//Interaction term in x direction
       first=first+state[i][j]*state[i][j+1];//Interaction term in y direction
       second=second+state[i][j];     // Magnetization term
     }
 }
 E=J*first+h*second; //total E
 return E;              
}

Die ich versuche so aufzurufen:

#define L 3
int (*state)[L+1][L+1];
Econf=initialE(state,J,h);

Meine Idee: Mit *state übergebe ich den ganzen Wert der Matrix. Mit state nur den Zeiger auf die Matrix. (richtig?)
Mit &state im unterprogramm speicher ich den Zeiger auch dort. Jetzt muss ich doch mit state meine Matrix aufrufen können?

Meine Fehlermeldung lautet:
cannot convert `int ()[4][4]' to `int' for argument `1' to `double initialE(int*, double, double)'

Ich verstehe leider nicht was er mit dem argument '1' meint.

Wen es interessiert: Es soll die Energie eines 2-dim Ising Models berechnet werden.

Danke schon mal für eure Hilfe

SeppJ

Das soll C sein? Falls ja, was soll dann das & in der ersten Zeile? So etwas gibt es in C nicht. Wenn dein Compiler das ohne Murren übersetzt hat, dann hast du einen C++-Compiler für C benutzt. Was du besser nicht tun solltest.

Merke zunächst einmal: Ein Zeiger ist kein Array, ein Array ist kein Zeiger. Ein Array als Teil eines Ausdrucks zerfällt jedoch oft in einen Zeiger auf sein erstes Element (Array to pointer decay), außer in ein paar wenigen Ausnahmefällen. Weiterhin haben Arrays keine Kopiersemantik, man kann kein Array einfach so in ein anderes kopieren mittels einer Zuweisung.

Somit bleiben drei gängige Wege, ein mehrdimensionales Array in eine Funktion zu bekommen. Diese unterscheiden sich darin, was über das Feld bekannt ist (Beispiele sind 2D, aber die Aussagen gelten allgemein):

1. Die Größe aller oder aller bis auf die äußerste Dimension sind bekannt:
Übergabe wie ein 1D-Array, bei dem der Typ der Elemente jedoch selber ein Array (mit statischer Größe) ist. Typische Funktionssignatur:

void foo(int (*array)[3], int length);

2. Die Größe der inneren Dimensionen ist variabel aber für ein einzelnes Array für alle "Zeilen" gleich:
Übergabe wie ein 1D-Array des Elementtyps und dann selber die Indizes berechnen (z.B. Feld[x][y] hat Index x * y_length + y). Typische Funktionssignatur:

void foo(int *array, int length_x, int length_y);

3. Alles ist variabel:
Dies ist gar kein richtiges mehrdimensionales Array mehr, sondern eine Art Liste von Listen. Die Daten sind von vornherein anders organisiert, ich erwähne es hier nur der Vollständigkeit halber. Hier hat man dann tatsächlich Zeiger auf Zeiger vorliegen. Man kennt dies zum Beispiel von der Signatur der main-Funktion:

int main(int length, char **array);

Man beachte, dass die Funktion bei dieser Signatur keine Information über die Größe der inneren Arrays hat. Diese Information muss also entweder in den Daten selber stecken (bei der main zum Beispiel über die Konvention der Nullterminierung der Daten) oder sonstwie übergeben werden.

Wutz

Wenn die zwei Dimensionen gleich gross und zur Compilezeit bekannt konstant sind, geht einfach

double initialE(int state[L+1][L+1],double J,double h) //calculation of energy for random state
{
 int first=0,second=0;
 double E;
  for (int k=0;k<L;k++){
      state[k][L]=state[k][0];
      state[L][k]=state[0][k];
      }
 for (int j=0;j<L;j++){
   for (int i=0;i<(L-1);i++)
     {
       first=first+state[i][j]*state[i+1][j];//Interaction term in x direction
       first=first+state[i][j]*state[i][j+1];//Interaction term in y direction
       second=second+state[i][j];     // Magnetization term
     }
 }
 E=J*first+h*second; //total E
 return E;              
}

...
int state[L+1][L+1]={{1,2,3,4},{4,5,6,7},{8,8,8,8},{9,9,9,9}};
Econf=initialE(state,J,h);