nach *Buffer++ - wie wieder zurück?

[Oliver L. (ollil)]

Moin,

irgendwie habe ich gerade n Brett vorm Kopf.

Folgender Code:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>

int test(uint8_t *Buffer, uint16_t Bytes)
{
        uint16_t a;
        for ( a = 0; a < Bytes; a++ ) {
                *Buffer++ = 0x01;
        }
        *Buffer = *Buffer-512;
        printf("%x\n",Buffer[0]);
}

int main()
{
        uint8_t Buffer[512];
        uint16_t Bytes = 512;

        test(Buffer,Bytes);
        printf("%x\n",Buffer[0]);
}

Ausgabe:
gcc -o test7 test7.c && ./test7
d0
1

wie komme ich in test() wieder auf das 1. Byte von Buffer? Buffer steht 
ja nach dem loop 512 Bytes weiter - ich will ihn wieder auf den Anfang 
zuruecksetzen, da ich einiges noch machen will. Ich will innerhalb des 
for-loops nicht mit Buffer[a] arbeiten, da dies langsamer ist.

[Peter II (Gast)]

>  *Buffer = *Buffer-512;

Buffer = Buffer-Bytes;

[Noname (Gast)]

>wie komme ich in test() wieder auf das 1. Byte von Buffer?

Speichere Dir den Zeiger erstmal irgendwo zwischen.

uint8_t * Tmp = Buffer;

Dann kannst Du ihn später in dem printf verwenden.

printf("%x\n", Tmp);

[Lukas (Gast)]

Was sollte denn in dieser Zeile passieren?

*Buffer++ = 0x01;

Ich sehs grad echt nicht!

[Fabian (Gast)]

int test(uint8_t *Buffer, uint16_t Bytes)
{
        uint16_t a;
        for ( a = 0; a < Bytes; a++ ) {
                Buffer[a] = 0x01;
        }
        printf("%x\n",Buffer[0]);
}

[Peter II (Gast)]

Fabian schrieb:
> int test(uint8_t *Buffer, uint16_t Bytes)
> {
>         uint16_t a;
>         for ( a = 0; a < Bytes; a++ ) {
>                 Buffer[a] = 0x01;
>         }
>         printf("%x\n",Buffer[0]);
> }

genauso wollte er es NICHT machen.

[Fabian (Gast)]

Oh sorry, überlesen. ;-)
Aber ist es wirklich langsamer?! - Sollte der Optimierungsprozess des 
Compilers dies nicht in den Griff bekommen?
Soll es wirklich schnell gehen und der Compiler das nicht regeln, würde 
ich es einfach als Inline-Asm implementieren.

[Peter II (Gast)]

Fabian schrieb:
> Oh sorry, überlesen. ;-)
> Aber ist es wirklich langsamer?!

auf einem PC nicht, auf einem kleinen Atmel kann das druchaus sein, weil 
er keine dazu passenden upcodes kennt.

[Karl H. (kbuchegg)]

Oliver Lehmann schrieb:

> wie komme ich in test() wieder auf das 1. Byte von Buffer?

Wenn du eine Pointer-Variable hast, dann benennst du durch die 
Verwendung des Variablen-Namens alleine immer die Adresse auf die dieser 
Pointer zeigt.

    Buffer = Buffer + 2;

setzt also die Adresse um 2 Einheiten weiter. Der Zeiger zeigt danach 
auf eine andere Stelle im Speicher.

Setzt du VOR den Namen der Pointer-Variablen einen *, dann bedeutet das 
'Dereferenzieren'. D.h. gemeint ist dann nicht die Adresse, die in der 
Pointer Variablen gespeichert ist, sondern der Wert, der im Speicher 
unter dieser Adresse zu finden ist.


Graphisch veranschaulicht. Eine Pointer Variable zeige im Speicher auf 
eine Speicherzelle, in der der Wert 5 abgelegt sei

                            +---+
   Buffer                   | 3 |
   +--------+               +---+
   |   o------------------->| 5 |
   +--------+               +---+
                            | 9 |
                            +---+

'Buffer' alleine, wäre die Spezifikation für das Rechteck, über dem 
'Buffer' steht. Damit wird also die Variable manipuliert, an der der 
Pfeil seinen Ausgang nimmt. Tut man das, dann zeigt der Pfeil danach 
woanders hin.

   Buffer = Buffer + 1;

ist also die Anweisung, Buffer auf das nächste Element im Speicher 
zeigen zu lassen

                            +---+
   Buffer                   | 3 |
   +--------+               +---+
   |   o-----------+        | 5 |
   +--------+      |        +---+
                   +------->| 9 |
                            +---+


