2D Array an Funktion übergeben?!

Da ist ein Stern zuviel.

> void readRAM( uint8_t *image )
> {
>     image[156] = '1';
>     printf("%c",image[156]);
> }
> int main()

>     readRAM( (uint8_t *)ram );
>     printf("%c", ram[1][28]);


Du schreibst in der Funktion an Image[156] und liest in der main() 
ram[1][28] aus?

Ah Okay, Die Bytes liegen ja hintereinander!

Kann man nicht irgendwie auf das Array anders drauf zugreifen?

1

void readRAM( uint8_t *image )

2

{

3

    *image[0][0] = '1';

4

}

Das man es irgendwie so auslesen kann?

Ich möchte ein Array senden über einen BUS was 64x128 Bytes groß ist, Da 
würde sich diese Art wie Ich zu letzt gepostet habe sehr anbieten. Das 
ist ziemlich übersichtlich.

So ungefähr..

1

void sendRAM( uint8_t *image )

2

{

3

  uint8_t i = 0;

4

5

  for(uint8_t x = 0 ; x < 64 ; x++)

6

  {

7

    for( ; i < 128 ; i++)

8

    {

9

      send(image[x][i]);

10

    }

11

  }

12

}

M. K. schrieb:
> Dann mach das doch genau so

Meinst Du damit, deinen Vorschlag?

M. K. schrieb:
> void sendRAM( uint8_t image[] )
> {
>   for(uint8_t x = 0 ; x < 64 ; x++)
>   {
>     for(uint8_t i = 0; i < 128 ; i++)
>     {
>       send(image[x+64*i]);
>     }
>   }
> }

Jetzt muss Ich aber noch mal was Fragen. Wieso x+64? Wenn Ich von 0 
Anfangen will zu lesen?

Elisa W. schrieb:
> Jetzt muss Ich aber noch mal was Fragen. Wieso x+64? Wenn Ich von 0
> Anfangen will zu lesen?

Mathe 2 Klasse : Punkt vor Strichrechnung!

ich würde die Größeninformation nicht irgendwo in der Funktion 
verstecken sondern entweder

void sendRAM( uint8_t image[64][128] )

oder sendRAM( uint8_t *image, int xsize, int ysize)

verwenden

Ralf schrieb:
> Elisa W. schrieb:
>> Jetzt muss Ich aber noch mal was Fragen. Wieso x+64? Wenn Ich von 0
>> Anfangen will zu lesen?
>
> Mathe 2 Klasse : Punkt vor Strichrechnung!

Mal nicht so überheblich!

2.Klasse - Rechnen hat mit Priorität und Assoziativität von Operatoren 
in C erst mal gar nichts zu tun!
Auch dann nicht - wenn es zufällig Parallelen gibt!

Danke!

Walter K. schrieb:
> in C erst mal gar nichts zu tun!
> Auch dann nicht - wenn es zufällig Parallelen gibt!

Ganz rein zufällig macht das der C-Compiler genau deswegen so weil es 
die Mathematik so lehrt. Das ist keine Erfindung der Programmierer des 
Compilers.

Walter schrieb:
> ich würde die Größeninformation nicht irgendwo in der Funktion
> verstecken sondern entweder
>
> void sendRAM( uint8_t image[64][128] )
>
> oder sendRAM( uint8_t *image, int xsize, int ysize)
>
> verwenden

ich halte die 2. Variante für die sauberste Lösung

Rolf M. schrieb:
> Die gibt es nicht zufällig, sondern in voller Absicht, da es ziemlich
> blöd wäre, solche grundlegenden Regeln nicht zu übernehmen.

Deshalb kennt der Taschenrechner/Calculator des in diesem Forum so hoch 
geschätzten und verehrten Betriebssystem-Schrotts - namens MS-Windows 
die Punkt vor Strich-Regel nur im "Wissenschaftlichen Mode"  ;-)

Das ist halt Microsoft ;-)

Das kann Ich jetzt noch nicht wirklich nachvollziehen.
Ich habe ein Array mit einem Reservierten Speicherbereich von 64 * 128 
Bytes.

Diese sind alle hintereinander angeordnet, richtig?
Das heißt ich müsste von

1

Image[0] - Image[127]

lesen um Bildlich gesehen auf

1

RAM[1][0]

zu kommen oder nicht?

