Gibt es Möglichkeiten der Array-Darstellung mit Pointers in C?

Question

Ich wurde mit Array und Zeiger in C. experimentieren Und hier

http://r4r.co.in/c/c_topics/c_array_basics/array_representation_in_memory.shtml

ich gelesen, dass

ar[2]=*(ar+(sizeof(datatype)*2)); 

jedoch nach dem Schreiben folgenden Testprogramm in C: -

#include<stdio.h> 
#include<conio.h> 

int main() 
{ 
    int array[]={10,11,12,13,14}; 

    printf("\nArray:%d",array); 
    printf("\nArray+4:%p",array+4); 
    printf("\nArray+(sizeof(int)*4):%p",array+((sizeof(int*))*4)); 
    printf("\n*(Array+4):%d",*(array+4)); 
    printf("\n*(Array+(sizeof(int)*4)):%d",*(array+((sizeof(int*))*4))); 

    getch(); 
    return 0; 
} 

Ich habe folgenden Ausgang: -

Array:2686700 
Array+4:0028FEFC 
Array+(sizeof(int)*4):0028FF2C 
*(Array+4):14 
*(Array+(sizeof(int)*4)):4214784 

von hier So stellte ich fest, dass der Ausdruck

array[4]=*(array+(sizeof(int)*4)); 

nicht Ausdruck arbeitet eher

array[4]=*(array+4); 

wahr ist.

So ist meine Schlussfolgerung richtig oder falsch. Wenn es falsch ist, warum ist das dann so? Bitte helft mir ich bin etwas verwirrt

Sprache: -C

Version: -gcc (TDM--1) 4.7.1

Plattform: -Windows 8,1

Answer 1

E1[E2] definiert sein äquivalent zu *((E1)+(E2)) (N1570 6.5.2.1), so wird array[4] immer *(array+4) sein, vorausgesetzt, dass es im gültigen Bereich ist.

+ Bediener zwischen einem Zeiger auf Ganzzahl verwendet wird, definiert, um (die ganze Zahl) Elemente (nicht Bytes) nach dem, was durch den Zeiger pointerd wird. (N1570 6.5.6), so wird *(array+(sizeof(int)*4)) außerhalb des Bereichs liegen, wenn sizeof(int) >= 2 und das Bewegen des Zeigers zu außerhalb des Bereichs undefiniertes Verhalten aufrufen.

Beachten Sie auch, dass Sie korrekte Formatbezeichner für printf() verwenden sollten, oder Sie rufen undefined Verhalten.

#include<stdio.h> 

int main(void) 
{ 
    int array[]={10,11,12,13,14}; 

    printf("\nArray:%p",(void*)array); 
    printf("\nArray+4:%p",(void*)(array+4)); 
    printf("\nArray+(sizeof(int)*4):%p",(void*)(array+((sizeof(int*))*4))); /* maybe undefined behavior */ 
    printf("\n*(Array+4):%d",*(array+4)); 
    printf("\n*(Array+(sizeof(int)*4)):%d",*(array+((sizeof(int*))*4))); /* maybe undefined behavior */ 

    return 0; 
} 

Answer 2

Sie falsch interpretiert ursprünglich die Art und Weise zusätzlich mit Zeigern arbeitet. Ein Zeiger ist eine Adresse plus der Objekttyp, auf den er zeigt. Also, Addition weiß, dass es sizeof() Bytes hinzufügen muss.

Siehe Difference Between *(Pointer + Index) and Pointer[] und this.

Plus in Anweisung

printf("\nArray+(sizeof(int)*4):%p",array+((sizeof(int*))*4)); 

Sie verwenden sizeof(int*) tatsächlich statt sizeof(int). Ebenso in einer anderen Zeile. Also druckst du nicht, was du denkst, dass du bist.

Beachten Sie auch die interesting facts about commutation.

Answer 3

Die Zeigerarithmetik berücksichtigt die Größe des spitzen Typs. Bei einem Zeiger auf ein Objekt vom Typ T gibt der Ausdruck p+1 die Adresse des nächsten Objekts vom Typ T an. Also, wenn p == 0x8000, p+1 kann 0x8001, 0x8002, 0x8004, 0x8008 oder einen anderen Wert abhängig von der Größe von T ergeben.

So a[i] == *(a + i); eine Adresse a, Offset iElemente (nicht Bytes) von dieser Adresse gegeben und das Ergebnis dereferenziert. Sie müssen den Versatz nicht mit der Größe des spitzen Typs multiplizieren.

Answer 4

printf("\n*(Array+(sizeof(int)*4)):%d",*(array+((sizeof(int*))*4))); 

sollte

printf("\n*(Array+(sizeof(int)*4)):%d",*(array+((sizeof(int))*4))); 

sein und das oben ist nur gültig, wenn das Array von int jedes Byte behandelt wird, was ich denke, ist unwahrscheinlich.