sizeof and strlen() do different things. In this case, your declaration char string[] = “october”; is the same as char string[8] = “october”; so the compiler can tell that the size of string is 8. It does this at compilation time. However, strlen() counts the number of characters in the string at run time. So, … Read more
No, you can’t. The compiler doesn’t know what the pointer is pointing to. There are tricks, like ending the array with a known out-of-band value and then counting the size up until that value, but that’s not using sizeof(). Another trick is the one mentioned by Zan, which is to stash the size somewhere. For … Read more
According to 6.5.3, there are two forms for sizeof as the following: sizeof unary-expression sizeof ( type-name ) Since arr in your code is a type-name, it has to be parenthesized.
“…after all it’s just a pointer…”? No. Array is not a pointer. Array is an array object: a solid continuous block of memory that stores the array elements, no pointers of any kind involved. In your case array has 6 elements of size 4 each. That is why your sizeof evaluates to 24. The common … Read more
The question is not meaningful, at least not without further context. The notion of “size” in Java is only reasonably well defined for primitives: A byte is 8 bit (unsurprisingly) an int is 32 bit, a long 64bit, etc. (see e.g. http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html for a full list). For object instances, it’s more complicated, because: Object instances … Read more
Yes, your assumption is correct, assuming an int and a pointer are both 4 bytes long on your machine. And no, arrays aren’t pointers. The array name sometimes decays into a pointer in certain contexts, but they aren’t the same thing. There is a whole section of the comp.lang.c FAQ dedicated to this common point … Read more
First off, a virtual function is not a pointer with 8 bytes. In C++ nothing but sizeof(char) is guaranteed to be any number of bytes. Second, only the first virtual function in a class increases its size (compiler-dependent, but on most – if not all – it’s like this). All subsequent methods do not. Non-virtual … Read more
Because sizeof(int) is unsigned. So -1 is converted to a large unsigned value.
Because p is of type int *, so *p is of type int, which is apparently 4 bytes wide on your implementation. And use %zu for printing size_t (what sizeof yields) if you don’t want your program to invoke undefined behavior.
The pointer is a pointer, and not an array. It can never be “recognized as an array”, because it is not an array. It is entirely up to you to remember the size of the array. For example: struct i_must_remember_the_size { size_t len; int * arr; }; struct i_must_remember_the_size a = { 10, NULL }; … Read more