1 / 37

Warm-Up Problem

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

vance
Télécharger la présentation

Warm-Up Problem

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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

More Related