Então eu tenho uma atribuição que eu tenho que codificar uma função em c que usa apenas as operações bit a bit de ~, &, ^, | , +, <<, >> e =. Eu tenho que usar apenas 20 operações. E eu não estou autorizado a usar estruturas de controle como, if-else, for, while, switch ou qualquer outra coisa que excita o código em blocos condicionais. Além dissotipo de fundição também está fora e os bytes que não são declarados no cabeçalho da função (que é dado a mim) são limitados a valores de 1 byte ou 8 bits; então eu tenho hex 0 a FF.

A função que tenho que codificar é uma mudança lógica. Então, ao invés de preencher o bit de sinal, os bits devem ser preenchidos com 0s

Isso é o que eu fiz:

int logicalShift(int x, int n) {
    int op=0xFFFFFFFF;
    int tcn=(~n+1);
    int sizeshift=0x20 & tcn;
    op=(op<<sizeshift);
    return ((x>>n) + (op));
}

Isto é o que eu espero obter (para um x = 0x80000000, e n = 0x01) Espero obter 0x40000000 que é 1073741824 em decimal. Isso é o que eu recebo. No entanto (para um x = 0x80000000, e n = 0x0 eu espero obter 0x80000000, no entanto eu recebo 0x7fffffff que é minha resposta menos um pouco. Eu poderia adicionar um pouco, mas atrapalha a primeira resposta. Então, o que estou fazendo errado que tenho um caso mas não o outro, também tentei.

int logicalShift(int x, int n) {
    int op=0xFFFFFFFF;
    int tcn=(~n+1);
    int sizeshift=0x20 & tcn;
    op=(op<<sizeshift);
    return ((x>>n) + (op  ^ ~n));
}

Eu pensei que se eu XOR o conjunto de bits zerando os bits de sinal com todos os 1's para o caso 0 eu terminaria com algo que não era negativo (aka) 0x7fffffff quando passasse pela conversão de compiladores para o complemento de 2. Acabou piorando. Por favor, me coloque na direção certa, o que devo considerar e por quê?