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

## From procedural to object-oriented programming

Procedural programming

- Focused on **functions** and the call stack
- Data and functions treated as **separate** abstractions
- Data must be passed into/returned out of functions, functions work on any piece of data that can be passed in via parameters

Object-oriented programming

- Data and functions packaged **together** into a single abstraction
- Data becomes more interesting (adds behavior)
- Functions become more focused (restricts data scope)

## Object-oriented programming

- Data and functions packaged together into a single abstraction
  - Data becomes more interesting (adds behavior)
  - Functions become more focused (restricts data scope)

### Today:

- An introduction to classes and structs
  - Member variables (state of an object)
  - Constructors
  - Member functions/operators (behaviors)
  - Encapsulation
  - Abstraction

At a later date:

- Inheritance (class 12)
- Polymorphism (12)
- Developing reusable OO designs (16-21)

## Class and struct

### From C++ Functions to C++ Structs/Classes

C++ functions encapsulate behavior

- Data used/modified by a function must be passed in via parameters
- Data produced by a function must be passed out via return type

Classes (and structs) encapsulate related data and behavior (**Encapsulation**)

- Member variables maintain each object’s state
- Member functions (methods) and operators have direct access to member variables of the object on which they are called
- Access to state of an object is often restricted
- **Abstraction** - a class presents only the relevant details of an object, through its public interface.

### C++ Structs vs. C++ Classes?

Class members are **private** by default, struct members are **public** by default

When to use a struct

- Use a struct for things that are mostly about the data
- **Add constructors and operators to work with STL containers/algorithms**

When to use a class

- Use a class for things where the behavior is the most important part
- Prefer classes when dealing with encapsulation/polymorphism (later)

```cpp
// point2d.h - struct declaration
struct Point2D {
    Point2D(int x, int y);
    bool operator< (const Point2D &) const; // a const member function
    int x_; // promise a member variable
    int y_;
};
```

```cpp
// point2d.cpp - methods functions
#include "point2d.h"

Point2D::Point2D(int x, int y) : 
x_(x), y_(y) {}

bool Point2D::operator< (const Point2D &other) const {
    return x_ < other.x_ || (x_ == other.x_ && y_ < other.y_);
}
```

### Structure of a class

```cpp
class Date {
    public: // public stores the member functions and variables accessible to the outside of class
    Date(); // default constructor
    Date (const Date &); // copy constructor
    Date(int year, int month, int day); // constructor with parameters
    virtual ~Date(); // (virtual) destructor
    Date& operator= (const Date &); // assignment operator
    int year() const; // accessor
    int month() const; // accessor
    int day() const; // accessor
    void year(int year); // mutator
    void month(int month); // mutator
    void day(int day); // mutator
    string yyymmdd() const; // generate a string representation of the date
    private: // private stores the member variables that only the class can access
    int year_;
    int month_;
    int day_;
};
```

#### Class constructor

- Same name as its class
- Establishes invariants for objects of the class
- **Base class/struct and member initialization list**
  - Used to initialize member variables
  - Used to construct base class when using inheritance
  - Must initialize const and reference members there
  - **Runs before the constructor body, object is fully initialized in constructor body**

```cpp
// date.h
class Date {
    public:
    Date();
    Date(const Date &);
    Date(int year, int month, int day);
    ~Date();
    // ...
    private:
    int year_;
    int month_;
    int day_;
};
```

```cpp
// date.cpp
Date::Date() : year_(0), month_(0), day_(0) {} // initialize member variables, use pre-defined values as default values
Date::Date(const Date &other) : year_(other.year_), month_(other.month_), day_(other.day_) {} // copy constructor
Date::Date(int year, int month, int day) : year_(year), month_(month), day_(day) {} // constructor with parameters
// ...
```

#### More on constructors

Compiler defined constructors:

- Compiler only defines a default constructor if no other constructor is declared
- Compiler defined constructors simply construct each member variable using the same operation

Default constructor for **built-in types** does nothing (leaves the variable uninitialized)!

It is an error to read an uninitialized variable

## Access control and friend declarations

Declaring access control scopes within a class - where is the member visible?

- `private`: visible only within the class
- `protected`: also visible within derived classes (more later)
- `public`: visible everywhere

Access control in a **class** is `private` by default

- It’s better style to label access control explicitly

A `struct` is the same as a `class`, except access control for a `struct` is `public` by default

- Usually used for things that are “mostly data”

### Issues with Encapsulation in C++

Encapsulation - state of an object is kept internally (private), state of an object can be changed via calls to its public interface (public member functions/operators)

Sometimes two classes are closely tied:

- One may need direct access to the other’s internal state
- But, other classes should not have the same direct access
- Containers and iterators are an example of this

We could:

1. Make the internal state public, but this violates **encapsulation**
2. Use an inheritance relationship and make the internal state protected, but the inheritance relationship doesn’t make sense
3. Create fine-grained accessors and mutators, but this clutters the interface and violates **abstraction**

### Friend declarations

Offer a limited way to open up class encapsulation

C++ allows a class to declare its “friends”

- Give access to specific classes or functions

Properties of the friend relation in C++

- Friendship gives complete access
  - Friend methods/functions behave like class members
  - public, protected, private scopes are all accessible by friends
- Friendship is asymmetric and voluntary
  - A class gets to say what friends it has (giving permission to them)
  - But one cannot “force friendship” on a class from outside it
- Friendship is not inherited
  - Specific friend relationships must be declared by each class
  - “Your parents’ friends are not necessarily your friends”


```cpp
// in Foo.h
class Foo {
    friend ostream &operator<< (ostream &out, const Foo &f); // declare a friend function, can be added at any line of the class declaration
    public:
    Foo(int x);
    ~Foo();
    // ...
    private:
    int baz_;
};

ostream &operator<< (ostream &out, const Foo &f);
```

```cpp
// in Foo.cpp
ostream &operator<< (ostream &out, const Foo &f) {
    out << f.baz_; // access private member variable via friend declaration
    return out;
}


```