负数size_t

Question

Is it well-specified (for unsigned types in general), that:

static_assert(-std::size_t{1} == ~std::size_t{0}, "!");

I just looked into libstdc++ 's std::align implementation and note using std::size_t negation:

inline void*
align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
{
  const auto __intptr = reinterpret_cast<uintptr_t>(__ptr);
  const auto __aligned = (__intptr - 1u + __align) & -__align;
  const auto __diff = __aligned - __intptr;
  if ((__size + __diff) > __space)
    return nullptr;
  else
    {
      __space -= __diff;
      return __ptr = reinterpret_cast<void*>(__aligned);
    }
}

Answer 1

Unsigned integer types are defined to wrap around, and the highest possible value representable in an unsigned integer type is the number with all bits set to one - so yes.

As cpp-reference states it ( arithmetic operators / overflow ):

Unsigned integer arithmetic is always performed modulo 2 ⁿ where n is the number of bits in that particular integer. Eg for unsigned int , adding one to UINT_MAX gives ​0 ​, and subtracting one from 0​ gives UINT_MAX .

Related: Is it safe to use negative integers with size_t?

Answer 2

Is it well-specified (for unsigned types in general), that:

 static_assert(-std::size_t{1} == ~std::size_t{0}, "!"); 

No, it is not.

For calculations using unsigned types, the assertion must hold. However, this assertion is not guaranteed to use unsigned types. Unsigned types narrower than int would be promoted to signed int or unsigned int (depending on the types' ranges) before - or ~ is applied. If it is promoted to signed int , and signed int does not use two's complement for representing negative values, the assertion can fail.

libstdc++'s code, as shown, does not perform any arithmetic in any unsigned type narrower than int though. The 1u in __aligned ensures each of the calculations use unsigned int or size_t , whichever is larger. This applies even to the subtraction in __space -= __diff .

Unsigned types at least as wide as unsigned int do not undergo integer promotions, so arithmetic and logical operations on them is applied in their own type, for which Johan Lundberg's answer applies: that's specified to be performed modulo 2 ^N .