adding the move assignment operator example

hws/matrix_class/optimization/README.md

@@ -0,0 +1,40 @@
+Compile and Run these two programs to see the performance difference, note that the two programs have the same main function.
+
+Here are the results:
+
+```console
+$ g++ matrix_fast.cpp -o matrix_fast
+$ g++ matrix_slow.cpp -o matrix_slow
+$ time ./matrix_fast
+
+real    0m1.134s
+user    0m1.130s
+sys     0m0.004s
+$ time ./matrix_fast
+
+real    0m1.138s
+user    0m1.134s
+sys     0m0.004s
+$ time ./matrix_fast
+
+real    0m1.139s
+user    0m1.139s
+sys     0m0.000s
+$ time ./matrix_slow
+
+real    0m2.159s
+user    0m2.159s
+sys     0m0.000s
+$ time ./matrix_slow
+
+real    0m2.161s
+user    0m2.157s
+sys     0m0.004s
+$ time ./matrix_slow
+
+real    0m2.207s
+user    0m2.200s
+sys     0m0.000s
+```
+
+As can be seen, the fast version is much faster than the slow version, this is because it avoids many memory allocations/deallocations.

hws/matrix_class/optimization/matrix_fast.cpp

@@ -0,0 +1,59 @@
+#include <iostream>
+#include <utility> // For std::move
+
+class Matrix {
+private:
+	int rows, cols;
+	int* data;	// intentionally make this as an int* pointer, instead of int** pointer,
+			// so as to distinguish this example from the homework matrix class.
+
+public:
+	// default constructor
+	Matrix(){
+		rows = 0;
+		cols = 0;
+		data = nullptr;
+	}
+
+	// constructor
+	Matrix(int r, int c) : rows(r), cols(c) {
+		data = new int[r * c]; // allocate memory
+		// std::cout << "Constructor: Allocating memory\n";
+	}
+
+	// move assignment operator
+	// noexcept: this keyword tells the compiler and optimizer that this function will never throw an exception.
+	// The compiler may optimize code differently if it knows that the function will not throw exceptions.
+	Matrix& operator=(Matrix&& other) noexcept {
+		// std::cout << "Move Assignment Operator Invoked\n";
+		if (this != &other) {
+			delete[] data; // free old memory
+			data = other.data;
+			rows = other.rows;
+			cols = other.cols;
+            
+			// leave `other` in a safe state
+			other.data = nullptr;
+			other.rows = 0;
+			other.cols = 0;
+		}
+		return *this;
+	}
+
+	// destructor
+	~Matrix() {
+		delete[] data;
+		// std::cout << "Destructor: Freeing memory\n";
+	}
+};
+
+int main() {
+	// these lines mimic what is used in the BatchTest function.
+	Matrix* m_arr = new Matrix[5];
+	for(int i=0; i<10000; i++){
+		for(int j=0; j<10000; j++){
+			m_arr[3] = Matrix(4,4);
+		}
+	}
+	delete [] m_arr;
+}

hws/matrix_class/optimization/matrix_slow.cpp

@@ -0,0 +1,52 @@
+#include <iostream>
+
+class Matrix {
+private:
+	int rows, cols;
+	int* data;	// intentionally make this as an int* pointer, instead of int** pointer,
+			// so as to distinguish this example from the homework matrix class.
+
+public:
+	// default constructor
+	Matrix(){
+		rows = 0;
+		cols = 0;
+		data = nullptr;
+	}
+
+	// constructor
+	Matrix(int r, int c) : rows(r), cols(c) {
+		data = new int[r * c]; // allocate memory
+		// std::cout << "Constructor: Allocating memory\n";
+	}
+
+	// assignment operator
+	Matrix& operator=(const Matrix& other) {
+		// std::cout << "Assignment Operator Invoked\n";
+		if (this != &other) {
+			delete[] data; // free old memory
+			rows = other.rows;
+			cols = other.cols;
+			data = new int[rows * cols];
+		}
+		return *this;
+
+	}
+
+	// destructor
+	~Matrix() {
+		delete[] data;
+		// std::cout << "Destructor: Freeing memory\n";
+	}
+};
+
+int main() {
+	// these lines mimic what is used in the BatchTest function.
+	Matrix* m_arr = new Matrix[5];
+	for(int i=0; i<10000; i++){
+		for(int j=0; j<10000; j++){
+			m_arr[3] = Matrix(4,4);
+		}
+	}
+	delete [] m_arr;
+}