C++ Operators

Course List http://www.c-jump.com/bcc/

C++ Operators

Arithmetic Operators
Integer Division
Modulus Operator
Relational Operators
More Relational Operators
Operator Associativity
Arithmetic If
Assignment Operators
Increment and Decrement Operators
Logical AND, logical OR operators
Logical operators short-circuiting

1. Arithmetic Operators

(x + 7) addition
(a - b) subtraction
(x * y) multiplication
(x / y) division
(r % s) modulus

2. Integer Division

Yields integer quotient
Integer numerator and denominator
No rounding occurs

Examples:

(7 / 4) equals to 1
(17 / 5) equals to 3


int main() 
{
    int x = (7 / 4);  // x == 1
    int y = (17 / 5); // y == 3
    return 0;
}

3. Modulus Operator

Yields remainder after integer division
Integer operands only
No rounding occurs

Examples:

(7 % 4) equals to 3
(17 % 5) equals to 2


int main() 
{
    int x = (7 % 4);  // x == 3
    int y = (17 % 5); // y == 2
    return 0;
}

4. Relational Operators

Decision making:
- (x > y) is x greater than y?
- (x < y) is x less than y?
- (x >= y) is x greater than or equal to y?
- (x <= y) is x less than or equal to y?

5. More Relational Operators

Decision making:
- (x == y) is x equal to y?
- (x != y) is x not equal to y?
Compare to:
- !(x == y) isn't x equal to y?
Note: avoid confusion between equality (==) and assignment (=).

6. Operator Associativity

Immutable property of all C++ operators
There are two types of associativity,
1. right-to-left associativity:
  - assignment operator:
    - a = b = c is interpreted as a = ( b = c )
  - unary operators:
    - !!b is interpreted as !( !b )
2. left-to-right associativity:
  - arithmetic and other binary operators:
    - a + b + c is interpreted as ( a + b ) + c

7. Arithmetic If

Decision making

    (condition) ? expression_true : expression_false

For example,


int main() 
{
    int x = 5;
    int y = 8;
    int z = ( x > y ) ? x : y; // select max value
    return 0;
}

8. Assignment Operators

Assign values to variables:


int main() 
{
    int x;
    int y;
    int z;

    x = 1; 
    y = x; 
    x += y;  // x = x + y; 
    z *= 3;  // z = z * 3; 
    return 0;
}

The last two operators,
- += and *=
are known as arithmetic assignment operators. They are pronounced as "add and assign," "multiply and assign ," respectively.

9. Increment and Decrement Operators

Shortcuts to add or subtract 1:


    ++i; // add one to i 
    --j; // subtract one from j

Related topics:
- (++) and (--) are unary operators
- side effects
- always used with modifiable values


int main()
{
    int i = 0;
    int k = (i + 1); // No side effects
    int k = ++i; // Side effect: i incremented
    return 0;
}

Logical AND, logical OR operators

The logical AND && operator returns 1 if both exp1 and exp2 are non-zero:


        if ( exp1 && exp2 ) {
            //...
        }

#include <cassert>
void main()
{
    int x = 1;
    int y = 2;
    // true: y > x
    // true: x > 0
    if ( y > x && x > 0 ) {
        assert( y > x );
        assert( x > 0 );
    }
}

The logical OR || operator returns 1 if either exp1, or exp2, or both are non-zero:


        if ( exp1 || exp2 ) {
            //...
        }

void main()
{
    int x = 1;
    int y = 2;
    if ( x == 1 || y == 2 ) {
        //...
    }
}

Logical operators short-circuiting

Expressions connected by && or || are evaluated left to right.

Evaluation stops as soon as the truth or falsehood of the result is known. This feature is known as short-circuiting.


void main()
{
    int x = 1;
    int y = 2;
    if ( x == y && y > 0 ) {
        // execution nevert gets here...
    }
    // expr y > 0 never evaluated!
    if ( x == 1 || y == 2 ) {
        // expr y == 2 never evaluated!
        // ...
    }
}