# V1046\. Unsafe usage of the 'bool' and integer types together in the operation '&\='\.

The analyzer has detected a bitwise AND operation where the types 'bool' and integer are used together in an unsafe way\. The problem is that the bitwise AND will return 'false' for even numbers since the least significant bit is always set to zero\. On the other hand, casting the integer value to 'bool' explicitly will make this operation safe\.

Consider the following synthetic example:

```cpp
int foo(bool a)
{
  return a ? 0 : 2;
}
....
bool var = ....;
var &= foo(false);
```

No matter the initial value of the 'var' variable, it will have the value 'false' after evaluating the '&\=' operation\. Suppose the 'foo' function returns the value 2\. In that case, the 'var & 2' operation will always return 0 as the only valid values of 'var' are 0 and 1\.

This code can be fixed in the following way:

```cpp
var &= foo(false) != 0;
```

Another way to fix it is to modify the function's return statement:

```cpp
int foo(bool a)
{
  return a ? 0 : 1;
}
```

If you have the function return only values within the range \[0;1\], the code will work correctly because we will be able to cast that value to 'bool' without losing it\.

The following example is taken from a real project:

```cpp
template<class FuncIterator>
bool SetFunctionList( FuncIterator begin, FuncIterator end) {
  bool ret = true;
  for (FuncIterator itr = begin; itr != end; ++itr) {
    const ROOT::Math::IMultiGenFunction *f = *itr;
    ret &= AddFunction(*f);
  }
  return ret;
}

int AddFunction(const ROOT::Math::IMultiGenFunction & func) {
  ROOT::Math::IMultiGenFunction *f = func.Clone();
  if (!f) return 0;
  fFunctions.push_back(f);
  return fFunctions.size();
}
```

The 'SetFunctionList' function checks the validity of the iterators passed to it as arguments and return 'false' if at least one of them is invalid or 'true' otherwise\. But the programmer made a mistake when writing the '&\=' operation\. The right operand is a function that returns an integer value within the range from 0 up to SIZE\_MAX\. Each time 'AddFunction' returns an even number, the 'ret' variable will be set to zero, even though it was meant to do so only in case of invalid iterators\.

The 'SetFunctionList' function can be fixed by explicitly casting the 'AddFunction' function's return result to 'bool' first:

```cpp
template<class FuncIterator>
bool SetFunctionList( FuncIterator begin, FuncIterator end) {
  bool ret = true;
  for (FuncIterator itr = begin; itr != end; ++itr) {
    const ROOT::Math::IMultiGenFunction *f = *itr;
    ret &= (bool)AddFunction(*f);
  }
  return ret;
}
```