Operators in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Understand the different operators built-in to C++
Demonstrate the ability to declare variables and using a variety of operators

Operators

Operators (1)

You should remember what an operator is from the first year programming module
To recap:
- an operator is a character that represents an action of some sort
- they are used for performing operations on variables and values (otherwise known as operands)
C++ has a collection of operators built-in:
- Arithmetic
- Assignment
- Comparison
- Logical
- Bitwise

Arithmetic

Arithmetic (1)

These operators are used with numeric values to perform mathematical operations
Arithmetic and assignment operators in C++ consist of:
- Addition
- Subtraction
- Division
- Multiplication
- Modulus

Arithmetic (2)

Addition

The addition operator makes use of:
- plus (+) character
- plus-equals (+=) characters
When presented with two values or variables, they will add them together

int x = 3;
int additionExample1 = 1 + 2;
int additionExample2 = 1 + x;
int additionExample3 = 2;

#include <iostream>
int x = 3;
int additionExample1 = 1 + 2;
int additionExample2 = 1 + x;
int additionExample3 = 2;
int main() {
    std::cout << "additionExample1 -> " << additionExample1 << std::endl;
    std::cout << "additionExample2 -> " << additionExample2 << std::endl;
    std::cout << "additionExample3 += x -> " << (additionExample3 += x) << std::endl;
    return 0;
}

additionExample1 -> 3
additionExample2 -> 4
additionExample3 += x -> 5

The addition operator uses the + character or += characters. When two values are presented and the + character is present, then the values will be added together.

On the screen there are three examples, additionExample1, additionExample2 and additionExample3. The first example, we can see that two integers have been added together, and when we print the variable we are returned with value four. The second example, we have a second variable declared called additionExample2 which stores the addition of 1 + x. In this instance, we are adding the value one, to integer value 3 that is stored in variable x. This results in the variable additionExample2 storing the value four.

In the third example, you will see that this time we are reassigning a variable by adding the value of another variable onto it. A new variable called additionExample3 has been created, and it stores value two. After this, we redeclare the variable by adding the value of variable x onto it. This will overwrite the initial value two and add three onto it. This results in the variable now storing value five.

Arithmetic (3)

Subtraction

The subtraction operator makes use of:
- minus (-) character
- minus-equals (-=) characters
When presented with two values or variables, they will subtract them from each other

int x = 3;
int subtractionExample1 = 2 - 2;
int subtractionExample2 = x - 1;
int subtractionExample3 = 2;

#include <iostream>
int x = 3;
int subtractionExample1 = 2 - 2;
int subtractionExample2 = x - 1;
int subtractionExample3 = 2;
int main() {
    std::cout << "subtractionExample1 -> " << subtractionExample1 << std::endl;
    std::cout << "subtractionExample2 -> " << subtractionExample2 << std::endl;
    std::cout << "subtractionExample3 -= x -> " << (subtractionExample3 -= x) << std::endl;
    return 0;
}

subtractionExample1 -> 0
subtractionExample2 -> 2
subtractionExample3 -= x -> -1

The subtraction operator uses the - character or -= characters. When two values are presented and the - character is present, then the values will be subtracted from one another.

On the screen, you can see our first a few of the examples. Here we have declared four variables, x, subtractionExample1, subtractionExample2, and subtractionExample3. In the first subtraction example, the variable stores the result of the equation 2 - 1. Therefore, whenever we refer to subtractionExample1, i.e., printing it, the value 1 will be returned. In the second example, we are subtracting one from the value that is stored in variable x. In this case, the equation would be 3 - 1 and the value two would be stored in the variable subtractionExample2.

In our third example we are reassigning the value that is stored in subtractionExample3 by taking away the value of x from the original value that was stored in subtractionExample3. The original value is two, and the value in x is three. Therefore, when the equation is executed the new value in subtractionExample3 would be minus one, as the equation being performed is 2 - 3.

Arithmetic (4)

Division

The division operator makes use of:
- forward slash (/) character
- forward-slash-equals (/=) characters
When presented with two values or variables, a division will be performed between the two variables

int x = 3;
int divisionExample1 = 9 / 3;
int divisionExample2 = x / 2;
int divisionExample3 = 9;

#include <iostream>
int x = 3;
int divisionExample1 = 9 / 3;
int divisionExample2 = x / 2;
int divisionExample3 = 9;
int main() {
    std::cout << "divisionExample1 -> " << divisionExample1 << std::endl;
    std::cout << "divisionExample2 -> " << divisionExample2 << std::endl;
    std::cout << "divisionExample3 /= x -> " << (divisionExample3 /= x) << std::endl;
    return 0;
}

divisionExample1 -> 3
divisionExample2 -> 1
divisionExample3 /= x -> 3

The division operator uses the / character or /= characters. When two values are presented and the / character is present, then the values will be divided from one another.