'*Buffer' hingegen ist die Spezifikation, das man sich auf das Ende des 
Pfeiles beziehen möchte. In diesem Fall eben die 5. Mittels *Buffer = 8; 
schreibt man also an die Stelle, auf die Buffer zeigt (ausgedrückt durch 
den *) eine 8

                            +---+
   Buffer                   | 3 |
   +--------+               +---+
   |   o------------------->| 8 |
   +--------+               +---+
                            | 9 |
                            +---+

Und das ist eine vollkommen andere Operation.

Und jetzt überleg noch mal, was wohl

       *Buffer = *Buffer-512;

macht. Worauf bezieht sich dieses Statement? Auf den Zeiger selber, oder 
auf das worauf er zeigt? Wo sind Dereferenzieungs-Sterne und wo nicht? 
Wo wird daher der Pointer selbst manipuliert und wo das, worauf er 
zeigt? Und wie deckt sich das mit dem, was du eigentlich tun willst?

[Oliver L. (ollil)]

Peter II schrieb:
>>  *Buffer = *Buffer-512;
>
> Buffer = Buffer-Bytes;

So funzt es! Herzlichen Dank....

und bzgl. Peter IIs Frage:

*Buffer++ = 0x01;

Schreibt an den Anfang des Zeiger Buffer den Wert 0x01.
Also equivalent zu Buffer[0] = 0x01;
Danach wird der Zeiger um 1 Byte erhöht, er zeigt dann also beim 
nächsten
Durchlauf der Schleife auf Buffer[1] - quasi.
0x01 ist hier nur ein Testwert zur Veranschalichung.

Und zummindest auf meinem ATMega mit gcc -O1 ist *Buffer++= schneller 
als Buffer[a]=. Nein, ich poste jetzt keinen ASM Code ;)

[Noname (Gast)]

Karl Heinz mal wieder. Kriegst n Keks. :-)

[Oliver L. (ollil)]

Karl Heinz Buchegger schrieb:

> Und jetzt überleg noch mal, was wohl       *Buffer = *Buffer-512;
> macht. Worauf bezieht sich dieses Statement? Auf den Zeiger selber, oder
> auf das worauf er zeigt?

Wunderschöne Erklärung, danke!
es bezieht sich auf  das Ende des Pfeiles und rechnet dann wohl 0x01-512

[Karl H. (kbuchegg)]

Oliver Lehmann schrieb:
> Karl Heinz Buchegger schrieb:
>
>> Und jetzt überleg noch mal, was wohl       *Buffer = *Buffer-512;
>> macht. Worauf bezieht sich dieses Statement? Auf den Zeiger selber, oder
>> auf das worauf er zeigt?
>
> Wunderschöne Erklärung, danke!

Das geile ist eigentlich:
Wenn du das kapiert und verinnerlicht hast, dann hast du Pointer 
verstanden. Alles weitere folgt daraus und ist eine direkte Konsequenz 
davon: Bei Pointern gibt es 2 Möglichkeiten der Operationen - entweder 
ich manipuliere die Adresse im Pointer selber oder ich manipuliere das 
worauf diese Adresse verweist. In C ist der Unterschied zwischen diesen 
beiden möglichen Operationen der '*' vor dem Variablennamen. Der wählt 
aus, welches Ende des PFeiles gemeint ist: der Anfang oder das Ende. 
Alle anderen Dinge sind nur syntaktische Variationen davon, die zwecks 
einfacherer Schreibweise eingeführt wurden.

[Marcus O. (marcus6100)]

Karl Heinz Buchegger schrieb:

> *Buffer = *Buffer-512;

>>> macht. Worauf bezieht sich dieses Statement? Auf den Zeiger selber, oder
>>> auf das worauf er zeigt?
>>
>> Wunderschöne Erklärung, danke!
>
> Das geile ist eigentlich:

Ja super. Alles toll.

C operator precedence direkt mal nachlesen als nächstes.

Von mir jetzt noch der Hinweis, dass Buffer ein uint8_t array ist,
und es deshalb nicht sinnvoll ist, den wert 0x01 - 512 = -511 drin
speichern und rauslesen zu wollen.


> *Buffer = *Buffer-512;

[Oliver L. (ollil)]

Marcus Overhagen schrieb:
> Von mir jetzt noch der Hinweis, dass Buffer ein uint8_t array ist,
> und es deshalb nicht sinnvoll ist, den wert 0x01 - 512 = -511 drin
> speichern und rauslesen zu wollen.
>
>
>> *Buffer = *Buffer-512;

Zum Glück hatte das auch keiner vor....