verständisfrage zu pointer auf array

[Jens (Gast)]

Hallo,
ich habe eine frage zu einem pointer.
Ich habe zum testen folgenden Code geschrieben

  int a[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

    int *b;
    printf("adresse b: %p\n", (void*)b); 
    b = &a[4];

    printf("adresse a: %p\n", (void*)a);  
  printf("adresse b: %p\n", (void*)b);
  printf("adresse a0: %p\n", &a[0]);
  printf("adresse a4: %p\n", &a[4]);
  printf("wert a0: %i\n", a[0]);
  printf("wert a4: %i\n", a[4]);
  printf("wert b0: %i\n", b[0]);
  printf("wert b4: %i\n", b[4]);
  printf("setze a[4] auf 44\n");
  a[4] = 44;
  printf("wert b0: %i\n", b[0]);
  printf("groesse a: %u\n", sizeof(a));
  printf("groesse b: %u\n", sizeof(b));
  printf("wert b12: %i\n", b[12]);
  printf("wert a16: %i\n", b[16]);
  
    return 0;

die Ausgabe ist

adresse b: 00400080
adresse a: 0061FEEC
adresse b: 0061FEFC
adresse a0: 0061FEEC
adresse a4: 0061FEFC
wert a0: 1
wert a4: 5
wert b0: 5
wert b4: 9
setze a[4] auf 44
wert b0: 44
groesse a: 48
groesse b: 4
wert b12: 4198966
wert a16: 2

Da habe ich jetzt zwei Fragen zu.
warum sind die Adressen von a[0] und a[4] auch 0061FEEC? Wie bekomme ich 
die Adresse von den einzelnen elementen?
Warum ist b[12] ungleich a[16]? dass dort müll drinn steht ist mir klar, 
aber sollte nicht bei beiden das selbe drinn stehen? Greifen doch beide 
auf die selbe adresse zu?

[Holger (Gast)]

Jens schrieb:
> [...]
> Da habe ich jetzt zwei Fragen zu.
> warum sind die Adressen von a[0] und a[4] auch 0061FEEC? Wie bekomme ich
> die Adresse von den einzelnen elementen?

Die Adressen von a[0] und a[4] sind nicht identisch. Wenn du genau 
hinschaust (am besten die HEX Zahlen mal in Kleinbuchstaben schreiben) 
siehst du das sie unterschiedlich sind:

[...]
adresse a0: 0061feec
adresse a4: 0061fefc
[...]

Das erste Element des Arrays liegt an der Speicherstelle des Speichers, 
der dem Array zugewiesen wurde. Wenn du also "b" auf "a" zeigen lassen 
würdest, würde "b" auf das erste Element des Ararys zeigen. Beide 
Anweisungen sind also identisch:

b = a;
b = &a[0];

> Warum ist b[12] ungleich a[16]? dass dort müll drinn steht ist mir klar,
> aber sollte nicht bei beiden das selbe drinn stehen? Greifen doch beide
> auf die selbe adresse zu?

Vermutlich weil du nicht "a[16]" ausgibst, sondern zweimal "b[12]" 
(Tippfehler).

Gruß,

Holger

[Holger (Gast)]

Jens schrieb:
> ("wert b12: %i\n", b[12]);
>   printf("wert a16: %i\n", b[16])

Holger schrieb:
>> Warum ist b[12] ungleich a[16]? dass dort müll drinn steht ist mir klar,
>> aber sollte nicht bei beiden das selbe drinn stehen? Greifen doch beide
>> auf die selbe adresse zu?
>
> Vermutlich weil du nicht "a[16]" ausgibst, sondern zweimal "b[12]"
> (Tippfehler).

Sorry, ich meinte das du zweimal auf den "b"-Zeiger zugreifst (b[12] und 
b[16]) anstatt bei der zweiten Ausgabe das Array zu benutzen (a[16]).

[Jens (Gast)]

Holger schrieb:
> [...]
> adresse a0: 0061feec
> adresse a4: 0061fefc
> [...]

Tatsächlich, ist mir nicht aufgefallen. wie kann man es denn klein 
printen?

Holger schrieb:
> Vermutlich weil du nicht "a[16]" ausgibst, sondern zweimal "b[12]"
> (Tippfehler).

Auch hier tatsächlich :). es war ein Tippfehler. wenn ich jetzt steht in 
beiden das selbe drinn.

Beseten dank :)

[Rolf M. (rmagnus)]

Jens schrieb:
> Holger schrieb:
>> [...]
>> adresse a0: 0061feec
>> adresse a4: 0061fefc
>> [...]
>
> Tatsächlich, ist mir nicht aufgefallen. wie kann man es denn klein
> printen?

Mir wären keine Optionen für %p bekannt. Da entscheidet der Compiler, 
wie die Ausgabe aussieht.

> Holger schrieb:
>> Vermutlich weil du nicht "a[16]" ausgibst, sondern zweimal "b[12]"
>> (Tippfehler).
>
> Auch hier tatsächlich :). es war ein Tippfehler. wenn ich jetzt steht in
> beiden das selbe drinn.

