Set all bytes of int to (unsigned char)0, guaranteed to represent zero?

by

C++ 11

I think the pertinent part are

3.9.1/1 In C++11

For character types, all bits of the object representation participate
in the value representation. For unsigned character types, all possible bit patterns of the value representation represent numbers. These requirements do not hold for other types.

Along with 3.9.1/7

The representations of integral types
shall define values by use of a pure binary numeration system.

C11

6.2.6.2 is very explicit

For unsigned integer types other than unsigned char, the bits of the object
representation shall be divided into two groups: value bits and padding bits (there need
not be any of the latter). If there are N value bits, each bit shall represent a different
power of 2 between 1 and 2N−1, so that objects of that type shall be capable of
representing values from 0 to 2N − 1 using a pure binary representation; this shall be
known as the value representation. The values of any padding bits are unspecified.

For signed integer types, the bits of the object representation shall be divided into three
groups: value bits, padding bits, and the sign bit. There need not be any padding bits;
signed char shall not have any padding bits. There shall be exactly one sign bit.
Each bit that is a value bit shall have the same value as the same bit in the object
representation of the corresponding unsigned type (if there are M value bits in the signed
type and N in the unsigned type, then M ≤ N). If the sign bit is zero, it shall not affect the resulting value. If the sign bit is one, the value shall be modified in one of the
following ways:

— the corresponding value with sign bit 0 is negated (sign and magnitude);

— the sign bit has the value −(2M) (two’s complement);

— the sign bit has the value −(2M − 1) (ones’ complement).

Which of these applies is implementation-defined, as is whether the value with sign bit 1
and all value bits zero (for the first two), or with sign bit and all value bits 1 (for ones’ complement), is a trap representation or a normal value. In the case of sign and
magnitude and ones’ complement, if this representation is a normal value it is called a
negative zero.

Summmary

I think the intend is the same for both standard.

  • char, signed char and unsigned char have all bits participating in the value

  • other integer types may have padding bits which don’t participate in the value. A wrong bit pattern in them may imply a not valid value.

  • the interpretation is a pure binary representation, something whose definition is expanded in the C11 citation above.

Two things which may be not clear:

  • can -0 (for sign and magnitude and _ones’ complement) be a trap value in C++

  • can one of the padding bits be a parity bit (i.e. can we modify the representation if we ensure that the padding bits aren’t modified or not)

I’d be conservative and assume yes for the both.

More Related Contents:

  1. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  2. Optimizing away a “while(1);” in C++0x
  3. Will std::string always be null-terminated in C++11?
  4. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  5. Is a moved-from vector always empty?
  6. c++ access static members using null pointer
  7. Why is modifying a string through a retrieved pointer to its data not allowed?
  8. Get pointer to object from pointer to some member
  9. So why is i = ++i + 1 well-defined in C++11?
  10. Is it legal to declare a constexpr initializer_list object?
  11. Are notes and examples in the core language specification of the C++ Standard non-normative?
  12. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  13. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  14. Are int8_t and uint8_t intended to be char types?
  15. When do extra parentheses have an effect, other than on operator precedence?
  16. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  17. What is the purpose of a declaration like int (x); or int (x) = 10;
  18. Legal to overwrite std::string’s null terminator?
  19. Does C++11 allow dollar signs in identifiers?
  20. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  21. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  22. Calling an explicit constructor with a braced-init list: ambiguous or not?
  23. Can we apply content not explicitly cited from the normative references to the C++ standard?
  24. Calling delete on NULL pointers – C++03 vs C++11
  25. std::tuple memory alignment
  26. Rvalues, lvalues and formal definitions
  27. Using std::bind with member function, use object pointer or not for this argument?
  28. What is use of the ref-qualifier `const &&`?
  29. memcpy/memmove to a union member, does this set the ‘active’ member?
  30. Overload resolution with ref-qualifiers

Leave a Comment