OpenEuphoria

Table of C and C++ operators, suitable for framing (he he)

• Posted by Al Getz <Xaxo at aol.com> Apr 16, 2001
• 452 views

Since there have been quite a few questions regarding C and C++
operators in the past, i decided to compile a list.
Here it is.
--Al

-------------------------------------------------------------


C Operators  (C++ operators follow)

There are three types of operators.
A unary expression consists of either a unary operator
prepended to an operand, or the sizeof keyword followed
by an expression. The expression can be either the name
of a variable or a cast expression. If the expression
is a cast expression, it must be enclosed in parentheses.
A binary expression consists of two operands joined by a
binary operator. A ternary expression consists of three
operands joined by the conditional-expression operator.

C includes the following unary operators:


– ~ !    Negation and complement operators

* &      Indirection and address-of operators

sizeof   Size operator

+        Unary plus operator

++ ––    Unary increment and decrement operators


Binary operators associate from left to right.
  C provides the following binary operators:


* / %    Multiplicative operators

+ –      Additive operators

<< >>    Shift operators

< > <= >= == !=    Relational operators

& | ^    Bitwise operators

&& ||    Logical operators

,        Sequential-evaluation operator



The conditional-expression operator has lower precedence
than binary expressions and differs from them in being
right associative. 

Expressions with operators also include assignment expressions,
which use unary or binary assignment operators. The unary
assignment operators are the increment (++) and
decrement (––) operators; the binary assignment
operators are the simple-assignment operator (=)
and the compound-assignment operators. Each
compound-assignment operator is a combination
of another binary operator with the simple-assignment 





C++ Operators

Operators specify an evaluation to be performed
on one of the following:

One operand (unary operator)
Two operands (binary operator)
Three operands (ternary operator) 
The C++ language includes all C operators and
adds several new operators. There might be
other special operators available
in your C++ version.  It's also possible that
your particular version doesnt have some of
these operators.


C++ Operator Precedence and Associativity

Operators follow a strict precedence which defines the
evaluation order of expressions containing these
operators. Operators associate with either the
expression on their left or the expression on
their right; this is called "associativity".
Operators in the same group have equal precedence
and are evaluated left to right in an expression
unless explicitly forced by a pair of parentheses, ( ).
This shows the precedence and associativity of C++
operators (from highest to lowest precedence). 

 
Operator   Name or Meaning, Associativity

::      Scope resolution, None

::      Global, None

[ ]     Array subscript, Left to right

( )     Function call, Left to right

( )     Conversion, None

.      Member selection (object), Left to right

–>     Member selection (pointer), Left to right

++     Postfix increment, None

––     Postfix decrement, None

new     Allocate object, None

delete     Deallocate object, None

delete[ ]    Deallocate object, None

++    Prefix increment, None

––    Prefix decrement, None

*    Dereference, None

&    Address-of, None

+    Unary plus, None

–    Arithmetic negation (unary), None

!    Logical NOT, None

~    Bitwise complement, None

sizeof     Size of object, None

sizeof ( )    Size of type, None

typeid( )  type name, None

(type)        Type cast (conversion), Right to left

const_cast    Type cast (conversion), None

dynamic_cast  Type cast (conversion), None

reinterpret_cast   Type cast (conversion), None

static_cast   Type cast (conversion), None

.*     Apply pointer to class member (objects), Left to right

–>*    Dereference pointer to class member, Left to right

*     Multiplication, Left to right

/     Division, Left to right

%     Remainder (modulus), Left to right

+     Addition, Left to right

–     Subtraction, Left to right

<<    Left shift, Left to right

>>    Right shift, Left to right

<    Less than, Left to right

>    Greater than, Left to right

<=    Less than or equal to, Left to right

>=    Greater than or equal to, Left to right

==    Equality, Left to right

!=    Inequality, Left to right

&     Bitwise AND, Left to right

^     Bitwise exclusive OR, Left to right

|     Bitwise OR, Left to right

&&    Logical AND, Left to right

||    Logical OR, Left to right

e1?e2:e3    Conditional, Right to left

=    Assignment, Right to left

*=    Multiplication assignment, Right to left

/=    Division assignment, Right to left

%=    Modulus assignment, Right to left

+=    Addition assignment, Right to left

–=    Subtraction assignment, Right to left

<<=    Left-shift assignment, Right to left

>>=    Right-shift assignment, Right to left

&=    Bitwise AND assignment, Right to left

|=    Bitwise inclusive OR assignment, Right to left

^=    Bitwise exclusive OR assignment, Right to left

,    Comma, Left to right