Mehrdimensionales array an funktion übergeben (C)

[T. (Gast)]

Hi,
ich bin noch relativ unerfahren mit C
Ich möchte ein mehrdimensionales Array an eine Funktion übergeben. Habe 
hierzu auch recht viel im Internet gefunden und mein funtkionsaufruf 
funktioniert zwar, aber der Compiler spuckt ne Warnung aus. Wie bekomme 
ich diese weg, oder vorallem Wieso kommt sie und wieso funtkioniert es 
trotzdem?

uint8_t change[8][8][8];


void get_spi_data(uint8_t data[][8][8]){
FUNKTION
}


main(){

...
get_spi_data(change);
...

}

Compiler sagt:

Warning    passing argument 1 of 'get_spi_data' from incompatible 
pointer type

[B. S. (bestucki)]

Dein Code erzeugt bei mir keine derartige Warnung. Könnte es sein, dass 
dein Array volatile ist?

[array isn 't pointer (Gast)]

> void get_spi_data(uint8_t data[][8][8])

...get_spi_data(uint8_t data[8][8][8])

...get_spi_data(uinti_t *data)

[B. S. (bestucki)]

array isn 't pointer schrieb:
> ...get_spi_data(uint8_t data[8][8][8])
>
> ...get_spi_data(uinti_t *data)

Was möchtest du uns damit sagen? Dass Arrays keine Zeiger sind, wissen 
wir. Falls du glaubst, zweimal das Gleiche hingeschrieben zu haben, muss 
ich dich enttäuschen.

Gut wäre, wenn sich der TO wieder melden und etwas Infromationen 
dalassen könnte. Momentan ist weder Compiler noch sonstwas bekannt. 
Nichteinmal, ob die Warnung wirklich im gezeigten Codeausschnitt ist.

[array isn 't pointer (Gast)]

Beide Zugriffe funktionieren und sind zulässig. Und das unabhängig vom 
Compiler. Ist hält so, Stück. ;-)

[B. S. (bestucki)]

array isn 't pointer schrieb:
> Beide Zugriffe funktionieren und sind zulässig. Und das unabhängig vom
> Compiler.

Na klar funktionierts, das Gleiche ist es trotzdem nicht. Einmal 
erwartet die Funktion

uint8_t (*)[8][8]

und das andere mal

uint8_t *

Einmal sieht der Funktionsaufruf so aus

get_spi_data(change);

und das andere Mal

get_spi_data(change[0][0]);

Edit: Aussdem kannst du das Array nicht mehr über data[0][0][0] 
ansprechen, die musst die Zugriffe manuell berechnen. Spielt natürlich 
keine Rolle, wenn man so oder so linear auf die Daten zugreifen muss.

array isn 't pointer schrieb:
> Ist hält so, Stück. ;-)

Hast du mich als Stück bezeichnet?

[array isn 't pointer (Gast)]

Beides funktioniert, ja? Dann sind wir uns in der Sache einig.

Wo schrieb ich, dass die beiden Varianten das Gleiche sind? Du hast den 
Nick doch richtig gedeutet???

Ist halt so Stucki. (im anderen Post hat die Androide Eingabehilfe 
zugeschlagen)

[Rolf M. (rmagnus)]

array isn 't pointer schrieb:
> Beides funktioniert, ja?

Das erste funktioniert, ist aber exakt das gleiche, wie der TE 
hingeschrieben hat. Die zusätzliche 8 wird vom Compiler ignoriert.
Das zweite ist einfach nur falsch, da der Typ nicht stimmt.

> Wo schrieb ich, dass die beiden Varianten das Gleiche sind?

Sie sind nicht nur nicht gleich, sondern auch nicht austauschbar.

Die Definition im ursprünglichen Code sieht für mich richtig aus und 
gibt beim gcc auch mit meinen üblichen Warneinstellungen (-std=c99 
-pedantic -Wall -Wextra) keine Warnung. Ich vermute stark, dass hier mal 
wieder nicht der echte Code, sondern was anderes extra für's Posting 
aufbereitet wurde, das den eigentlichen Fehler gar nicht enthält.

[B. S. (bestucki)]

array isn 't pointer schrieb:
> Wo schrieb ich, dass die beiden Varianten das Gleiche sind?

Nirgends. Ich wusste nur nicht, was du uns mit deinem ersten Post sagen 
willst. Der Code vom TO erzeugt die Warnung nicht, eine Änderung auf 
deine zweite Funktionssignatur würde genau diese Warnung hervorrufen. 
Deswegen die Nachfrage.


array isn 't pointer schrieb:
> Ist halt so Stucki. (im anderen Post hat die Androide Eingabehilfe
> zugeschlagen)

Kein Problem, deswegen hab ich nachgefragt.

[T. (Gast)]

Hey,
fuck sorry, ihr habt recht -.- ich hab n fehler beim posting.

die Variable ist als volatile deklariert.
Compiler ich glaube gnu c99 ?! (Atmel Studio 7, code ist für ein Cortex 
M7 (SamV71) )

Wie gesagt, bin ziemlich neu in C und nehme Verbesserungsvorschläge 
gerne an!

hier der original code:

//var
volatile uint8_t LedCube[8][8][8];  //[x][y][z]

//prototype
void get_spi_cube_data(uint8_t led_cube_data[][8][8]);



Aufruf in main:

get_spi_cube_data(LedCube);




//Funktion
void get_spi_cube_data(uint8_t led_cube_data[][8][8]){
  uint8_t x, y, z =0;
  uint8_t yl = 8;  //for layer (y=0 - yl=7; y=1 - yl=6; .. ; y=7 - yl=0) hardware'problem'
  uint8_t instance=0;
  uint8_t led_cube_data_copy[8][8][8];  

  for (instance = 0; instance < 31; instance++){
    yl = 8;
    for (y=0; y<8; y++){
      yl = yl - 1;
      spi_data[instance][yl]=0;
      for (x=0; x<8; x++){
        for (z=0; z<8; z++){
          led_cube_data_copy[x][y][z] = led_cube_data[x][y][z];    //copying led cube data
          if (led_cube_data_copy[x][y][z]>0){
            led_cube_data_copy[x][y][z] = led_cube_data_copy[x][y][z] - 1;  //Lower LEDcounter by one
            spi_data[instance][yl] |= (1 << (x+(z*8)));      //set according LED in Layer
            //layer[y] set x and z leds
          }
        }
      }
    }
  }
}

[Rolf M. (rmagnus)]

T. schrieb:
> //var
> volatile uint8_t LedCube[8][8][8];  //[x][y][z]
>
> //prototype
> void get_spi_cube_data(uint8_t led_cube_data[][8][8]);

Dann ist es ja kein Wunder. Wenn deine Variable volatile ist, musst du 
auch den Parameter volatile machen.