Unconventional Operator Behavior

While C++ technically allows you to make operators behave however you want, doing so is generally considered poor practice. Let's look at why, and what guidelines you should follow:

1#include <iostream>
2
3struct BadVector3 {
4  float x, y, z;
5
6  // BAD: + operator performs multiplication 
7  BadVector3 operator+(
8    const BadVector3& other) const {
9    // Multiplying instead of adding!
10    return BadVector3{
11      x * other.x,
12      y * other.y,
13      z * other.z
14    };
15  }
16};
17
18struct GoodVector3 {
19  float x, y, z;
20
21  // GOOD: + operator performs addition as expected 
22  GoodVector3 operator+(
23    const GoodVector3& other) const {
24    return GoodVector3{
25      x + other.x,
26      y + other.y,
27      z + other.z
28    };
29  }
30};
31
32int main() {
33  BadVector3 v1{2, 3, 4};
34  BadVector3 v2{3, 4, 5};
35
36  // Misleading! Actually multiplies
37  BadVector3 result{v1 + v2};
38
39  std::cout << "Unexpected result: "
40  << result.x << "\n"; // Prints 6, not 5!
41}

1Unexpected result: 6

Guidelines for Operator Behavior

• Follow the principle of least surprise - operators should behave as users expect
• + should perform addition or concatenation
• should perform multiplication or scaling
• == should test for equality
• should perform subtraction or negation
• += should modify the left operand by adding the right operand

Why These Guidelines Matter

If operators behave unexpectedly:

1Vector3 pos{1, 2, 3};
2Vector3 movement{4, 5, 6};
3
4// Developer expects addition,
5// but gets multiplication instead!
6Vector3 newPos{pos + movement};

Breaking these conventions makes code:

• Harder to read and understand
• More prone to bugs
• Less maintainable
• Confusing for other developers

Instead of overloading operators to do unexpected things, create appropriately named functions for those operations. This makes your code's behavior clear and predictable.