CODEWITHSUNDEEP
c++bit-manipulationbit
user6074529
user6074529

Reputation:

Appending bits in C/C++

I want to append two unsigned 32bit integers into 1 64 bit integer. I have tried this code, but it fails. However, it works for 16bit integers into 1 32 bit

Code: 

char buffer[33];
char buffer2[33];
char buffer3[33];

/*
uint16 int1 = 6535;
uint16 int2 = 6532;
uint32 int3;
*/


uint32 int1 = 653545;
uint32 int2 = 562425;
uint64 int3;

int3 = int1;
int3 = (int3 << 32 /*(when I am doing 16 bit integers, this 32 turns into a 16)*/) | int2;


itoa(int1, buffer, 2);
itoa(int2, buffer2, 2);
itoa(int3, buffer3, 2);



 std::cout << buffer << "|" << buffer2 << " = \n" << buffer3 << "\n";

Output when the 16bit portion is enabled:

1100110000111|1100110000100 =
11001100001110001100110000100

Output when the 32bit portion is enabled:

10011111100011101001|10001001010011111001 =
10001001010011111001

Why is it not working? Thanks

Upvotes: 3

Views: 2357

Answers (2)

Chews
Chews

Reputation: 26

Try declaring buffer3 as buffer3[65]

Edit: Sorry. But I don't understand what the complaint is about. In fact the answer is just as expected. You can infer it from your own result for the 16 bit input. Since when you are oring the 32 '0' bits in lsb with second integer it will have leading zeroes in msb (when assigned to a 32 bit int which is in the signature of atoi) which are truncated in atoi (only the integer value equivalent will be read in the string, hence the string has to be 0X0 terminated, otherwise it would have a determinable size), giving the result.

Upvotes: 1

Sam Varshavchik
Sam Varshavchik

Reputation: 118292

I see nothing wrong with this code. It works for me. If there's a bug, it's in the code that's not shown.

Version of the given code, using standardized type declarations and iostream manipulations, instead of platform-specific library calls. The bit operations are identical to the example given.

#include <iostream>
#include <iomanip>
#include <stdint.h>    

int main()
{
    uint32_t int1 = 653545;
    uint32_t int2 = 562425;
    uint64_t int3;

    int3 = int1;
    int3 = (int3 << 32) | int2;

    std::cout << std::hex << std::setw(8) << std::setfill('0')
          << int1 << " "
          << std::setw(8) << std::setfill('0')
          << int2 << "="
          << std::setw(16) << std::setfill('0')
          << int3 << std::endl;
    return (0);
}

Resulting output:

0009f8e9 000894f9=0009f8e9000894f9

The bitwise operation looks correct to me. When working with bits, hexadecimal is more convenient. Any bug, if there is one, is in the code that was not shown in the question. As far as "appending bits in C++" goes, what you have in your code appears to be correct.

Upvotes: 3

Related Questions