如何将位数组转换为char

Question

I am trying to edit each byte of a buffer by modifying the LSB(Least Significant Bit) according to some requirements. I am using the unsigned char type for the bytes, so please let me know IF that is correct/wrong.

unsigned char buffer[MAXBUFFER];

Next, i'm using this function

char *uchartob(char s[9], unsigned char u)

which modifies and returns the first parameter as an array of bits. This function works just fine, as the bits in the array represent the second parameter.

Here's where the hassle begins. I am going to point out what I'm trying to do step by step so you guys can let me know where i'm taking the wrong turn.

I am saving the result of the above function (called for each element of the buffer) in a variable

char binary_byte[9];             // array of bits

I am testing the LSB simply comparing it to some flag like above.

if (binary_byte[7]==bit_flag)     // i go on and modify it like this
binary_byte[7]=0;                // or 1, depending on the case

Next, I'm trying to convert the array of bits binary_byte (it is an array of bits, isn't it?) back into a byte/unsigned char and update the data in the buffer at the same time . I hope I am making myself clear enough, as I am really confused at the moment.

buffer[position_in_buffer]=binary_byte[0]<<7| // actualize the current BYTE in the buffer
                        binary_byte[1]<<6|
                        binary_byte[2]<<5|
                        binary_byte[3]<<4|
                        binary_byte[4]<<3|
                        binary_byte[5]<<2|
                        binary_byte[6]<<1|
                        binary_byte[7];

Keep in mind that the bit at the position binary_byte[7] may be modified, that's the point of all this.

The solution is not really elegant, but it's working , even though i am really insecure of what i did (I tried to do it with bitwise operators but without success)

The weird thing is when I am trying to print the updated character from the buffer. It has the same bits as the previous character, but it's a completely different one.

My final question is : What effect does changing only the LSB in a byte have? What should I expect? . As you can see, I'm getting only "new" characters even when i shouldn't.

Answer 1

bitwise:

set bit => a |= 1 << x;

reset bit => a &= ~(1 << x);

bit check => a & (1 << x);

flip bit => a ^= (1 << x)

If you can not manage this you can always use std::bitset .

Helper macros :

#define SET_BIT(where, bit_number) ((where) |= 1 << (bit_number))

#define RESET_BIT(where, bit_number) ((where) &= ~(1 << (bit_number)))

#define FLIP_BIT(where, bit_number) ((where) ^= 1 << (bit_number))

#define GET_BIT_VALUE(where, bit_number) (((where) & (1 << (bit_number))) >> bit_number) //this will retun 0 or 1

Helper application to print bits :

#include <iostream>
#include <cstdint>

#define GET_BIT_VALUE(where, bit_number) (((where) & (1 << (bit_number))) >> bit_number)

template<typename T>
void print_bits(T const& value)
{
    for(uint8_t bit_count = 0;
        bit_count < (sizeof(T)<<3);
        ++bit_count)
    {
        std::cout << GET_BIT_VALUE(value, bit_count) << std::endl;
    }
}

int main()
{
    unsigned int f = 8;
    print_bits(f);
}

Answer 2

So I'm still a little unsure what you are trying to accomplish here but since you are trying to modify individual bits of a byte I would propose using the following data structure:

union bit_byte
{
    struct{
        unsigned bit0 : 1;
        unsigned bit1 : 1;
        unsigned bit2 : 1;
        unsigned bit3 : 1;
        unsigned bit4 : 1;
        unsigned bit5 : 1;
        unsigned bit6 : 1;
        unsigned bit7 : 1;
    } bits;

    unsigned char all;
};

This will allow you to access each bit of your byte and still get your byte representation. Here some quick sample code:

bit_byte myValue;
myValue.bits.bit0 = 1;    // Set the LSB

// Test the LSB
if(myValue.bits.bit0 == 1) {
    myValue.bits.bit7 = 1;
}

printf("%i", myValue.all);