CS 31 Discussion, Week 9 Faisal Alquaddoomi, Office Hours: BH 2432, W 4:30-6:30pm, F 12:30-1:30pm

Structs Review Structs are useful for holding collections of named variables – Differ from arrays in that the types can be different, and each ‘slot’ has a name rather than a number Use the struct { }; syntax to create a new type, e.g. struct MyStruct { int p; }; Create instances using the new type, e.g. MyStruct thing; Use the field access operator ‘.’ to access a variable in a struct, e.g. thing.p = 150;

Structs Review, Part 2 Pointers to structs can be declared, e.g. MyStruct *ptr = &thing; Field accesses on a pointers can be accomplished either through (*ptr).p = 300; // deference-and-dot, or… ptr->p = 300; // arrow, works same as above Both change the original object, ‘thing’

Structs Review, Part 3 Structs can be passed to functions – the default is pass-by-value, which copies the entire struct, and can be inefficient Struct pointers can be passed instead – can be marked const to prevent modification to the original object (const == “read-only”) As with all other types, structs can be passed-by- reference using the ‘&’ type, e.g. void someFunc(MyStruct& thing) { /* thing is a reference; changing it changes the original param */ }

Aside: Dynamic Memory Two types of memory: – stack (what we’ve been using so far for variables, parameters, etc.) – heap (aka “dynamic memory”) Stack memory is allocated inside of functions and is deallocated automatically when the function ends – “int x;” inside of main(), for instance, allocates 4 bytes on the stack, which is released when main() ends This is why we couldn’t pass back the local array in project 6; it was in the stack memory for that function, and was thus freed when the function ended

Dynamic Memory Cont’d Heap memory, on the other hand, is explicitly allocated and deallocated – allocated via the ‘new’ keyword (returns a pointer to the new memory) int *p = new int; – deallocated via the delete keyword: delete p; Heap memory, unlike stack memory, is allocated at runtime, meaning that expressions like the following will work: int x = 250; int *p = new int[x]; Losing track of heap memory (i.e. by allocating it and then forgetting to deallocate it) is called a memory leak – Over time, memory leaks can cause your program to crash, because all of the memory may eventually be leaked If new can’t allocate the memory you ask for, it’ll return NULL; for example: int *p = new int[ ];

Problems with Structs The main problem: structs only store data Up till now, data (values/variables) and code (functions) have been totally separate things – We write functions to manipulate parameters (data), and return the result as data – Functions have local variables, but they’re only used as temporaries to perform the purpose of the function; once the function ends, the only thing that remains is the result (and any side effects, like changing call-by-reference parameters) This is out of whack with how we view the world – Objects in the world have data (a person’s name, for instance) – Objects change over time (i.e. the data is modified) – Objects in the world also have operations that only make sense *for that object* and can only modify the data within that particular object

Typical Example: A Car Let’s say that we’re writing an inventory system for a used car dealership Need to keep track of cars, as well as update them What sorts of data do cars have? – Make, model, mileage… What kinds of operations can we perform on cars? Only concerned with two for now: drive(miles), which updates the mileage checking the mileage’s current value

First Approach: Using a Struct We’d declare a struct Car, with fields make (string), model (string), and mileage (int): struct Car { string make; string model; int mileage; }; We’ll declare a function for updating the mileage, drive(int miles, …) (classes, ex. 1) We can check the mileage by just accessing the mileage field directly

Problems with the Struct Approach Say that we’re an unscrupulous car dealer We have a car instance myCar; we can easily set the mileage to 10 miles like so: myCar.mileage = 10; // good as new! There’s no relationship between the drive() function and the struct – if that function can modify it, so can anyone else Not to mention that having a bunch of functions floating around that relate to the struct is kind of messy…

More Problems with Structs When creating an instance of a struct, all the fields have default values until we explicitly set them – It’s easy to forget to set a field, with potentially disastrous results When a struct goes out of scope (e.g. the function in which it’s declared ends), it’s simply freed – It can’t do anything intelligent, like free up dynamic memory; as mentioned, this leads to memory leaks Back to the problem at hand: We need a way to associate structs and functions so that a function “belongs” to a struct

Enter Classes A class is very much like a struct, except that it contains both data and functions – Much like structs, classes are like blueprints When we build a house (or a car, or a person) out of a class, we call the resulting thing an instance – We call functions in a class methods – The fields of a class are often called members – The methods of a class operate on the data in the instance of a class (Minor exception: “static” members belong to the class itself and not to an instance)

Rewriting Our Car as a Class A class looks almost exactly like a struct (at first): class Car { string make, model; int mileage; }; We now add the methods we need to it (classes, ex. 2), specifically drive() In order to fix the problem of anyone being able to change the mileage, we have to introduce an additional concept: access protection

Classes and Access Protection Since structs are just data, there’s no way to indicate that only certain functions should be able to change certain fields of a struct Now that classes can have methods, we can identify methods as “privileged” to accessing certain data – They’re “privileged” in the sense that they can see and change data that outside code can’t Making data “privileged” is accomplished via “access protection specifiers”: – public: anyone can see/modify this data – private: only this class can see/modify this data – protected: this class and any classes that inherit from it can see/modify this data (don’t need to understand this) Access protection specifiers apply to methods as well – if a method is private, only that class can call it (usually from other, public methods of the class)

