2D Array an Funktion übergeben?!

[Elisa W. (Gast)]

Guten Morgen,

wieso kann man innerhalb der Funktion den Wert der zuvor rein 
geschrieben wurde, korrekt auslesen und sobald sie verlassen wird und 
die gleiche Speicherstelle wieder ausgelesen wird, steht irgendein Müll 
drin?

[Elisa W. (Gast)]

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

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


int main()
{
  uint8_t ram[64][128];

  readRAM( (uint8_t **)ram );
  printf("%c", *ram[0]);
  
    return 0 ;
}

[PittyJ (Gast)]

Da ist ein Stern zuviel.

[M. K. (sylaina)]

mehr als nur ein Stern, so klappts:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
void readRAM( uint8_t *image )
{
    image[156] = '1';
    printf("%c",image[156]);
}


int main()
{
    uint8_t ram[64][128];
    
    readRAM( (uint8_t *)ram );
    printf("%c", ram[1][28]);
    
    return 0 ;
}

[Elisa W. (Gast)]

> 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?

[Elisa W. (Gast)]

Ah Okay, Die Bytes liegen ja hintereinander!

[Elisa W. (Gast)]

Kann man nicht irgendwie auf das Array anders drauf zugreifen?

void readRAM( uint8_t *image )
{
    *image[0][0] = '1';
}

Das man es irgendwie so auslesen kann?

[M. K. (sylaina)]

Elisa W. schrieb:
> Ah Okay, Die Bytes liegen ja hintereinander!

Riiichtig ;)

[M. K. (sylaina)]

Elisa W. schrieb:
> Das man es irgendwie so auslesen kann?

Also 1.: Du liest es ja gar nicht aus sondern beschreibst es.
Und 2.: Was willst du denn genau machen? Das ist wohl sinnvoller zu 
klären als jetzt noch 15 Posts um den heißen Brei zu reden.

[Elisa W. (Gast)]

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.

[Elisa W. (Gast)]

So ungefähr..

void sendRAM( uint8_t *image )
{
  uint8_t i = 0;
  
  for(uint8_t x = 0 ; x < 64 ; x++)
  {
    for( ; i < 128 ; i++)
    {
      send(image[x][i]);
    }
  }
}

[M. K. (sylaina)]

Dann mach das doch genau so

Zur besseren Lesbarkeit würde ich es aber so schreiben:

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

Ist meiner Meinung nach übersichtlicher

[Elisa W. (Gast)]

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

Meinst Du damit, deinen Vorschlag?

[M. K. (sylaina)]

Ja. Ich nehme an dein Bild hat 64 Zeilen und 128 Spalten. Dann würde so 
das Bild Zeilenweise übertragen werden.

[Elisa W. (Gast)]

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?

[M. K. (sylaina)]

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

Beginnt doch mit 0. Zu Beginn ist doch x und i jeweils 0, damit greift 
man auf image[0] zu. Das letzte Element ist image[63+64*127] zu, das ist 
image[8191], also das letzte Element von image[]

[Ralf (Gast)]

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!

[Rolf M. (rmagnus)]

Ralf schrieb:
> Mathe 2 Klasse : Punkt vor Strichrechnung!

Um das auch optisch leichter erfassbar zu machen, hätte ich aber 
geschrieben:

  send(image[64*i + x]);

[Walter (Gast)]

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

[Walter K. (Gast)]

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!

[Ralf (Gast)]

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.

[Rolf M. (rmagnus)]

Walter K. schrieb:
>> 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 in C gilt selbstverständlich Punkt vor Strich. Dass das als Teil 
einer größeren Liste von Operator-Prioritäten und Assoziativitäten 
umgesetzt ist,  ändert daran nichts.

> Auch dann nicht - wenn es zufällig Parallelen gibt!

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

> Danke!

Gern geschehen!

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

