Эффективное приведение без знака к знаку, избегающее поведения, определяемого реализацией

этот код зависит только от поведения, предписанного спецификацией, поэтому требование (a) легко выполняется:

int unsigned_to_signed(unsigned n)
{
  int result = INT_MAX;

  if (n > INT_MAX && n < INT_MIN)
    throw runtime_error("no signed int for this number");

  for (unsigned i = INT_MAX; i != n; --i)
    --result;

  return result;
}

это не так просто с требованием (b). Это компилируется в no-op с gcc 4.6.3 (- Os,- O2,- O3) и с clang 3.0 (- Os,- O,- O2, - O3). Intel 12.1.0 отказывается оптимизировать это. И у меня нет информации о Visual С.

вы можете явно сказать компилятору, что вы хотите сделать:

int unsigned_to_signed(unsigned n) {
  if (n > INT_MAX) {
    if (n <= UINT_MAX + INT_MIN) {
      throw "no result";
    }
    return static_cast<int>(n + INT_MIN) - (UINT_MAX + INT_MIN + 1);
  } else {
    return static_cast<int>(n);
  }
}

составляет с gcc 4.7.2 на x86_64-linux (g++ -O -S test.cpp) к

_Z18unsigned_to_signedj:
    movl    %edi, %eax
    ret

если x - это наш вклад...

если x > INT_MAX мы хотим найти постоянную k такое, что 0 x - k*INT_MAX INT_MAX.

это просто...unsigned int k = x / INT_MAX;. Тогда пусть unsigned int x2 = x - k*INT_MAX;

теперь мы можем литой x2 до int безопасно. Пусть int x3 = static_cast<int>(x2);

теперь мы хотим вычесть что-то вроде UINT_MAX - k * INT_MAX + 1 С x3, если k > 0.

теперь, на системе дополнения 2s, пока x > INT_MAX, это работает к:

unsigned int k = x / INT_MAX;
x -= k*INT_MAX;
int r = int(x);
r += k*INT_MAX;
r -= UINT_MAX+1;

отметим, что UINT_MAX+1 равен нулю в C++ гарантировано, преобразование в int было noop, и мы вычитали k*INT_MAX затем добавил его обратно на "то же значение". Так что приемлемый оптимизатор должен быть в состоянии стереть все это дурачество!

это оставляет проблему x > INT_MAX или нет. Ну, мы создаем 2 ветки, одна с x > INT_MAX, и один без. Тот, у кого нет, делает прямое приведение, которое компилятор оптимизирует до noop. Один ... делает НУП после оптимизатор выполнен. Умный оптимизатор реализует обе ветви к одному и тому же, и отбрасывает ветвь.

вопросы: если UINT_MAX действительно большой относительно INT_MAX выше может не работать. Я предполагаю, что k*INT_MAX <= UINT_MAX+1 неявно.

мы могли бы, вероятно, атаковать это с некоторыми перечислениями, как:

enum { divisor = UINT_MAX/INT_MAX, remainder = UINT_MAX-divisor*INT_MAX };

которые работают на 2 и 1 в системе дополнения 2s, я считаю (мы гарантируем, что эта математика будет работать? Это сложно...), и делать логику на основе на них, которые легко оптимизируются на системах дополнения non-2s...

это также открывает случай исключение. Это возможно только в том случае, если UINT_MAX намного больше (INT_MIN-INT_MAX), поэтому вы можете поместить свой код исключения в блок if, задавая точно такой вопрос, и это не замедлит вас в традиционной системе.

я не знаю, как строить эти константы времени компиляции, чтобы правильно справиться с этим.

мои деньги на использование memcpy. Любой приличный компилятор знает, как его оптимизировать:

#include <stdio.h>
#include <memory.h>
#include <limits.h>

static inline int unsigned_to_signed(unsigned n)
{
    int result;
    memcpy( &result, &n, sizeof(result));
    return result;
}

int main(int argc, const char * argv[])
{
    unsigned int x = UINT_MAX - 1;
    int xx = unsigned_to_signed(x);
    return xx;
}

для меня (Xcode 8.3.2, Apple LLVM 8.1,- O3), который производит:

_main:                                  ## @main
Lfunc_begin0:
    .loc    1 21 0                  ## /Users/Someone/main.c:21:0
    .cfi_startproc
