Konstanter Zeiger auf ein Array der Größe 2 eines volatile structs

[Walter T. (nicolas)]

Guten Abend,

mir gehen gerade Zeiger wieder auf den ... Nerv.

typedef struct
{
    int a;
    int b;
}
Mystruct_t;

volatile Mystruct_t arr[2];

void foo(void)
{
    Mystruct_t volatile (*const arrp)[2] = &arr;

    arrp[0]->a = 10;
    arrp[1]->a = 20;
}

Was ich vor habe, kann man sich ja denken, wenn man nicht gerade ein 
Compiler ist. Ich verstehe aber gerade (mal wieder) nicht, wie der 
Compiler das sieht. Der macht nämlich bei der zweiten Zuweisung einen 
Offset von 16 anstelle der erwarteten 8 Bytes:

(78)  {
(79)      Mystruct_t volatile (*const arrp)[2] = &arr;
(80)  
(81)      arrp[0]->a = 10;
08002D6C  ldr  r3, [pc, #8]  ; (0x8002d78 <foo+12>)
08002D6E  movs  r2, #10
08002D70  str  r2, [r3, #0]
(82)      arrp[1]->a = 20;
08002D72  movs  r2, #20
08002D74  str  r2, [r3, #16]
08002D76  bx  lr
08002D78  asrs  r0, r2, #4
08002D7A  movs  r0, #0

Natürlich kein Fehler, keine Warnung, keine Badbox.

arr[] ist ein volatiles Array mit zwei Elementen aus structs vom Typ 
Mystruct_t.

arrp sollte ein konstanter Zeiger auf ein volatiles Array mit zwei 
Elementen vom Typ Mystruct_t sein.

Wo liegt mein Denkfehler?

(Das hier geht natürlich:

    Mystruct_t volatile *const arrp = &arr[0];

    (*(arrp+1)).a = 20;

aber die Frage ist ja, was oben schief läuft.)

[A. S. (Gast)]

Wenn &arr schon keine Warnung bringt, sind Warnungen wohl aus.

Was ist sizeof(Mystruct_t)?

Und wofür die Klammern und *const arrp?

[Walter T. (nicolas)]

A. S. schrieb:
> Was ist sizeof(Mystruct_t)?

8, wie erwartet.

A. S. schrieb:
> Wenn &arr schon keine Warnung bringt, sind Warnungen wohl aus.

Hm, stimmt, ich referenziere eine Ebene zu tief. Da muss ich nochmal von 
vorn knobeln. Ich hätte hier wirklich gerne Indexschreibweise.

A. S. schrieb:
> Und wofür die Klammern und *const arrp?

Beim Optimierungs-Level 1 wird der Zugriff auf die Speicherstelle nicht 
wegoptimiert, wenn ich den Zeiger nicht konstant mache.

[EAF (Gast)]

Walter T. schrieb:
> Ich hätte hier wirklich gerne Indexschreibweise.
Und?
Was hindert dich?

typedef struct
{
    int a;
    int b;
}
Mystruct_t;

volatile Mystruct_t arr[2];

void foo(void)
{
    Mystruct_t *array = arr;
    array[0].a = 10;
    array[1].a = 20;
}

[Walter T. (nicolas)]

Hng. Vielleicht sollte ich heute abend einfach nicht programmieren.

Danke!

[Nop (Gast)]

Walter T. schrieb:

> arrp sollte ein konstanter Zeiger auf ein volatiles Array mit zwei
> Elementen vom Typ Mystruct_t sein.

Na eben. Wenn Du einen Pointer raufzählst (wie in arrp[1]), wird die 
Datenbreite seines zugrundeliegenden Typen in Bytes addiert. Der 
zugrundeliegende Typ ist ein volatiles Array mit zwei Elementen vom Typ 
Mystruct_t (je 8 Bytes), also 16 Bytes.

[Markus F. (mfro)]

void foo(void)
{
   Mystruct_t volatile (*const arrp)[2] = &arr;

   (*arrp)[0].a = 10;
   (*arrp)[1].a = 20;
}

tät's auch

[ein lupenreiner Demokrat (Gast)]

Nö, er hat ja

Walter T. schrieb:
> volatile Mystruct_t arr[2];
>

und nicht

Mystruct_t arr[42][2];

Ein mal ein Array von int-Werten und ein mal ein Array von 
zweidimensionalen int-Arrays.

[Sebastian (Gast)]

Walter T. schrieb:
> arrp sollte ein konstanter Zeiger auf ein volatiles Array mit zwei
> Elementen vom Typ Mystruct_t sein.

Nein. Oder hast du mehrere solcher Arrays?

LG, Sebastian