Grüss Gott,
ich muss auf einem vorhandenen Code basierend meine Weiterentwicklung
dran hängen.
Es geht darum, dass ich ein globales, zweidimensionales Array, mittels
eines Pointers (Singleton) überschreiben möchte. Es ist mir aber nicht
ganz klar, wie ich die einzelnen Elemente des Arrays ansprechen kann,
bzw. Frage ist ob ich die Adresse der 2D Arrays überhaupt richtig
zurückgebe.
Der Code entspricht nicht dem 100%, soll aber eine Vorstellung geben was
ich meine;
hallo, danke für die Unterstützung, hat jetzt geklappt...
was mich noch ein bisschen verwirrt, der Rückgabewert von der get()
Funktion, mal wird hier das Array mit dem Adressoperator übergeben, mal
ohne. Den Adressoperator würde ich eher erwarten, wenn ich ein bestimmes
Element des Arrays ansprechen möchte [i][j]. Und ohne den Adressoperator
erwarte ich die Startadresse des ersten Elements übergeben zu
bekommen...
FastExperte schrieb:> hallo, danke für die Unterstützung, hat jetzt geklappt...> was mich noch ein bisschen verwirrt, der Rückgabewert von der get()> Funktion, mal wird hier das Array mit dem Adressoperator übergeben, mal> ohne. Den Adressoperator würde ich eher erwarten, wenn ich ein bestimmes> Element des Arrays ansprechen möchte [i][j].> Und ohne den Adressoperator erwarte ich die Startadresse des ersten Elements> übergeben zu bekommen...
Das ist ja auch so. Man muss sich nur klar sein, dass es in C
mehrdimensionale Arrays in dem Sinne nicht gibt. Es ist einfach ein
Array aus Arrays. Das erste Element des äußeren Arrays ist daher wieder
ein Array.
Variante 1: Ein Zeiger auf das erste Element des äußeren Arrays:
1
typedefmeinStructarray_of_DIM_2_t[DIM_2];
2
3
array_of_DIM_2_t*getMeinArray(void)
4
{
5
returnmeinArray;
6
}
meinArray ist hier äquivalent zu &meinArray[0] - die Adresse des ersten
Elements.
Variante 2: Ein Zeiger auf das erste Element des ersten Elements:
1
meinStruct*p=&meinArray[0][0];
Hier hat man einfach einen Zeiger auf ein Element des inneren Arrays.
Dabei geht aber dann die zweite Dimension verloren, und man muss die
passende Index-Berechnung selber machen. Es wird einfach wie auf ein
"plattes" Array zugegriffen.
Und hier noch Variante 3: Ein Zeiger auf das Array selbst:
1
typedefmeinStructmeinArray_t[DIM1][DIM2];
2
3
meinArray_t*getMeinArray(void)
4
{
5
return&meinArray;
6
}
In dem Fall muss der Zeiger dann vor dem Zugriff eben ganz normal
dereferenziert werden.
Hallo, muss noch mal nach hacken...
Rolf M. schrieb:> Variante 1: Ein Zeiger auf das erste Element des äußeren Arrays:
d.h. wenn ich hier den Zeiger inkrementiere, zeige ich dann auf das 2te
Element der 1 Dimension ?
pointer[0][0] --> inc --> pointer[1][0] --> inc --> pointer[2][0]
Rolf M. schrieb:> Variante 2: Ein Zeiger auf das erste Element des ersten Elements:
hier würde ich einfach alle Elemente nach eindander durchlaufen...
pointer[0][0] --> inc --> pointer[0][1]-->inc-->pointer[0][2]...bis
pointer[2][2]
Rolf M. schrieb:> Und hier noch Variante 3: Ein Zeiger auf das Array selbst:
wie verhält sich der Zeiger hier...?
Rolf M. schrieb:> Man muss sich nur klar sein, dass es in C> mehrdimensionale Arrays in dem Sinne nicht gibt.
Richtig.
Rolf M. schrieb:> Es ist einfach ein Array aus Arrays
Nö, es sind im Endeffekt eindimensionale Arrays der Größe
DIM1*DIM2*...*DIMn.
Und genau so kann man auch darauf zugreifen:
array[x][y] == array[x*DIM2+y]
array[x][y][z] == array[x*DIM2*DIM3+y*DIM3+z]
...
Außerdem liefert der Name des Array die Addresse des Arrays, welche die
Addresse des ersten Elemnts ist. Also für den Code aus dem ersten Post:
meinArray == &meinArray == &meinArray[0][0]
Alles vom Typ meinStruct*
Dazu kommt noch:
array[x] == *(array+x)
Um auf den Ursprungspost zurückzukommen:
guest schrieb:> Rolf M. schrieb:>> Es ist einfach ein Array aus Arrays> Nö, es sind im Endeffekt eindimensionale Arrays der Größe> DIM1*DIM2*...*DIMn.
So liegen sie im Speicher, aber sie sind nicht das selbe.
> Und genau so kann man auch darauf zugreifen:> array[x][y] == array[x*DIM2+y]
Nein, das kann man so nicht. Man muss zwei Indizes angeben, sonst gibt
es einen Fehler, weil der Typ nicht stimmt.
> Außerdem liefert der Name des Array die Addresse des Arrays, welche die> Addresse des ersten Elemnts ist.
Stimmt auch nicht. Die Speicherstelle, auf die verwiesen wird, ist zwar
die selbe, aber der Typ ist unterschiedlich.
> Also für den Code aus dem ersten Post:> meinArray == &meinArray == &meinArray[0][0]> Alles vom Typ meinStruct*
Nein, die Typen sind alle drei unterschiedlich. Nur das dritte ist vom
Typ meinStruct*.
> Dazu kommt noch:> array[x] == *(array+x)
Das ist zwar richtig, hier aber eigentlich nicht relevant.
> Um auf den Ursprungspost zurückzukommen:> meinStruct * getMeinArray(void)> {> return meinArray;> }
Hier stimmen die Typen auch nicht. Der Compiler sollte hier einen
Typkonflikt anmahnen.
> void setMeinArray(void)> {> uint32 neuerWert = 200;> meinStruct * array = getMeinArray();> array[1][1].uint32_variable = neuerWert;
Das wird zu einem Fehler führen, da array[1] bereits vom Typ meinStruct
ist und nicht mehr dereferenziert werden kann, was du aber mit dem
zweiten [1] versuchst. Ursprung dieses Problems ist der falsche
Rückgabetyp von getMeinArray().
guest schrieb:> Dazu kommt noch:> array[x] == *(array+x)
Und, damit die wirklich schönen Ecken der Sprache C nicht völlig in
Vergessenheit geraten:
array[x] == x[array]
Oliver