Next: C Constants, Up: C

##### 15.4.1.1 C and C`++` Operators

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 storage-class specifiers; `char`; `enum`; and, for C`++`, `bool`.
- Floating-point types include `float`, `double`, and `long double` (if supported by the target platform).
- 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 comma-separated 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 precedence. The operator op is any one of the operators `|`, `^`, `&`, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`.
`?:`
  The ternary operator. a`?` b`:` c can be thought of as: if a then b else c. The argument 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 exclusive-or. 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 non-zero 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 non-zero for true.
`<<`, `>>`
  left shift, and right shift. Defined on integral types.
`@`
  The gdb “artificial array” operator (see Expressions).
`+`, `-`
  Addition and subtraction. Defined on integral types, floating-point types and pointer types.
`*`, `/`, `%`
  Multiplication, division, and modulus. Multiplication and division are defined on integral and floating-point 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)`’ to examine the address where a C`++` reference variable (declared with ‘`&ref`’) is stored.

`-`
  Negative. Defined on integral and floating-point 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 pointer-to-structure 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.
`.*`, `->*`
  Dereferences of pointers to members.
`[]`
  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 Expressions). Same precedence as `::`, above.

If an operator is redefined in the user code, gdb usually attempts to invoke the redefined version instead of using the operator's predefined meaning.