##### 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.`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 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.