Das bringt nicht viel. Der Parameter ist ein Zeiger auf ein Array aus 
128 Elementen vom Typ uint8_t. Die 64 wird vom Compiler weder beim 
Aufruf berücksichtigt, noch kann man sie innerhalb der Funktion wieder 
irgendwie zurückgewinnen (sizeof gibt dir nur die Größe eines Zeigers).
Am Ende ist es also nur eine Art Doku für denjenigen, der diesen 
Funktionskopf liest.

[Dirk B. (dirkb2)]

Ein 2D-Array zerfällt bei einem Funktionsaufruf nicht in einen 
Doppelzeiger.


Seit C99 gibt es VLA (Variable Length Array).

Die haben zwar einen schlechten Ruf (wenn man damit Arrays definiert).

Als Funktionsparameter oder auch als Zeiger auf ein Array sind sie 
super.

sendRAM(int xsize, int ysize, uint8_t image[xsize][ysize])

Die Reihenfolge ist wichtig, erst die Dimensionen, dann die Adresse.
In der Funktion kann man dann Problemlos mit [] auf das Array zugreifen.

[Walter K. (Gast)]

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

[Walter K. (Gast)]

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"  ;-)

[Ralf (Gast)]

Das ist halt Microsoft ;-)

[Rolf M. (rmagnus)]

Dirk B. schrieb:
> Ein 2D-Array zerfällt bei einem Funktionsaufruf nicht in einen
> Doppelzeiger.

Nein, es zerfällt wie ich oben schrieb in einen Zeiger auf ein Array.

> Als Funktionsparameter oder auch als Zeiger auf ein Array sind sie
> super.
> sendRAM(int xsize, int ysize, uint8_t image[xsize][ysize])
> Die Reihenfolge ist wichtig, erst die Dimensionen, dann die Adresse.
> In der Funktion kann man dann Problemlos mit [] auf das Array zugreifen.

Auch das ändert aber nichts daran, dass es ein Zeiger auf ein Array ist 
und das xsize beim Parameter image keine Auswirkung hat. Wenn man den 
Parameter stattdesen als uint8_t image[][ysize] angibt, hat das exakt 
die gleiche Bedeutung.

[Elisa W. (Gast)]

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

Image[0] - Image[127]

lesen um Bildlich gesehen auf

RAM[1][0]

zu kommen oder nicht?

[Ralf (Gast)]

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

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

[Ralf (Gast)]

Und weil du ganz oben mit Zeigern gearbeitet hast :

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

[M. K. (sylaina)]

Elisa W. schrieb:
> 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
>

> Image[0] - Image[127]
>

> lesen um Bildlich gesehen auf
>

> RAM[1][0]
>

> zu kommen oder nicht?

Öhm, nö. Schau dir auf jeden Fall noch mal die Zeigersachen an. Ein 
Array ist ja eigentlich auch nix anderes als ein Zeiger.

[Rolf M. (rmagnus)]

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

Arg! Bitte nicht sowas verbreiten. Das ist falsch! Ein großer Teil der 
Probleme, die Leute mit Zeigern in C haben, resultiert daraus, dass sie 
den Unterschied nicht verstehen - ganz besonders bei mehrdimensionalen 
Arrays.

[M. K. (sylaina)]

Rolf M. schrieb:
> Arg! Bitte nicht sowas verbreiten. Das ist falsch!

Hm, aber das hier sieht so verdammt ähnlich aus:

uint8_t* myPointer;
myPointer[0] = myValue0;
myPointer[1] = myValue1;
myPointer[2] = myValue2;

uint8_t myArray[3];
myArray[0] = myValue0;
myArray[1] = myValue1;
myArray[2] = myValue2;

Also ich käme nie auf die Idee ein Array als Pointer zu missbrauchen, 
klar. Aber das Verhalten von Arrays und Pointern ist doch recht ähnlich. 
Kannst du das etwas genauer erläutern?

[Walter K. (Gast)]

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.

[Dirk B. (dirkb2)]

M. K. schrieb:
> Hm, aber das hier sieht so verdammt ähnlich aus:
>
> uint8_t* myPointer;
> myPointer[0] = myValue0;

