2147483647 + 1 is evaluated as the sum of two ints and therefore overflows. 2147483648 is too big to fit in an int and is therefore assumed by the compiler to be a long (or a long long in MSVC). It therefore does not overflow. To perform the summation as a long long use the … Read more
Jim Martin’s comment from §3.6.9. “Using AUTO_INCREMENT” of the MySQL documentation: Just in case there’s any question, the AUTO_INCREMENT field /DOES NOT WRAP/. Once you hit the limit for the field size, INSERTs generate an error. (As per Jeremy Cole) A quick test with MySQL 5.1.45 results in an error of: ERROR 1467 (HY000): Failed … Read more
C# integer operations don’t throw exceptions upon overflow by default. You can achieve that via the project settings, or by making the calculation checked: int result = checked(largeInt + otherLargeInt); Now the operation will throw. The opposite is unchecked, which makes any operation explicitly unchecked. Obviously, this only makes sense when you’ve got checked operations … Read more
Yes, but… It is certainly possible, but it is usually nonsensical (for any program that doesn’t use billions of these numbers): #include <stdint.h> // don’t want to rely on something like long long struct bad_idea { uint64_t var : 40; }; Here, var will indeed have a width of 40 bits at the expense of … Read more
Integer variables are stored as 16-bit (2-byte) numbers Office VBA Reference Long (long integer) variables are stored as signed 32-bit (4-byte) numbers Office VBA Reference So, the benefit is in reduced memory space. An Integer takes up half the memory that a Long does. Now, we are talking about 2 bytes, so it’s not going … Read more
I’m going to assume that the online compilers use GCC or compatible compiler. Of course, any other compiler is also allowed to do the same optimization, but GCC documentation explains well what it does: -faggressive-loop-optimizations This option tells the loop optimizer to use language constraints to derive bounds for the number of iterations of a … Read more
If you’re interested in a purely theoretical answer, the C++ standard allows undefined behaviour to “time travel”: [intro.execution]/5: A conforming implementation executing a well-formed program shall produce the same observable behavior as one of the possible executions of the corresponding instance of the abstract machine with the same program and the same input. However, if … Read more
This is due to integer overflow. When thisVal is very large and anotherVal is negative then subtracting the latter from the former yields a result that is bigger than thisVal which may overflow to the negative range.
1. Detecting the overflow: x = a * b; if (a != 0 && x / a != b) { // overflow handling } Edit: Fixed division by 0 (thanks Mark!) 2. Computing the carry is quite involved. One approach is to split both operands into half-words, then apply long multiplication to the half-words: uint64_t … Read more
is still overflow of these types an undefined behavior? Yes. Per Paragraph 5/4 of the C++11 Standard (regarding any expression in general): If during the evaluation of an expression, the result is not mathematically defined or not in the range of representable values for its type, the behavior is undefined. […] The fact that a … Read more