Mir wurde gesagt, dass C-Typen maschinenabhängig sind. Heute wollte ich das überprüfen.
void legacyTypes()
{
/* character types */
char k_char = 'a';
//Signedness --> signed & unsigned
signed char k_char_s = 'a';
unsigned char k_char_u = 'a';
/* integer types */
int k_int = 1; /* Same as "signed int" */
//Signedness --> signed & unsigned
signed int k_int_s = -2;
unsigned int k_int_u = 3;
//Size --> short, _____, long, long long
short int k_s_int = 4;
long int k_l_int = 5;
long long int k_ll_int = 6;
/* real number types */
float k_float = 7;
double k_double = 8;
}Ich habe es auf einem 32-Bit-Maschine Verwendung des minGW C-Compilers
_legacyTypes:
pushl %ebp
movl %esp, %ebp
subl $48, %esp
movb $97, -1(%ebp) # char
movb $97, -2(%ebp) # signed char
movb $97, -3(%ebp) # unsigned char
movl $1, -8(%ebp) # int
movl $-2, -12(%ebp)# signed int
movl $3, -16(%ebp) # unsigned int
movw $4, -18(%ebp) # short int
movl $5, -24(%ebp) # long int
movl $6, -32(%ebp) # long long int
movl $0, -28(%ebp)
movl $0x40e00000, %eax
movl %eax, -36(%ebp)
fldl LC2
fstpl -48(%ebp)
leave
retIch habe denselben Code auf 64-Bit-Prozessor (Intel Core 2 Duo) auf GCC (linux)
legacyTypes:
.LFB2:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
movq %rsp, %rbp
.cfi_offset 6, -16
.cfi_def_cfa_register 6
movb $97, -1(%rbp) # char
movb $97, -2(%rbp) # signed char
movb $97, -3(%rbp) # unsigned char
movl $1, -12(%rbp) # int
movl $-2, -16(%rbp)# signed int
movl $3, -20(%rbp) # unsigned int
movw $4, -6(%rbp) # short int
movq $5, -32(%rbp) # long int
movq $6, -40(%rbp) # long long int
movl $0x40e00000, %eax
movl %eax, -24(%rbp)
movabsq $4620693217682128896, %rax
movq %rax, -48(%rbp)
leave
retBeobachtungen
-
char, signed char, unsigned char, int, unsigned int, signed int, short int, unsigned short int, signed short int belegen alle die gleiche Anzahl von Bytes auf 32-Bit und 64-Bit Prozessoren.
-
Die einzige Änderung betrifft die
long int&long long intbeide belegen 32-Bit auf 32-Bit-Maschinen und 64-Bit auf 64-Bit-Maschinen. -
Und auch die Zeiger, die 32-Bit auf 32-Bit-CPU & 64-Bit auf 64-Bit-CPU nehmen.
Fragen:
- Ich kann nicht sagen, dass das, was in den Büchern steht, falsch ist. Aber ich vermisse hier etwas. Was genau bedeutet "Variablentypen sind maschinenabhängig"?
- Wie Sie sehen können, gibt es keinen Unterschied zwischen Anweisungen für vorzeichenlose und vorzeichenbehaftete Zahlen. Wie kommt es dann, dass der Bereich der Zahlen, die mit beiden adressiert werden können, unterschiedlich ist?
- Ich habe gelesen Wie kann man die feste Größe von C-Variablentypen auf verschiedenen Rechnern beibehalten? Ich habe weder den Zweck der Frage noch ihre Antworten verstanden. Was ist die Beibehaltung der festen Größe? Sie sind alle gleich groß. Ich habe nicht verstanden, wie diese Antworten die gleiche Größe gewährleisten sollen.
EDIT:
Ist es nicht unmöglich, die gleiche Größe auf verschiedenen Maschinen bereitzustellen? Ich meine, wie kann man dieselbe Zeigergröße auf 64-Bit- und 32-Bit-Maschinen beibehalten?
