Go to the previous, next section.
Operators must be defined on values of specific types. For instance,
+
is defined on numbers, but not on structures. Operators are
often defined on groups of types.
For the purposes of C and C++, the following definitions hold:

Integral types include
int
with any of its storageclass
specifiers; char
; and enum
.

Floatingpoint types include
float
and double
.

Pointer types include all types defined as
(type
*)
.

Scalar types include all of the above.
The following operators are supported. They are listed here
in order of increasing precedence:
,
 The comma or sequencing operator. Expressions in a commaseparated list
are evaluated from left to right, with the result of the entire
expression being the last expression evaluated.
=
 Assignment. The value of an assignment expression is the value
assigned. Defined on scalar types.
op=
 Used in an expression of the form
a op= b
,
and translated to a = a op b
.
op=
and =
have the same precendence.
op is any one of the operators 
, ^
, &
,
<<
, >>
, +
, 
, *
, /
, %
.
?:
 The ternary operator.
a ? b : c
can be thought
of as: if a then b else c. a should be of an
integral type.

 Logical OR. Defined on integral types.
&&
 Logical AND. Defined on integral types.

 Bitwise OR. Defined on integral types.
^
 Bitwise exclusiveOR. Defined on integral types.
&
 Bitwise AND. Defined on integral types.
==, !=
 Equality and inequality. Defined on scalar types. The value of these
expressions is 0 for false and nonzero for true.
<, >, <=, >=
 Less than, greater than, less than or equal, greater than or equal.
Defined on scalar types. The value of these expressions is 0 for false
and nonzero for true.
<<, >>
 left shift, and right shift. Defined on integral types.
@
 The GDB "artificial array" operator (see section Expressions).
+, 
 Addition and subtraction. Defined on integral types, floatingpoint types and
pointer types.
*, /, %
 Multiplication, division, and modulus. Multiplication and division are
defined on integral and floatingpoint types. Modulus is defined on
integral types.
++, 
 Increment and decrement. When appearing before a variable, the
operation is performed before the variable is used in an expression;
when appearing after it, the variable's value is used before the
operation takes place.
*
 Pointer dereferencing. Defined on pointer types. Same precedence as
++
.
&
 Address operator. Defined on variables. Same precedence as
++
.
For debugging C++, GDB implements a use of `&' beyond what is
allowed in the C++ language itself: you can use `&(&ref)'
(or, if you prefer, simply `&&ref') to examine the address
where a C++ reference variable (declared with `&ref') is
stored.

 Negative. Defined on integral and floatingpoint types. Same
precedence as
++
.
!
 Logical negation. Defined on integral types. Same precedence as
++
.
~
 Bitwise complement operator. Defined on integral types. Same precedence as
++
.
., >
 Structure member, and pointertostructure member. For convenience,
GDB regards the two as equivalent, choosing whether to dereference a
pointer based on the stored type information.
Defined on
struct
and union
data.
[]
 Array indexing.
a[i]
is defined as
*(a+i)
. Same precedence as >
.
()
 Function parameter list. Same precedence as
>
.
::
 C++ scope resolution operator. Defined on
struct
, union
, and class
types.
::
 Doubled colons
also
represent the GDB scope operator (see section Expressions).
Same precedence as
::
, above.
Go to the previous, next section.