Lecture 13 - Copy Constructor, Destructor, Assignment Operator

Author: bryan-cho

Lecture 13.md

@@ -0,0 +1,241 @@
+# Lecture 13 - Oct. 27, 2015
+
+"The Big Three", Copy Constructor, Destructor, operator=
+
+## Copy Constructor
+
+Used to construct a new object as a copy of an existing object.
+
+```cpp
+Student billy(60, 70, 80);
+Student bobby = billy;
+```
+
+There is a built-in copy constructor.
+
+Every class "comes with": 
+
+* Default constructor **(goes away when you write your own constructor)**
+* Copy constructor
+* Destructor
+* Copy assignment operator
+
+For a class C, the copy constructor takes one parameter: const reference to object.
+
+```cpp
+class C {
+    public:
+        C(const C &other) {}; //convention is to use other or rhs (right hand side)
+}
+```
+
+An example of this is shown with the Student class:
+
+```cpp
+class Student {
+    private:
+        int assignments;
+        int midterm;
+        int final;
+    public:
+        Student(const Student &other) 
+        : assignments(other.assignment)
+        , midterm(other.midterm)
+        , final(other.final) {}
+}
+```
+
+The copy constructor shown above is the same behavior as the built-in copy constructor.
+
+Consider the following:
+
+```cpp
+class Node {
+    private:
+        int data;
+        Node *next;
+    public:
+        Node(int data, Node *next) 
+        : data(data)
+        , next(next) 
+        {}
+        Node(const Node &other)
+        : data(other.data)
+        , next(other.next)
+        {}
+};
+
+Node *np = new Node(1, new Node(2, newNode(3, nullptr)));
+Node m = *np;                 //copy constructor
+Node *npCopy = new Node(*np); //copy constructor
+
+//68: np[-]--> [1|-]--> [2|-]--> [3|/]
+//69: m[1|-]-------------^ points to *np's next instead of doing a deep copy
+//70: npCopy[-]-->[1|-]--^ similarly, points to *np's next 
+```
+
+The default copy constructor does a shallow copy.
+
+We often want a "deep copy" when an object contains fields that are dynamically allocated (i.e. on the heap).
+
+What we should do is the following:
+
+```cpp
+class Node {
+    private:
+        int data;
+        Node *next;
+    public:
+        Node(const Node &other) {
+            this->data = other.data;
+            if (other.next == nullptr) {
+                this->next = nullptr;
+            } else {
+                // Need to dereference, we send in a Node object.
+                this->next = new Node(*(other.next));
+            }
+        }
+}
+``` 
+
+This will do a deep copy of the linked list.
+
+We show an alternative way of writing the copy constructor:
+
+```cpp
+class Node {
+    private:
+        int data;
+        Node *next;
+    public:
+        Node(const Node &other)
+        : data(other.data)
+        , next(other.next ? new Node(*(other.next)) : nullptr)
+        {}
+}
+```
+
+Places where a copy constructor is called:
+
+1. Creating an object as a copy of another
+2. When an object is passed by value
+3. When an object is returned by value (returning a stack allocated object)
+
+We must pass in a const reference to a copy constructor.
+
+This is because if we pass in the object by value, the copy constructor will be invoked each time.
+
+### Single Parameter Constructors
+
+```cpp
+class Node {
+    public:
+        Node(int data)
+        : data(data)
+        , next(nullptr) 
+        {}
+}
+
+void foo(Node n) {}
+
+Node n(4);  // valid
+foo(n);     // valid
+
+Node m = 4; // valid
+foo(4);     // valid
+```
+
+Single Parameter Constructors create implicit conversions.
+
+```
+string str = "hello";
+```
+
+`std::string` has a 1 parameter constructor
+
+Does an implicit conversion from `const char * --> std::string`
+
+We can use the `explicit` keyword to disable this behavior.
+
+```cpp
+class Node {
+    public:
+        explicit Node(int data)
+        : data(data)
+        , next(nullptr) 
+        {}
+}
+```
+
+Now this will make
+
+```cpp
+Node m = 4; // invalid
+foo(4);     // invalid
+```
+
+## Destructor
+
+When an object is destroyed, a special method called the destructor runs.
+
+Stack allocated object is destroyed when it goes out of scope.
+
+Heap allocated object is destroyed when it is deleted.
+
+* A class only has one destructor
+* 0 parameter method (no return type)
+
+The name of a destructor is the name of the class prefixed with ~.
+
+* You get a built-in destructor with every class.
+    * Calls the destructor on any fields that are objects
+
+```cpp
+Node *np = ...;
+
+// np -->[1|-]-->[2|-]-->[3|/]
+
+delete np;
+
+struct Node {
+    int data;
+    Node *next;
+    ~Node() {
+        delete next;
+    }
+}
+```
+
+Calling delete on `NULL` is safe.
+
+The call to a `nullptr` will be what terminates the recursive execution of the destructor.
+
+## Separate Compilation
+
+**Recall**: we split our programs into
+
+.h files (type definitions)         .cc files (function implementations)
+
+In the header files, we should now include method headers.
+
+In the implementation files, we now should include method implementations.
+
+The way we implement methods is by using this notation:
+
+```cpp
+(Class name)::(Method name)() {}
+
+Node::Node() {}
+void Node::push(int val) {}
+int Node::pop() {}
+...
+etc.
+```
+
+## Assignment Operator
+
+`Student bobby(billy);` copy constructor
+
+`Student jane;` 0 parameter constructor
+
+`jane = billy` updating an existing object to be a copy of the existing object

