Casting of infinity to integer is undefined. The behavior is undefined if the truncated value cannot be represented in the destination type. Says it all. Since truncation removes precision but not magnitude, a truncated infinity is still infinity and integers cannot represent infinity.
Unfortunately, even x86-64 implementations can differ – from Intel’s instruction set reference,BSF and BSR, with a source operand value of (0), leaves the destination undefined, and sets the ZF (zero flag). So the behaviour may not be consistent between micro-architectures or, say, AMD and Intel. (I believe AMD leaves the destination unmodified.) The newer LZCNT … Read more
Undefined means explicitly unreliable. Software should be reliable. You shouldn’t have to say much else. A frozen pond is a good example of an undefined walking surface. Just because you make it across once doesn’t mean you should add the shortcut to your paper route, especially if you’re planning for the four seasons.
This is a great question, but let me give an idea for why I think it might be impossible (or at least very hard) in general. Presumably, such an implementation would almost be a C++ interpreter, or at least a compiler for something more like Lisp or Java. It would need to keep extra data … Read more
Some template metaprogramming with SFINAE, perhaps. #include <type_traits> template <typename T, typename std::enable_if<std::is_unsigned<T>::value && (sizeof(T) <= sizeof(unsigned int)) , int>::type = 0> T safe_multiply(T a, T b) { return (unsigned int)a * (unsigned int)b; } template <typename T, typename std::enable_if<std::is_unsigned<T>::value && (sizeof(T) > sizeof(unsigned int)) , int>::type = 0> T safe_multiply(T a, T b) { … Read more
Pointers to elements of arrays are allowed to point to a valid element, or one past the end. If you increment a pointer in a way that goes more than one past the end, the behavior is undefined. For your 0-sized array, p is already pointing one past the end, so incrementing it is not … Read more
The JCE Specification lists standard names that an implementation is expected to support. “SHA-1” is specified, as are SHA-256, SHA-384, and SHA-512. “SHA”, “SHA-0″ and SHA-2” are not standard names and therefore may not be supported at all. You cannot guarantee what “SHA” will return, if anything at all, because it is not in the … Read more
It’s “undefined behavior,” meaning that based on the standard you can’t predict what will happen when you try this. It may do different things depending on the particular machine, compiler, and state of the program. In this case, what will most often happen is that the answer will be “yes.” A variable, const or not, … Read more
Forget casts. Use memcpy. float xhalf = 0.5f*x; uint32_t i; assert(sizeof(x) == sizeof(i)); std::memcpy(&i, &x, sizeof(i)); i = 0x5f375a86 – (i>>1); std::memcpy(&x, &i, sizeof(i)); x = x*(1.5f – xhalf*x*x); return x; The original code tries to initialize the int32_t by first accessing the float object through an int32_t pointer, which is where the rules are … Read more
Classically, compilers treated “undefined behavior” as simply an excuse not to check for various types of errors and merely “let it happen anyway.” But contemporary compilers are starting to use undefined behavior to guide optimizations. Consider this code: int table[5]; bool does_table_contain(int v) { for (int i = 0; i <= 5; i++) { if … Read more