Mein Google listet mir z.B. so etwas auf :

https://de.wikibooks.org/wiki/C-Programmierung:_Arrays

Und weil du ganz oben mit Zeigern gearbeitet hast :

https://de.wikibooks.org/wiki/C-Programmierung:_Zeiger

Elisa W. schrieb:
> Ich habe ein Array mit einem Reservierten Speicherbereich von 64 * 128
> Bytes.
>
> Diese sind alle hintereinander angeordnet, richtig?
> Das heißt ich müsste vonImage[0] - Image[127]
> lesen um Bildlich gesehen aufRAM[1][0]
> zu kommen oder nicht?

ja, Dein Array liegt sequentiell im Speicher.
D.h. mehrdimensionale Arrays in C sind letztendlich immer 
eindimensional.

wie Du richtig geschrieben hast:
( array_intern ist jetzt nur ein Konstrukt zur Erklärung )
array[0][000] => array_intern[0]
array[0][001] => array_intern[1]
array[0][002] => array_intern[2]
...
array[0][127] => array_intern[127]

array[1][000] => array_intern[128]
array[1][001] => array_intern[129]
array[1][002] => array_intern[130]
...
array[1][127] => array_intern[255]
......
array[63][127] => array_intern[8191]

Und nein - ein Array ist kein Zeiger .. aber es besteht im Prinzip nur 
aus Zeigern, welche auf die zum Array gehörenden Variablen zeigen.

Anbei mal ein Screenshot.

Wenn Ich..

1

  ram[0][0] = 'a';

2

  ram[1][0] = 'b';

Dann stelle Ich mir das wie eine Art Tabelle vor.

ram[Zeile 0][Spalte 0] = 'a'
ram[Zeile 1][Spalte 0] = 'b'

Oben in der Ausgabe ist das 'b' nicht an Zeile '1'. Wieso?

1

void readRAM(uint8_t *image)

2

{

3

  uint8_t y = 0, x = 0;

4

5

  for( ; y < 64 ; y++)

6

  {

7

    printf("Zeile %d.:      ",y);

8

    for( x = 0 ; x < 128 ; x++)

9

    {

10

      printf("%c",image[x]);

11

    }

12

    printf(" END \r\n");

13

    image++;

14

  }

15

}

16

17

int main ()

18

{

19

  uint8_t ram[64][128];

20

21

  memset((uint8_t*)ram,'0',8091);

22

23

  ram[0][0] = 'a';

24

  ram[1][0] = 'b';

25

26

  readRAM((uint8_t*)ram);

27

28

    return 0;

29

}

Okay.
Für eine Anfängerin wie Mich ist das ziemlich tricky.
Schade das man nicht einfach wie an anderer Stelle mit [x][y] drauf 
zugreifen kann. Das würde viel zum Verständniss beitragen.

Nimm mal ein kleineres Array und lass dein Prog Schritt für Schritt mit 
einem Debugger laufen und schau zu was passiert. Ansonsten sie dir die 
Wikibook links an.

Ein Tipp : setze das image++; in die x Schleife.

for( x = 0 ; x < 128 ; x++)
    {
      printf("%c",*image);
      image++;
    }
    printf(" END \r\n");

oder so lasen wie bei dir dann aber

image += 128;

Rolf M. schrieb:
>> void sendRAM( uint8_t image[64][128] )
>
> Das bringt nicht viel.

mir schon, zumindest kann ich dann mit
image[y][x]

auf das array zugreifen und muss nicht so einen hack schreiben
image[x+64*i]

und das ganze dann vielleicht noch an 10 Stellen in der Funktion

Elisa W. schrieb:
> uint8_t y = 0, x = 0;
>
>   for( ; y < 64 ; y++)

Initialisier die Variablen direkt in der For Schleife, nicht zuvor. Der 
Compiler optimiert das schon weg, nur bewahrt es den Code hinsichtlich 
der Fehleranfälligkeit und der Compiler kann zudem besser optimieren.

So machst du deinen Code nur unübersichtlicher durch eine vermeintliche 
Optimierung und gewinnst rein gar nichts.

Rolf M. schrieb:
> Wenn du das an 10 Stellen in der Funktion brauchst, kannst du den Index
> auch einmal am Anfang berechnen und dann an den 10 Stellen nur noch
> benutzen.

