die Verwendung der sizeof-operator
Die Ausgabe des folgenden Programms
#include<stdio.h>
int main(){
int *p[10];
printf("%ld %ld\n",sizeof(*p),sizeof(p));
}
ist
8 <--- sizeof(*p) gives size of single element in the array of int *p[10]
80 <--- sizeof(p) gives size of whole array which is 10 * 8 in size.
nun sehen Sie das folgende Programm
#include<stdio.h>
#define TOTAL_ELEMENTS (sizeof(array) / sizeof(array[0]))
int array[] = {23,34,12,17,204,99,16};
int main()
{
int d;
printf("sizeof(array) = %ld \n",sizeof(array));
printf("sizeof(array[0]) = %ld \n",sizeof(array[0]));
printf("sizeof int %ld\n",sizeof(int));
printf("TOTAL_ELEMENTS=%ld \n",TOTAL_ELEMENTS);
for(d=-1;d <= (TOTAL_ELEMENTS-2);d++)
printf("%d\n",array[d+1]);
return 0;
}
ist
sizeof(array) = 28
sizeof(array[0]) = 4 <--here
sizeof int 4
TOTAL_ELEMENTS=7
Was ich nicht verstehe ist, warum ist die sizeof(array[0]) anders, sowohl die Ausgänge.
- Ich denke, man kompiliert eine 64-bit-Computer, der andere für 32 bit.
- int hat 4 bytes, auch auf 64-bit Maschinen
- keine diesen wurden die beiden Programme auf der gleichen Maschine laufen.
- Sie schrieb "gleichen Maschine" - was ist das compiler/IDE und auch die Maschine?
- Rao Ubuntu 10.04 64-Maschine-compiler gcc version 4.4.3 (Ubuntu 4.4.3-4ubuntu5) editor vi
Du musst angemeldet sein, um einen Kommentar abzugeben.
int *p[10];
ist ein array von Zeigern.
*p
ist das erste element des Arrays von Zeigern. Es ist also ein Zeiger auf eine ganze Zahl. Es ist nicht eine ganze Zahl ist.
int array[] = {23,34,12,17,204,99,16};
ist ein Integer-array. Soarray[0]
ist das erste element des Arrays. Es ist also eine ganze Zahl.Die Größe eines Zeigers auf einen integer (
*p
) und ein integer (array[0]
) unterschiedlich sind.So
sizeof(*p)
undsizeof(array[0])
sind verschiedenen.
sizeof(p)
gibt die Größe des Arrays von Zeigern. So ist es: 10 x 8 = 80.d.h. (Anzahl der Elemente) x (Größe eines Elements)
sizeof(array)
gibt die Größe des Arrays von ganzen zahlen. So ist es: 7 x 4 = 28.Im ersten Beispiel, das element ist ein Zeiger auf int, während im zweiten Beispiel ist es nur int. Sie können sehen, dass der Zeiger 8 bytes, int nur 4 Byte.
Im ersten Fall ist, haben Sie ein array von Zeigern auf int, so dass Ihre Größe ist 8, nicht 4.
Im ersten Beispiel die Größe eines Zeigers verwendet wird und in der zweiten die Größe eines integer. Sie können verschiedene Größen haben vor allem auf 64-bit-Systemen.
array[0]
Typint
*p
Typint*
Diesem vielleicht demonstriert die stilistische Torheit schreiben
eher als
wo die zweite macht es klarer, dass int* ist der Typ der array wird deklariert.
int*
beschreibt einen Datentyp, so macht es Sinn, das deutlich zu machen, indem kuscheln der Typ-Modifizierer*
den Basistypint
anstatt auf den Bezeichnerp
- es ist nicht Teil des Bezeichners.Den 64-bit-Umgebung setzt int auf 32 bit und long und Zeiger 64 bit ..
*p ist ein Zeiger 8 bytes
sizeof(p) -ist-Größe von 10 Zeigern - also 80 bytes
Sind die Chancen Sie haben, AMD64-Maschine - überprüfen Sie diese details (einschließlich weitere Möglichkeiten)
http://gcc.gnu.org/onlinedocs/gcc/i386-and-x86_002d64-Options.html