## Operator Overloading

```
Complex c1{5, 2}, c2{-4, 4};
Complex c3 = c1 + c2;
// Compiler sees:
Complex c3 = operator+(c1, c2);
operator<<(cout, c3);
```

### non-member operator overloads

```
Complex operator+(const Complex &lhs,
const Complex &rhs) {
return Complex{lhs.real() + rhs.real(),
lhs.imag() + rhs.imag()};
}
Complex c3 = operator+(c1, c2);
// Operator-overload is provided as a separate function
// defined outside of the class
```

### member operator overloads

```
class Complex {
double re, im;
public:
Complex operator+(const Complex &rhs) const {
return Complex{re + rhs.re, im + rhs.im};
}
};
Complex c3 = c1.operator(c2);
// Operator-overload is specified as a member function on the type
// LHS of the operation is the obj that the function is called on
```

### Comparison

```
Complex c3 = operator+(c1, c2); // non-member
Complex c3 = c1.operator+(c2); // member
```

Member operator overload is unavailable in some cases e.g. c1 is primitive.

### Tips

Use other implementation by switching the order of operation. Also, it is great to implement this way when operators are opposite meaning.

```
Complex operator+(const Complex &c, double v);
Complex operator+(double v, const Complex &c);
Complex operator+(const Complex &c, double v) {
// do the operator work
}
Complex operator+(double v, const Complex &c) {
return c + v; // swap and use the other operator
}
```

## Complex Constructors

```
// all the cases
Complex(double re, double im);
Complex(double re);
Complex();
// or, single constructor with default value
Complex(double re = 0, double im = 0);
```

## Implicit Conversion on Constructors

```
Complex(double re = 0, double im = 0);
Complex operator+(const Complex &, const Complex &) { /* ... */ };
Complex c1{5, 3};
Complex c2 = c1 + 4;
// compilter will automatically convert this way
Complex c2 = operator+(c1, Complex{4});
```

## Artimetic Assignment

```
Complex & Complex::operator+=(const Complex &rhs) {
re += rhs.re;
im += rhs.im;
return *this;
};
Complex c1{10, -5}, c2{3, 4};
c1 += c2; // c1 = {13, -1}
```

`*this`

dereferences the pointer to get to the object itself.

```
Complex operator+(const Complex &lhs, const Complex &rhs) {
return Complex{lhs} += rhs;
}
```

## Output Stream

- Output your type's value in some clean, simple way
- Do not output any newlines
- Return
`ostream`

reference as the function's return-value

```
Complex c3 = c1 + c2;
cout << c3 << "\n";
```

```
// `ostream` is in the standard library so it is unable to create
// member overload.
ostream & operator<<(ostream &os, const Complex &c) {
os << "(" << c.real() << "," << c.imag() << ")";
return os;
}
```

Expression is evaluated from left to right. Each `operator<<`

call returns the output-stream, so that the next `operator<<`

call can use it for output.

## Coming up next

- Lecture 6: Copy and assignment operator with Heap, Inline