C++ Notes: Expressions

Parentheses () have three uses:

Grouping to control order of evaluation, or for clarity.
Eg, (a + b) * (c - d)
After a function name to enclose parameters. Eg, x = sum(a, b);
Around a type name to form a cast. Eg, i = (int)x;

Order of evaluation

Higher precedence are done before lower precedence.
Left to right among equal precedence except: unary, assignment, conditional operators.

Abbreviations
i, j - integer (char, short, int, long) values.
m, n - numeric values (integers, floating-point).
b, c - int expr: 0=true, non-zero=false; x, y - any type.
s, t - string; a - array; p - pointer; f - field.

Operator Precedence

::
. [] -> (args) post ++ --
   type_id dynamic_cast static_cast
   cont_cast reinterpret_cast
unary + - * & pre ++ --
   ! ~ (type) new sizeof delete
->* .*
* / %
+ -
<< >>
< <= > >=
== !=
&
^
|
&&
||
?:
= += -= etc
throw
,

Remember only

unary operators
* / %
+ -
comparisons
&& ||
= assignments

Use () for all others

Arithmetic Operators
The result of arithmetic operators is double if either operand is double, else float if either operand is float, else long if either operand is long, else int.
++i	Add 1 to i before using the value.
--i	As above for subtraction
i++	Add 1 to i after using the value.
i--	As above for subtraction
n + m	Addition. Eg 7+5 is 12, 3 + 0.14 is 3.14
n - m	Subtraction
n * m	Multiplication. Eg 3 * 6 is 18
n / m	Division. Eg 3.0 / 2 is 1.5 , 3 / 2 is 1
n % m	Remainder (Mod) after dividing n by m. Eg 7 % 3 is 1
Comparison Operators
The result of all comparisons is 0 (false) or non-zero (true).
< <= == != > >=
Logical Operators
Logical values are zero (false) and non-zero (true).
b && c	Conditional "and". true if both operands are true, otherwise false. Short circuit evaluation. Eg (false && anything) is false.
b \|\| c	Conditional "or". true if either operand is true, otherwise false. Short circuit evaluation. Eg (true \|\| anything) is true.
!b	true if b is false, false if b is true.
Conditional Operator
b?x:y	if b is true, the value is x, else y. x and y must be the same type.
Assignment Operators
=	Left-hand-side must be an lvalue.
+= -= *= ...	All binary operators (except && and \|\|) can be combined with assignment. Eg a += 1 is the same as a = a + 1

Bitwise Operators
Bitwise operators operate on bits of ints. Result is int.
i & j	Bits are "anded" - 1 if both bits are 1
i \| j	Bits are "ored" - 1 if either bit is 1
i ^ j	Bits are "xored" - 1 if bits are different
~i	Bits are complemented (0 -> 1, 1 -> 0)
i << j	Bits in i are shifted j bits to the left, zeros inserted on right.
i >> j	Bits in i are shifted j bits to the right. On left 0 bits inserted for unsigned, sign bits for signed.
I/O Operators
There are two operators defined in <iostream>.
cout << x	Output "insertion" operator.
cin >> x	Input "extraction" operator.
Reference Operators
a[i]	Array element access.
s.f	Member. The f field or method of struct/class s.
p->f	Member. The f field or method of struct/class pointer p.
&x	Address of x.
*p	Dereference pointer p.
.*	Dereference pointer to class memeber.
->*	Dereference pointer to pointer to class memeber.
std::cout	Scope resolution operator.
Misc Operators
s + t	String concatenation.
sizeof x	Memory size of x in bytes. Usually written as function.
Casts
Use casts to make type conversion clear, and especially when "narrowing" range of a value. There are two forms. Use the function form only with simple type names. Here x is a value and t is a type.
t(x)	Casts x to type t. Eg i = int(f);
(t)x	Casts x to type t. Eg us = (unsigned short)i;