Operators

The chapters befor deals with variables and constants and now we use them with operators. It is not necessary to know all of them but they are all listed as reference book.

Assignment operator (=)

The assignment operator assigns a value to a variable.

Always are assigned Values from right to left to the variable with the assignment operator.

In this example the value of variable x is assigned to value of y. By doin this has the variable x the same value as y.

Consider also that we are only assigning the value of y to x at the moment of the assignment operation. Therefore, if y changes at a later moment, it will not affect the new value taken by x.

Example:

This program prints on screen the final values of x and y (4 and 5, respectively). Notice how a was not affected by the final modification of y, even though we declared x = y earlier.

Assignment operations are expressions that means that an expression can be made of several operations or combined with other assignment operations.

In this expression, y is assigned the result of 6 subtract from 3 and the value of another assignment expression which has itself a value of 3. It is the same as:

The result is the assignment of integer value 3 of variable y.

The next example is also valid in C++.

It assigns 2 to the all three variables: x, y and z; always from right-to-left.

Arithmetic operators ( +, -, *, /, % )

In C++ are five arithmetic operators supported as following.

The operators at the above table like addition, subtraction, multiplication and division correspond literally to their respective mathematical operators. The modulo operator (%) is the division of two natural numbers with remainder.

In the variable x assigning the value 1, since dividing 5 by 2 results in 2, with remainder of 1.

Compound assignment (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

A compound assignment operator assigning the current value of a variable by performing an operation on it. That is the same like a result of an operation which is assigned to a variable.

Example:

Increment and decrement (++, --)

The increase operator (++) increment a stored value by one and the decrease operator (--) reduce a stored value by one. They are equivalent to +=1 and to -=1, respectively.

These three expressions are all equivalent in its functionality.

This three expressions may have produced different executable code in the early C compilers depending on which one was used. Nowadays through code optimizing by the compiler should produce the three expressions exactly the same executable code.

It exists a pecularity of this operators they can used as a prefix and as a suffix. That means that it can be written as ++x or as x++ to example. Both variances do the same thus increased a value by one but with an important difference, because the prefix type increased an expression to final and the suffix type increased the value that x had befor being increased by one. In a loop a suffix type increased after an iteration.

In this Example, the value assigned to y is the value of x after being increased.

While in this Example, it is the value x assigned to y before being increased.

Relational and comparison operators (==, !=, >, <, >=, <=)

Two expressions can be compared using relational and equality operators. For example, to know if two values are equal or if one is greater than the other.

The result of such a settlement is either true or false.

Relational Operators:

It can be compared numeric constants, mathematician expressions, variables and expressions with assignment operations like ((a = 3) == b).

Attention the comparision operator (==) is not equal to the assignment operator (=), because the assignment operator assign a value to its left variable (x = 1) and comparision operator check of equality.

Logical operators (!, &&, ||)

The operator ! is the C++ operator for the Boolean operation NOT. It has only one operand, to its right, and inverts it, producing false if its operand is true, and true if its operand is false. Basically, it returns the opposite Boolean value of evaluating its operand.

The logical operators && and || are used when evaluating two expressions to obtain a single relational result.

The operator && corresponds to the Boolean logical operation AND, which yields true if both its operands are true, and false otherwise.

Truth Table:

The operator || represents the Boolean logical term OR, which yields true if either of its operands is true, thus being false only when both operands are false.

Truth Table:

When using the logical operators, C++ only evaluates what is necessary from left to right to come up with the combined relational result, ignoring the rest. Therefore, in the last example ((2 == 2) || (7 < 4)), C++ evaluates first whether 2 = 2 is true, and if so, it never checks whether 7 < 4 is true or not. This is known as short-circuit evaluation.

This is mostly important when the right-hand expression has side effects, such as altering values:

Here, the combined conditional expression would increase i by one, but only if the condition on the left of && is true, because otherwise, the condition on the right-hand side (++i < n) is never evaluated.

Conditional ternary operator (?)

The conditional operator returning a value if the expression evaluates to true and a different one if it evaluates to false.

If condition is true, the entire expression evaluates to result1, and otherwise to result2.

Example:

Comma operator (,)

The comma operator (,) is used to separate two or more expressions that are included where only one expression is expected. When the set of expressions has to be evaluated for a value, only the right-most expression is considered.

In this example assigned the value 5 to y first, and then assigned y - 2 to variable x. So, at the end, variable x would contain the value 3 while variable y would contain value 5.

Bitwise operators (&, |, ^, ~, <<, >>)

Bitwise operators modify variables considering the bit patterns that represent the values they store.

Explicit type casting operator

Type casting operators allow to convert a value of a given type to another type. It exist several ways to convert a type to another in C++ but the simplest is to precede the new type enclosed in round parentheses.

The data type of type floating-point with the value 3.14159 is converted to type int and all of the remainder is lost. The notation as follows is possible too.

Both notation of casting types are valid in C++.

sizeof

This operator accepts one parameter, which can be either a type or a variable, and returns the size in bytes of that type or object.

Here, x is assigned the value 1, because char is a type with a size of one byte.

The value returned by sizeof is a compile-time constant, so it is always determined before program execution.

Operator precedence

A single expression may have multiple operators.

In this expression assigned 6 to variable x, because the operator % has a higher precedence as the operator + and it assigned 5 % 2 with remainder 1 and at last it assigned 5 + 1 to variable x. Parts of an expression can be enclosed in parenthesis to override this precedence order.

Table of C++ operators from greatest to smallest priority: