Как безопасно выполнять static_cast между unsigned int и int?

Хотя есть способы сделать это с помощью приведений и преобразований, большинство из них полагаются на неопределенное поведение, которое имеет четко определенное поведение на некоторых машинах / с некоторыми компиляторами. Вместо того, чтобы полагаться на неопределенное поведение, скопируйте данные:

int signed_val;
std::memcpy (signed_val, val, sizeof(int));
return signed_val;

Цитирование стандарта С++ 03, §4.7/3 (интегральные преобразования):

Если целевой тип знаковый, значение не изменяется, если оно может быть представлено в целевом типе (и ширине битового поля); в противном случае значение определяется реализацией.

Поскольку результат определяется реализацией, по определению невозможно создать действительно переносимое решение.

Вы можете инвертировать беззнаковое число с дополнением до двух, взяв дополнение и добавив единицу. Итак, давайте сделаем это для негативов:

if (val < 0x80000000) // positive values need no conversion
  return val;
if (val == 0x80000000) // Complement-and-addition will overflow, so special case this
  return -0x80000000; // aka INT_MIN
else
  return -(int)(~val + 1);

Это предполагает, что ваши целые числа представлены 32-битным представлением с дополнением до двух (или имеют аналогичный диапазон). Он не зависит от какого-либо неопределенного поведения, связанного с переполнением целого числа со знаком (обратите внимание, что поведение переполнения целого числа unsigned четко определено, хотя и здесь этого не должно происходить!).

Обратите внимание, что если ваши целые числа не 32-битные, все становится сложнее. Возможно, вам придется использовать что-то вроде ~(~0U >> 1) вместо 0x80000000. Кроме того, если ваши целые числа не являются дополнением до двух, у вас могут возникнуть проблемы с переполнением для определенных значений (например, на машине с дополнением до единицы -0x80000000 не может быть представлено в виде 32-разрядного целого числа со знаком). Однако машины без дополнения до двух сегодня очень редки, так что это вряд ли будет проблемой.

Вот еще одно решение, которое сработало для меня:

if (val <= INT_MAX) {
    return static_cast<int>(val);
}
else {
    int ret = static_cast<int>(val & ~INT_MIN);
    return ret | INT_MIN;
}

Если я маскирую старший бит, я избегаю переполнения при приведении. Затем я могу безопасно вернуть его обратно.

C++20 будет иметь std::bit_cast, который дословно копирует биты:

#include <bit>
#include <cassert>
#include <iostream>

int main()
{
    int i = -42;
    auto u = std::bit_cast<unsigned>(i);
    // Prints 4294967254 on two's compliment platforms where int is 32 bits
    std::cout << u << "\n";

    auto roundtripped = std::bit_cast<int>(u);
    assert(roundtripped == i);
    std::cout << roundtripped << "\n"; // Prints -42

    return 0;
}

cppreference показывает пример того, как можно реализовать свои собственные bit_cast с точки зрения memcpy (в примечаниях).

Хотя OpenVMS вряд ли получит поддержку С++ 20 в ближайшее время, я надеюсь, что этот ответ поможет кому-то найти тот же вопрос с помощью поиска в Интернете.

unsigned int u = ~0U;
int s = *reinterpret_cast<int*>(&u); // -1

Наоборот:

int s = -1;
unsigned int u = *reinterpret_cast<unsigned int*>(&s); // all ones