More Arithmetic Operators

More Arithmetic Operators

As demonstrates, an executing program can alter a variable’s value by performing some arithmetic on its current value. A variable may increase by one or decrease by five.

increments x by one, making it one bigger than it was before this statement was executed. C++ has a shorter statement that accomplishes the same effect: 

x--; // Same as x = x - 1;
--x; // Same as x = x - 1;
++y; // Same as y = y + 1;

Code Example

#include <iostream>
int main() 
{
    int x1 = 1, y1 = 10, x2 = 100, y2 = 1000;
    std::cout << "x1=" << x1 << ", y1=" << y1 << ", x2=" << x2 << ", y2=" << y2 << '\n';
    y1 = x1++;
    std::cout << "x1=" << x1 << ", y1=" << y1 << ", x2=" << x2 << ", y2=" << y2 << '\n';
    y2 = ++x2;
    std::cout << "x1=" << x1 << ", y1=" << y1 << ", x2=" << x2 << ", y2=" << y2 << '\n';

}
//Output
x1=1, y1=10, x2=100, y2=1000
x1=2, y1=1, x2=100, y2=1000
x1=2, y1=1, x2=101, y2=101

If x1 has the value 1 just before the statement y1 = x1++; then immediately after the statement executes x1 is 2 and y1 is 1. If x1 has the value 1 just before the statement y1 = ++x1; then immediately after the statement executes x1 is 2 and y1 is also 2.

As you can see, the pre-increment operator uses the new value of the incremented variable when evaluating the overall expression. In contrast, the post-increment operator uses the original value of the incremented variable when evaluating the overall expression. The pre- and post-decrement operator behaves similarly.

For beginning programmers it is best to avoid using the increment and decrement operators within more complex expressions.

For example, the statement x = x + 5;

can be shorted to x += 5; This statement means “increase x by five.” Any statement of the form

The bit positions of a 32-bit C++ unsigned integer
The bit positions of a 32-bit C++ unsigned integer

Bitwise Operators

These special operators allow programmers to examine or manipulate the individual bits that make up data values. They are known as the bitwise operators. These operators consist of &, |, ^, ∼ , >>, and <<.

The bitwise and operator, &, takes two integer subexpressions and computes an integer result.

  • If bit 0 in both e1 and e2 is 1, then bit 0 in the result is 1; otherwise, bit 0 in the result is 0.
  • If bit 1 in both e1 and e2 is 1, then bit 1 in the result is 1; otherwise, bit 1 in the result is 0.
  • If bit 2 in both e1 and e2 is 1, then bit 2 in the result is 1; otherwise, bit 2 in the result is 0
  • If bit 31 in both e1 and e2 is 1, then bit 31 in the result is 1; otherwise, bit 31 in the result is 0.

For example, the expression 13 & 14 evaluates to 12, since: Bitwise AND

  • 13base(10) = 000000000000000000000000000011012
  • &
  • 14base(10) = 000000000000000000000000000011102
  • 12base(10) = 000000000000000000000000000011002

For example, the expression 13 | 14 evaluates to 15, since: Bitwise OR

  • 13base(10) = 000000000000000000000000000011012
  • |
  • 14base(10) = 000000000000000000000000000011102
  • 15base(10) = 000000000000000000000000000011112

For example, the expression 13 ^ 14 evaluates to 3, since: Bitwise XOR

  • 13base(10) = 000000000000000000000000000011012
  • ˆ
  • 14base(10) = 000000000000000000000000000011102
  • 3base(10) = 000000000000000000000000000000112

For example, the unsigned expression ∼ 13u evaluates to 4,294,967,282, since: Bitwise NOT

  • 1310 = 000000000000000000000000000011012 negate ↓
  • ~
  • −1410 = 111111111111111111111111111100102 
#include <iostream>
int main() {
    int x, y;
    std::cout << "Please enter two integers: ";
    std::cin >> x >> y;
    std::cout << x << " & " << y << " = " << (x & y) << '\n';
    std::cout << x << " | " << y << " = " << (x | y) << '\n';
    std::cout << x << " ^ " << y << " = " << (x ^ y) << '\n';
    std::cout << "∼" << x << " = " << ∼x << '\n';
    std::cout << x << " << " << 2 << " = " << (x << 2) << '\n';
    std::cout << x << " >> " << 2 << " = " << (x >> 2) << '\n';
}

The shift operators move all the bits in an integer to the left or right:

  • Shift left (<<). The expression x << y, where x and y are integer types, shifts all the bits in x to the left y places. Zeros fill vacated positions. The expression 5 << 2 evaluates to 20, since 510 = 1012 shifted two places to the left yields 101002 = 2010. Observe that x << y is equal to x×2 y .

Shift right (>>). The expression x >> y, where x and y are integer types, shifts all the bits in x to the right y places. What fills the vacated bits on the left depends on whether the integer is signed or unsigned (for example, int vs. unsigned):

Related Posts