sizeof returns an unsigned integer, so TOTAL_ELEMENTS is also unsigned. d is signed. Initially, d is -1. However, when doing the comparison, d is implicitly typecast to unsigned, so it is no longer -1 when being compared to TOTAL_ELEMENTS, it is actually UINT_MAX (which is 4294967295 on my machine, but might differ for others). Also, … Read more
In C++ an empty class or struct has a sizeof at least 1 by definition. From the C++ standard, 9/3 “Classes”: “Complete objects and member subobjects of class type shall have nonzero size.” In C an empty struct is not permitted, except by extension (or a flaw in the compiler). This is a consequence of … Read more
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
C++11, §5.3.3 ¶6 The result of sizeof and sizeof… is a constant of type std::size_t. [ Note: std::size_t is defined in the standard header (18.2). — end note ] You can also do a quick check: #include <iostream> #include <typeinfo> #include <cstdlib> int main() { std::cout<<(typeid(sizeof(int))==typeid(std::size_t))<<std::endl; return 0; } which correctly outputs 1 on my … Read more
If you have an array then sizeof(array) returns the number of bytes the array occupies. Since each element can take more than 1 byte of space, you have to divide the result with the size of one element (sizeof(array[0])). This gives you number of elements in the array. Example: std::uint32_t array[10]; auto sizeOfInt = sizeof(std::uint32_t); … Read more
Use stdint.h for specific sizes of integer data types, and also use appropriate suffixes for integer literal constants, e.g.: #include <stdint.h> int64_t i2 = 0x0000444400004444LL;
size_t is defined by the C standard to be the unsigned integer return type of the sizeof operator (C99 6.3.5.4.4), and the argument of malloc and friends (C99 7.20.3.3 etc). The actual range is set such that the maximum (SIZE_MAX) is at least 65535 (C99 7.18.3.2). However, this doesn’t let us determine sizeof(size_t). The implementation … 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
It’s actually quite common to store a number without needing to know the exact size of the type. There are plenty of quantities in my programs that I can reasonably assume won’t exceed 2 billion, or enforce that they don’t. But that doesn’t mean I need an exact 32 bit type to store them, any … Read more
2500000000 doesn’t fit in an int, so the compiler correctly interprets it as a long (or long long, or a type where it fits). 1250000000 does, and so does 2. The parameter to sizeof isn’t evaluated, so the compiler can’t possibly know that the multiplication doesn’t fit in an int, and so returns the size … Read more