Answer.

Background:

In the C++ language, expressions and operators are fundamental building blocks that originated in C. C++ supports a wide range of operators from various categories: arithmetic, logical, bitwise, comparison, assignment, as well as the ternary and comma operators. With the development of the language, operators became available for overloading, which expands the possibilities of writing expressive and concise code.

Problem:

Correctly composing expressions and understanding the order of their execution often poses challenges for developers, especially in complex expressions with multiple priorities and operator associativity. Mistakes can lead to changes in the meaning of calculations, unintended side effects, or even undefined behavior.

Solution:

For the reliable operation of the program, it is important to have a good understanding of operator priorities, their associativity, and types (unary, binary, ternary, left/right). In most cases, it is recommended to explicitly group operations with parentheses and not to abuse complex expressions. For user-defined types, operator overloading is allowed, taking into account the principle of minimally and obviously necessary logic.

Code example:

#include <iostream>
class Point {
public:
    int x, y;
    Point(int x, int y) : x(x), y(y) {}
    Point operator+(const Point& other) const {
        return Point(x + other.x, y + other.y);
    }
};

int main() {
    Point a(1, 2), b(3, 4);
    Point c = a + b;
    std::cout << c.x << ", " << c.y << std::endl; // 4, 6
    int d = 1 + 2 * 3; // 7, not 9!
    return 0;
}

Key features:

Operator priority and associativity.
Overloading operators for user-defined types.
The influence of operand types on the result of the expression evaluation.

Tricky questions.

Can the comma operator be overloaded? If so, when might it be useful?

Yes, the comma operator can be overloaded, but it is rarely used because it almost always reduces code readability. An example of overloading can be found in some specific containers for implementing method chaining.

What is the result of the expression 1 + 2 << 3? Why?

The expression is evaluated as follows: first, 2 << 3 (bitwise left shift, result 16), then 1 + 16 (total 17), since << has a lower priority than addition.

int result = 1 + 2 << 3; // result: 17, not 24!

How does the type of expression (signed/unsigned) affect the result in comparison, for example, -1 < 1u?

When comparing signed and unsigned values, the signed value is converted to unsigned, and -1 becomes a very large positive number, so the comparison result will be false.

std::cout << (-1 < 1u) << std::endl; // will output 0 (false)

Common mistakes and anti-patterns

Neglect of parentheses in complex expressions
Type casting errors when comparing signed and unsigned
Dangerous overloading of operators for unintended purposes

Real-life example

Negative case

A developer overloaded the '+' operator for the Complex class to add with int, implicitly altering the summation logic, forgetting about priorities. The compiler accepted it, but the result incorrectly added the real part with the integer, causing bugs in calculations.

Pros:

Syntax is concise

Cons:

Difficult to understand
Pitfalls with types

Positive case

The operator is overloaded only for adding Complex with another Complex. The documentation clearly states what operations are supported, and all expressions are explicitly grouped.