The first sef of examples the screen have four variables, x, divisionExample1, divisionExample2, and divisionExample3. The first example, shows a division equation of 9 / 3 and the result of this equation will be stored in the variable divisionExample1, which in this instance is 3.0. You may notice that with a division, a floating point number is returned. This can be observed better with our second example, divisionExample2. In this example, we are dividing the value of x by two. In this case, the equation is 3 / 2 which results in 1.5 and this value will then be stored in divisionExample2.

On the right-hand-side of the screen, we have one further example. You may be familiar with this type of example now, and here we shall be reassigning the value of divisionExample3 by using the /= operator. This will reassign the value of the variable by the result of the equation 9 / 3, which in this case is 3.0.

Arithmetic (5)

Multiplication

The multiplication operator makes use of:
- asterisk (*) character
- asterisk-equals (*=) characters
When presented with two values or variables, a multiplication will be performed between the two variables

int x = 3;
int multiplicationExample1 = 9 * 3;
int multiplicationExample2 = x * 2;
int multiplicationExample3 = 9;

#include <iostream>
int x = 3;
int multiplicationExample1 = 9 * 3;
int multiplicationExample2 = x * 2;
int multiplicationExample3 = 9;
int main() {
    std::cout << "multiplicationExample1 -> " << multiplicationExample1 << std::endl;
    std::cout << "multiplicationExample2 -> " << multiplicationExample2 << std::endl;
    std::cout << "multiplicationExample3 *= x -> " << (multiplicationExample3 *= x) << std::endl;
    return 0;
}

multiplicationExample1 -> 27
multiplicationExample2 -> 6
multiplicationExample3 *= x -> 27

Arithmetic (6)

Modulus

The modulus operator makes use of:
- percentage (%) character
- percentage-equals (%=) characters
When presented with two values or variables, it will return the remainder of a division calculation

int x = 8;
int modulusExample1 = 2 % 4;
int modulusExample2 = x % 2;
int modulusExample3 = 3;

#include <iostream>
int x = 8;
int modulusExample1 = 2 % 4;
int modulusExample2 = x % 2;
int modulusExample3 = 3;
int main() {
    std::cout << "modulusExample1 -> " << modulusExample1 << std::endl;
    std::cout << "modulusExample2 -> " << modulusExample2 << std::endl;
    std::cout << "modulusExample3 %= x -> " << (modulusExample3 %= x) << std::endl;
    return 0;
}

modulusExample1 -> 2
modulusExample2 -> 0
modulusExample3 %= x -> 3

The modulus operator uses the % character or %= characters. When two values are presented and the % character is present, it will return the remainder of a division calculation.

On the screen, you can see that four variables have been declared, these are: x, modulusExmaple1, modulusExample2, and modulusExample3. The first modulus example looks at finding the remainder between two and four. Modulus works slightly different to division. When the calculation 2 / 4 is performed, the answer is 0.5. However, when we do 2 % 4 the answer we get is two.

Comparison

Comparison (1)

These operators are used to compare two values together
Comparison operators in C++ consist of:
- Same As
- Not Equal
- Greater Than
- Greater Than or Equal To
- Lower Than
- Lower Than or Equal To

Comparison (2)

Same As

The same as operator makes use of:
- equal-equal (==) characters
This operator is used to check if one variable is the same as another

int x = 3;
int y = 3;
int z = 5;
bool sameAsExample1 = (x == y);
bool sameAsExample2 = (x == z);

#include <iostream>
int x = 3;
int y = 3;
int z = 5;
bool sameAsExample1 = (x == y);
bool sameAsExample2 = (x == z);
int main() {
    std::cout << "sameAsExample1 -> " << sameAsExample1 << std::endl;
    std::cout << "sameAsExample2 -> " << sameAsExample2 << std::endl;
    return 0;
}

sameAsExample1 -> 1
sameAsExample2 -> 0

The same as operator uses the == characters. When two values are presented and the == characters are used it will perform a check on the two values to determine whether they are the same or not.

On the screen are two examples, sameAsExample1, and sameAsExample2, with them both performing a comparison check but on different values. In the first example. sameAsExample1 the values of x and y are being compared to determine if they are the same or not. The values in each of these variables are three, and as such the outcome of this check is true, or in C++, the value that is returned is 1.

However, in the second example, the variables x and z are being compared against each other. In this instance, the value of z is five, and we should all know that three and five are different. Therefore, the result of this comparison check would be false, or in C++, the value that is returned is 0.

Comparison (3)

Not Equal

The not equal operator makes use of:
- exclamation-equal (!=) characters
This operator is used to check if one variable is not the same as another

int x = 3;
int y = 3;
int z = 5;
bool notEqualExample1 = (x != y);
bool notEqualExample2 = (x != z);

#include <iostream>
int x = 3;
int y = 3;
int z = 5;
bool notEqualExample1 = (x != y);
bool notEqualExample2 = (x != z);
int main() {
    std::cout << "notEqualExample1 -> " << notEqualExample1 << std::endl;
    std::cout << "notEqualExample2 -> " << notEqualExample2 << std::endl;
    return 0;
}

notEqualExample1 -> 0
notEqualExample2 -> 1

