Classes: Member Functions and Implementation

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

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

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

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

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

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

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

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. 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. Constructors • Goal: • construct objects of the class • allocate memory • Four important observations… • name • return type • overloading • calling

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. 2. Constructors – Return Type • They don't have a return type. It's simply omitted. • Ex: bankAccount(); • NOT void • NOT double, int, etc.

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. 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. 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. Problem • Given the libraryBook class… • string author; • string title; • int year; • string isbn; • Define a default constructor. • Define two initializer constructors.

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

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. 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. 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. 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. 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. 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. 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. Exercise • Declare an accessor for the libraryBook type. • string getTitle() const; • Write the function header for the accessor. • string libraryBook::getTitle() const

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