summaryrefslogtreecommitdiff
path: root/01-12.md
diff options
context:
space:
mode:
Diffstat (limited to '01-12.md')
-rw-r--r--01-12.md227
1 files changed, 227 insertions, 0 deletions
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 <iostream.h>
+#include <stdlib.h>
+#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
+```