The not equal operator uses the != characters. When two values are presented and the != characters are used it will perform a check on the two values to determine whether they are not the same.

The examples shown on the screen are the same as those that were shown on the previous slide. But you may notice that the outcomes are reversed. In the first example, notEqualExample1 we can see that a check is performed on the variables x and y to determine if they are not equal. In this instance, as the values stored in x and y are both the same, the check fails (as they are the same) and as such, false is returned, or in C++, the value that is returned is 0.

In our second example, notEqualExample2 a check is performed on variables x and z to determine whether the two variables are not equal to each other. In this instance, the values three and five are not the same, and the check returns the value true,, or in C++, the value that is returned is 0, and this is stored inside the variable.

Comparison (4)

Greater Than

The greater than operator makes use of:
- right-angle-bracket (>) character
This operator is used to check if one variable is greater than another

int x = 3;
int y = 2;
int z = 1;
bool greaterThanExample1 = (x > y);
bool greaterThanExample2 = (z > x);

#include <iostream>
int x = 3;
int y = 2;
int z = 1;
bool greaterThanExample1 = (x > y);
bool greaterThanExample2 = (z > x);
int main() {
    std::cout << "greaterThanExample1 -> " << greaterThanExample1 << std::endl;
    std::cout << "greaterThanExample2 -> " << greaterThanExample2 << std::endl;
    return 0;
}

greaterThanExample1 -> 1
greaterThanExample2 -> 0

The greater than operator uses the > character. When two values are presented and the > character is used it will perform a check on the two values to determine whether one is greater than the other or not.

On the screen are two examples. The first example, greaterThanExample1 performs a check on whether the value of variable x is greater than the value of variable y. In this instance, we are checking whether three is greater than two. As three is greater than two, in this case the comparison check will return true.

In the second example, greaterThanExample2, a comparison check is performed on whether variable z is greater than variable x. The values stored in each of these variables are one and three, respectively. Hopefully, you should be aware that one is not greater than three, and therefore, in this instance the comparison check would evaluate to false.

Comparison (5)

Greater Than or Equal To

The greater than or equal to operator makes use of:
- right-angle-bracket-equal (>=) characters
This operator is used to check if one variable is greater than another
- or whether it is equal to it

int x = 3;
int y = 2;
int z = 3;
bool greaterThanEqualToExample1 = (x >= y);
bool greaterThanEqualToExample2 = (z > x);
bool greaterThanEqualToExample3 = (z >= x);

#include <iostream>
int x = 3;
int y = 2;
int z = 3;
bool greaterThanEqualToExample1 = (x >= y);
bool greaterThanEqualToExample2 = (z > x);
bool greaterThanEqualToExample3 = (z >= x);
int main() {
    std::cout << "greaterThanEqualToExample1 -> " << greaterThanEqualToExample1 << std::endl;
    std::cout << "greaterThanEqualToExample2 -> " << greaterThanEqualToExample2 << std::endl;
    std::cout << "greaterThanEqualToExample3 -> " << greaterThanEqualToExample3 << std::endl;
    return 0;
}

greaterThanEqualToExample1 -> 1
greaterThanEqualToExample2 -> 0
greaterThanEqualToExample3 -> 1

The greater than or equal to operator uses the >= characters. When two values are presented and the >= characters are used it will perform a check on the two values to determine whether one is greater than the other or if it is equal to.

For this operator, you can see that we have three examples on the screen. The first example is concerned with checking whether variable x is greater than or equal to variable y. Here, we are checking whether value three is greater than or equal to two, and in this instance it will result in true.

The second example and third example is where it gets interesting. In the second example, we can see that a check is being performed on whether z is greater than x. If we look at both of these variables, we can see that they both hold value three and the statement has evaluated to false. This is to be expected, as three is the same as three, and we are not doing a same as comparison.

Therefore, when we look at the third example, we can see here that our comparison check is slightly different. Here we are checking whether three is greater than or equal to three. In this instance, the result will return true as three is equal to three in this case.

Comparison (6)

Less Than

The less than operator makes use of:
- left-angle-bracket (<) character
This operator is used to check if one variable is less than another

int x = 3;
int y = 2;
int z = 1;
bool lessThanEqualToExample1 = (x < y);
bool lessThanEqualToExample2 = (z < x);

#include <iostream>
int x = 3;
int y = 2;
int z = 1;
bool lessThanEqualToExample1 = (x < y);
bool lessThanEqualToExample2 = (z < x);
int main() {
    std::cout << "lessThanEqualToExample1 -> " << lessThanEqualToExample1 << std::endl;
    std::cout << "lessThanEqualToExample2 -> " << lessThanEqualToExample2 << std::endl;
    return 0;
}

lessThanEqualToExample1 -> 0
lessThanEqualToExample2 -> 1

The less than operator uses the left-angle-bracket character. When two values are presented and the left-angle-bracket character is used, it will perform a check on the two values to determine whether one is less than the other or not.

