Por lo tanto, tengo una asignación que tengo para codificar una función en c que usa solo las operaciones a nivel de bits de ~, &, ^, | , +, <<, >>, y =. Tengo que usar solo 20 operaciones. Y no se me permite usar estructuras de control tales como, if-else, for, while, switch, o cualquier otra cosa que excuya el código en bloques condicionales. tambiénTipo de casting también está fuera y los bytes que no están declarados en el encabezado de la función (que se me proporciona) están limitados a valores de 1 byte u 8 bits; así que tengo hex 0 a FF.

La función que tengo que codificar es un cambio lógico hacia la derecha. Así que en lugar de que los bits se llenen con el bit de signo, se deben llenar con 0

Esto es lo que he hecho:

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

Esto es lo que espero obtener (para una x = 0x80000000, y n = 0x01) espero obtener 0x40000000 que es 1073741824 en decimal. Esto es lo que obtengo. Sin embargo (para una x = 0x80000000, y n = 0x0 espero obtener 0x80000000, sin embargo, obtengo 0x7fffffff, que es mi respuesta menos un poco. Podría agregar un poco, pero confunde la primera respuesta. Entonces, ¿qué estoy haciendo mal? que tengo un caso pero no el otro. También lo he intentado.

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));
}

Pensé que si XORÍA el conjunto de bits reduciendo a cero los bits de signo con todos los 1 para el caso 0, obtendría algo que no era negativo (alias) 0x7fffffff cuando pasaba por la conversión de los compiladores al complemento de 2. Terminó haciéndolo peor. Por favor, indíqueme en la dirección correcta, ¿qué debo considerar y por qué?