From 1a62445e14debcbdc539bebe6ce46e5282c9cee0 Mon Sep 17 00:00:00 2001 From: lshprung Date: Tue, 12 Jan 2021 10:47:12 -0800 Subject: Post-class 01/12 --- 01-12.md | 227 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 227 insertions(+) create mode 100644 01-12.md (limited to '01-12.md') diff --git a/01-12.md b/01-12.md new file mode 100644 index 0000000..b07f77d --- /dev/null +++ b/01-12.md @@ -0,0 +1,227 @@ +[\<- 01/07](01-07.md) + +# OOP: Classes, Objects, and ADTs + +## Object Oriented Programming + +- OOP is a programming language model organized around **objects** rather than "actions" and **data** rather than logic +- There are 4 major principles that make a language Object Oriented + - Encapsulation + - Data Abstraction + - Polymorphism + - Inheritance + +### Encapsulation + +- Hiding mechanism, hiding of data implementation + - Private variables + - Public accessor methods + +### Abstractions + +- A concept or an idea which is not associated with any particular instance + - Expressing the "intent" and not the "implementation" + - **Abstract** classes and **virtual** members + +### Polymorphism + +- One name, many forms! + - What does `a+b` mean? + - What is `a` and what is `b`? + +### Inheritance + +- "is a" or "has a" relationship between objects + - Dog "is a" mammal + - Ferrari "is a" car, "has an" engine + +## Class + +**A class is a new kind of data type** + +- A collection of data, such as integers, characters, and so on +- We implement data structures as classes +- A class has the ability to include special functions, called **member functions** which are designed specifically to manipulate the class + +### Example: Thinking Cap + +``` +class thinking_cap{ + + public: + void slots(char new_green[], char new_red[]); + void push_green() const; + void push_red() const; + + private: + char green_string[50]; + char red_string[50]; +}; +``` + +- Note: the `const` means that the function cannot change the data in the variables of the class + - `const` should be specified for all "getter" functions + +### Files for Thinking Cap + +- The `thinking_cap` class definition, which we have just seen, is placed with documentation in a file called `thinker.hxx` outlined here +- The implementations of the three member functions will be placed in a separate file called `thinker.cxx`, which we will examine in a few minutes + +### Using the Thinking Cap + +- A program that wants to use the `thinking_cap` must **include** the thinker header file (along with its other head inclusions) +- The program starts by calling the slots member function for student + +``` +#include +#include +#include "thinker.h" + +int main(){ + thinking_cap student; + thinking_cap fan; + + student.slots("Hello", "Goodbye"); + fan.slots("Go Broncos!", "Boo!"); + student.push_green(); //expected output: "Hello" + fan.push_green(); //expected output: "Go Broncos!" + student.push_red(); //expected output: "Goodbye" +} +``` + +### Thinking Cap Implementation + +- The below code belongs in the `thinking_cap` class definition + +``` +void thinking_cap::slots(char new_green[], char new_red[]){ + assert(strlen(new_green) < 50); + assert(strlen(new_red) < 50); + strcpy(green_string, new_green); + strcpy(red_string, new_red); +} + +void thinking_cap::push_green{ + cout << green_string << endl; +} +``` + +### A Common Pattern + +- Often, one or more member functions will place data in the member variables so that other member functions may use that data + +### Summary + +- Classes have member variables and member functions. An object is a variable where the data type is a class +- You should know how to declare a new class type, how to implement its member functions, how to use the class type +- Frequently, the member functions of an class type place information in the member variables, or use information that's already in the member variables +- In the future, we will see more features of OOP + +--- + +## Class Constructors + +- **Constructors** provide an initialization function **that is guaranteed to be called** +- **A constructor is a member function** with **these special properties** + - A constructor is **called automatically** whenever a variable of the class is declared + - The **name of a constructor must be the same as the name of the class** + - A constructor **does not have any return value** + - You must not write `void` (or any other return type) at the front of the constructor's head + +### Example + +``` +namespace scu_coen79_2A{ + class point{ + + public: + //CONSTRUCTOR + point(double i_x=0; double i_y=0); + + void shift(double x_amount, double y_amount); + void rotate90(); + double get_x() const { return x; } //inline function + double get_y() const { return y; } //inline function + + private: + double x; //x coordinate of this point + double y; //y coordinate of this point + }; +} +``` + +- Notice that the above code has a couple of inline functions + - It is best practice to only do this for very short functions + +### Write a Constructor for Thinking Cap + +``` +//prototype in the class definition +thinking_cap(); + +//definition +thinking_cap::thinking_cap(){ + strcpy(green_string, "Hi"); //default green_string is "Hi" + strcpy(red_string, "Bye"); //default red_string is "Bye" +} +``` + +### Automatic Constructor + +- If you write a class with no constructor, + - The compiler automatically creates a simple default constructor + - **This automatic default constructor doesn't do much work** + +### Value Semantic + +- The value semantics of a class determines how values are copied from one object to another +- In C++, the value semantics consists of two operations: + - Assignment operator + - Copy constructor + +### Assignment Operator + +**Example** +- DS1 is a data structure that includes the names of employees in a hospital +- DS2 is an object that can include names of employees +- We want to assign the values in DS1 to DS2. This is what we do: + +``` +employeeName DS2; +DS2 = DS1; +``` + +- The **automatic assignment operator** simple **copies each member variable** from the object on the left of the assignment + +**Note**: Automatic assignment operator **does not always work** (future lectures) + +### Copy Constructor + +**Example** + +- DS1 is a data structure that includes the names of employees in a hospital +- We want to create an object DS2 while making it an exact copy of DS1 +- This is what we do: + +``` +employeeNames DS2(DS1); +``` + +- **A constructor with exactly one argument** +- The data type of the argument is the same as the constructor's class +- Or equivalently + +``` +employeeNames DS2 = DS1; +``` + +### C++ Copy Constructor + +- C++ provides an **automatic copy constructor** +- The automatic copy constructor initializes a new object by **merely copying all the member variables from the existing object** +- When you implement a class, **the documentation should include a comment indicating that the value semantics is safe to use** + +``` +//VALUE SEMANTICS for the XYZ class: + //Assignments and the copy constructor may be used with XYZ objects +``` -- cgit