On the screen, you will see two examples, lessThanExample1 and lessThanExample2. In the first example, we are checking whether the value in variable x is less than the value in variable y. In this case, we are checking whether three is less than two, and this comparison evaluates to false.

The second example is slightly different, and with this comparison we are checking whether z is less than x. In this instance, z is storing the value one, and x is storing the value three. From this check, it evaluates to true as one is less than three.

Comparison (7)

Less Than or Equal To

The less than or equal to operator makes use of:
- left-angle-bracket-equal (<=) characters
This operator is used to check if one variable is less than another
- or whether it is equal to it

int x = 3;
int y = 2;
int z = 3;
bool lessThanEqualToExample1 = (x >= y);
bool lessThanEqualToExample2 = (z > x);
bool lessThanEqualToExample3 = (z >= x);

#include <iostream>
int x = 3;
int y = 2;
int z = 3;
bool lessThanEqualToExample1 = (x >= y);
bool lessThanEqualToExample2 = (z > x);
bool lessThanEqualToExample3 = (z >= x);
int main() {
    std::cout << "lessThanEqualToExample1 -> " << lessThanEqualToExample1 << std::endl;
    std::cout << "lessThanEqualToExample2 -> " << lessThanEqualToExample2 << std::endl;
    std::cout << "lessThanEqualToExample3 -> " << lessThanEqualToExample3 << std::endl;
    return 0;
}

lessThanEqualToExample1 -> 1
lessThanEqualToExample2 -> 0
lessThanEqualToExample3 -> 1

The less than or equal to operator uses the <= characters. When two values are presented and the <= characters are used it will perform a check on the two values to determine whether one is less than the other or if it is equal to.

On the screen, you can see three examples. The first example lessThanEqualToExample1 is checking whether the variable x is less than or equal to y. These variables both hold the value three and two respectively. As three is not less than, or equal to, three the value stored in the variable is False.

The next two examples are a little different. In the second example, we are checking whether variable z is less than x, in this case checking whether three is less than three. In this instance, it returns False as they are both the same value. However, when we perform less than, or equal to, check on these two variables, the outcome is slightly different. In this case, the value stored in lessThanEqualToExample3 is True, as the values of z and x are both the same, being value three.

Logical

Logical (1)

These operators are used to combine comparison operators
Logical operators in C++ consist of:
- And
- Or
- Not

Logical (2)

And

The and operator checks whether both comparison operators evaluate to true
Uses two ampersand (&&) characters for the logical check
- if both checks evaluate to true then true is returned
- if one of the checks evaluate to false then false will be returned

bool andExample1 = (6 > 5 && 6 < 10);
bool andExample2 = (6 > 7 && 6 < 10);

#include <iostream>
bool andExample1 = (6 > 5 && 6 < 10);
bool andExample2 = (6 > 7 && 6 < 10);
int main() {
    std::cout << "andExample1 -> " << andExample1 << std::endl;
    std::cout << "andExample2 -> " << andExample2 << std::endl;
    return 0;
}

andExample1 -> 1
andExample2 -> 0

The and operator uses two ampersand characters and will perform a check on both statements and will return true if and only if both of these statements evaluate to be true. If one of these statements were to evaluate to false then false would be returned instead.

On the screen you will see two examples, andExample1 and andExample2. Each of these variables holds two conditional checks, greater than and less than. The first example checks whether six is greater than five, and whether six is less than ten. If each of these conditional checks were to evaluate to true then the variable will store the boolean value true. In this instance, we can see that the first example stores the value true once the code has been executed. This is because six is indeed greater than five, and six is indeed less than ten. As both of these checks have evaluated to true the value true has been returned.

In the second example, we have the same sort of methodology. There are two conditional checks, with the first checking whether six is greater than seven and a second check on whether six is less than ten. We already know that six is less than ten, and therefore this check will evaluate to true. However, the first condition is checking whether six is greater than seven. Hopefully, you should be aware that six is not greater than seven, and therefore this check would evaluate to false. This would result in comparing the false and true boolean values. As we have a single false in one of our conditions, the overall statement will evaluate to false.

It is important to remember, that with the and logical check, both conditions must evaluate to true.

Logical (3)

Or

The or operator checks whether one of the comparison operators evaluate to true
Uses two pipe (||) characters for the logical check
- if one of these checks evaluate to true then true is returned

bool orExample1 = (6 > 5 || 6 < 10);

#include <iostream>
bool orExample1 = (6 > 5 || 6 < 10);
int main() {
    std::cout << "orExample1 -> " << orExample1 << std::endl;
    return 0;
}

orExample1 -> 1

The or operator uses two pipes as the conditional check and will perform a check on both statements and will return true if and only if one of these statements evaluate to be true. It does not matter if one of these statements evaluate to false, as long as one of the conditional checks evaluates to true then true will always be returned. A false boolean value will only be returned if both conditions were to evaluate to false.

