Nicht in der Lage, die Ausgabe dieses C-Pointers zu Arraycode zu verstehen

Question

Hier ist Code über das Array zu Zeiger. Das Problem ist, dass ich die Ausgabe nicht verstehe. Nach was ich studierte *p bedeutet, dass Wert an Adresse p enthält und *(*p) Wert bei Adresse bei (Wert bei Adresse p enthält) dann, warum der Ausgang ist anders.

Code:

--------------------------------------------------------------------------- 
#include<stdio.h> 

void main() 
{ 
static int a[ ] = { 0, 1, 2, 3, 4 } ; 
int *p[ ] = { a, a + 1, a + 2, a + 3, a + 4 } ; 
printf ("\n%u %u %d", p, *p, * (*p)) ; 
} 

und Ausgang ist

3545106368 6293840 0 

Bitte helfen Sie mir diese Ausgabe zu verstehen. Halte es einfach und leicht für mich.

Answer 1

In Erinnerung Ihre Arrays sieht ungefähr so ​​aus:

 

+------+------+------+------+------+ 
| a[0] | a[1] | a[2] | a[3] | a[4] | 
+------+------+------+------+------+ 
^ ^ ^ ^ ^
|  |  |  |  | 
+------+------+------+------+------+ 
| p[0] | p[1] | p[2] | p[3] | p[4] | 
+------+------+------+------+------+ 

D.h. Jedes Element von zeigt auf das entsprechende Element in a.

Dann müssen Sie lernen, dass wenn ein Array verwendet wird, es zu einem Zeiger auf sein erstes Element zerfällt, d. H. Der Ausdruck ist dasselbe wie &p[0]. Wenn Sie also p ausdrucken, drucken Sie die Adresse des ersten Elements des Arrays p aus.

Wenn Sie den Zeiger von dereferenzieren, dann tun Sie effektiv *&p[0]. Die Dereferenzierungs- und Adressoperatoren heben sich gegenseitig auf. Wenn Sie also *p drucken, drucken Sie p[0], was der Wert des ersten Elements im Array p ist. Dieses Element, p[0], ist seinerseits ein Zeiger auf a[0]. Wenn Sie also diesen Zeiger dereferenzieren (in **p, was gleich *p[0] ist), dann erhalten Sie den Wert a[0].

---

Auch für jedes Array oder Zeiger p und Index i der Ausdruck p[i] ist die gleiche wie *(p + i). Daraus folgt, dass p[0] das gleiche ist wie *(p + 0), was dasselbe ist wie *(p), was dasselbe ist wie *p.

Daraus folgt die Logik, dass und &p[0] die gleichen sind.

Und Ihnen wirklich zu schrauben um aufgrund der commutative property der Zugabe der Ausdruck *(p + i) ist die gleiche wie *(i + p) die i[p] auf den eigentümlichen, aber gültigen Ausdruck führt. Wenn Sie einen Zeiger mit printf drucken, sollten Sie das "%p" Format verwenden. Es braucht ein void* als Argument, und Sie müssen auch die Zeiger für das Programm umwandeln, um gültig zu sein.Ihr printf Anruf sollte so aussehen:

printf ("%p %p %d\n", (void *) p, (void *) *p, **p) ; 

Siehe z.B. this printf (and family) reference für weitere Informationen.

Answer 2

int *p[ ] 

hier p ist ein Array mit Zeigern zu Integer.

0 1 2 3 4 
| | | | | 
a a+1 a+2 a+3 a+4 => p 

printf ("\n%u %u %d", p, *p, * (*p)) ; 

p ist Zeiger auf das erste Element der p welche a ist (die einen Zeiger auf 0 ist)

*p ist Wert bei p die a ist, die eine Adresse ist, die auf 0 verweist.

*(*p) ist wie *a die geben s 0.

Auch der richtige Bezeichner für eine Adresse ist *p und nicht *u.