Mfcttrf

There was a similar question here, but the user in that question seemed to have a much larger array, or vector. If I have:

bool boolArray[4];

And I want to check if all elements are false, I can check [ 0 ], [ 1 ] , [ 2 ] and [ 3 ] either separately, or I can loop through it. Since (as far as I know) false should have value 0 and anything other than 0 is true, I thought about simply doing:

if ( *(int*) boolArray) 

This works, but I realize that it relies on bool being one byte and int being four bytes. If I cast to (std::uint32_t) would it be OK, or is it still a bad idea? I just happen to have 3 or 4 bools in an array and was wondering if this is safe, and if not if there is a better way to do it.

Also, in the case I end up with more than 4 bools but less than 8 can I do the same thing with a std::uint64_t or unsigned long long or something?

As πάντα ῥεῖ noticed in comments, std::bitset is probably the best way to deal with that in UB-free manner.

std::bitset<4> boolArray ;
if(boolArray.any()) 
 //do the thing

If you want to stick to arrays, you could use std::any_of, but this requires (possibly peculiar to the readers) usage of functor which just returns its argument:

bool boolArray[4];
if(std::any_of(std::begin(boolArray), std::end(boolArray), [](bool b)return b;) 
 //do the thing

Type-punning 4 bools to int might be a bad idea - you cannot be sure of the size of each of the types. It probably will work on most architectures, but std::bitset is guaranteed to work everywhere, under any circumstances.

You can use std::bitset<N>::any:

Any returns true if any of the bits are set to true, otherwise false.

#include <iostream> 
#include <bitset> 

int main ()

 std::bitset<4> foo;
 // modify foo here


 if (foo.any())
 std::cout << foo << " has " << foo.count() << " bits set.n";
 else
 std::cout << foo << " has no bits set.n";

 return 0;

Live

If you want to return true if all or none of the bits set to on, you can use std::bitset<N>::all or std::bitset<N>::none respectively.

The standard library has what you need in the form of the std::all_of, std::any_of, std::none_of algorithms.

...And for the obligatory "roll your own" answer, we can provide a simple "or"-like function for any array bool[N], like so:

template<size_t N>
constexpr bool or_all(const bool (&bs)[N]) 
 for (bool b : bs) 
 if (b) return b; 
 

 return false;

Or more concisely,

template<size_t N>
constexpr bool or_all(const bool (&bs)[N]) 
 for (bool b : bs) if (b) return b; 
 return false;

This also has the benefit of both short-circuiting like ||, and being optimised out entirely if calculable at compile time.

Apart from that, if you want to examine the original idea of type-punning bool[N] to some other type to simplify observation, I would very much recommend that you don't do that view it as char[N2] instead, where N2 == (sizeof(bool) * N). This would allow you to provide a simple representation viewer that can automatically scale to the viewed object's actual size, allow iteration over its individual bytes, and allow you to more easily determine whether the representation matches specific values (such as, e.g., zero or non-zero). I'm not entirely sure off the top of my head whether such examination would invoke any UB, but I can say for certain that any such type's construction cannot be a viable constant-expression, due to requiring a reinterpret cast to char* or unsigned char* or similar (either explicitly, or in std::memcpy()), and thus couldn't as easily be optimised out.

Several answers have already explained good alternatives, particularly std::bitset and std::any_of(). I am writing separately to point out that, unless you know something we don't, it is not safe to type pun between bool and int in this fashion, for several reasons:

1. 
   int might not be four bytes, as multiple answers have pointed out.


2. 
   int can have trap representations. That is, it is legal for certain bit patterns to cause undefined behavior when they are cast to int. This is rare on modern architectures, but might arise on (for example) ia64, or any system with signed zeros.


3. Regardless of whether you have to worry about (1) or (2), your code violates the strict aliasing rule, so compilers are free to "optimize" it under the assumption that the bools and the int are entirely separate objects with non-overlapping lifetimes. For example, the compiler might decide that the code which initializes the bool array is a dead store and eliminate it, because the bools "must have" ceased to exist* at some point before you dereferenced the pointer. More complicated situations can also arise relating to register reuse and load/store reordering. All of these infelicities are expressly permitted by the C++ standard, which says the behavior is undefined when you engage in this kind of type punning.

You should use one of the alternative solutions provided by the other answers.

* It is legal to reuse the memory pointed to by boolArray by casting it to int and storing an integer, although if you actually want to do this, you must then pass boolArray through std::launder if you want to read the resulting int later. Regardless, the compiler is entitled to assume that you have done this once it sees the read, even if you don't call launder.