Midterm.md

@@ -0,0 +1,93 @@
+# Midterm - Oct. 29, 2015
+
+On the exam:
+
+Preprocessor
+
+Separate Compilation
+
+Constructor
+
+Copy constructor
+
+Shell script (Similar to runSuite)
+
+- Shell
+- Linux File System, Special Directories
+- cd, pwd, ls, echo, rm, 
+- Globbing patterns
+- cat
+- Input/Output Redirection
+- Pipes
+- egrep
+- File Permissions (chmod)
+- Shell Variables ($PATH)
+- Shell Scripts
+- Command Line Arguments to a script
+- $#, $?, /dev/null, $0
+- script functions
+- if statement
+- While loop
+- for loop
+- Testing
+- C++
+- Hello World
+- Compiling/Executing C++ programs
+- Stream Objects (cin, cout, cerr)
+- I/O Operators (>>, <<)
+- cin.fail(), cin.eof()
+- implicit conversion of a stream to void* (e.g. cin to void*)
+- << and >> are binary operators: must produce an expression
+- << and >> cascading
+- cin.ignore(), cin.clear() 
+- std::string
+- Semantics of reading from cin
+- I/O Manipulators: hex, dec, showpoint, setprecision , boolalpha, header <iomanip>
+- Stream Abstraction for files
+- header <fstream>, ifstream, ofstream
+- when is a file opened, when is it closed
+- Stream abstraction for strings
+- header <sstream>, istringstream, ostringstream
+- Converting a string to an integer
+- comparison between readInts5.cc and readsIntSS.cc
+- Strings in C++
+- std::string is not the same as a c-style string
+- string operations: concat, length, comparisons, length
+- Default Arguments 
+- Function Overloading
+- Review: Declaration Before Use
+- Review: Pointers
+- Review: Arrays
+- Structs in C vs structs in C++
+- Review: Constants (see review slides 1151/lectures/ReviewSlides)
+- Review: Passing by Value, Passing a pointer (see review slides 1159/lectures/ReviewSlides)
+- References 
+- Things you can and cannot do with references
+- Pass by reference
+- Why does cin >> x work in C++ when in C we had to do scanf("%s",&x)
+- Pass by Value vs Passing a pointer vs Pass by reference: pros and cons of each
+- Dynamic Memory Allocation: new and delete
+- Review Slides: Stack vs Heap Allocation 
+- Operator Overloading
+- Examples: Vec, Grade
+- The C and C++ Preprocessor
+- #include: copy and paste
+- #define: search and replace
+- Using #define for Conditional Compilation (OS example, DEBUG example)
+- Separate Compilation (lectures/c++/separate) 
+- C++ Classes
+- What is a class, what is an object, what are "functions" inside classes
+- Distinction between functions and methods
+- Initializing Objects
+- C Style Initialization
+- Constructors
+- Built-in 0 parameter ctor
+- Initializing const and reference fields
+- Steps that occur when an object is created
+- Member Initialization List (MIL)
+- Advantages of MIL
+- Copy Ctor
+- default ctor (shallow copy)
+- deep copy ctor
+- When to use deep copy
+- Places where a copy ctor is called

README.md

@@ -25,3 +25,5 @@ Lecture 10 - Dynamic Memory, Operators, Preprocessor
 Lecture 11 - Preprocessor Part II, Separate Compilation
 
 Lecture 12 - C++ Objects
+
+Lecture 13 - Copy Constructor, Destructor, Assignment Operator