C standard forbids it – when compiled with gcc -pedantic, it produces invalid application of ‘sizeof’ to a function type warning. However gcc compiles it and returns 1 for sizeof(main), and it is not a size of function pointer. It seems to be compiler-dependent.
If the type of the variable is changed, the sizeof will not require changing if the variable is the argument, rather than the type. Regarding @icepack’s comment: the possibility or likelihood of change for type vs. variable name is not the issue. Imagine the variable name is used as the the argument to sizeof and … Read more
sizeof is a compile time operator.
The standard does not allow objects (and classes thereof) of size 0, since that would make it possible for two distinct objects to have the same memory address. That’s why even empty classes must have a size of (at least) 1.
A union always takes up as much space as the largest member. It doesn’t matter what is currently in use. union { short x; int y; long long z; } An instance of the above union will always take at least a long long for storage. Side note: As noted by Stefano, the actual space … Read more
The type void has no size; that would be a compilation error. For the same reason you can’t do something like: void n; EDIT. To my surprise, doing sizeof(void) actually does compile in GNU C: $ echo ‘int main() { printf(“%d”, sizeof(void)); }’ | gcc -xc -w – && ./a.out 1 However, in C++ it … Read more
First let’s dissect the parameter, T(&)[size]. Read declarations from inside out, right to left, parenthesis group first: It’s an unnamed parameter that is a reference to an array of size size of type T. That is, it accepts a reference to any array, where the type and size of the array are template parameters. If … Read more
sizeof returns size_t which is unsigned and so -1 is being converted to a very large unsigned number. Using the right warning level would have helped here, clang with the -Wconversion or -Weverything(note this is not for production use) flags warns us: warning: implicit conversion changes signedness: ‘int’ to ‘unsigned long’ [-Wsign-conversion] if (sizeof(int) > … Read more
You are asking for the size of a char* which is 4 indeed, not the size of the buffer. The sizeof operator can not return the size of a dynamically allocated buffer, only the size of static types and structs known at compile time.
sizeof(“f”) must return 2, one for the ‘f’ and one for the terminating ‘\0’. sizeof(foo) returns 4 on a 32-bit machine and 8 on a 64-bit machine because foo is a pointer. sizeof(bar) returns 2 because bar is an array of two characters, the ‘b’ and the terminating ‘\0’. The string literal has the type … Read more