These are the operators in order of precedence, with the first section having the highest precedence. All the operators in a single section have the same precedence.
Unary operators are the only operators taking a single operand, all other operators are binary operators with two operands.
!: Bitwise complement.
+: Unary plus. This has no effect on its numeric operand.
-: Unary minus. Negates its numeric operand.
&: Reducing and. Performs the logic and of all the bits in the operand. The result is false if and only if the operand has at least one false bit.
|: Reducing or. Performs the logic or of all the bits in the operand. The result is true if and only if the operand has at least one true bit.
^: Reducing xor. Performs the logic exclusive or of all the bits in the operand. The result is false when the operand has an even number of true bits, and true when the operand has an odd number of true bits.
as: Converts the left-hand-side operand (LHS) to the type specified in the right-hand side (RHS).
**: Raises the LHS to the power of the RHS.
Multiplication and division operators
/: Division. Dividing two unsized integers yields a rational number. Dividing a sized integer truncates the result towards zero.
%: Remainer. The remainder from the division by
/, such that if
d = a / band
r = a % b, then
a == b * d + r. Since
/rounds towards zero, the sign of
ris the same as the sign of
These opertions have left-to-right associativity, that is,
a / b * c == (a / b) * c.
<<: Left shift. For unsized integers, rational numbers and floating-point numbers,
a << bis equivalent to
amultiplied by two raised to the power of
>>: Right shift. For unsigned numbers this is a logical shift, that is, the bits inserted from the left side are zeros. For signed numbers this is an arithmetic shift, that is, the bits inserted from the left side are the same as the sign bit.
The shift operators can take a negative RHS, such that
a << b == a >> -b.
Bitwise logic and concatenation operators
&: Bitwise and.
|: Bitwise or.
^: Bitwise xor.
!&: Bitwise nand.
!|: Bitwise nor.
!^: Bitwise xnor.
The bitwise logic and concatenation operators all have the same
precedence, but mixing them is not allowed, you need to use brackets
to mix logic operators. The expressions
a & b & c and
a ~ b ~ c
are valid, but the expression
a & b | c is not valid, it must be
written as either
(a & b) | c or
a & (b | c).
Unlike arithmetic operations such as addition, relational operators
can have one
signed operand and one
unsigned operand, and the
result will be logically correct. The size of the operands can also be
mixed. Comparing a value of type
unsigned(6) and a value of type
signed(4) is equivalent to first converting both of them to
signed(7), which can hold both values exactly, and then comparing
the converted values.
==: True if LHS is equal to RHS.
!=: True if LHS is not equal to RHS.
<: True if LHS is less than to RHS.
<=: True if LHS is less than or equal to to RHS.
>: True if LHS is greater than to RHS.
>=: True if LHS is greater than or equal to RHS.
Relational operators can be chained such that, for example, writing
a <= b <= c is equivalent to writing
(a <= b) and (b <= c). The
operators do not need to be the same, although the expression
a <= b > c, which is equivalent to
(a <= b) and (b > c), does not
look as natural as the previous example.