Pointer auf zweidim. Array übergeben und hineinschreiben

[gast (Gast)]

Hallo eine frage?

Ich habe eine zweidimensionales array in main.c

uint8_t data[8][128];

Jetzt moche ich in meiner glcd.c auf diese Array schreiben. Ich möchte 
es aber nicht mit extern machen und ich möchte es auch nicht mit einer 
Funktion writeData machen. Ich möchte es mit einem Zeiger machen wenn es 
geht.

Ich dachte an sowas.

Zuerst einen pointer in main.c der auf data zeigt.

 uint8_t *data_p = data[128];

Kleine Fukntion mit der ich mir den pointer holen kann.

uint8_t *getData(void)
{
 return data_p; //return pointer 
}

so aber wie kann ich jetzt in glcd.c auf diesen schreiben.

als ich es mit extern machte konnte ich zum Beispiel ja so auf das Array 
schreiben

data[x][y] = "0xFF";

Aber wie schreibe ich jetzt darauf? ich habe ja keine data[][] mehr 
sonder nur eine *data[] eigentlich oder? Das ist ja das gleiche aber mir 
fehlt aber eben die Möglichkeit den x Wert zu setzten.

Na ja ich hoffe ihr kommt mit.

Danke schon mal falls jemand versteht was ich meine

[Karl H. (kbuchegg)]

Der Schluessel zum Ganzen besteht darin, dass
du die Größe der ersten Dimension kennen musst.

  array[x][y]

ist nichts anderes als

  *array + x * sizeof( T ) * DimX + y * sizeof( T )

wobei DimX die Dimensionsangabe in der ersten Dimension
darstellt. In deinem Fall sind das 8

[mgiaco (Gast)]

Da komm ich noch nicht ganz mit wie du das meinst ich habe auch in K&R 
gesucht aber nichts gefunden.

[Karl H. (kbuchegg)]

Ein 2 dimensionales Array wird wie ein eindimensionales
übergeben: Als Pointer auf das erste Array Element.
Insofern unterscheidet sich ein 2 (oder ein mehrdimensionales)
Array in nichts von einem 1-dimensionalem. Das Einzige was
anders ist, ist die Umrechnung der Indizierung auf die
tatsächliche Speicheradresse.

Bei einem 2-dimensionalem Array, liegen die einzelnen
Zeilen direkt hintereinander im Speicher:

  uint8_t t[3][4];

    +---+---+---+---+---+---+---+---+---+---+---+---+
    |   |   |   |   |   |   |   |   |   |   |   |   |
    +---+---+---+---+---+---+---+---+---+---+---+---+

    |       |       |       |       |       |
    [0][0]  [0][2]  [1][0]  [1][2]  [2][0]  [2][2]

        |       |       |       |       |       |
        [0][1]  [0][3]  [1][1]  [1][3]  [2][1]  [2][3]

(Prinzip: "der letzte Index läuft am schnellsten")

Um also auszurechnen, wo ab Beginn des Arrays, das
Element [x][y] liegt, muss bekannt sein, wieviele Elemente
die letzte Dimension umfasst. In diesem Falle also 4.

Das Array Element [x][y] findet sich daher an der Position
  x * 4 + y

Probier es mit obiger Zeichnung aus: Wo ist das Element
[1][2]

  1 * 4 + 2 = 6

Also ist das Element[1][4] das Element Nr. 6
Und in der Tat zeigt die Zeichnung, dass das stimmt.


(Ich hab in meiner Antwort vom Vormittag geschlampt, da
ist einiges falsch. Tut mir leid).

Wenn du also nur einen Pointer auf den Beginn des Arrays hast,
hilft dir das nicht weiter. Du musst auch alle Array Dimensionen,
bis auf die erste haben.

[Arc N. (arc)]

andere Möglichkeit...

typedef uint8_t data_t[8][128];
data_t data;

data_t* getData(void) {
  return &data;
}

void test(data_t p) {
  p[4][3] = 1;
}

// Aufruf 
test(*getData());