Intermediate Operations

~Value

Operand1 & Operand2

#include <iostream>
using namespace std;

main()
{
const int N1 = 187;
const int N2 = 242;

cout << N1 << " & " << N2 << " = " << (N1 & N2) << "\n\n";

return 0;
}

Comparing Bits: The Bitwise OR Operator |

You can perform another type of comparison on bits using the bitwise OR operator that is represented by |. Its syntax is:

Value1 | Value2

Once again, the compiler compares the corresponding bits of each operand. If at least one of the equivalent bits is 1, the comparison produces 1. The comparison produces 0 only if both bits are 0. This operation is resumed as follows:

Once again, let’s consider decimals 187 and 242. Their bitwise OR comparison would render the following result:

You can also let the compiler perform the operation and produce a result. Here is an example:

Comparing Bits: The Bitwise-Exclusive XOR Operator ^

Like the previous two operators, the bitwise-exclusive OR operator performs a bit comparison of two values. It syntax is:

Value1 ^ Value2

The compiler compares the bit of one value to the corresponding bit of the other value. If one of the bits is 0 and the other is 1, the comparison produces 1. In the other two cases, that is, if both bits have the same value, the comparison produces 0. This operation is resumed as follows:

We will again consider decimals 187 and 242. Their bitwise-exclusive XOR comparison would render the following result:

If the compiler performs this operation, it can produce a result as in the following example:

#include <iostream>
using namespace std;

main()
{
	const int N1 = 187;
	const int N2 = 242;

	cout << N1 << " ^ " << N2 << " = " << (N1 ^ N2) << "\n\n";
}

This would produce:

Bit Shift Operators: The Left Shift <<

In the previous lesson, we learned that bits are aligned in some consecutive manner to store data as needed. One operation you can perform on such bits consists of moving bits in a direction of your choice.

C++ provides the left shift operator represented with << and its syntax is:

Value << ConstantInteger

The left shift operator, <<, is a binary operator whose right operand must be a constant integer. When performing the operation, the compiler would “push” Value’s bits to the left by the number of ConstantInteger. The number of ConstantInteger bits on the left side of Value would disappear. The bits on the left side of Value would replace them. After moving to the left, the space left by the most right bits would be filled with 0 bits.

Imagine you have a variable named Value and whose value is 42. The binary value of 42 is 0010 1010 (you are probably asking, "Why the hell do I need to know this?" and my answer is, "I have no idea" but you ain't got no choice; ain't no one else gonna learn this stuff for you). Imagine you want to shift Value to the left by 2 bits. You would proceed as follows:

The resulting binary number is 1010 1000 and its decimal value is  1*2⁷ + 0*2⁶ + 1*2⁵ + 0*2⁴ + 1*2³ + 0*2² + 0*2¹ + 0*2⁰ = 1*128 + 0*64 + 1*32 + 0*16 + 1*8 + 0*4 + 0*2 + 0*1 = 128 + 0 + 32 + 0 + 8 + 0 + 0 + 0 = 128 + 32 + 8 = 168

This can also be illustrated in the following program:

#include <iostream>
using namespace std;

main()
{
	const int Value = 42;

	cout << Value << " << 2 = " << (Value << 2) << "\n\n";
}

Bit Shift Operators: The Right Shift >>

As opposed to the left operator, the right shift moves bits to the right by a natural number. Everything is done as for the left shift except that the concept is applied to the opposed direction.

Therefore, if you shift 42 to the right, the binary result would be 0000 1010, whose decimal value is 10.

Inline Assembly

Introduction

All the variables that we have used so far were declared in, and passed to, the random memory (RAM). Once a variable is declared and “put” in the memory, whenever it is involved in a calculation or assignment, the microprocessor sends a request to the memory to retrieve the value of the variable.

The Central Processing Unit (CPU), also called the microprocessor, has its own memory. The microprocessor is made of memory cells called registers. Unlike the memory in the RAM, the access of the memory in the microprocessor is more precise; so precise that the registers are referred to by using their names. Some of the most commonly used registers (also called general purpose registers) are called EAX, EBX, ECX, EDX, ESI, etc. These registers are mostly used in the Assembly Language for low-level programming.

Most modern compilers allow you to include Assembly Language code in your program. Using this feature, you can write a section or sections of Assembly language. When Assembly is included in your C++ program, it is referred to as Inline Assembly.

Passing Values to Registers

Using registers allows the programmer to write assignments directly destined for the microprocessor. The assignments and operations in the Assembly language are called instructions. When instructions are used by registers, the processing of the program is fast because the microprocessor does not have to retrieve the values of the variables in the RAM; these values, since existing in the registers, are readily available.

A section that has Assembly code starts with __asm followed by some other techniques. When the compiler encounters this keyword, it knows that the subsequent code would be in Assembly language and it would treat it accordingly. For example, instead of performing a calculation in the RAM, the following program will assign values to two integer variables, namely Number1 and Number2, then it calculate their sum of those two numbers and stores the result in another variable called Result. After the calculation, the Assembly section sends the result back to the C++ compiler to display the variables and their values:

#ifdef __BORLANDC__

  #pragma argsused

#endif



#include <iostream>

using namespace std;



int main( int argc, char * argv[] )

{

    int Number1, Number2, Result;



    __asm

    {

        MOV Number1, 248 // Initialize Number1

        MOV Number2, 405 // Initialize Number2

        MOV EAX, Number1 // Put the value of Number1 in the EAX register

        ADD EAX, Number2 // Add the value of Number2 to the content of EAX

        MOV Result, EAX  // Put the content of EAX into Result

    }                    // That's it



    cout << "Number1 = " << Number1 << endl;

    cout << "Number2 = " << Number2 << endl;

    cout << "\nAfter adding Number1 to Number2," << endl;

    cout << "Result  = " << Result << endl;



    return 0;

}

umber1 = 248

Number2 = 405



After adding Number1 to Number2,

Result  = 653