C Função para setar bits

[iamrobo]

Eu estou acompanhando as atividades sobre macro e manipulação de bits do livro practical C. Tem uma questão de fixação que não estou conseguindo fazer. 
Ela diz: "Faça um código que tenha uma função set(bool p, unsigned int a, unsigned int b, unsigned int number) que sete n bits, definido pelo intervalo a e b, com o valor de p

(0 ou 1) na variável number e o resultado jogue no retorno."

 

Tentei fazer o seguinte código mas não funcionou:

 

#include <stdio.h>
#include <stdbool.h>
#define left(number) (number = number >> 1)
#define right(number) (number = number << 1)

int set(bool p, unsigned int a, unsigned int b, unsigned int number)
{
    if (p == 1)
    {
        for (int aux = a; aux < b; aux++)
        {
            number = number & 1;
            left(number);
        }
        return number;
    }
}
int main()
{
    unsigned int number, a, b;
    bool p;
    int auxiliador;
    scanf("%d", &auxiliador);
    p = auxiliador;
    scanf("%d", &number);
    scanf("%d", &a);
    scanf("%d", &b);
    printf("%d", set(p, a, b, number));
}

 

Testes:
1
1
2
8
saída: 14
mas no código ta saindo 0. Alguém poderia me dar uma luz?

 

[.if]

38 minutos atrás, iamrobo disse:

n bits, definido pelo intervalo a e b,

Se é que entendo algo, não entendi esta parte.

Olha esta macro bacaninha de décadas atrás...

#define setbit(var,bitno) ((var) |= 1 << (bitno))
#define clrbit(var,bitno) ((var) &= ~(1 << (bitno)))
#define xorbit(var,bitno) ((var) ^= 1 << (bitno))

Pode não vos ser totalmente inútil

[Flávio Pedroza]

Acredito que sua lógica está errada.

Pelo que entendi, considerando o exemplo, temos: number = 8 (1000 em binário). 

a = 1 e b =2 significa que iremos setar os bits 1 a  2 do número. Então, 1000 se transformar em 1110, que é 14 em decimal;

Para setar cada, bit, devemos fazer um OR (|) com a mascará correspondente. Por exemplo, para setar o bit da posição 1, fazemos:

   1000

or 0100

    1100

Para o bit da posição 2:

    1100

or 0010

    1110 (14)

Então seu código ficaria assim:

 

#include <stdio.h>
#include <stdbool.h>


int set(bool p, unsigned int a, unsigned int b, unsigned int number)
{
    if (p == 1)
    {
        for (int aux = a; aux <= b; aux++)
        {
            number |=  1 << aux;
        }
    }
   return number;
}
int main()
{
    unsigned int number, a, b;
    bool p;
    int auxiliador;
    scanf("%d", &auxiliador);
    p = auxiliador;
    scanf("%d", &a);
    scanf("%d", &b);
    scanf("%d", &number);
    printf("%d", set(p, a, b, number));
    return 0;
}

Para zerar o bit, você tem que fazer um AND (&) com a mascará correspondente, que no caso seria o inverso (~)

Por exemplo, para zerar o bit da posição 1, fazemos:

   1110

&  1011 (1011 é o inverso de 0100)

    1010

Para o bit da posição 2:

    1010

&  1101 (1101 é o inverso de 0010)

    1000 (8)

 

Deixo essa parte com você.

[Ansi C]

6 horas atrás, iamrobo disse:

#define left(number) (number = number >> 1)
#define right(number) (number = number << 1)

Essas operações (acima) são figurativamente esteiras que puxa e empurra todos os bits. Tua meta é ligar e desligar bit em `number` sem empurrar ou puxar o `number`

Veja

6 horas atrás, iamrobo disse:

        for (int aux = a; aux < b; aux++)
        {
            number = number & 1;
            left(number);
        }

Ao puxar com left `number` (na direção do menos significativo|dividir por 2) a máquina transforma a estrutura. Se persistir nessa estratégia, não aplique no destino (`number`) e de atenção para qual direção vai à tração dos bits porque ela é conforme o índice do bit na constante.

Observe

Se `number` = (0), e faz `number` &= 1, `number` será 00000000000000000000000000000000,

Se `number` = (1), e faz `number` &= 1, `number` será 00000000000000000000000000000001,

Se puxar `number`, a máquina fará operações que sobrepõe os bits mais significativos na direção do menos:

Logo

`number` >>= 1, será 00000000000000000000000000000000

Portanto,

6 horas atrás, iamrobo disse:

no código ta saindo 0