Thread: Why does sizeof only return 4???

Because you're just doing sizeof on a series of pointers.

sizeof() cannot tell you how much memory a pointer points to.

Use strlen() if you want to measure the length of each string.

Hmm... let's say we changed your program to this:

Code:

#include <stdio.h>
 
 
int main(int argc, char *argv[])
{
    int i;
    char *types[] = {"dog", "cat", "chicken", "ox", "whale", "dolphin" };
 
 
    for(i=0;i<6;i++)
        printf("A %s is: %d bytes in size!\n", types[i], sizeof(types[i]));
 
 
    system("pause");
    return 0;
}

Why doesn't this return the appropriate sizes for the given animals?

Basically, types is an array of pointers to char. Therefore, types[i] is a pointer to char. Hence, sizeof(types[i]) results in the size of a pointer to char. It does not matter that these pointers happen to be pointing to the first characters of strings that happen to be C type names or animal names.

I suppose that if you wanted to, you could do something like:

Code:

#include <stdio.h>

#define PRINT_SIZE(x) printf("A " #x " is: %u bytes in size!\n", sizeof(x))

int main(void)
{
    PRINT_SIZE(int);
    PRINT_SIZE(char);
    PRINT_SIZE(long);
    PRINT_SIZE(double);
    PRINT_SIZE(long long);
    PRINT_SIZE(char*);
    return 0;
}

But of course it isn't a loop.

In the question it seems like you are mixing up compiled languages with dynamic languages. Once a C program is compiled, the resulting program has no built-in knowledge about any C keywords. In other words, things like sizeof are all figured out at compile-time. Rather than using sizeof(), try making your own function to accomplish the task it seems you are trying to do:

Code:

// csize(keyword): return size of the C keyword or -1 if unknown
size_t csize(const char *keyword)
{
    if (strcmp(keyword, "int") == 0)
        return sizeof(int);
    else if (strcmp(keyword, "char") == 0)
        return sizeof(char);
    // else if ...
    else
        return -1;
}

You can extend it for all types which are keywords in C. Of course, this approach will always be incomplete because you can make custom defined types in C, which would require basically re-implementing part of the compiler in order to figure out their sizes at runtime.