You can use an expression such as: sizeof Foo().bar As the argument of sizeof isn’t evaluated, only its type, no temporary is actually created. If Foo wasn’t default constructible (unlike your example), you’d have to use a different expression such as one involving a pointer. (Thanks to Mike Seymour) sizeof ((Foo*)0)->bar
All the compiler knows about is the pointer, which is why you’re getting the size of the pointer back. To see the size of the allocated object, use one of the following code snippets: With ARC: #import <malloc/malloc.h> // … NSLog(@”Size of %@: %zd”, NSStringFromClass([myObject class]), malloc_size((__bridge const void *) myObject)); Without ARC: #import <malloc/malloc.h> … Read more
Roger already showed how to use SizeOf method from the unsafe package. Make sure you read this before relying on the value returned by the function: The size does not include any memory possibly referenced by x. For instance, if x is a slice, Sizeof returns the size of the slice descriptor, not the size … Read more
sizeof is interpreted at compile time, and the compiler knows how the array was declared (and thus how much space it takes up). Calling sizeof on a dynamically-allocated array will likely not do what you want, because (as you mention) the end point of the array is not specified.
Section 3.9.3: The cv-qualified or cv-unqualified versions of a type are distinct types; however, they shall have the same representation and alignment requirements (3.11). 53 “cv-qualified” here refers to const and volatile. So the answer is, yes. const and volatile only specify the limitations/attributes of access to the specified object. They are not considered to … Read more
When you pass an array into a function in C, the array decays into a pointer to its first element. When you use sizeof on the parameter, you are taking the size of the pointer, not the array itself. If you need the function to know the size of the array, you should pass it … Read more
The C++ standard (and C, for that matter) effectively define byte as the size of a char type, not as an eight-bit quantity1. As per C++11 1.7/1 (my bold): The fundamental storage unit in the C++ memory model is the byte. A byte is at least large enough to contain any member of the basic … Read more
In both cases, the last rofl is the variable name. A variable name is in scope as soon as it appears; and for the remainder of the current scope, that identifier in an ordinary context(*) always means the variable name. The sizeof operator does not introduce any special cases for name lookup. In fact, there … Read more
sizeof gives you the size in bytes, not the number of elements. As Alok says, to get the number of elements, divide the size in bytes of the array by the size in bytes of one element. The correct C idiom is: sizeof a / sizeof a[0]
The other likely size for it is that of int, being the “efficient” integer type for the platform. On architectures where it makes any difference whether the implementation chooses 1 or sizeof(int) there could be a trade-off between size (but if you’re happy to waste 7 bits per bool, why shouldn’t you be happy to … Read more