"Die Größe der C-Variablen ist maschinenabhängig." Stimmt das wirklich? Zahlen mit und ohne Vorzeichen ;

Question

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
    ret

Ich 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
    ret

Beobachtungen

• 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 int beide 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?

Answer 1

Hier ist eine andere Implementierung -- ganz anders als die, die Sie gewohnt sind, aber eine, die heute noch im Internet präsent ist, auch wenn sie nicht mehr für allgemeine Zwecke verwendet wird, außer von Retro-Computing-Hobbyisten -- Keine der Größen sind die gleichen wie Ihre:

@type sizes.c
#include <stdio.h>
#include <limits.h>

int main()
{
   printf("CHAR_BIT = %d\n", CHAR_BIT);
   printf("sizeof(char) = %d\n", sizeof(char));
   printf("sizeof(short) = %d\n", sizeof(short));
   printf("sizeof(int) = %d\n", sizeof(int));
   printf("sizeof(long) = %d\n", sizeof(long));
   printf("sizeof(float) = %d\n", sizeof(float));
   printf("sizeof(double) = %d\n", sizeof(double));
   return 0;
}
@run sizes.exe
CHAR_BIT = 9
sizeof(char) = 1
sizeof(short) = 2
sizeof(int) = 4
sizeof(long) = 4
sizeof(float) = 4
sizeof(double) = 8