add 1 to a bitset of 32 bits

Question

I have a bitset of 32 bit and i wish to add 1 to it using the binary method of addition. So I have a in binary format and now I want to add 1 to it in binary style, is there a default method to do it or will I have to create a function for it.

    #include<string.h>
    #include<iostream>
    #include<bitset>
    #include<cstlib>
    int main(){
        int a;
        cin >> hex >> a;
        bitset<32> binary(a);
        }

Answer 1

std::bitset is assignable from an unsigned long or unsigned long long.

It also has accessors for these types.

#include <bitset>

auto get() -> std::bitset<32>;
auto put(std::bitset<32>) -> void;

int main(){
    auto bs = get();
    bs = bs.to_ulong() + 1;
    put(bs);
}

example assembler output:

main:
  sub rsp, 8
  call get()
  lea edi, [rax+1]
  call put(std::bitset<32ul>)
  xor eax, eax
  add rsp, 8
  ret

Note that the compiler is bright enough to realise that there's no need to do any copying or conversion.

Answer 2

While the answer in itself is easy, I'll contribute to some good coding style advice.

You could, given the code you show, use std::bitset::to_ulong() and then add, or do whatever you want before converting back.

But there are few style issues on your code, and one who could break some of the logic on future architectures.

The int datatype is not guaranteed to be 32-bit by the standard. It is guaranteed to represent the integral type the architecture you're compiling for is the most efficient with.

uint32_t is what you need, it is guaranteed to be 32 bit long, on all architectures.

And, std::bitset is not really good at it's job. It's not efficient at all for sizes greater than the int type, as indexing needs to be done, and not more efficient than the int type if it's below the size of the int type. And, by the fact that the way to do non bitwise operations with it is to cast it to long , it is not guaranteed that your addition will be faster or even the same speed as if it were with int.

So , for your usage of it, the most efficient type would definitly be uint32_t, being unsigned protecting it of some undefined behavior on signed types bitwise operations.

And, while you are at coding efficient and maintanable code, you can read this : Why is "using namespace std" considered bad practice?