The following hi(overloadable operators) operators can be overloaded:
        verb(
    +       -       *       /       %       ^       &       |
    ~       !       ,       =       <       >       <=      >=
    ++      --      <<      >>      ==      !=      &&      ||
    +=      -=      *=      /=      %=      ^=      &=      |=
    <<=     >>=     []      ()      ->      ->*     new     new[]
    delete  delete[]
        )
    Several operators have em(textual alternatives):

    center(
    attrib(style="margin-left:auto;margin-right:auto;")
        hi(operators: textual alternatives)
    tableatt(2)(cl)(
    rowline()
    row(cell(textual alternative)               cell(operator))
    rowline()
    row(cell(  ti(and)hi(operator and))       cell(tt( && )))
    row(cell(  ti(and_eq)hi(operator and_eq)) cell(tt( &= )))
    row(cell(  ti(bitand)hi(operator bitand)) cell(tt( &  )))
    row(cell(  ti(bitor)hi(operator bitor))   cell(tt( |  )))
    row(cell(  ti(compl)hi(operator compl))   cell(tt( ~  )))
    row(cell(  ti(not)hi(operator not))       cell(tt( !  )))
    row(cell(  ti(not_eq)hi(operator not_eq)) cell(tt( != )))
    row(cell(  ti(or)hi(operator or))         cell(tt( || )))
    row(cell(  ti(or_eq)hi(operator or_eq))   cell(tt( |= )))
    row(cell(  ti(xor)hi(operator xor))       cell(tt( ^  )))
    row(cell(  ti(xor_eq)hi(operator xor_eq)) cell(tt( ^= )))
    rowline()
    )
    )

    `Textual' alternatives of operators are also overloadable (e.g.,
tt(operator and)). However, note that textual alternatives are not
em(additional) operators. So, within the same context tt(operator&&) and
tt(operator and) can not em(both) be overloaded.

    Several of these operators may only be overloaded as member functions
    hi(operator overloading: within classes only) em(within) a class. This
holds true for the tt('='), the tt('[]'), the tt('()') and the tt('->')
operators. Consequently, it isn't possible to redefine, e.g., the assignment
operator globally in such a way that it accepts a tt(char const *) as an
tt(lvalue) and a tt(String &) as an em(rvalue). Fortunately, that isn't
necessary either, as we have seen in section ref(ConversionOperators).

    Finally, the following operators cannot be  overloaded:
        verb(
    .       .*      ::      ?:      sizeof  typeid
        )
