Passing Arguments and The Big 5

Midterm Grades Average of first five code reviews Do not count extra credit Do not scale or drop for joining class late Do not take into account missing grades Are internal only and based on 17.8% of your final grade F < 55 C >= 55 < 70 B >= 70 < 80 A >= 80

Grading Change for Extension In the extension we will be relaxing the grading standard as follows. We will find the worst win rate by scoreing 200 on boards of 10, 20, and 30 size. Then you will be scaled down 10*max(99-winrate, 0)% capped at 80% Examples You have a winrate of 97.4% you would have a down scaling of -16% You have a winrate of 99.2% you would have a down scaling of -0% You have a winrate of 87.3% you would have a down scaling of -80%

Possible Strategy vs Random Pickup several seeds Plant several seeds Wait a several turns (parallel growth) Harvest harvest trees Score a large amount points Repeat until victory

Passing Arguments by Value Pass to the function a copy of a variable Advantages Safe – the variable will not be changed in the calling context Disadvantages Slow – copying can be slow to copy a large objects as a variable Arrays Not passed by value

Passing Arguments by Pointer Pass to the function a copy of the address of a variable Advantages Flexible – can change the value of the object Fast – only need to copy a pointer not the whole object Disadvantages Unsafe – can change the value of the variable in the calling function Complex – the variable is a pointer rather then and needs * or -> to access Arrays Always passed as a pointer since the name of an array is a pointer

Reference Variables Not pointers C++ Reference Variables Can not be null or uninitialized C++ Reference Variables Declare like pointers but use & rather then * They "refer" to another variable, but act like a variable Must be initialized when created so can never be null int my_int = 7; int &my_ref = my_int; my_ref = 8; cout << my_int << endl;

Passing Arguments by Reference Pass to the function a reference to a variable Advantages Flexible – can change the value of the object Fast – only need to copy an address not the whole object Disadvantages Unsafe – can change the value of the variable in the calling function Confusing – can not tell the difference at the call site Const Ref Safe like value but fast like a pointer

Return Values Advantages Disadvantages Safe – Will always work correctly Disadvantages Slow – If a large object must be copied it could be slow With C++11 usually avoided more so with C++14

Return Pointers Advantages Disadvantages Allocations – Allows returning of heap allocated objects Disadvantages Unsafe – returning a stack address no longer be valid after the return

Return Reference Advantages Disadvantages Use Fast – always fast since only copying an address Disadvantages Unsafe – returning a reference to a stack variable will no longer be valid after the return Use Returning values from outside the function

What happens? void fn(int x) { x = 10; } int main() { int x = 200; fn(x); cout << x; What probably happens? 10 printed 200 printed Won't compile Some unknown value printed Segfault and crash

What happens? void fn(int &x) { x = 10; } int main() { int x = 200; fn(x); cout << x; What probably happens? 10 printed 200 printed Won't compile Some unknown value printed Segfault and crash

What happens? void fn(int *x) { x = 10; } int main() { int x = 200; fn(x); cout << x; What probably happens? 10 printed 200 printed Won't compile Some unknown value printed Segfault and crash

What happens? void fn(int *x) { x = 10; } int main() { int x = 200; fn(&x); cout << x; What probably happens? 10 printed 200 printed Won't compile Some unknown value printed Segfault and crash

Classes – No Internal "new" Member variables Methods Constructor Rule of Zero

Case Study: StringHolder class StringHolder { std::string *string_; public: StringHolder() : string_(nullptr) {}; StringHolder(const char *initial_string); const char* c_str() const noexcept; void ChangeString(const char *input_string); };

Classes – Containers Use "new" Rule of Zero won't work Deep vs Shallow Copy

Rule of Three – Copy Assignment Operator StringHolder& operator=(const StringHolder &source)

Rule of Three - Copy Constructor StringHolder(const StringHolder &source)

Rule of Three - Destructor ~StringHolder()

Rule of Three vs Rule of Five Rule of five (move semantics new with C++11) Move Constructor Move Assignment Operator rvalue reference && Can bind to a temporary (rvalue)

Rule of Three - Move Constructor StringHolder(StringHolder&& source)

Rule of Three – Move Assignment Operator StringHolder& operator=(StringHolder&& source)