I have this function and everything works until a and b both equal 1. When that happens the carry bit is going to 2 when its supposed to be only 0 or 1. Is my algorithm wrong for the carry bit
carry_bits |= ((a & mask) & (b & mask)) << 1u;

``````bool add7bits( unsigned int a, unsigned int b, unsigned int *carry_out, unsigned int     *overflow_out, unsigned int *sum_out)
{
if ( a > ( ( 1u << NUM_BITS ) - 1 ) )
{
cout << "a value: " << a << " is too large" << endl;
return false;
}
else if ( b > ( ( 1u << NUM_BITS ) - 1 ) )
{
cout << "b value: " << b << " is too large" << endl;
return false;
}
else
{
unsigned int sum_bits = 0;
unsigned int carry_bits = 0;
// Use a mask to access the specific bits of interest
unsigned int mask = 1u;

// Handle rightmost bit as a half-adder (no carry input)
// sum = a ^ b
// c_out = a & b
sum_bits |= ( a & mask) ^ ( b & mask);

// The carry _out_ from this stage sets the carry in for the next,
// that is, the next higher bit in the carry_bits value

carry_bits |= ((a & mask) & (b & mask)) << 1u;

// The remaining bits must be handled with the full adder logic. The last
// adder in the chain's carry out becomes the carry output return
// value of this function.
mask = 1u << 1;

sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
carry_bits |= ((a & mask) & (b & mask)) << 1u;

mask = 1u << 2;
sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
carry_bits |= ((a & mask) & (b & mask)) << 1u;

mask = 1u << 3;
sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
carry_bits |= ((a & mask) & (b & mask)) << 1u;

mask = 1u << 4;
sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
carry_bits |= ((a & mask) & (b & mask)) << 1u;

mask = 1u << 5;
sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
carry_bits |= ((a & mask) & (b & mask)) << 1u;
// Handle bit 6 separately.
mask = 1u << 6;
sum_bits = ((a ^b) ^ carry_bits);
carry_bits |= ((a & mask) & (b & mask)) << 1u;

// Determine the overflow by checking if a and b are both 1.
bool overflow = false;
if ((a & mask) & (b & mask))
overflow = true;
// ...
//
*sum_out = sum_bits;
*carry_out = carry_bits;
*overflow_out = overflow;
cout << a << " + " << b << " = " << *sum_out << endl;;
cout << "Carry: " << *carry_out << endl;
cout << "Overflow: " << *overflow_out << endl;
return true;
}
}
``````

`carry_bits |= ((a & mask) & (b & mask)) << 1u;`

When a is 1, `a & mask` is 1, or in binary 00000001.
When b is 1, `b & mask` is 1, or in binary 00000001.

So `((a & mask) & (b & mask))` is`00000001 & 00000001`, which gives 00000001.

You then apply this:`<< 1u` which is left shifting 00000001, so you get 00000010, which is binary for 2.

That's why you get 2.

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, learning, and sharing knowledge.