On the screen, you can see a single example: orExample1. The variable will hold the value of the logical test on two comparison checks: whether six is greater than five, or if six is less than four. Hopefully, you should be aware that six is greater than five and this comparison check will return true. However, on the second comparison we are checking whether six is less than four and in this instance it evaluates as false.

The outcomes of these two comparison checks are then used in our logical test, checking the outcome of true or false. As we have a single true amongst our checks, the overall test would evaluate to true, as you can see from the outcome printed on the screen.

Logical (4)

Not

The not operator will return the reverse of an evaluated condition
Uses a single exclamation (!) character for the logical check
- if something is returned as true it will then be returned as false and vice-versa

bool notExample1 = (6 > 5);
bool notExample2 = !(6 > 5);

#include <iostream>
bool notExample1 = (6 > 5);
bool notExample2 = !(6 > 5);
int main() {
    std::cout << "notExample1 -> " << notExample1 << std::endl;
    std::cout << "notExample2 -> " << notExample2 << std::endl;
    return 0;
}

notExample1 -> 1
notExample2 -> 0

The operator is used to reverse the original condition that has been evaluated, it uses an exclamation character to inverse the conditional check. For example, if a comparison check was evaluated to true then this would be reversed and return as false instead.

On the screen, you will see two examples: notExample1 and notExample2. The first example is a comparison check on whether six is greater than five, and by now I would hope you come to realise that this expression evaluates to true. However, when it comes to the second example, the not keyword has been applied to comparison check and the opposite boolean value has been returned. In this instance, our comparison check has gone from returning true to returning false.

Bitwise

Bitwise (1)

These operators are used to perform operations on individual bits
- they can only be used on char and int data types
Bitwise operators in C++ consist of:
- Binary AND
- Binary OR
- Binary XOR
- Binary Complement
- Binary Shift Left
- Binary Shift Right

The final set of operators we shall be looking at are referred to as bitwise operators. These are used in C++ to perform operations on the individual bits of the character and integer data types. There are six bitwise operators for C++, and they are the following: AND, OR, XOR, Complement, Shift Left, and Shift Right. Over the next few slides, we shall look at these different operators and how they are used. You may require some knowledge on binary numbers to understand these next few slides. Therefore, if you do not know binary numbers, or require a recap, you may want to pause the video here and look up some resources on binary.

Bitwise (2)

Binary AND

The Binary AND operator uses a single ampersand (&) character
- will return 1 if and only if both of the operands are 1
- otherwise it will return 0

int binaryAndExample1 = 12;
int binaryAndExample2 = 25;
int binaryAndExample3 = (binaryAndExample1 & binaryAndExample2);

#include <iostream>
#include <bitset>
int binaryAndExample1 = 12;
int binaryAndExample2 = 25;
int binaryAndExample3 = (binaryAndExample1 & binaryAndExample2);
int main() {
    std::bitset<8> x(binaryAndExample1);
    std::bitset<8> y(binaryAndExample2);
    std::bitset<8> z(binaryAndExample3);
    std::cout << "binaryAndExample1 -> " << binaryAndExample1 << "\t\tBinary Form: " << x << std::endl;
    std::cout << "binaryAndExample2 -> " << binaryAndExample2 << "\t\tBinary Form: " << y << std::endl;
    std::cout << "binaryAndExample3 -> " << binaryAndExample3 << "\t\tBinary Form: " << z << std::endl;
    return 0;
}

binaryAndExample1 -> 12		Binary Form: 00001100
binaryAndExample2 -> 25		Binary Form: 00011001
binaryAndExample3 -> 8		Binary Form: 00001000

The first bitwise operator we shall be looking at is the binary AND operator, which uses a single ampersand character in order to perform the operation.

The purpose of this operator is to flip the digits of the binary number when comparing two of them together. For example, if a one is present in both of the binary strings, then it will remain as one. However, if a one and zero were present in the comparison, then a zero will be returned. This will make more sense if we were to look at an example together.

On the screen, you will see that I have two integer numbers being stored in the variables named binaryAndExample1 and binaryAndExample2. They both store 12 and 25 respectively. You will see in the blue box that I print these integer values to the screen, but I also provide the binary representation of them. For example, the number twelve in binary eight-bit form is 00 00 11 00, whereas the binary form for the number twenty-five is 00 01 10 01.

Looking closely at these two binary numbers, and apply the binary AND onto them, we can begin changing the individual bits. The rule we need to follow is the following:

if both operands (or digits) being compared are one, they stay as one; otherwise it will be changed to zero

Now that we know our rule, let’s look at changing these bits manually.

We start at the right-most bit of our two binary representations. In this case, for binaryAndExample1 the right-most bit is zero, and for binaryAndExample2 it is one. As only one of these values is a one, then our operator will return zero. This can be evidenced in our third variable, binaryAndExample3, where the right-most bit has been changed to zero. We repeat this process for each bit in our binary string. You will see in the first and second examples that when we get to the fourth-bit from the right, there is a one present in both strings. Therefore, in this instance, we are required to keep the one and move onto the next bit.