*64 ist nur ein Shift, daher relativ billig, zudem optimiert der 
Compiler das eh raus sofern aktuell genug ist.

M. K. schrieb:
> Nochmal die Bitte: Erkläre es mir/uns (hier lesen sicher mehr mit) bitte
> einmal. Das wäre sehr nett.

Moin,

ich verstehe zwar nicht so recht, was es da nicht zu verstehen gibt,
aber ich versuche es mal:

Ein Pointer ist eine Variable. Dier wird angelegt und vom Linker
locatiert. Sie belegt exakt sviel speicher, wie eine Adresse auf deinem
Target benötigt (mein Cortex M7 4Byte), mehr nicht.

Ein Array besteht aus dem Speicherplatz der Daten die das Array bilden.
ZB ein paar tauesend bytes (je nach groesse).
Der Linker muss diese Daten auch irgendwo hinlegen. Und somit gibt es
eine Adresse bei der die Daten liegen. Aber es gibt keinen Pointer.

Man kann zB eine Pointer anlegen, die Adresse des Pointers ermitteln
(&myptr), an eine Funktion uebergeben, die ein Datenobjekt kreiert
(dafuer speicher allociert der irgendwo wo platz ist zum liegen kommt)
und diese Adresse in den Pointer schreibt.
Danach kann der Aufrufer seinen Pointer dereferenziern und somit auf das 
Datenobject zugreifen. Er kann aber auch seine Pointer ins Nirvana 
zeigen
lassen und dort dereferenzieren.
Da kommt nur meistens nix gescheites bei raus.

Darth Moan schrieb:
> Ein Pointer ist eine Variable. Dier wird angelegt und vom Linker
> locatiert. Sie belegt exakt sviel speicher, wie eine Adresse auf deinem
> Target benötigt (mein Cortex M7 4Byte), mehr nicht.
>
> Ein Array besteht aus dem Speicherplatz der Daten die das Array bilden.
> ZB ein paar tauesend bytes (je nach groesse).
> Der Linker muss diese Daten auch irgendwo hinlegen. Und somit gibt es
> eine Adresse bei der die Daten liegen. Aber es gibt keinen Pointer.

Da fragt ein Anfänger nach den Eigenheiten von zweidimensionalen Feldern 
in C -
und dann kommt zum Schluss so ein Stuss, wie der von Darth Moin -
und bleibt dann als letzter Beitrag unwidersprochen stehen!

Walter K. schrieb:
> Da fragt ein Anfänger nach den Eigenheiten von zweidimensionalen Feldern
> in C -
> und dann kommt zum Schluss so ein Stuss, wie der von Darth Moin -
> und bleibt dann als letzter Beitrag unwidersprochen stehen!

Tja, du willst jetzt also den Anfängern einreden, dass es keinen
Unterschied zwischen einem Pointer und einem Array gibt.

Wer soetwas behauptet, der ist entweder dumm, oder niedertraechtig weil
er Anfaengern Stuss einreden will.

Oder er hat gar nicht gelesen, worauf jemand geantwortet hat?

M. K. schrieb:
> Array ist ja eigentlich auch nix anderes als ein Zeiger.

M. K. schrieb:
>> Genauso wie das Gleichsetzen von Zeigern und Arrays "eigentlich" ein
>> Bein ist. Denn dieser Vergleich hinkt sehr stark.
>
> Nochmal die Bitte: Erkläre es mir/uns (hier lesen sicher mehr mit) bitte
> einmal. Das wäre sehr nett.

Aber lesen ist ja auch so old school.

Rolf M. schrieb:
>> und muss nicht so einen hack schreiben
>> image[x+64*i]
>>
>> und das ganze dann vielleicht noch an 10 Stellen in der Funktion
>
> Wenn du das an 10 Stellen in der Funktion brauchst, kannst du den Index
> auch einmal am Anfang berechnen und dann an den 10 Stellen nur noch
> benutzen.

ja, wenn man immer nur auf ein Element des arrays zugreifen wollte, das 
ist aber eher selten,

was ist einfacher zu lesen und zu verstehen:

value = image[x-1,y-1] + image[x, y-1] + image[x+1, y-1]

oder

value = image[(y-1)*64+x-1] + image[(y-1)*64+x] + image[(y-1)*64+x-1]