# CSE332S Object-Oriented Programming in C++ (Lecture 11)

## Operator overloading intro

> Insertion operator (`<<`) - pushes data from an object into an ostream
>
> Extraction operator (`>>`) - pulls data off of an istream and stores it into an object
> 
> Defined for built-in types, but what about **user-defined types**?

**Operator overloading** - we can provide overloaded versions of operators to work with objects of our classes and structs

Example:

```cpp
// declaration in point2d.h

struct Point2D {
    Point2d(int x, int y);
    int x_;
    int y_;
}

// definition in point2d.cpp
Point2D::Point2D(int x, int y): x_(x), y_(y) {}

// main function
int main() {
    Point2D p1(5,5);
    cout << p1 << endl; // this is equivalent to calling `operator<<(ostream &, const Point2d &);` Not declared yet.
    cout <<  "enter 2 coordinates, separated by a space" << endl;
    cin >> p1; // this is equivalent to calling `operator>>(istream &, const Point2d &);` Not declared yet.
    cout << p1 << endl;
    return 0;
}
```

Example of declaration of operator:

```cpp
// declaration in point2d.h
struct Point2D {
    Point2D(int x, int y);
    int x_;
    int y_;
}

istream & operator>> (istream
&, Point2D &);

ostream & operator<< (ostream
&, const Point2D &);

// definition in point2d.cpp
Point2D::Point2D(int x, int y): x_(x), y_(y) {}

istream & operator>> (istream &i, Point2d &p) {
    // we will change p so don't put const on it
    i >> p.x_ >> p.y_;
    return i;
}
ostream & operator<< (ostream &o, const Point2D &p) {
    // we will not change p, so put const
    o << p.x_ << “ “ << p.y_;
    return o;
}
```

## Operator overloading: Containers

Require element type they hold to implement a certain interface:

- Containers take ownership of the elements they contain - a copy of the element is made and the copy is inserted into the container (implies element needs a **copy constructor**)
- Ordered associative containers maintain order with elements `<` operator
- Unordered containers compare elements for equivalence with `==` operator

```cpp
// declaration in point2d.h
struct Point2D {
    Point2D(int x, int y);
    bool operator< (const Point2D &) const;
    bool operator== (const Point2D &) const;
    int x_;
    int y_;
}
// must be a non-member
operator istream & operator>> (istream &, Point2D &);
// must be a non-member
operator ostream & operator<< (ostrea &, const Point2D &);

// definition in point2d.cpp
// order by x_ value, then y_
bool Point2D::operator<(const Point2D & p) const {
    if(x_ < p,x_) {return true;}
    if(x_ == p.x_) {
        return y_ < p.y_;
    }
    return false;
}
```

## Operator overloading: Algorithms

Require elements to implement a specific **interface** - can find what this interface is via the cpp reference pages

Example: `std::sort()` requires elements implement `operator<`, `std::accumulate()`
requires `operator+`

Suppose we want to calculate the centroid of all Point2D objects in a `vector<Point2D>`

We can use `accumulate()` to sum all x coordinates, and all y coordinates. Then divide each by the size of the vector.

By default, accumulate uses the elements `+` operator.

```cpp
// declaration, within the struct Point2D declaration in point2d.h, used by accumulate algorithm
Point2D operator+(const Point2D &) const;

// definition, in point2d.cpp
Point2D Point2D::operator+ (const Point2D &p) const {
    return Point2D(x_ + p.x_, y_ + p.y_);
}

// in main()
// assume v is populated with points
Point2D accumulated = accumulate(v.begin(), v.end(), Point2D(0,0));

Point2D centroid (accumulated.x_/v.size(), accumulated.y_/v.size());
```

## Callable objects

Make the algorithms even more general

Can be used parameterize policy

- E.g., the order produced by a sorting algorithm
- E.g., the order maintained by an associative containers

Each callable object does a single, specific operation

- E.g., returns true if first value is less than second value

Algorithms often have overloaded versions

- E.g., sort that takes two iterators (uses `operator<`)
- E.g., sort that takes two iterators and a binary predicate, uses the binary predicate to compare elements in range

### Callable Objects

Callable objects support function call syntax

- A function or function pointer

```cpp
// function pointer
bool (*PF) (const string &, const string &);
// function
bool string_func (const string &, const string &);
```

- A struct or class providing an overloaded `operator()`

```cpp
// an example of self-defined operator
struct strings_ok {
    bool operator() (const string &s, const string &t) {
        return (s != "quit") && (t != "quit");
    }
};
```