Once all the bits in our binary string have been examined, and changed if necessary, we can see that the final binary string is 00 00 10 00. Which, when converted to an integer, is the value eight, as can be seen in the third example when printed to the terminal window.

Bitwise (3)

Binary OR

The Binary OR operator uses a single pipe (|) character
- will return 1 if at least one of the operands is 1
- otherwise it will return 0

int binaryOrExample1 = 12;
int binaryOrExample2 = 25;
int binaryOrExample3 = (binaryOrExample1 | binaryOrExample2);

#include <iostream>
#include <bitset>
int binaryOrExample1 = 12;
int binaryOrExample2 = 25;
int binaryOrExample3 = (binaryOrExample1 | binaryOrExample2);
int main() {
    std::bitset<8> x(binaryOrExample1);
    std::bitset<8> y(binaryOrExample2);
    std::bitset<8> z(binaryOrExample3);
    std::cout << "binaryOrExample1 -> " << binaryOrExample1 << "\t\tBinary Form: " << x << std::endl;
    std::cout << "binaryOrExample2 -> " << binaryOrExample2 << "\t\tBinary Form: " << y << std::endl;
    std::cout << "binaryOrExample3 -> " << binaryOrExample3 << "\t\tBinary Form: " << z << std::endl;
    return 0;
}

binaryOrExample1 -> 12		Binary Form: 00001100
binaryOrExample2 -> 25		Binary Form: 00011001
binaryOrExample3 -> 29		Binary Form: 00011101

The second bitwise operator we shall be looking at is the binary OR operator, which uses a single pipe character in order to perform the operation.

The purpose of this operator is to flip the digits of the binary number when comparing two of them together. For example, if a one is present in either of the binary strings, then it will remain as one. Otherwise, a zero will be returned. This will make more sense if we were to look at an example together.

On the screen, you will see that I have two integer numbers being stored in the variables named binaryOrExample1 and binaryOrExample2. They both store 12 and 25 respectively. You will see in the blue box that I print these integer values to the screen, but I also provide the binary representation of them. For example, the number twelve in binary eight-bit form is 00 00 11 00, whereas the binary form for the number twenty-five is 00 01 10 01.

Looking closely at these two binary numbers, and apply the binary OR onto them, we can begin changing the individual bits. The rule we need to follow is the following:

if either of the operands (or digits) being compared are one, they stay as one; otherwise it will be changed to zero

Now that we know our rule, let’s look at changing these bits manually.

We start at the right-most bit of our two binary representations. In this case, for binaryOrExample1 the right-most bit is zero, and for binaryOrExample2 it is one. Because one of these values is one, then when the operation is performed, one will be returned. This can be seen in our third example, binaryOrExample3, where we can see that the right-most digit is one. We repeat this process for each of the remaining seven bits, only replacing those digits where it satisfies our rule.

You will see that the outcome of this, is that our binary string for the third example is 00 01 11 01, which when converted to an integer becomes twenty-nine. Looking back at our previous bitwise operator, you can see that a different value has been returned due to the outcome of how we have changed the bits. The previous bitwise operator returned eight whilst in this case it has returned twenty-nine.

Bitwise (4)

Binary XOR

The Binary XOR operator uses a single caret (^) character
- will return 1 if and only if one of the operands is 1
- however, if bother operands are 0, or both are 1, it will return 0

int binaryXorExample1 = 12;
int binaryXorExample2 = 25;
int binaryXorExample3 = (binaryXorExample1 ^ binaryXorExample2);

#include <iostream>
#include <bitset>
int binaryXorExample1 = 12;
int binaryXorExample2 = 25;
int binaryXorExample3 = (binaryXorExample1 ^ binaryXorExample2);
int main() {
    std::bitset<8> x(binaryXorExample1);
    std::bitset<8> y(binaryXorExample2);
    std::bitset<8> z(binaryXorExample3);
    std::cout << "binaryXorExample1 -> " << binaryXorExample1 << "\t\tBinary Form: " << x << std::endl;
    std::cout << "binaryXorExample2 -> " << binaryXorExample2 << "\t\tBinary Form: " << y << std::endl;
    std::cout << "binaryXorExample3 -> " << binaryXorExample3 << "\t\tBinary Form: " << z << std::endl;
    return 0;
}

binaryXorExample1 -> 12		Binary Form: 00001100
binaryXorExample2 -> 25		Binary Form: 00011001
binaryXorExample3 -> 21		Binary Form: 00010101

The third bitwise operator we shall be looking at is the binary XOR operator, which uses a single caret character in order to perform the operation.

The purpose of this operator is to flip the digits of the binary number when comparing two of them together. For example, if a one is present in only one of the binary strings, then it will remain as one. However, if both operands were a zero or a one, then a zero will be returned. This will make more sense if we were to look at an example together.

On the screen, you will see that I have two integer numbers being stored in the variables named binaryXorExample1 and binaryXorExample2. They both store 12 and 25 respectively. You will see in the blue box that I print these integer values to the screen, but I also provide the binary representation of them. For example, the number twelve in binary eight-bit form is 00 00 11 00, whereas the binary form for the number twenty-five is 00 01 10 01.

