Arithmetic Operators

Arithmetic expressions in C++ can be evaluated using arithmetic operators such as addition (+), subtraction (-), multiplication (*), division (/), and modulus (%).

Each operator has precedence which determines in which order operators in an expression are evaluated. Operators with lower-precedence numbers has higher precedence and are evaluated before higher precedence numbers. Parentheses have the highest-precedence, so they can be used to override precedence order. Operators with the same precedence number are evaluated from left to right in the order they appear.

Increment and Decrement Operators

Unary operator (one operand) and subtraction is a binary operator (two operands).

If prefix form is used then increment or decrement will be done before the rest of the expression, and if postfix form is used then increment or decrement will be done after the complete expression is evaluated.

Assignment Statements

An assignment statement is used to assign a value to a variable while a program is running.

Syntax:

1. variableName = expression;

• The equal (=) symbol is the assignment operator which tells the computer to evaluate the expression on the right side of the assignment operator and store the result in the variable on the left side of the operator.
• expression can include one or more literal constants, named constants, variables, or arithmetic operators.
• The data type of expression in an assignment statement must match the data type of the variable. If they don’t match, the compiler will use implicit type casting to get them to match. It’s better to explicitly cast to correct data type yourself.

A assignment operator can be abbreviated as well. Statement must be of the form variableName = variableName arithmeticOperator value, which is abbreviated as variableName arithmeticOperator= value . Most common operators are += , -= , *= , /= , and %=. Table 4.6 shows the expression and abbreviations of it.

Table 4.6

Expression	Abbreviated Expression
a = a + b;	a += b;
a = a - b;	a -= b;
a = a * b;	a *= b;
a = a / b;	a /= b;
a = a % b;	a %= b;

Relational Operators

Relational (also called Comparison operators) are used to compare two values that have the same data type. Table 4.7 shows the relational operators used and its meaning.

Relational expressions are evaluated to a numerical value of 1 or 0 only. If the value is 1, the expression is true. If the value is 0, the expression is false. It is adviseable that not to use equality (==) or inequality operator (!=) to compare real numbers. Real numbers cannot be stored exactly, therefore, test that absolute value of their difference is within some small threshold. char values are automatically coerced to int values for comparison purposes. Strings are compared on a character by character basis. The string with the first lower character is considered smaller

Logical Operators

Logical operators allow the combining of two or more conditions (sub-conditions) into one compound condition. Also called Boolean operators and always evaluate to true or false.

The two most common are And (&&) and Or (||). All sub-conditions must be true for a compound condition using And to be true. Only one of the sub-conditions must be true for a compound condition using Or to be true. And is evaluated before Or in an expression.

Logical operators are evaluated after arithmetic and comparison operators. Parentheses can override precedence ordering.

Truth tables summarize how computer evaluates logical operators. Only necessary sub-conditions are evaluated; called short-circuit evaluation . For example: if the first sub-condition in an And clause is false, the second sub-condition need not be evaluated.

Table 4.10

Truth Table for And (&&) Operator
Subcondition1	Subcondition2	Subcondition1 && subcondition2
True	True	True
True	False	False
False	True	False
False	False	False

Table 4.11

Truth Table for Or (||) Operator
Subcondition1	Subcondition2	Subcondition1 && subcondition2
True	True	True
True	False	True
False	True	True
False	False	False

Table 4.12

Truth Table for Or (||) Operator
Subcondition	!Subcondition2
True	False
False	True