1. Passing Arguments and The Big 5

2. 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

3. 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%

4. 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

5. 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

6. 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

7. 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;

8. 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

9. 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

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

11. 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

12. 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

13. 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

14. 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

15. 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

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

17. 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); };

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

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

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

21. Rule of Three - Destructor
~StringHolder()

22. 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)

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

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