Looking closely at these two binary numbers, and apply the binary XOR onto them, we can begin changing the individual bits. The rule we need to follow is the following:

if only one of the operands (or digits) being compared are one, they stay as one; otherwise it will be changed to zero

Now that we know our rule, let’s look at changing these bits manually.

We start at the right-most bit of our two binary representations. In this case, for binaryXorExample1 the right-most bit is zero, and for binaryOrExample2 it is one. Because one of these values is one, then when the operation is performed, one will be returned. This can be seen in our third example, binaryXorExample3, where we can see that the right-most digit is one. We repeat this process for each of the remaining seven bits, only replacing those digits where it satisfies our rule.

Let’s skip a bit, and move onto the fifth-bit in our binary strings. We can see that for our first example the fifth bit is a one, and in our second example it is also a one. When we apply our rule on these bits, the returned value will be zero; this is because a one is only returned when only a single bit of each operand is a one.

You will see that the outcome of this, is that our binary string for the third example is 00 01 01 01, which when converted to an integer becomes twenty-one. Again, there is a difference between the value that has been returned here and from our previous two bitwise operators. Once again, this is a result of how we have changed our bits due to the rule I stated earlier.

Bitwise (5)

Binary Complement

The Binary Complement operator uses a single tilde (~) character
- wll flip the binary digits, i.e. 1 to 0 and 0 to 1

int binaryCompExample1 = 35;
int binaryCompExample2 = ~binaryCompExample1;

#include <iostream>
#include <bitset>
int binaryCompExample1 = 35;
int binaryCompExample2 = ~binaryCompExample1;
int main() {
    std::bitset<8> x(binaryCompExample1);
    std::bitset<8> y(binaryCompExample2);
    std::cout << "binaryCompExample1 -> " << binaryCompExample1 << "\t\tBinary Form: " << x << std::endl;
    std::cout << "binaryCompExample2 -> " << binaryCompExample2 << "\t\tBinary Form: " << y << std::endl;
    return 0;
}

binaryCompExample1 -> 35		Binary Form: 00100011
binaryCompExample2 -> -36		Binary Form: 11011100

The fourth bitwise operator we shall be looking at is the binary complement operator, which uses a single tilde character in order to perform the operation.

The purpose of this operator is to flip the digits of the binary number when comparing two of them together. For example, if a one is present in the binary string, then it is changed to zero and vice-versa. This operation is only performed on a single integer or binary string.

On the screen, you will see that I have a single integer numbers being stored in the variables named binaryCompExample1 and it stores the value 35. You will see in the blue box, that I print the integer values to the screen, but I also provide the binary representation for it. For example, the number thirty-five in binary eight-bit form is 00 10 00 11.

To apply our binary complement operator, we can create a new variable, in this case called binaryCompExample2 and assign the variable binaryCompExample1 but prepend a tilde character to the beginning of the variable name. This will then begin the process of changing the bits in the binary string. Let’s have a look at the example on the screen in a little more depth.

On the screen, in the blue box, you will see the binary string for our variable binaryCompExample1, which is storing the integer value thirty-five. In binary form, this would be 00 10 00 11. When we apply the binary complement operator on this variable, it will begin changing each bit to its opposite. For example, one would become zero, and zero would become one.

You can see this has been achieved by looking at our second example, binaryCompExample2, whereby the binary string is the direct inverse of the previous example. For each zero, we now have a one, and for each one, we now have a zero. This results in a different integer number being returned, in this case it is minus thirty-six. But why is this?

Well, if you have studied binary numbers previously, you may be aware of the two’s complement rule, whereby a leading one in the binary string means the number is negative, whilst a leading zero means the number is positive. Therefore, as our second examples binary string begins with a one, the number is in fact a negative number.

Bitwise Operator (6)

Binary Shift Left

The Binary Shift Left operator uses a two left-angle-bracket (<<) character
- it will shift all binary digits to the left by a given number of bits
- bit positions vacated by the left shift operator are filled with a 0

int binaryShiftLeftExample1 = 32;
for (int i = 1; i <= 2; ++i) {
  binaryShiftLeftExample1 << i;
}

#include <iostream>
#include <bitset>
int binaryShiftLeftExample1 = 32;
int main() {
    std::bitset<8> x(binaryShiftLeftExample1);
    std::cout << "binaryShiftLeftExample1 -> " << binaryShiftLeftExample1 << "\t\tBinary Form: " << x << std::endl;    
    for (int i = 1; i <= 2; ++i) {
      std::cout << "Left Shift by " << i << ": " << (binaryShiftLeftExample1 << i) << "\t\t\tBinary Form: " << std::bitset<8>(binaryShiftLeftExample1 << i).to_string() <<  std::endl; 
    }
    return 0;
}

binaryShiftLeftExample1 -> 32		Binary Form: 00100000
Left Shift by 1: 64			Binary Form: 01000000
Left Shift by 2: 128			Binary Form: 10000000

