Inserting a byte into a mutli byte type by index

Question

I have found this answer to a similar question where one can extract a byte from a larger type. What I would like to know is what would be the reverse of this procedure by the use of an index value?

To extract a byte from a 32bit type user Pete Wilson gave this:

int a = (the_int >> 24) & 0xff;  // high-order (leftmost) byte: bits 24-31
int b = (the_int >> 16) & 0xff;  // next byte, counting from left: bits 16-23
int c = (the_int >>  8) & 0xff;  // next byte, bits 8-15
int d = the_int         & 0xff;  // low-order byte: bits 0-7

I would like to do the opposite with an index value:

// assume int = 32bit or 4 bytes and unsigned char = 8bit or 1 byte
void insertByte( unsigned char a, unsigned int& value, unsigned idx ) {
    // How to take byte and insert it into the byte position
    // of value at idx where idx is [0-3] from the right
}

Here's an example by value:

unsigned char a = 0x9D;
unsigned int value = 0;

insertByte( a, value, 0 ); // value = 0x0000009D;
insertByte( a, value, 1 ); // value = 0x00009D00;
insertByte( a, value, 2 ); // value = 0x009D0000;
insertByte( a, value, 3 ); // value = 0x9D000000;
// insertByte( a, value, >3 ); // invalid index

Edit

User jamit made a good point with his question in the comments. I think at this moment because this will be the behavior of a constructor to a class template; I want to insert and replace, not insert and shift.

Example:

unsigned int value = 0x01234567;
unsigned char a = 0x9D;
insertByte( a, value, 2 );
// value = 0x019D4567

Insert or set the byte? Inserting a byte suggests the existing bytes will be moved to make room for the new byte. — JaMiT, May 17 '19 at 02:34
@JaMiT Good point; I want the byte at that location in the larger size to equal that of the byte being passed in; so it would more than likely be an insert and replace not an insert and shift. — Francis Cugler, May 17 '19 at 02:38
@JaMiT I edited my answer to reflect you point about the bits being shifted... — Francis Cugler, May 17 '19 at 02:45

user1178830 · Accepted Answer · 2019-05-17T02:46:35.957

2

Just cast your char to an int and shift it by the required amount of bytes and add it to your value.

void insertByte( unsigned char a, int& value, unsigned int idx ) {
    if(idx > 3)
        return;
    // Clear the value at position idx
    value &= ~(0xff << (idx*8));

    int tmp = a;
    tmp = (tmp << (idx * 8));

    // Set the value at position idx
    value |= tmp; 
}

edited May 17 '19 at 02:46

answered May 17 '19 at 02:33

user1178830

436
3
11

I think I can use this as a guide. I have a template Register class that can be any of `std::uint8_t`, `std::uint16_t`, `std::uint32_t` and `std::uint64_t` that can be constructed from any `Register`. I already was able to create a smaller `Register` from a larger `Register` based on index. Now I'm trying to do the reverse. Now I'm trying to construct a larger `Register` from a smaller `Register` by inserting that smaller word size into the larger word size at that index. – Francis Cugler May 17 '19 at 02:36
I've adjusted the answer in accordance with your edit, this should do what you want. – user1178830 May 17 '19 at 02:48
@user1178830 Also it should of been unsigned int and not int, but it should still do the same thing. – Francis Cugler May 17 '19 at 02:50
I just tested it; and it works like a charm; now it's just a matter of integrating it into my class template; thank you very much! – Francis Cugler May 17 '19 at 03:03

score 1 · Answer 2 · answered May 17 '19 at 02:54

To invert what you got from the other answer:

unsigned a = (the_int & 0x00ffffff) | (the_byte << 24);  // set high-order byte: bits 24-31
unsigned b = (the_int & 0xff00ffff) | (the_byte << 16);  // next byte, bits 16-23
unsigned c = (the_int & 0xffff00ff) | (the_byte << 8);   // next byte, bits 8-15
unsigned d = (the_int & 0xffffff00) | (the_byte);        // low-order byte: bits 0-7

The opposite of bitwise-and is bitwise-or, and the opposite of right-shift is left-shift. The remaining complication is to clear any old value in the byte, which is done with new masks. (If you ignore the new masks, this is a left-shift followed by a bitwise-or. Compare that to extracting the bytes with a right-shift followed by a bitwise-and.)

The current revision of user1178830's answer is a more programatic way to accomplish this.

Inserting a byte into a mutli byte type by index

2 Answers2