As an example, consider the situation (as mentioned in the introduction to this chapter) that you want to execute code based on whether a variable, myVal , is less than 10. To do this, you need some indication of whether the statement " myVal is less than 10" is true or false, that is, you need to know the Boolean result of a comparison.

Boolean comparisons require the use of Boolean comparison operators (also known as relational operators), which are shown in the following table. In all cases here var1 is a bool type variable, while the types of var2 and var3 may vary.

You might use operators such as these on numeric values in code such as:

bool isLessThan10;


isLessThan10 = myVal < 10;

This code will result in isLessThan10 being assigned the value true if myVal stores a value less than 10, or false otherwise.

You can also use these comparison operators on other types, such as strings:

bool isKarli;


isKarli = myString == "Karli";

Here, isKarli will only be true if myString stores the string "Karli" .

You can also focus on Boolean values:

bool isTrue;


isTrue = myBool == true;

although here you are limited to the use of == and != operators.

There are some other Boolean operators that are intended specifically for working with Boolean values, shown in the following table.

So, the last code snippet above could also be expressed as:

bool isTrue;


isTrue = myBool & true;

The & and operators also have two similar operators, known as conditional Boolean operators, shown in the next table.

The result of these operators is exactly the same as & and , but there is an important difference in the way this result is obtained, which can result in better performance. Both of these look at the value of their first operand ( var2 in the preceding table) and based on the value of this operand may not need to process the second operator ( var3 above) at all.

If the value of the first operand of the && operator is false , then there is no need to consider the value of the second operand, because the result will be false regardless. Similarly, the operator will return true if its first operand is true , regardless of the value of the second operand.

This isn't the case for the & and operators you saw earlier. With these, both operands will always be evaluated.

Because of this conditional evaluation of operands, you will see a small performance increase if you use && and instead of & and . This will be particularly apparent in applications that use these operators a lot. As a rule of thumb, always use && and where possible.

Note that these operators really come into their own in more complicated situations, where computation of the second operand is only possible with certain values of the first operand, for example:

var1 = (var2 != 0) && (var3 / var2 > 2);

Here, if var2 is zero then dividing var3 by var2 will result in either a "division by zero" error or var1 being defined as infinite (the latter is possible, and detectable, with some types such as float ).

Bitwise Operators

In the light of the discussion in the last section, you may be asking why the & and operators exist at all. The reason is that these operators may be used to perform operations on numeric values. In fact, they operate on the series of bits stored in a variable rather than the value of the variable.

Let's consider these in turn , starting with & . Each bit in the first operand is compared with the bit in the same position in the second operand, resulting in the bit in the same position in the resultant value being assigned a value as shown in the following table.

is similar, but the result bits are different, as shown in the next table.

For example, consider the operation shown in the following code:

int result, op1, op2;


op1 = 4;


op2 = 5;


result = op1 & op2;

Here, you must consider the binary representations of op1 and op2 , which are 100 and 101, respectively. The result is obtained by comparing the binary digits in equivalent positions in these two representations as follows :

• The leftmost bit of result is 1 if the leftmost bit of op1 and op2 are both 1, or 0 otherwise.

• The next bit of result is 1 if the next bit of op1 and op2 are both 1, or 0 otherwise.

• Continue for all remaining bits.

In this example, the leftmost bits of op1 and op 2 are both 1, so the leftmost bit of result will be 1, too. The next bits are both 0, and the third bits are 1 and 0, respectively, so the second and third bits of result will be 0. The final value of result in binary representation is, therefore, 100, so result is assigned the value 4. This is shown graphically in the following table.

The same process occurs if you use the operator, except that in this case each result bit is 1 if either of the operand bits in the same position is 1. This is shown in the next table.

You can also use the Δ ^ operator in the same way, where each result bit is 1 if one or other of the operand bits in the same position is one, but not both, as shown in the following table.