The fifth bitwise operator we shall be looking at is the binary shift left operator, which uses a two left-angle-bracket character in order to perform the operation.

The purpose of this operator is to move the digits of the binary string to the left by a given number of bits. The bits that have been vacated by the left shift are filled in with a zero. On the screen, you will see that I have a single integer number being stored in the variable named binaryShiftLeftExample1 and it stores the value 32. You will see in the blue box, that I print the integer value to the screen, but I also provide the binary representation for it. For example, the number thirty-two in binary eight-bit form is 00 10 00 00.

Let’s have a look at how the left shift operator works on this example. On the screen, you will see the variable I have just discussed, but below it is a control statement, otherwise known as a for loop. Do not worry about the syntax for this loop at this moment in time, as you will be introduced to this later on in the module. However, for now, just consider that my loop will be iterating through the range, one to two.

I will be using the counter-variable, i to shift the digits in binaryShiftLeftExample1 by the number it is currently at. Let’s have a look at what is happening. For the first iteration of our loop, the variable i will be at one. Therefore, inside the body of our for loop we shall shift the digits of our binary string left by one. You will see in the blue box that when we do this, our integer number changes from thirty-two to sixty-four and this is because our digit one has been moved towards the left by one-bit. Essentially, we added a zero at the end of our binary string in order to do this.

Once this shift has been completed, our loop with iterating once more and the variable i will store value two. This time, our shift left operator will add two zeroes to the end of our binary string, thus shifting the digit one to the left two times. You might see where this is going, and this time our integer number would be 128.

What do you think will happen if we were to shift our digits to the left by three? Pause. Well, you have probably worked it out, and our integer value will double once again and become 256. The key takeaway from this is that each time we shift our binary string to the left, a zero is added at the end of the binary string, and the value of our integer will increase accordingly.

Bitwise Operator (7)

Binary Shift Right

The Binary Shift Right operator uses a two right-angle-bracket (>>) character
- it will shift all binary digits to the right by a given number of bits
- bit positions vacated by the right shift operator are filled with a 0

int binaryShiftRightExample1 = 32;
for (int i = 1; i <= 2; ++i) {
  binaryShiftRightExample1 >> i;
}

#include <iostream>
#include <bitset>
int binaryShiftRightExample1 = 32;
int main() {
    std::bitset<8> x(binaryShiftRightExample1);
    std::cout << "binaryShiftRightExample1 -> " << binaryShiftRightExample1 << "\t\tBinary Form: " << x << std::endl;    
    for (int i = 1; i <= 2; ++i) {
      std::cout << "Right Shift by " << i << ": " << (binaryShiftRightExample1 >> i) << "\t\t\tBinary Form: " << std::bitset<8>(binaryShiftRightExample1 >> i).to_string() <<  std::endl; 
    }
    return 0;
}

binaryShiftRightExample1 -> 32		Binary Form: 00100000
Right Shift by 1: 16			Binary Form: 00010000
Right Shift by 2: 8			Binary Form: 00001000

The sixth and final bitwise operator we shall be looking at is the binary shift right operator, which uses a two right-angle-bracket character in order to perform the operation. This operator is very similar to the previous operator, but does the inverse of what was previously explained.

The purpose of this operator is to move the digits of the binary string to the right by a given number of bits. The bits that have been vacated by the right shift are filled in with a zero. On the screen, you will see that I have a single integer number being stored in the variable named binaryShiftRightExample1 and it stores the value 32. You will see in the blue box, that I print the integer value to the screen, but I also provide the binary representation for it. For example, the number thirty-two in binary eight-bit form is 00 10 00 00.

Let’s have a look at how the right shift operator works on this example. On the screen, you will see the variable I have just discussed, but below it is a control statement that we discussed earlier. It will increment between the range of one to two.

I will be using the counter-variable, i to shift the digits in binaryShiftRightExample1 by the number it is currently at. Let’s have a look at what is happening. For the first iteration of our loop, the variable i will be at one. Therefore, inside the body of our for loop we shall shift the digits of our binary string right by one. You will see in the blue box that when we do this, our integer number changes from thirty-two to sixteen and this is because our digit one has been moved towards the right by one-bit. Essentially, we added a zero at the beginning of our binary string in order to do this.

Once this shift has been completed, our loop with iterating once more and the variable i will store value two. This time, our shift right operator will add two zeroes to the beginning of our binary string, thus shifting the digit one to the right two times. You might see where this is going, and this time our integer number would be eight.

What do you think will happen if we were to shift our digits to the right by three? Pause. Well, you have probably worked it out, and our integer value will halve once again and become 4. The key takeaway from this is that each time we shift our binary string to the right, a zero is added at the beginning of the binary string, and the value of our integer will decrease accordingly.

Goodbye

Goodbye (1)

Questions and Support

Questions? Post them on the Community Page on Aula
Additional Support? Visit the Module Support Page
Contact Details:
- Dr Ian Cornelius, ab6459@coventry.ac.uk