How to perform boolean operations in c++ [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 5 years ago.
Improve this question
I want to add two bolean vectors
vector<bool> v1= {0,0,1}
vector<bool> v2= {1,0,1}
vector<bool> resultedVector = v1+v2
The answer should be:
resultedVector = {1,1,0};
Does anyone know, how to do in c++/c++11 ?
I want to increment every time given boolean vector by 1. And just want to use binary operations. Or could create bolean truth table of given number of variable.

Answer 1

To perform binary addition in C++, you can use the function described here:
Adding binary numbers in C++
I implemented the function from that link to fit your specifications like this:
std::vector<bool> add(const std::vector<bool>& a, const std::vector<bool>& b)
{
bool c;
std::vector<bool> result;
for(int i = 0; i < a.size() ; i++){
result.push_back(false);
result[i] = ((a[i] ^ b[i]) ^ c); // c is carry
c = ((a[i] & b[i]) | (a[i] & c)) | (b[i] & c);
}
return result;
}
This function takes two vectors of bools (and assumes they are the same size) and returns their result vector. Obviously this function doesn't handle overflow or numbers of different sizes. You can modify it yourself if you need those capabilities. Also, you seem to be talking about an overloaded operator for a bool vector, and you can do that by checking out operator overloading, but this logic will allow you to add two boolean numbers stored in vectors.

Answer 2

I'm not sure that I understand your question. Since this looks like homework and the point of the question seems to be operators overloading, here's an idea, not the complete answer:
#include <vector>
std::vector< bool > operator+( const std::vector<bool>& a, const std::vector<bool>& b )
{
std::vector< bool > r;
// your code goes here
return r;
}
int main()
{
std::vector< bool > a, b, c;
c = a + b;
return 0;
}
EDIT - one day later
Here's a solution to your increment problem (demo):
#include <iostream>
#include <vector>
// preinc - no grow on overflow
std::vector< bool >& operator++( std::vector<bool>& v )
{
for ( auto e : v )
if ( e = !e )
break;
return v;
}
// postinc - no grow on overflow
std::vector< bool > operator++( std::vector<bool>& v, int )
{
auto t { v };
operator++( v );
return t;
}
// insert
std::ostream& operator<<( std::ostream& os, const std::vector< bool > v )
{
for ( std::vector< bool >::const_reverse_iterator ci = v.rbegin(); ci != v.rend(); ++ci )
os << *ci ? '1' : '0';
return os;
}
int main()
{
std::vector< bool > b {0,0,0,0};
for ( int i = 0; i < 16; ++i )
{
std::cout << b << std::endl;
++b;
}
return 0;
}

Answer 3

Here's how you can use a stateful functor:
struct BitAdder {
bool carry_ = 0x0; // Range is [0, 1].
// Only accepts single bit values for a and b.
bool operator()(bool a, bool b) {
assert(a == (a & 0x1) && b == (b & 0x1));
char sum = a + b + carry_;
carry_ = (sum & 0x2) >> 1; // Keep in range.
return sum & 0x1;
}
};
// Code is more straightforward when bits are stored in reverse.
std::vector<bool> v = {0, 1, 1, 1, 0}; // To be interpreted as: 1110 (14).
std::vector<bool> w = {1, 0, 1, 1, 0}; // To be interpreted as: 1101 (13).
std::vector<bool> result = {0, 0, 0, 0, 0}; // Will become: 11011 (27).
assert(v.size() <= w.size()); // v and w can be iterated over together.
assert(v.size() <= result.size()); // There is enough space to store the bits.
assert(v[v.size() - 1] + w[v.size() - 1] < 2); // No overflow can happen.
std::transform(v.cbegin(), v.cend(), w.cbegin(), result.begin(), BitAdder());
std::cout << "want: 11011, got: ";
std::copy(result.crbegin(), result.crend(), std::ostream_iterator<bool>(std::cout));
std::cout << '\n';
Live Demo