Lecture 15: Classes, Constructors, and Operator Overloading

## Constructor Overloading

### Multiple Constructors
        ```cpp
        class Rectangle {
        private:
            int length, breadth;

public:
            // Default constructor
            Rectangle() {
                length = breadth = 1;
            }

// Parameterized constructor
            Rectangle(int l, int b) {
                length = l;
                breadth = b;
            }

// Copy constructor
            Rectangle(const Rectangle& r) {
                length = r.length;
                breadth = r.breadth;
            }

int area() {
                return length * breadth;
            }
        };

int main() {
            Rectangle r1;          // Default: 1x1
            Rectangle r2(5, 10);   // Parameterized: 5x10
            Rectangle r3 = r2;     // Copy: 5x10

cout << r1.area() << endl;  // 1
            cout << r2.area() << endl;  // 50
            cout << r3.area() << endl;  // 50
        }
        ```

## Destructor Example

```cpp
        #include <iostream>
        using namespace std;

class ResourceManager {
        private:
            int* data;

public:
            ResourceManager(int size) {
                data = new int[size];  // Allocate memory
                cout << "Constructor: Allocated " << size << " ints" << endl;
            }

~ResourceManager() {
                delete[] data;  // Free memory
                cout << "Destructor: Freed memory" << endl;
            }

void display() {
                cout << "ResourceManager object alive" << endl;
            }
        };

int main() {
            {
                ResourceManager rm(10);
                rm.display();
            }  // rm goes out of scope, destructor called

cout << "Back in main" << endl;
            return 0;
        }
        ```

**Output:**
        ```
        Constructor: Allocated 10 ints
        ResourceManager object alive
        Destructor: Freed memory
        Back in main
        ```

## Binary Operator Overloading Example

### Complex Number Class
        ```cpp
        #include <iostream>
        using namespace std;

class Complex {
        private:
            double real, imag;

public:
            // Constructor
            Complex(double r = 0, double i = 0) {
                real = r;
                imag = i;
            }

// Addition operator
            Complex operator+(const Complex& other) {
                Complex result;
                result.real = real + other.real;
                result.imag = imag + other.imag;
                return result;
            }

// Display function
            void display() {
                cout << real << " + " << imag << "i" << endl;
            }
        };

int main() {
            Complex c1(1, 2), c2(3, 4);
            Complex sum = c1 + c2;  // Calls c1.operator+(c2)

cout << "c1: "; c1.display();
            cout << "c2: "; c2.display();
            cout << "Sum: "; sum.display();

return 0;
        }
        ```

**Output:**
        ```
        c1: 1 + 2i
        c2: 3 + 4i
        Sum: 4 + 6i
        ```

## Stream Operators: `<<` and `>>`

### Why Stream Operators?
        - Enable natural I/O syntax with objects
        - `cout << obj` instead of `obj.display()`
        - `cin >> obj` for input

---

### Output Stream Operator (`<<`)
        - Friend function (not member function)
        - Returns `ostream&` for chaining
        - First parameter: `ostream& out`
        - Second parameter: `const ClassType& obj`

```cpp
        #include <iostream>
        using namespace std;

class Complex {
        private:
            double real, imag;

public:
            Complex(double r = 0, double i = 0) : real(r), imag(i) {}

// Friend function for output
            friend ostream& operator<<(ostream& out, const Complex& c) {
                out << c.real << " + " << c.imag << "i";
                return out;
            }
        };

int main() {
            Complex c(3, 4);
            cout << "Complex number: " << c << endl;
            return 0;
        }
        ```

## Comparison Operators: `==`, `!=`, `<`, etc.

```cpp
        class Time {
        private:
            int hours, minutes;

public:
            Time(int h = 0, int m = 0) : hours(h), minutes(m) {}

// Equality operator
            bool operator==(const Time& other) const {
                return (hours == other.hours && minutes == other.minutes);
            }

// Less than operator
            bool operator<(const Time& other) const {
                if (hours != other.hours)
                    return hours < other.hours;
                return minutes < other.minutes;
            }

// Other comparison operators can be derived
            bool operator!=(const Time& other) const {
                return !(*this == other);
            }

bool operator<=(const Time& other) const {
                return (*this < other) || (*this == other);
            }

friend ostream& operator<<(ostream& out, const Time& t) {
                out << t.hours << ":" << t.minutes;
                return out;
            }
        };

int main() {
            Time t1(9, 30), t2(10, 15);

if (t1 < t2) {
                cout << "t1 comes before t2" << endl;
            }

if (t1 != t2) {
                cout << "t1 and t2 are different" << endl;
            }

return 0;
        }
        ```

