Post-class 01/12

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
+```