Why isn't my outcome the same as the tutorial's, even when copy/pasting?

Question

I am learning C from this website. However, when I come up to this tutorial, I seem to be getting strange outcomes. The site recommended to try to make the code without looking at the example first, so I tried entering this code.

#include <stdio.h>
int main()
{
    printf("The \"long\" keyword is pretty useful!\n");

    int a=5;
    long int la=5;
    long long int lla=5;
    double b=5;
    long double lb=5;
    printf("%d (as a normal int) is %d bytes big!\n", a, sizeof(a));
    printf("%d (as a long int) is %d bytes big!\n",la, sizeof(la));
    printf("%d (as a long long int) is %d bytes big!\n",lla, sizeof(lla));
    printf("%lf (as a normal double) is %d bytes big!\n",b, sizeof(b));
    printf("%lf (as a long double) is %d bytes big!\n"),lb, sizeof(lb);
}

and I get this response

The "long" keyword is pretty useful!
5 (as a normal int) is 4 bytes big!
5 (as a long int) is 4 bytes big!
5 (as a long long int) is 0 bytes big!
5.000000 (as a normal double) is 8 bytes big!
5.000000 (as a long double) is 8 bytes big!

It didn't make any sense, so eventually I looked at the example, and saw that it didn't declare any numbers, just the variables. Skipping a mistake I made regarding calling for a variable when there's no set number, I tried doing this instead:

    int a;
    long int la;
    long long int lla;
    double b;
    long double lb;
    printf("A normal int is %d bytes big!\n", sizeof(a));
    printf("A long int is %d bytes big!\n", sizeof(la));
    printf("A long long int is %d bytes big!\n", sizeof(lla));
    printf("A normal double is %d bytes big!\n", sizeof(b));
    printf("A long double is %d bytes big!\n"), sizeof(lb);

to which I get the outcome:

The "long" keyword is pretty useful!
A normal int is 4 bytes big!
A long int is 4 bytes big!
A long long int is 8 bytes big!
A normal double is 8 bytes big!
A long double is 8 bytes big!

Which is almost the intended outcome, except "long int" is 4 bytes big, the same size as a normally declared int, for some unknown reason. Same with "long double".

Eventually, I decided to just copy/paste the example the website gave, to make sure if I'm making a mistake or not, which is this:

    #include <stdio.h>
    int main() {
        int a;
        long b;   // equivalent to long int b;
        long long c;  // equivalent to long long int c;
        double e;
        long double f;
        printf("Size of int = %ld bytes \n", sizeof(a));
        printf("Size of long int = %ld bytes\n", sizeof(b));
        printf("Size of long long int = %ld bytes\n", sizeof(c));
        printf("Size of double = %ld bytes\n", sizeof(e));
        printf("Size of long double = %ld bytes\n", sizeof(f));

        return 0;
    }

And the site says the example should return

Size of int = 4 bytes 
Size of long int = 8 bytes
Size of long long int = 8 bytes
Size of double = 8 bytes
Size of long double = 16 bytes

But for me, it returns:

Size of int = 4 bytes
Size of long int = 4 bytes
Size of long long int = 8 bytes
Size of double = 8 bytes
Size of long double = 12 bytes

This is the only part that I can't seem to find the answer as to why it's not returning the same as what the site says.

I have no clue as to why it's doing this, nor why my first attempt seemed to not return the "sizeof" parts correctly (especially the third line, that returns that a long long int is 0 bytes big.) Does anyone know?

Answer 1

The problem is that you're using the wrong formats to print long int and long long int. %d is only for int, not the longer variants.

Because the format you're using is incorrect, you're getting undefined behavior. It's not printing the size of long long int correctly because it extracted the parameters incorrectly, that's why it shows 0 there.

    printf("%d (as a normal int) is %ld bytes big!\n", a, sizeof(a));
    printf("%ld (as a long int) is %ld bytes big!\n",la, sizeof(la));
    printf("%lld (as a long long int) is %ld bytes big!\n",lla, sizeof(lla));

See How to printf long long

You're also supposed to use %zu for size_t values, but in practice it usually works with %ld. You should always check the compiler warnings. The compiler will issue a warning when you use the wrong format specifier. You need to make sure that you enable those warnings, and fix them.

Answer 2

Your first try:

printf("%d (as a long long int) is %d bytes big!\n",lla, sizeof(lla));

has the problem that you're passing a long long int and a size_t to printf(), but your format specifier is %d, which indicates the parameters are ints. The correct format specifiers are %lld (long long int) and %zu (size_t). The result is undefined behavior, and the program can do anything in response (though usually, it'll either crash or print nonsense).

Your second try

printf("A long int is %d bytes big!\n", sizeof(la));

is close enough to correct that you're running into a different issue: the sizes of data types varies between processors, compilers, and operating systems. Based on the results you and the tutorial are seeing, I'm guessing you're using MSVC on (probably 64-bit) Windows, while the tutorial is using GCC on 64-bit Linux.

This difference is one of the reasons the sizeof operator exists. The C standard doesn't specify exact sizes for the basic data types, only minimums. Compilers are allowed to increase the sizes for speed, compatibility, or other reasons.