## Assignment Operator (`=`)

### Why Overload Assignment?
        - C++ provides default assignment operator
        - May not be sufficient for dynamic resources
        - Need deep copy instead of shallow copy

---

```cpp
        class String {
        private:
            char* data;
            int length;

public:
            // Constructor
            String(const char* str = "") {
                length = strlen(str);
                data = new char[length + 1];
                strcpy(data, str);
            }

// Copy constructor (not shown)
            String(const String& other) {
                length = other.length;
                data = new char[length + 1];
                strcpy(data, other.data);
            }

// Assignment operator
            String& operator=(const String& other) {
                if (this != &other) {  // Self-assignment check
                    delete[] data;    // Free existing memory

length = other.length;
                    data = new char[length + 1];
                    strcpy(data, other.data);
                }
                return *this;  // Return reference for chaining
            }

~String() {
                delete[] data;
            }

void display() const {
                cout << data << endl;
            }
        };

int main() {
            String s1("Hello");
            String s2;
            s2 = s1;  // Assignment
            s1.display();
            s2.display();
            return 0;
        }
        ```

## Common Error: Returning by Value vs Reference

### Error Example
        ```cpp
        #include <iostream>
        using namespace std;

class Complex {
        private:
            double real, imag;

public:
            Complex(double r = 0, double i = 0) : real(r), imag(i) {}

Complex operator+(const Complex& other) {
                Complex temp;
                temp.real = real + other.real;
                temp.imag = imag + other.imag;
                return temp;
            }

Complex& operator++() {  // prefix ++
                real += 1;
                imag += 1;
                return *this;
            }

void display() const {
                cout << real << " + " << imag << "i" << endl;
            }
        };

int main() {
            Complex a(1, 2), b(3, 4);
            Complex c = a + b;
            ++a;

c.display();  // 4 + 6i
            a.display();  // 2 + 3i
            return 0;
        }
```

---

**Good Practice:** 
        - Binary operators usually return by value
        - Unary operators that modify (like `++`) return by reference
        - Assignment operators return by reference for chaining

## Best Practices for Operator Overloading

### Design Principles
        1. **Intuitive Behavior**: Operators should do what users expect
           ```cpp
           a + b;  // Should behave like mathematical addition
           a += b; // Equivalent to a = a + b
           ```

2. **Consistency**: Related operators should be consistent
           ```cpp
           if (a == b) should be equivalent to !(a != b)
           if (a < b) then !(b < a) or (a == b)
           ```

3. **Minimal Set**: Only overload operators that make sense
           - Don't overload `+` for Date class to add years
           - Use member functions for operations without clear operators

---
        
           ### Design Principles

4. **Return Types**:
           - Binary operators: return by value
           - Assignment operators: return `Type&` for chaining
           - Comparison operators: return `bool`
           - Stream operators: return stream reference

5. **Friend vs Member Functions**:
           - Use member functions when possible (no `friend` needed)
           - Use `friend` only for symmetric operators like `<<`

## Summary

### Key Takeaways

**Classes:**
        - Blueprint for creating objects
        - Encapsulate data and behavior
        - Access specifiers: `private`, `public`, `protected`

**Constructors:**
        - Initialize objects automatically
        - Default, parameterized, and copy constructors
        - Constructor overloading for flexible initialization

---

**Destructors:**
        - Cleanup resources when objects are destroyed
        - Automatically called
        - Essential for memory management

**Operator Overloading:**
        - Make operators work with user-defined types
        - Syntax: `operator<symbol>()`
        - Member functions or friend functions
        - Common operators: `+`, `<<`, `==`, `=`

---

### Best Practices
        - Keep constructors simple
        - Implement RAII (Resource Acquisition Is Initialization)
        - Overload operators only when intuitive
        - Ensure consistency across related operators
        - Handle self-assignment in assignment operators

Back to Course Outline

Back to Course Outline
Previous: Lecture 14
Next: Lecture 16