Exceptions An exception signals an error, and has the ability to propagate upward through the call stack for easier management To “raise” an exception, syntax: throw “Error message here.\n”; The argument to “throw” can be any type object – e.g. to hold more data about the current context of the exception

Exceptions To catch an exception, enclose the volatile code in a try{ … } block Then the optional following catch (ExceptionType e) { … } block gets triggered when the type of the exception matches ExceptionType, and the argument to “throw” gets stored in “e”. The catch block is then executed and the code continues after the entire try…catch sequence Uncaught exceptions typically cause programs to halt, but can depend on their execution environment

Example: Divide By Zero Write a function to calculate x/y If y is 0, throw an exception

Example: Overloaded [] operator For a list, overload the [] operator, but throw an exception when the passed index is out of bounds Prototype: ReturnType& ClassName::operator[](IndexType b); Useful for lists, but have to handle out-of-bounds via exceptions or other error handling Can overload for specific object parameters, for more semantic indexing

Advanced Class Features Static vs instance members Static: bound to the class itself as a globally accessible variable Instance: bound to individual objects of the class E.g. class Student{ static int studentCount; //shared across all instances std::string name; // Specific to single instances }

Static Member variables Declared with “static” modifier before type Must be initialized outside the class (unless also a const) E.g. int Student::studentCount = 0; Shared across all class members Can also be accessed by ClassName::varName if it is public

Static member functions Declared with “static” before the return type Cannot access any instance variables Does not need a class to be instantiated to call: MyClass::someStaticFunc() Can also be called from a class object: instanceObj.someStaticFunc()

Friends of Classes We can specify that functions (or entire classes) are allowed to access private members of a certain class Syntax: friend ReturnType FunctionName (ParameterTypeList) Can also declare entire classes a friend, but isn’t generally useful, since it allows access to any member functions of the friend, even ones added later Better off just combining the classes

Inheritance Often, software encapsulates multiple concepts for which some attributes/behaviors overlap E.g. A computer (role-playing) game has: Monsters: name, location, hp, equipment, faction, AI details, etc. Players: name, location, hp, equipment, customization, input handling, etc. Objects: name, location, type, effects, price, etc. C++ provides semantics to help prevent duplication of functionality (not through templates), and allowing classes to be related to each other

Subclasses Syntax: class ParentClass{ … }; class ChildClass : ParentClass { … } We call ParentClass the “Base Class” and ChildClass the “Derived Class” In a derived class, it inherits all members of the base class! Methods Attributes However, access may be limited

Class Access Private members of a base class are inaccessible to the derived classes, unless through accessible mutators/accessors What about public? We can control their behavior! New access specifier: “protected” Same as private, but will change subclass behavior

Subclass Access The access specification (public, protected, private) determines how the base class members are inherited class ChildClass : public ParentClass { … } class ChildClass : protected ParentClass { … } class ChildClass : private ParentClass { … } class ChildClass : ParentClass { … } // Defaults to private

Subclass AcCess

Subclass Access

Subclass Access Summary: Base class private members are never (directly) accessible from derived But they’re still there! “private” makes public and protected base members private in the derived class “protected” makes public and protected base members protected in the derived class “public” keeps public and protected base members the same access in the derived class

Subclass creation/deletion What needs to happen when we have B : A and then call “new B()” ? Since B has all the same attributes as A, it makes sense that they need to be initialized the same way for a regular A object The base class constructor is called first, then the derived class constructor When destructing, they are called in reverse order (derived first, then base)

Non-Default Constructors If we need to pass arguments to the base constructor, we can! Consider classes Rectangle, and Cube : Rectangle Suppose rectangle holds the length and width of a rectangle Cube adds a height member Rectangle has non-default ctor: Rectangle(int len, int wid) If we want the non-default ctor for cube, we can define: Cube(int l, int w, int h) : Rectangle(w, l) { height = h; } Calls Rectangle(w, l) first, then sets the height

Constructor Summary General format: ClassName::ClassName(ParameterList) : BaseClassName(ArgumentList) But by default, the base default constructor will be called first, so we can omit the second half if we’re ok with that

Redefining Inherited Members Main idea: we can re-define (aka override) inherited member functions or variables Be careful of naming conflicts, they do not throw errors! Example: override “Person” name getter to add title

Class Hierarchy One can chain inheritence Parlance: A B D C If A is a class, and B : A We can also write C : B C would inherit from B as normal We can also add D : A Parlance: “B is a A” “C is a B” ”D is a A” A B D C

Polymorphism Main idea: a reference/pointer to a particular object can also serve as a reference/pointer to any superclass of that object E.g. If we have class “Person” and “Faculty : Person” we can do Person* p = new Faculty( … ); // Different types, but is valid! E.g. If we have class “Person” and “Faculty : Person” We can define function print(Person& p), then call it with a “Faculty” argument! But, as written, will not call overloaded members inside “Faculty”

Polymorphism Dynamic Binding: Determining which functions to call at runtime, versus at compile time In the polymorphic example above, any private members of the ”Person& p” parameter are bound at compile time I.e. if we overloaded any, they would be ignored :( We can enable dynamic binding by using the virtual keyword in the prototype: virtual returnType functionName( parameterList ); The compiler will then not bind and wait until runtime The virtual keyword is inherited by any overrides

Polymorphism In general, any potential super class should have a virtual destructor Using the example above: Person* p = new Faculty(); // Calls both constructors delete p; // Only calls the Person destructor!

Inheritance Pitfalls Overriding a member that you should not E.g. id number attributes Prevent with final modifier at the end of the prototype, e.g., virtual returnType funcName(params) const final; Failing to override a function because (slightly) different signature Class Person{ functionA() const; } Class Faculty : Person { functionA(); } Bad bad bad! Does not override! The compiler can help: keyword override tells it that it should be overriding a base class member, e.g., virtual returnType funcName(params) const override;

Abstract Base Class An “Abstract” class is a class which contains a pure virtual function Pure virtual function has the virtual keyword and is prototyped with “= 0”, e.g., virtual int getNumber() const = 0; // pure virtual Abstract classes cannot be directly instantiated, and any non-virtual subclasses must override all pure virtual functions

Multiple Inheritance With similar syntax, a class can inherit from multiple base classes To justify this, return to the “building blocks” analogy of inheritance Can be difficult because of ambiguous member definitions More information in the book Not covered in detail in this course

Standard Library A set of packaged generics that come with standard C++ Examples Doubly linked lists Queues Stacks Maps Multi-threading … Full list: http://en.cppreference.com/w/cpp/header

Example: Polymorphism In Games Write a text-based adventure that lets the user choose different options, changing the “state” of the game with each option Main Idea: The state will be an instance of a polymorphic class, where state- specific actions override some super-class We will employ some standard library tools