Overloading Arithmetic Assignment Operators

To overload arithmetic assignment operators like +=, -=, *=, /=, and %= for your custom type, you need to define them as member functions that modify the object itself and return a reference to the modified object.

Here's an example of overloading the += and *= operators for a custom Vector class:

1#include <iostream>
2
3class Vector {
4 private:
5  float x, y, z;
6
7 public:
8  Vector(float a, float b, float c)
9    : x(a), y(b), z(c) {}
10
11  Vector& operator+=(const Vector& other) {
12    x += other.x;
13    y += other.y;
14    z += other.z;
15    return *this;
16  }
17
18  Vector& operator*=(float scalar) {
19    x *= scalar;
20    y *= scalar;
21    z *= scalar;
22    return *this;
23  }
24
25  void print() const {
26    std::cout << "(" << x << ", " << y
27      << ", " << z << ")\n";
28  }
29};
30
31int main() {
32  Vector v(1.0f, 2.0f, 3.0f);
33  Vector u(0.5f, 0.5f, 0.5f);
34
35  v += u;
36  v.print();
37
38  v *= 2.0f;
39  v.print();
40}

1(1.5, 2.5, 3.5)
2(3, 5, 7)

In this example, we define the += and *= operators as member functions of the Vector class. The += operator adds the components of another Vector object to the current object, while the *= operator multiplies each component of the current object by a scalar value.

Both operators modify the object itself and return a reference to the modified object using *this. This allows for chaining multiple arithmetic assignment operations.

By overloading these operators, we can use the familiar syntax of += and *= with our custom Vector objects, making the code more readable and expressive.

Remember to define the behavior of these operators according to the specific semantics of your custom type.