Convert struct to bool value

Question

I am trying to convert struct with boolean value into an another variable of boolean type. I am trying using static_cast and reinterpet_cast.

int main()
{
    bool c,d;

    struct b {
        bool b1 = false; 
        bool b2 = false;
    };

    c = reinterpret_cast<uint8_t*>(&b);
    d = (static_cast<uint8_t*>(static_cast<void*>(&b)));
    cout <<c <<endl;
    cout <<d <<endl;

    return 0;
}

The error is:

main.cpp:22:38: error: expected primary-expression before ')' token
     c = reinterpret_cast<uint8_t*>(&b);
                                      ^
main.cpp:23:53: error: expected primary-expression before ')' token
     d = (static_cast<uint8_t*>(static_cast<void*>(&b)));

Answer 1

You cannot convert an instance of a struct to a bool where the value is the Boolean or of all it's members with just a cast. You need to tell the compiler how to make the object a bool and you do that by overloading the operator bool for the class. In there you do the logic to tell if it should be considered true or false. That would look like

struct Foo
{
    bool a = true;
    bool b = true;
    bool c = false;
    operator bool() { return a || b || c; }
};

int main()
{
    Foo f;
    std::cout << static_cast<bool>(f);
}

ouput:

1

If you have a lot of members like you said you should consider using an array instead of separate members so you can write a loop instead. C++ doesn't have reflection yet so there is no easy way to tell it to or together all the members.

Answer 2

If you have control over the struct definition, this might be a good place to use bit-wise logic. If you have up to 128 boolean values, you could handle them them all within a couple 64-bit vars. To check an individual boolean, you'd use a mask to only check against the intended bit. And for the case described in the question, you could do a boolean-OR operation on the 64-bit vars. something like this:

struct b {
    uint64_t boolset_a;
    uint64_t boolset_b;
}

So if you had defined var_b to be of type struct b, you could do this to see if any of them were true: var_b.boolset_a || var_b.boolset_b

This should, I believe, be a more efficient methodology as it will not require 100+ boolean operations to see if any of them are true.

Answer 3

I'd not do a cast but I'd use a member function with an explicit name:

int main()
{
  struct b {
    bool b1 = false;
    bool b2 = false;
    bool b3 = false;    
    bool AtLeastOneIsTrue() { return b1 || b2 || b3;  };
  };

  b str;
  str.b2 = true;
  cout << str.AtLeastOneIsTrue() << endl;

  str.b2 = false;
  cout << str.AtLeastOneIsTrue() << endl;
}

Output

1
0

But on the other hand if your struct has 100 different bool members, the AtLeastOneIsTrue function would be terrible. An array of bool or a vector of bool would be more appropriate then.

Sample using a vector:

#include <iostream>
#include <vector>

using namespace std;

int main()
{
  struct b {
    vector<bool> values;

    b(int numberofbools) { values.assign(numberofbools, false); };  // constructor

    bool AtLeastOneIsTrue()
    {
      for (bool v : values)
      {
        if (v)
          return true;
      }

      return false;
    };

    void Set(int number, bool value)
    {
      values[number] = value;
    }
  };


  b str(100);   // str has 100 bool values, all false

  cout << str.AtLeastOneIsTrue() << endl;  // print1 0

  str.Set(3, true);                        // set value number 3 to true
  cout << str.AtLeastOneIsTrue() << endl;  // prints 1
}

Answer 4

IMHO, your better create a member function or an operator for the struct, like shown by NathanOliver, that operates on the booleans in there. In fact, your could create at least two member functions, one that tells you whether any of the booleans is true, and other that tells you if all are true.

My approach, as this will probably need to be extendable in some sense in a normal project in the future, is to use a vector of booleans, or better a map, so that each boolean can be given a name, and then two functions (methods if they belong to a bigger class, like a configuration entity) that provide the all/any computation on those flags.

A quick and dirty example of this approach is shown below (compile with C++11 activated, for the auto loop, or modify otherwise):

#include <iostream>
#include <string>
#include <map>

using namespace std;

typedef map<string, bool> Flags;

bool allOK(Flags & fl) {
    bool result = true;
    for (auto & kv : fl) { result &= kv.second; }
    return result;
}

bool anyOK(Flags & fl) {
    bool result = false;
    for (auto & kv : fl) { result |= kv.second; }
    return result;
}

int main(int argc, char * arg[])
{
    Flags flags;

    flags["a"] = true;
    flags["b"] = true;
    flags["the_third_flag"] = false;

    cout << "1. ALL OK: " << boolalpha << allOK(flags)
         << " - ANY OK: " << anyOK(flags) << '\n';

    flags["the_third_flag"] = true;
    cout << "2. ALL OK: " << boolalpha << allOK(flags)
         << " - ANY OK: " << anyOK(flags) << '\n';

    flags["a"] = false;
    flags["b"] = false;
    flags["the_third_flag"] = false;
    flags["a_last_flag"] = false;
    cout << "3. ALL OK: " << boolalpha << allOK(flags)
         << " - ANY OK: " << anyOK(flags) << '\n';

    return 0;
}