1. Classes: Member Functions and Implementation November 22, 2002 CSE103 - Penn State University Prepared by Doug Hogan

2. 2 Announcements Homework 5 is due Monday. Correction to lab 12 handout: Surface area of a cylinder is 2  r 2 + 2  rh. No class next Wednesday.

3. 3 Overview Review Implementation Class interface and Functions Review of the form Constructors Modifiers Accessors

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

5. 5 Review Implementation of class member functions is similar to 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 ( :: )

6. 6 Scope Resolution The class name and the scope resolution operator ( :: ) go directly before the function name e.g. void bankAccount::withdraw(int amount) NOT bankAccount::void withdraw(int amount)

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

8. 8 More Implementation Examples void bankAccount::deposit(int amount) // PRE: amount in dollars and amount > $0 // POST: amount had been added on to balance { balance = balance + amount; } Exercise: Implement withdraw. void bankAccount::withdraw(int amount) // PRE: amount in dollars and amount > $0 // POST: amount had been subtracted from the balance { balance = balance - amount; }

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

10. 10 Review What are the three categories of member functions? 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

11. 11 Continuing Bank Account… Last time I asked you to… Think of one more constructor, modifier, and accessor that would be good additions to the bankAccount class. Your ideas??

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

13. 13 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();

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

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

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

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

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

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

20. 20 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 Starting Out With C++. libraryBook book2(“Starting Out With C++”);

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

22. 22 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 Modifiers that just "set" the value of a private variable from a parameter without doing any calculations

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

24. 24 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 Accessors that just “get" the value of a private variable from a parameter without doing any calculations

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

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

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

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

29. 29 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?

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

31. 31 Preview of What’s Next… Implementation Tips for implementing each kind of function Client end More on working with objects Test drivers More Examples Odds and Ends from Chapter 13 For next time: work on the blue worksheet