В двоичном формате преобразовать величину со знаком в дополнение до двух. Все на С

Чтобы преобразовать величину знака x в дополнение до двух y:

1) На машине с дополнением до двух.
2) Используются только !, ~, &, ^, |, +, ‹‹, >>
3) Не используются ?:, -, *, /
> 4) Не предполагает 4-байтовый тип int
5) Работает со всеми целыми числами величины знака, включая +0 и -0

#include <limits.h>
int sm2tc(int x) {
  int sign = x & INT_MIN;
  int negmask = UINT_MAX + !sign;
  return (x & ~negmask) | (negmask & ((~x + 1)^INT_MIN));
}

Этот ответ относится к повторяющемуся вопросу Как преобразовать из знака-величины до дополнения до двух , выбранный ответ которого не соответствовал заявленным критериям OP с учетом ограничения операции.

Эти проблемы крайне глупы, на мой взгляд...

#include <stdint.h>
#include <stdio.h>

int32_t test1(uint32_t x) {
    const uint32_t sign  = (x & 0x80000000); // Total operations: 1
    const uint32_t value = (x & 0x7FFFFFFF); // Total operations: 2

    // Let's create a value N, where N is equal to:
    // if (sign)
    //     N = 0xFFFFFFFF;
    // else
    //     N = 0x00000000;
    uint32_t N = sign;  // Total operations: 2
    N = N | (N >> 1);   // Total operations: 4 
    N = N | (N >> 2);   // Total operations: 6
    N = N | (N >> 4);   // Total operations: 8
    N = N | (N >> 8);   // Total operations: 10
    N = N | (N >> 16);  // Total operations: 12

    // Let's create a value MaybeOne, where MaybeOne is equal to:
    // if (sign)
    //     MaybeOne = 1;
    // else
    //     MaybeOne = 0;
    uint32_t MaybeOne = N & 0x1; // Total operations: 13

    // Now, Let's perform the following step:
    // if (sign)
    //     return (value ^ 0xFFFFFFFF) + 1;
    // else
    //     return (value ^ 0x00000000) + 0;
    return (value ^ N) + MaybeOne; // Total operations: 15
}

int32_t test2(uint32_t x) {
    int32_t sign = (x & 0x80000000);
    int32_t value = (x & 0x7FFFFFFF);

    if (sign)
        return -value;
    else
        return value;
}

int main() {
    uint32_t i;
    for (i=0; i<0xFFFFFFFF; ++i) 
        if (test1(i) != test2(i))
            printf("0x%08x\n", i);
}

Кроме того, используя комментарий от Eric Postpischil, мы можем значительно сократить количество операций:

int32_t test3(uint32_t x) {
    const uint32_t sign  = (x >> 31);        // Total operations: 1
    const uint32_t value = (x & 0x7FFFFFFF); // Total operations: 2

    // Let's create a value N, where N is equal to:
    // if (sign)
    //     N = 0xFFFFFFFF;
    // else
    //     N = 0x00000000;
    const uint32_t N = ~sign + 1;  // Total operations: 4

    // Let's create a value MaybeOne, where MaybeOne is equal to:
    // if (sign)
    //     MaybeOne = 1;
    // else
    //     MaybeOne = 0;
    uint32_t MaybeOne = sign; // Total operations: 4

    // Now, Let's perform the following step:
    // if (sign)
    //     return (value ^ 0xFFFFFFFF) + 1;
    // else
    //     return (value ^ 0x00000000) + 0;
    return (value ^ N) + MaybeOne; // Total operations: 6
}

У вас нет доступных условий, но вы можете маскировать. Существуют различные способы создания маски в зависимости от значения знака.

Далее используются очень полезные советы Эрика Постпишила!

Если знак равен 0 (т.е. положительный), то маска станет равной 0, в противном случае это все еще нужное вам значение -> условное без условного

#include <stdarg.h>
#include <stdio.h>
int sign2two(unsigned int a){
    int sign = a>>31; // alternative: sign = !!((a<<1>>1)+~a+1);  see below
    unsigned int withoutSign = a << 1 >> 1;
    unsigned int mask = ~sign +1;
    printf("withoutSign is: %u\nsign is: %u\nmask is: %x\n", 
        withoutSign, sign, mask);
    unsigned int temp = (withoutSign^mask)+sign;
    return *(int*)&temp;
}
void printSign2two(unsigned int a){
    printf("the 2s complement number: %i\n\n", sign2two(a));
}
int main(){
    printSign2two(0x00000005);
    printSign2two(0x80000005);
    return 0;
}

вывод:

withoutSign is: 5
sign is: 0
mask is: 0
the 2s complement number: 5

withoutSign is: 5
sign is: 1
mask is: ffffffff
the 2s complement number: -5

Примечание по поводу sign = !!((a<<1>>1)+~a+1);. В нем используется несколько больше операторов, чем в sign = a>>31, но он не зависит от разрядности 32/64.

• <<1>>1 очищает старший бит,
• затем мы хотим проверить, отличается ли он от оригинала. поскольку -a не разрешено, мы используем +~a+1 (еще раз спасибо, Эрик Постпишил)
• если нет разницы, у нас уже есть значение 0, которое мы хотим, иначе у нас есть какое-то огромное число
• мы тогда используем !! изменить огромное число на 1.