3. Zeiger - Stack

Zeiger - Stack

  • U

    Hallo, ich versuche gerade mit den Zeigern und dem Stack zu arbeiten. Dabei bin ich auf folgendes Stückchen Code gestoßen:

    void function(int a, int b, int c) {
   char buffer1[5];
   char buffer2[10];
   int *ret;

   ret = buffer1 + 12;
   (*ret) += 8;
}

    Wie ich das sehe werden 2 Arrays, einmal mit 5 und dann eins mit 10 Bytes definiert.
    Dann folgt die Deklaration eines Zeigers auf Integerwerte.
    Aber dann... Kann das sein das in dieser Zeile was fehlt? und zwar, sollte sie nicht so lauten?

    ret = &buffer1 + 12

    und was wird da nun im Orginalcode genau gemacht?

    ret = buffer1 + 12 ergibt für mich keinen richtigen Sinn ...
    (*ret) += 8; ergibt für mich keinen richtigen Sinn ...

    ret = &buffer1 + 12 -> ret bekommt die Speicheradresse von buffer1 erhöht um 12
    (*ret) += 8; -> *ret zeigt auf die erhöhte Adresse und wird wiederum um 8 erhöht... ?

    Ich bin etwas ratlos 😕

    0
  • S

    Der name einse array ist der pointer darauf

    buffer1 == &buffer1[0];

    mfg

    0
  • R

    und zwar, sollte sie nicht so lauten?

    ret = &buffer1 + 12

    Nein. Der Compiler wird meckern, aber nicht, weil das & fehlt, sondern weil man einem int-Pointer einen char-Pointer zuweist.

    ret = buffer1 + 12 ergibt für mich keinen richtigen Sinn ...

    Das ist auch gut so, ret zeigt nun ins Nirvana (also eigentlich an eine ziemlich zufällige Stackadresse).

    (*ret) += 8; -> *ret zeigt auf die erhöhte Adresse und wird wiederum um 8 erhöht... ?

    Nein, der int, auf den ret nun zeigt, wird um 8 erhöht.

    Ich bin etwas ratlos 😕

    Verständlich 🙄

    0
  • G

    spjoe schrieb:

    Der name einse array ist der pointer darauf

    Etwas unglücklich formuliert. Array bleibt Array. Der Compiler kann aber dieses bei Bedarf implizit in einen Zeiger auf das erste Element umwandeln.

    uTaNG schrieb:

    ret = buffer1 + 12 ergibt für mich keinen richtigen Sinn ...

    Nun, wie ich schon sagte, kann der Compiler hier buffer1 (char[5]) in einen Zeiger auf das erste Element umwandeln (char*). Was dann gemacht wird, fällt unter die Rubrik Zeigerarithmetik. Man "zählt" praktisch 12 Elemente weiter. Das Ergebnis ist wieder ein Zeiger (hier char*). Letztendlich ist

    buffer1 + 12

    das gleiche wie

    &buffer1[12]

    Mal abgesehen davon, dass das Verhalten hier undefiniert ist, da buffer1 nur 5 Elemente hat, und der Speicher buffer1 + 12 uU gar nicht existiert, wird ein Compiler bei der anschliessenden Zuweisung an ret meckern, da dieses vom Typ int* ist.

    0
  • E

    Ich könnte schwören das schon mal gesehen zu haben. hmmm wo wohl... :p

    MfG
    ~
    SMASH THE STACK FOR FUN.~

    0
Anmelden zum Antworten