An enum is guaranteed to be represented by an integer, but the actual type (and its signedness) is implementation-dependent. You can force an enumeration to be represented by a signed type by giving one of the enumerators a negative value: enum SignedEnum { a = -1 }; In C++0x, the underlying type of an enumeration … Read more
The CPU does not know nor does it care. Instead, bits in the Flags register are set on certain operations, and how your program acts on those flags depends on what the source code told it to. E.g., mov eax, 0FFFFFFFFh test eax, eax js isNegative vs. mov eax, 0FFFFFFFFh test eax, eax jb isNegative … Read more
I don’t know about studies and statistics, but yes, there are definitely optimizations taking this into account that compilers actually do. And yes, they are very important (tldr loop vectorization for example). Besides the compiler optimizations, there is another aspect to be taken into account. With UB you get C/C++ signed integers to behave arithmetically … Read more
It is actually possible to get rid of the if statement and the addition if you do it like this. byte[] foobar = ..; int value = (foobar[10] & 0xff); This way Java doesn’t interpret the byte as a negative number and flip the sign bit on the integer also.
It’s all in your things.size() type. It isn’t int, but size_t (it exists in C++, not in C) which equals to some “usual” unsigned type, i.e. unsigned int for x86_32. Operator “less” (<) cannot be applied to two operands of different sign. There’s just no such opcodes, and standard doesn’t specify, whether compiler can make … Read more
Assuming: You have 2’s-complement representations in mind; and, By (unsigned long) you mean unsigned 32-bit integer, then you just need to add 2**32 (or 1 << 32) to the negative value. For example, apply this to -1: >>> -1 -1 >>> _ + 2**32 4294967295L >>> bin(_) ‘0b11111111111111111111111111111111’ Assumption #1 means you want -1 to … Read more
The problem is in your comparison: if ((-1) < SIZE) sizeof typically returns an unsigned long, so SIZE will be unsigned long, whereas -1 is just an int. The rules for promotion in C and related languages mean that -1 will be converted to size_t before the comparison, so -1 will become a very large … Read more
No, addresses aren’t always positive – on x86_64, pointers are sign-extended and the address space is clustered symmetrically around 0 (though it is usual for the “negative” addresses to be kernel addresses). However the point is mostly moot, since C only defines the meaning of < and > pointer comparisons between pointers that are to … Read more
One way to think about it is that signed, two’s complement format works by assigning each bit a power of two, then flipping the sign of the last power of two. Let’s look at -4, for example, which is represented as 100. This means that the value is -1 x 2^2 + 0 x 2^1 … Read more
The number itself is always interpreted as a non-negative number. Hexadecimal constants don’t have a sign or any inherent way to express a negative number. The type of the constant is the first one of these which can represent their value: int unsigned int long int unsigned long int long long int unsigned long long … Read more