Frage zu Pointern und casten

[Stefan (Gast)]

Hallo,

wie wirkt sich das Casten genau bei folgender Pointer-Verwendung aus?

uint8_t  mem[1000];
uint8_t  *ptr
uint16_t index;

uint32_t data;

ptr   = &mem[0];
index = 10;
data  = (uint32_t*) (ptr + index);

Wirkt (uint32_t*) auch auf den Index, dh. bekomme ich die
Daten ab mem[40] ausgelesen, oder

wirkt zuerst die Klammer um (ptr + index), bekomme ich also die
Daten ab mem[10] ausgelesen?


Vielen Dank, Stefan

[Rufus Τ. F. (rufus)]

Die zweite Variante ist es.

[Karl H. (kbuchegg)]

Stefan schrieb:
> Hallo,
>
> wie wirkt sich das Casten genau bei folgender Pointer-Verwendung aus?

Es ergibt einen Fehler

 data  = *(uint32_t*) (ptr + index);

> wirkt zuerst die Klammer um (ptr + index), bekomme ich also die
> Daten ab mem[10] ausgelesen?

Wie bei Klammern üblich, werden zuerst die Teile in der Klammer 
berechnet. Die Klammern bilden aus dem in ihnen enthaltenen Dingen eine 
Einheit. Die wird berechnet und erst das Ergebnis davon wird durch den 
Cast auf einen uint32_t Pointer umgecastet.

[Stefan (Gast)]

Vielen Dank, Rufus.


Gruß, Stefan

P.S.:
Ich habe das Sternchen in der Zuweisung versgessen, hätte natürlich 
heissen sollen:

data  = *( (uint32_t*) (ptr + index) );

[Stefan (Gast)]

Vielen Dank, Karl Heinz,

dass die Klammer auch auf den cast wirkt, hatte ich schon fast vermutet, 
aber ganz sicher war ich dann doch nicht.

Gruß, Stefan

[Jürgen (Gast)]

Evtl. bekommst du auch eine Exception oder Daten von der falschen Stelle 
(ARM), je nachdem wie dein Prozessor auf falsch ausgerichtete Zugriffe 
reagiert (Stichwort Alignment).

Je nach Endianness kann da auch etwas anderes herauskommen.

Anders gesagt, sowas tut man nicht.
Das ist ein extrem windiges Konstrukt, das in solider Software nichts zu 
suchen hat.

Besser ist

data = 
    ((uint32_t) ptr[index + 0]) << 0) |
    ((uint32_t) ptr[index + 1]) << 8) |
    ((uint32_t) ptr[index + 2]) << 16) |
    ((uint32_t) ptr[index + 3]) << 24);

schön in ein Unterprogramm verpackt.

Oder auch

data = 
    ((uint32_t) ptr[index + 0]) << 24) |
    ((uint32_t) ptr[index + 1]) << 16) |
    ((uint32_t) ptr[index + 2]) << 8) |
    ((uint32_t) ptr[index + 3]) << 0);

falls die Daten Big-Endian sind.

[Stefan (Gast)]

Hallo Jürgen,

im Prinzip hast Du ja Recht, aber in diesem speziellen Fall denke ich, 
dass ich das vertreten kann.

Es geht um eine Graphik, die kopiert werden soll. Und durch den 32-Bit 
Zugriff beschleunige ich das Ganze deutlich, unterm Strich sicher um den 
Faktor 2-3. Die Graphikverarbeitung ist im gesamten Programm der 
rechenintensivste Teil.

Das Ganze läuft auf einem Cortex M3. Der hat mit dem missaligned Zugriff 
keine Probleme (die entsprechende Stelle im Manual hat mich eigendlich 
erst auf diese Idee gebracht). Und der zusätzliche Buszugriff ist 
Peanuts gegen den Aufwand, wenn ich jedes Byte einzeln verarbeite.


Viele Grüße, Stefan Kleinwort