# CS11 Intro C++: Lecture 5

``````Complex c1{5, 2}, c2{-4, 4};
Complex c3 = c1 + c2;

// Compiler sees:
Complex c3 = operator+(c1, c2);
operator<<(cout, c3);``````

``````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``````

``````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
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.