Wo zeigt denn myPointer hin?
Wie sieht es mit sizeof aus?
Kannst du das Array auf einen andere Speicheradresse zeigen lasse?
Kannst du die Größe von dem Array ändern?

Ähnlich ist nicht gleich.

Bei beiden funktioniert Zeigerarithmetik und die dereferenzierung 
mittels * und [].

[Elisa W. (Gast)]

Anbei mal ein Screenshot.

Wenn Ich..

  ram[0][0] = 'a';
  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?

void readRAM(uint8_t *image)
{
  uint8_t y = 0, x = 0;
  
  for( ; y < 64 ; y++)
  {
    printf("Zeile %d.:      ",y);
    for( x = 0 ; x < 128 ; x++)
    {
      printf("%c",image[x]);
    }
    printf(" END \r\n");
    image++;
  }
}

int main ()
{
  uint8_t ram[64][128];
    
  memset((uint8_t*)ram,'0',8091);
  
  ram[0][0] = 'a';
  ram[1][0] = 'b';
  
  readRAM((uint8_t*)ram);

    return 0;
}

[Rolf M. (rmagnus)]

Elisa W. schrieb:
> Oben in der Ausgabe ist das 'b' nicht an Zeile '1'. Wieso?

Weil du ja quasi x und y einfach nur zusammenaddierst.

Elisa W. schrieb:
> for( ; y < 64 ; y++)
>   {
>     printf("Zeile %d.:      ",y);
>     for( x = 0 ; x < 128 ; x++)

Bei jedem Schleifendurchlauf der inneren Schleife gehst du um genau ein 
Element uint8_t, also ein Byte weiter.

>     {
>       printf("%c",image[x]);
>     }
>     printf(" END \r\n");
>     image++;

Bei jedem Schleifendurchlauf der äußeren Schleife gehst du ebenfalls um 
genau ein Element uint8_t, also ein Byte weiter.

>   }

[Elisa W. (Gast)]

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.

[Digitalaudio (Gast)]

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.

[Martin (Gast)]

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

[Martin (Gast)]

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

[Martin (Gast)]

oder so lasen wie bei dir dann aber

image += 128;

[M. K. (sylaina)]

Dirk B. schrieb:
> Ähnlich ist nicht gleich.

Deswegen schrieb ich "eigentlich ein Zeiger" ;)

[Rolf M. (rmagnus)]

M. K. schrieb:
> Deswegen schrieb ich "eigentlich ein Zeiger" ;)

Genauso wie das Gleichsetzen von Zeigern und Arrays "eigentlich" ein 
Bein ist. Denn dieser Vergleich hinkt sehr stark.

[Dirk B. (dirkb2)]

Elisa W. schrieb:
> Schade das man nicht einfach wie an anderer Stelle mit [x][y] drauf

Das geht.
Du musst aber die Variable richtig definieren:

void readRAM(uint8_t image[][128])

oder mit VLA auch variabel:

sendRAM(int size, uint8_t image[][size])

[Walter (Gast)]

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

[Hans (Gast)]

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. (rmagnus)]

Walter schrieb:
> 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

Ja, das schon. Ich meinte, dass die 64, die dort steht, keine Auswirkung 
hat und nur Augenwischerei ist. Du schriebst, dass du die 64 nicht in 
der Funktion "verstecken" willst. Weiter als bis zum Funktionskopf 
schafft sie es so aber auch nicht.

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

[Hans (Gast)]

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. (sylaina)]

Rolf M. 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.

[Darth Moan (Gast)]

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.

[Walter K. (Gast)]

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!

[Darth Moan (Gast)]

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.

[M. K. (sylaina)]

Darth Moan schrieb:
> Aber lesen ist ja auch so old school

Seh ich ähnlich. Du hast das jedenfalls schön erklärt, danke dir dafür.

[Walter (Gast)]

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]

[M. K. (sylaina)]

Ich finde ja, an deiner zweiten Variante sieht man viel schneller, dass 
da wohl 64 Zeilen durchlaufen werden, an der erste Variante sieht man 
das IMO nicht sofort.