Wobei das nicht zwingend so sein muss. Denn beim Zugriff ausßerhalb des 
Arrays kommt nicht nur "müll" raus, sondern das ganze Verhalten ist 
undefiniert. Da kann alles passieren, und durch Optimierungen können 
ggf. auch recht unerwartete Effekte auftreten. Ein Absturz des Programms 
wäre natürlich auch möglich.

[Holger (Gast)]

Jens schrieb:
> Tatsächlich, ist mir nicht aufgefallen. wie kann man es denn klein

Du kannst anstatt %p einfach %x bzw. %X benutzen (im ersten Fall ist die 
Ausgabe mit Klein- im zweiten mit Großbuchstaben).

[Alexander S. (alesi)]

Jens schrieb:

int a[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

Nur am Rande: Hier würde ich

int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

schreiben. Der Compiler berechnet die Größe und es ist automatisch 
konsistent.

[Rolf M. (rmagnus)]

Holger schrieb:
> Jens schrieb:
>> Tatsächlich, ist mir nicht aufgefallen. wie kann man es denn klein
>
> Du kannst anstatt %p einfach %x bzw. %X benutzen (im ersten Fall ist die
> Ausgabe mit Klein- im zweiten mit Großbuchstaben).

Das hängt dann allerdings vom System ab, ob das passt. %p ist eigentlich 
schon das richtige für Zeiger.

[Yalu X. (yalu) (Moderator)]

Rolf M. schrieb:
> Holger schrieb:
>> Jens schrieb:
>>> Tatsächlich, ist mir nicht aufgefallen. wie kann man es denn klein
>>
>> Du kannst anstatt %p einfach %x bzw. %X benutzen (im ersten Fall ist die
>> Ausgabe mit Klein- im zweiten mit Großbuchstaben).
>
> Das hängt dann allerdings vom System ab, ob das passt.

Auf 64-Bit-Plattformen mit 32-Bit-int-Typ werden damit die höherwertigen
32 Bit des Pointers bei der Ausgabe abgeschnitten.

> %p ist eigentlich schon das richtige für Zeiger.

Oder alternativ %"PRIxPTR" & Co. Damit kann man zwischen verschiedenen
Darstellungen der Hexzahl wählen:

#include <stdio.h>
#include <inttypes.h>

int a[12] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

int main(void) {
  printf("%%p          -> %p\n", a);                        // ok
  printf("%%x          -> %x\n", a);                        // Warnung
  printf("%%X          -> %X\n", a);                        // Warnung
  printf("%%\"PRIxPTR\"  -> %"PRIxPTR"\n", (uintptr_t)a);   // ok
  printf("%%\"PRIXPTR\"  -> %"PRIXPTR"\n", (uintptr_t)a);   // ok
  printf("%%#\"PRIxPTR\" -> %#"PRIxPTR"\n", (uintptr_t)a);  // ok
  printf("%%#\"PRIXPTR\" -> %#"PRIXPTR"\n", (uintptr_t)a);  // ok
}

Ausgabe:

%p          -> 0x563e5392c040
%x          -> 5392c040
%X          -> 5392C040
%"PRIxPTR"  -> 563e5392c040
%"PRIXPTR"  -> 563E5392C040
%#"PRIxPTR" -> 0x563e5392c040
%#"PRIXPTR" -> 0X563E5392C040

[Rolf M. (rmagnus)]

Yalu X. schrieb:
>> Das hängt dann allerdings vom System ab, ob das passt.
>
> Auf 64-Bit-Plattformen mit 32-Bit-int-Typ werden damit die höherwertigen
> 32 Bit des Pointers bei der Ausgabe abgeschnitten.

Oder auch die niederwertigen, je nach Endianness. Und die Anzeige bringt 
auch nix mehr, wenn das Zeigerformat etwas komplizierter ist als einfach 
nur ein einzelner Hex-Wert. Kommt heut zugegebenermaßen wohl nicht mehr 
so oft vor.

[Roland (Gast)]

Rolf M. schrieb:
> Kommt heut zugegebenermaßen wohl nicht mehr
> so oft vor

Warum nicht?

[Rolf M. (rmagnus)]

Roland schrieb:
> Rolf M. schrieb:
>> Kommt heut zugegebenermaßen wohl nicht mehr
>> so oft vor
>
> Warum nicht?

Ich würde sagen, weil man in der Regel heute eher mit einem 
durchgängigen linearen Adressraum arbeitet und nicht wie z.B. noch unter 
DOS mit seiner Unterteilung in Segement- und Offset-Register und sehr 
starker Überlappung. Da gab es noch Zeigerwerte, die dann z.B: 1000:A010 
heißen. Und 1001:A000 war zwar ein anderer Zeigerwert, der aber auf die 
selbe physische Adresse zeigte.

[Gaehn... (Gast)]

Jens schrieb:
> int *b;
>     printf("adresse b: %p\n", (void*)b);

Wird hier nicht auf den Inhalt der Adresse zugegriffen?

[Dirk B. (dirkb2)]

Gaehn... schrieb:
> Jens schrieb:
>> int *b;
>>     printf("adresse b: %p\n", (void*)b);
>
> Wird hier nicht auf den Inhalt der Adresse zugegriffen?

Da wird nicht auf den Inhalt der Adresse zugegriffen.

Das ist ein Cast (Typumwandlung)

[Gaehn... (Gast)]

Hast natürlich Recht, ist noch zu früh.