It’s a constraint violation, and your compiler should diagnose it. If it compiles it in spite of that, your program has undefined behaviour [thanks to @Steve Jessop for the clarification of the failure mode, and see @Michael Burr’s answer for why some compilers allow this]: From C11, 6.5.3.4./1: The sizeof operator shall not be applied … Read more
The lambda in question actually has no state. Examine: struct lambda { auto operator()() const { return 17; } }; And if we had lambda f;, it is an empty class. Not only is the above lambda functionally similar to your lambda, it is (basically) how your lambda is implemented! (It also needs an implicit … Read more
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.
The following could be ambiguous: sizeof int * + 1 Is that (sizeof (int*)) + 1, or (sizeof(int)) * (+1)? Obviously the C language could have introduced a rule to resolve the ambiguity, but I can imagine why it didn’t bother. With the language as it stands, a type specifier never appears “naked” in an … Read more
Because the C standard says so, and it gets the only vote. As consequences: The operand of sizeof can be a parenthesised type, sizeof (int), instead of an object expression. The parentheses are unnecessary: int a; printf(“%d\n”, sizeof a); is perfectly fine. They’re often seen, firstly because they’re needed as part of a type cast … Read more
It is always one in C99, section 6.5.3.4: When applied to an operand that has type char, unsigned char, or signed char, (or a qualified version thereof) the result is 1. Edit: not part of your question, but for interest from Harbison and Steele’s. C: A Reference Manual, Third Edition, Prentice Hall, 1991 (pre c99) … Read more
discussion on same subject “More specifically the integral promotions. In K&R C it was virtually (?) impossible to use a character value without it being promoted to int first, so making character constant int in the first place eliminated that step. There were and still are multi character constants such as ‘abcd’ or however many … Read more
An array-type is implicitly converted into pointer type when you pass it in to a function. So, void PrintSize(int p_someArray[10]) { printf(“%zu\n”, sizeof(p_someArray)); } and void PrintSize(int *p_someArray) { printf(“%zu\n”, sizeof(p_someArray)); } are equivalent. So what you get is the value of sizeof(int*)
You need to add: #include <stdlib.h> This file includes the declaration for the built-in function malloc. If you don’t do that, the compiler thinks you want to define your own function named malloc and it warns you because: You don’t explicitly declare it and There already is a built-in function by that name which has … Read more
sizeof is not a function. It’s a unary operator like ! or ~. sizeof(my_arr)[0] parses as sizeof (my_arr)[0], which is just sizeof my_arr[0] with redundant parentheses. This is just like !(my_arr)[0] parses as !(my_arr[0]). In general, postfix operators have higher precedence than prefix operators in C. sizeof *a[i]++ parses as sizeof (*((a[i])++)) (the postfix operators … Read more