Warm-Up Problem

1. Warm-Up Problem • Just like with primitive data types (int, double, etc.), we can create arrays of objects. • ex: bankAccount employees[100]; • Problem: It’s payday. Put $500 in each employee’s account. • for(int i = 0; i < 99; i++){ employees[i].deposit(500);} • (i < 99 should be i <= 99 or i < 100, but I'm leaving that be as a place for an alertness point in the review of this problem in future lectures. )

2. Classes:Member Functions and Starting Implementation Edited for CMPSC 122 Penn State University Prepared by Doug Hogan

3. Overview • Review and Follow Up • Preview of Implementation • Classification of Class Functions • Class interface and Functions • Review of the form • Constructors • Modifiers • Accessors

4. Review of Strings • Last time, we finished with a problem: • string returnedExpression(string inputString) • // PRE: inputString is a line of valid C++ code // (<=80 chars) containing the "return"// keyword and ending with a semicolon • // POST: FCTVAL == the expression that follows // the return keyword, not including the// semicolon • Recall the string member functions: • stringObject.length() • stringObject.find(string) • stringObject.substr(startLocation, length) • How do we use these functions to construct a solution?

5. Solution • string returnedExpression(string inputString) • // PRE: inputString is a line of valid C++ code (<=80 chars) containing // the "return" keyword and ending with a semicolon • // POST: FCTVAL == the expression that follows the return keyword, // not including the semicolon • First, find where "return" is located • int returnLoc = inputString.find("return"); • Next, find how long the string is • int exprLength = inputString.length(); • Find how long the expression is: • exprLength -= 1;// don’t want semicolon • exprLength -= returnLoc;// or stuff before "return" • exprLength -= 7;// or "return "

6. Solution • string returnedExpression(string inputString) • // PRE: inputString is a line of valid C++ code (<=80 chars) containing // the "return" keyword and ending with a semicolon • // POST: FCTVAL == the expression that follows the return keyword, // not including the semicolon • Finally, construct and return the expression as a substring: • return inputString.substr(returnLoc+7, exprLength);

7. Object Oriented Terms • Class • Object • Member • Encapsulation • Information Hiding • Message • Abstraction

8. Review: Library Book Problem • Your ideas? • member data? • member functions? • We’ll work with this set of member data: • string author; • string title; • int year; • string isbn;

9. A Preview of Implementation • Implementation of class member functions is similar to implementing nonmember functions • Function headers vs. function prototypes • The main difference: • Member functions need to know what class they belong to (their scope) • Scope resolution operator (::)

10. Scope Resolution • The class name and the scope resolution operator (::) go directly before the function name • e.g. voidbankAccount::withdraw(int amount) • NOTbankAccount::void withdraw(int amount)

11. default_acct scope resolution name balance “?” private member data 0 Implementation Example • Implementation of the bankAccount constructor: • bankAccount::bankAccount()// POST: default bankAccount object constructed with // name == “?” and balance == 0{ name = "?"; balance = 0;}

12. More Implementation Examples • voidbankAccount::deposit(int amount)// PRE: amount in dollars and amount > $0// POST: amount has been added on to balance{ balance = balance + amount;} • Problem: Implement withdraw. • voidbankAccount::withdraw(int amount)// PRE: amount in dollars and amount > $0// POST: amount has been subtracted from balance{ balance = balance - amount;}

13. Class Interface • Defines the WHAT, not the HOW • General form: • class className{ public:// member function declarations private:// member data declarations};

14. Three Types of Functions • Class member functions are classified into three categories: • constructors • create objects (allocate memory, set initial state) • modifiers • change the state of objects • accessors • make information about the state of the object available outside the class

15. Exercise • Classify the functions of bankAccount • constructors • bankAccount(); • modifiers • void withdraw(int amount); • void deposit(int amount); • accessors • double getBalance();

16. Continuing Bank Account… • Work with a partner to think of one more constructor, modifier, and accessor that would be good additions to the bankAccount class. • Your ideas??

17. Onward… • Now we'll look at each of the three kinds of member functions in more detail.

18. Constructors • Goal: • construct objects of the class • allocate memory • Four important observations… • name • return type • overloading • calling

19. 1. Constructors: Names • Constructors MUST have the same name as the class itself. • That's how you'll make instances of the class (objects). • Example: • bankAccount class • constructor: bankAccount(); • rectangle class • constructor: rectangle();

20. 2. Constructors – Return Type • They don't have a return type. It's simply omitted. • Ex: bankAccount(); • NOT void • NOT double, int, etc.

21. 3. Constructors - Overloading • Constructors can be overloaded • Can have several constructors • same name • different lists of parameters • This ability allows you to create • a default constructor • no parameters • initializer constructors • parameters specifying initial state of an object

22. 3. Constructors - Overloading • Example default constructor: • bankAccount();// POST: A default bankAccount object is // created with name set to a blank and // and balance set to $0.00 • Example initializer constructors: • bankAccount(string initName, double initBalance);// PRE: initName has been assigned a value // && initBalance >= 0.00 and initBalance is in // dollars // POST: A bankAccount object is created with // name set to initName// and balance set to initBalance • bankAccount(string initName); • bankAccount(double initBalance);

23. 4. Constructors – Calling (Client) • Not called directly, i.e. no dot notation • Default constructor call: • bankAccount myAcct; • no parentheses • Initializer constructor call: • bankAccount myAcct("Homer", 100);

24. Problem • Given the libraryBook class… • string author; • string title; • int year; • string isbn; • Define a default constructor. • Define two initializer constructors.

25. Problem • Define a default constructor. • libraryBook(); • Define two initializer constructors. • libraryBook(string initTitle, string initAuthor, string initISBN, int initYear); • libraryBook(string initTitle);

26. Another exercise… • Given the constructors we defined • libraryBook(); • libraryBook(string initTitle, string initAuthor, string initISBN, int initYear); • libraryBook(string initTitle); • Construct a default libraryBook object. • libraryBook book1; • Construct a libraryBook object with the initial title Algorithms Unlocked. • libraryBook book2("Algorithms Unlocked");

27. Modifiers • The functions that do most of the work. • Note: Objects have three characteristics: • name • state • set of operations • Modifiers define the set of operations.

28. Modifiers • Allow the client to make changes to the private variables. • Declarations look like the ones for nonmember functions. • Often, but not always, they have a void return type. • “Set” functions or setters • Modifiers that just "set" the value of a private variable from a parameter without doing any calculations

29. Modifiers - Examples • void withdraw(double amount);// PRE: amount >= 0.00 and amount // is in dollars // POST: amount is deducted from // balance • A set function: • void resetAccount(string newName, double newBalance);// PRE: newName has been assigned a value // && newBalance >= 0.00 and newBalance is // in dollars // POST: This account object is reset with // name set to newName and balance// set to newBalance

30. Accessors • Allow the client to see what values the private variables have. • Don't allow the client to make changes. • Return type is that of the variable being "accessed." • "Get" functions or getters • Accessors that just "get" the value of a private variable without doing any calculations

31. Accessors • Should be declared const • They don't change the state of any variables.  • Forces the issue of not making changes • Example: • double getBalance() const;// POST: FCTVAL == current // balance of this account // in dollars

32. More complicated accessors • Some calculation based on the data • as long as it doesn’t change the member data • e.g. balance after interest w/o actually crediting it • A data member converted to different units • e.g. Fahrenheit version of Celsius temp. • Part of a data member • e.g. the cents part of a dollar amount

33. Exercise • Declare an accessor for the libraryBook type. • string getTitle() const; • Write the function header for the accessor. • string libraryBook::getTitle() const

34. Pre- and Postconditions • A few new things to note • Preconditions • What must be true for the method to behave as intended • Anything about the state of the object? • Should another method have been called first? • May need to look at private data members individually

35. Pre- and Postconditions • Postconditions • What is the state of the object after this method has been called? What is returned or displayed? • What private data members have changed? How?

36. Summary • Implementation • Scope resolution operator (::) and class name directly before function name • Remove semicolons • Interface & functions • Constructors – create instances, allocate memory • same name as class • no return type • can have multiple with same name • not called with dot notation • Modifiers – change state of private variables, define operations • Accessors – allows client to see state of private variables • Pre- and postconditions

37. Preview of What’s to Come… • Implementation • Tips for implementing each kind of function • Client end • More on working with objects • Test drivers • More Examples • Advanced Issues • For next time: work on theblueworksheet and a short lab exercise