## BB#0:
    pushq    %rbp
Ltmp0:
    .cfi_def_cfa_offset 16
Ltmp1:
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
Ltmp2:
    .cfi_def_cfa_register %rbp
    ##DEBUG_VALUE: main:argc <- %EDI
    ##DEBUG_VALUE: main:argv <- %RSI
Ltmp3:
    ##DEBUG_VALUE: main:x <- 2147483646
    ##DEBUG_VALUE: main:xx <- 2147483646
    .loc    1 24 5 prologue_end     ## /Users/Someone/main.c:24:5
    movl    $-2, %eax
    popq    %rbp
    retq
Ltmp4:
Lfunc_end0:
    .cfi_endproc

std::numeric_limits<int>::is_modulo является константой времени компиляции. таким образом, вы можете использовать его для специализации шаблона. проблема решена, по крайней мере, если компилятор играет вместе с подстановкой.

#include <limits>
#include <stdexcept>
#include <string>

#ifdef TESTING_SF
    bool const testing_sf = true;
#else
    bool const testing_sf = false;
#endif

// C++ "extensions"
namespace cppx {
    using std::runtime_error;
    using std::string;

    inline bool hopefully( bool const c ) { return c; }
    inline bool throw_x( string const& s ) { throw runtime_error( s ); }

}  // namespace cppx

// C++ "portability perversions"
namespace cppp {
    using cppx::hopefully;
    using cppx::throw_x;
    using std::numeric_limits;

    namespace detail {
        template< bool isTwosComplement >
        int signed_from( unsigned const n )
        {
            if( n <= unsigned( numeric_limits<int>::max() ) )
            {
                return static_cast<int>( n );
            }

            unsigned const u_max = unsigned( -1 );
            unsigned const u_half = u_max/2 + 1;

            if( n == u_half )
            {
                throw_x( "signed_from: unsupported value (negative max)" );
            }

            int const i_quarter = static_cast<int>( u_half/2 );
            int const int_n1 = static_cast<int>( n - u_half );
            int const int_n2 = int_n1 - i_quarter;
            int const int_n3 = int_n2 - i_quarter;

            hopefully( n == static_cast<unsigned>( int_n3 ) )
                || throw_x( "signed_from: range error" );

            return int_n3;
        }

        template<>
        inline int signed_from<true>( unsigned const n )
        {
            return static_cast<int>( n );
        }
    }    // namespace detail

    inline int signed_from( unsigned const n )
    {
        bool const is_modulo = numeric_limits< int >::is_modulo;
        return detail::signed_from< is_modulo && !testing_sf >( n );
    }
}    // namespace cppp

#include <iostream>
using namespace std;
int main()
{
    int const x = cppp::signed_from( -42u );
    wcout << x << endl;
}

---

EDIT: исправлен код, чтобы избежать возможной ловушки на немодульных машинах int (известно, что существует только одна, а именно архаически настроенные версии Unisys Clearpath). Для простоты это делается не поддерживая значение -2^n-1 где n число int биты значения, на такой машине (т. е. на Clearpath). на практике это значение также не будет поддерживаться машиной (т. е. с представлением знака и величины или дополнением 1).

Я думаю, что тип int составляет не менее двух байтов, поэтому INT_MIN и INT_MAX могут меняться на разных платформах.

основные типы

≤climits≥ header

это совершенно стандартно-совместимый и будет компилироваться в no-op на MSVC / gcc.

int unsigned_to_signed(unsigned int n)
{
    union UltimateCast
    {
        unsigned int In;
        int Out;
    } cast;

    cast.In = n;

    return cast.Out;
}

для вызывающего кода, например:

volatile unsigned int i = 32167;

int main()
{
    return unsigned_to_signed( i );
}

мы будем иметь этот вывод сборки (g++ - O3-S):

__Z18unsigned_to_signedj:
    movl    4(%esp), %eax
    ret
_main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    call    ___main
    movl    _i, %eax
    leave
    ret
    .globl  _i
    .data
    .align 4
_i:
    .long   32167

и объявлении unsigned_to_signed() как inline выходы:

_main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    call    ___main
    movl    _i, %eax
    leave
    ret
    .globl  _i
    .data
    .align 4
_i:
    .long   32167

что довольно аккуратный код.