Back to the Car Class We’ll make mileage private so that the car dealer can’t change it – (except by calling the public method drive(), which can only increase it) Problem: how do we check the mileage? Solution: we write an “accessor method” (also called a “getter”), which just returns the value of a private member (classes, ex. 3) – This way, the value can be read, but not changed – In order to make these methods play nice with const references, we should flag any methods that don’t change the class’s data as ‘const’ Even more problematic: how do we set the mileage initially? – mileage is now private, so we can’t set it after we create it, e.g.: Car myCar; myCar.mileage = 0; // ^ error: it’s private! – We’ll address this problem with a constructor in a bit…

Using Methods of a Class First, let’s construct an instance of car: Car myCar; Now we can call methods of it like so: myCar.drive(100); // update our mileage We can use the accessors, too: cout << myCar.getMileage() << endl; Each method has access to a special keyword called this that points to the current instance on which the method was called – In this case, inside of drive() and getMileage(), this points to myCar – Since accessing a member of the current instance is so common, ‘this’ is implied – you can refer to mileage as either ‘mileage’ or ‘this->mileage’

The Car Class and Constructors If we make a new instance, we want the instance to start with valid data – mileage should be 0, for instance, and the make/model should always be set to something By default, we have to set these manually – even worse, private members like mileage can’t be set when we create the class This is where a constructor becomes useful, a special method that’s invoked when an instance is first created

Constructor Definition A constructor is created by defining a method with no return type and with the same name as its enclosing class, e.g.: class Car { private: string make, model; int mileage; public: Car() { mileage = 0; } }; The constructor will be run when the class is instantiated, e.g.: Car myCar; // mileage is set to 0

Constructors with Parameters We can optionally specify initial values for our other fields, like the make and model, accomplished by adding parameters to our constructor: class Car { private: string make, model; int mileage; public: Car(string make, string model) { this->make = make; this->model = model; mileage = 0; } };

Creating a Car Instance with a Parameterized Constructor Now that the Car constructor includes parameters, they must be specified like so: Car myCar(“Chevrolet”, “Malibu”); // make == “Chevrolet”, model == “Malibu” Note also the use of the special this pointer in the constructor – Always points to the current instance inside of a method – Usually implied, e.g. using ‘mileage’ inside of the constructor implicitly refers to ‘this->mileage;’ – You can use it explicitly when there’s a conflict between the name of a local variable/parameter and a member In the constructor example, parameters “make” and “model” shadow the members with the same names, thus this must be used to access the members

Aside #1: Multiple Constructors Say that you don’t want to require that the user of your class specify the make and model every time they make a car instance A class can contain multiple constructors, each one with a different “signature” (that is, the parameters for that method) – The appropriate method will be chosen based on the arguments that were given (classes, ex. 4) – It’s usually nice to have a constructor that takes no arguments (or at least the bare minimum), and include other constructors that allow the user to set other fields In general, the practice of using multiple functions with the same name, but different signatures is called overloading – Each function is actually distinct from the others; the function to call is determined by examining the arguments

Aside #2: Destructors Just as a constructor is called when an instance is created, a destructor is called when an instance is destroyed – This occurs when the instance goes out of scope (i.e. if the instance is a local variable in a function and the function ends) – It can also occur when a dynamically allocated instance is freed via the delete keyword Destructors follow the same naming convention as constructors (no return type, same name as class), with some caveats: – Their name begins with a tilde (~), e.g. ~Car() { } – Destructors don’t take any parameters, as there’s no way to specify what the parameters should be Destructors, like constructors, are optional, but are useful when you need to clean up after yourself – Most often used to free dynamic memory that belongs to the class

Classes Review Classes are the same as structs, except for the use of the class keyword and the ability to have methods, functions that operate on the class’s fields (which are called members) – (In fact, in C++ structs are actually classes that have all their data public as default) Methods and members can be public, private, or protected, which determines how code outside the class can interact with it – A class’s methods have access to all of that class’s data, public or private; only public methods of a class can be called, and public members accessed, from outside the class – It’s common to add public “getter” methods that return private fields, allowing them to be read but not modified “getters” should be const so that they can be used with const class references The this keyword, when used inside of the methods of a class, always refers to the current instance – Usually implied, so you can refer to a field of a class without it, but can be useful when a local variable/parameter has the same name as a field

Classes Review, Part 2 Classes can optionally include a special constructor method that sets up an instance – Has no return type, same name as the class – This constructor can include parameters, which must be specified when the class is created – A class can have multiple constructors differentiated by their signatures (namely, the parameters they take) Classes can also include a destructor which cleans up an instance when it’s destroyed – Defined the same way as a constructor… – …except that it has no parameters and has a tilde (~) before the class name – Since it takes no parameters, there can only be a single destructor for each class

Extra Dynamic Memory Exercise: a Car Repair Work Queue Let’s write a class that will keep track of a variable number of cars in a structure called a “queue” – First-in, first-out data structure We don’t want to waste space, so allocating a giant array isn’t going to work We’ll have to use both classes and dynamically allocated memory Refer to (carinventory, ex.1) for the code