Ch 7. Constructors and Other Tools

Transcription

1 Ch 7. Constructors and Other Tools September 3, 2013 Advanced Networking Technology Lab. (YU-ANTL) Dept. of Information & Comm. Eng, Graduate School, Yeungnam University, KOREA (Tel : ; Fax : ytkim@yu.ac.kr)

2 Constructors Definitions Calling Outline More Tools const parameter modifier Inline functions Static member data ch 7-2

3 Initialization of objects Constructors Initialize some or all member variables Other actions possible as well A special kind of member function Automatically called when object declared Very useful tool Key principle of OOP ch 7-3

4 Constructor Definitions Constructors defined like any member function Except: 1) Must have same name as class 2) Cannot return a value; not even void! ch 7-4

5 Constructor Definition Example Class definition with constructor: class DayOfYear public: DayOfYear(int monthvalue, int dayvalue); //Constructor initializes month & day void input(); void output(); private: int month; int day; ch 7-5

6 Constructor Notes Notice name of constructor: DayOfYear Same name as class itself! Constructor declaration has no return-type Not even void! Constructor in public section It s called when objects are declared If private, could never declare objects! ch 7-6

7 Calling Constructors Declare objects: DayOfYear date1(7, 4), date2(5, 5); Objects are created here Constructor is called Values in parentheses passed as arguments to constructor Member variables month, day initialized: date1.month 7 date2.month 5 date1.dat 4 date2.day 5 ch 7-7

8 Consider: Constructor Equivalency DayOfYear date1, date2 date1.dayofyear(7, 4); // ILLEGAL! date2.dayofyear(5, 5); // ILLEGAL! Seemingly OK CANNOT call constructors like other member functions! ch 7-8

9 Constructor Code Constructor definition is like all other member functions: DayOfYear::DayOfYear(int monthvalue, int dayvalue) month = monthvalue; day = dayvalue; Note 1: same name around :: Clearly identifies a constructor Note 2: no return type Just as in class definition ch 7-9

10 Alternative Definition Previous definition equivalent to: DayOfYear::DayOfYear(int monthvalue, int dayvalue) : month(monthvalue), day(dayvalue) Third line called "Initialization Section" Body left empty Preferable definition version ch 7-10

11 Constructor Additional Purpose Not just initialize data Body doesn t have to be empty In initializer version Validate the data! Ensure only appropriate data is assigned to class private member variables Powerful OOP principle ch 7-11

12 Overloaded Constructors Can overload constructors just like other functions Recall: a signature consists of: Name of function Parameter list Provide constructors for all possible argument-lists Particularly "how many" ch 7-12

13 Class with Constructors Example ch 7-13

14 ch 7-14

15 ch 7-15

16 Constructor with No Arguments Can be confusing Standard functions with no arguments: Called with syntax: callmyfunction(); Including empty parentheses Object declarations with no "initializers": DayOfYear date1; // This way! DayOfYear date(); // NO! What is this really? Compiler sees a function declaration/prototype! Yes! Look closely! ch 7-16

17 Explicit Constructor Calls Can also call constructor AGAIN After object declared Recall: constructor was automatically called then Can call via object s name; standard member function call Convenient method of setting member variables Method quite different from standard member function call ch 7-17

18 Explicit Constructor Call Example Such a call returns "anonymous object" Which can then be assigned In Action: DayOfYear holiday(7, 4); Constructor called at object s declaration Now to "re-initialize": holiday = DayOfYear(5, 5); Explicit constructor call Returns new "anonymous object" Assigned back to current object ch 7-18

19 Default Constructor Defined as: constructor w/ no arguments One should always be defined Auto-Generated? Yes & No If no constructors AT ALL are defined Yes If any constructors are defined No If no default constructor: Cannot declare: MyClass myobject; With no initializers ch 7-19

20 Class Type Member Variables Class member variables can be any type Including objects of other classes! Type of class relationship Powerful OOP principle Need special notation for constructors So they can call "back" to member object s constructor ch 7-20

21 Class Member Variable Example: ch 7-21

22 ch 7-22

23 ch 7-23

24 ch 7-24

25 ch 7-25

26 Parameter Passing Methods Efficiency of parameter passing Call-by-value Requires copy be made Overhead Call-by-reference Placeholder for actual argument Most efficient method Negligible difference for simple types For class types clear advantage Call-by-reference desirable Especially for "large" data, like class types ch 7-26

27 The const Parameter Modifier Large data types (typically classes) Desirable to use pass-by-reference Even if function will not make modifications Protect argument Use constant parameter Also called constant call-by-reference parameter Place keyword const before type Makes parameter "read-only" Attempts to modify result in compiler error ch 7-27

28 Use of const If no need for function modifications Protect parameter with const Protect ALL such parameters void BankAccount::output() const Using const, we can also protect class member function s parameters void welcome(const BankAccount& youraccount) ch 7-28

29 // Display 7.4 The const Parameter Modifier #include <iostream> #include <cmath> #include <cstdlib> using namespace std; //Data consists of two items, an amount of money for the account balance //and a percent for the interest rate. class BankAccount public: BankAccount(double balance, double rate); //Initializes balance and rate according to arguments. BankAccount(int dollars, int cents, double rate); //Initializes the account balance to $dollars.cents. For a negative balance both //dollars and cents must be negative. Initializes the interest rate to rate percent. BankAccount(int dollars, double rate); //Initializes the account balance to $dollars.00 and //initializes the interest rate to rate percent. BankAccount( ); //Initializes the account balance to $0.00 and the interest rate to 0.0%. ch 7-29

30 void update( ); //Postcondition: One year of simple interest has been added to the account. void input( ); void output( ) const; double getbalance( ) const; int getdollars( ) const; int getcents( ) const; double getrate( ) const;//returns interest rate as a percent. void setbalance(double balance); void setbalance(int dollars, int cents); //checks that arguments are both nonnegative or both nonpositive void setrate(double newrate); //If newrate is nonnegative, it becomes the new rate. Otherwise abort program. private: //A negative amount is represented as negative dollars and negative cents. //For example, negative $4.50 sets accountdollars to -4 and accountcents to -50. int accountdollars; //of balance int accountcents; //of balance double rate; //as a percent int dollarspart(double amount) const; int centspart(double amount) const; int round(double number) const; double fraction(double percent) const; //Converts a percent to a fraction. For example, fraction(50.3) returns ; ch 7-30

31 //Returns true if the balance in account1 is greater than that //in account2. Otherwise returns false. bool islarger(const BankAccount& account1, const BankAccount& account2); void welcome(const BankAccount& youraccount); int main( ) BankAccount account1( , 4.5), account2; welcome(account1); cout << "Enter data for account 2:\ n"; account2.input( ); if (islarger(account1, account2)) cout << "account1 is larger.\ n"; else cout << "account2 is at least as large as account1.\ n"; return 0; bool islarger(const BankAccount& account1, const BankAccount& account2) return(account1.getbalance( ) > account2.getbalance( )); void welcome(const BankAccount& youraccount) cout << "Welcome to our bank.\ n" << "The status of your account is:\ n"; youraccount.output( ); ch 7-31

32 //Uses iostream and cstdlib: void BankAccount::output( ) const int absdollars = abs(accountdollars); int abscents = abs(accountcents); cout << "Account balance: $"; if (accountdollars < 0) cout << "-"; cout << absdollars; if (abscents >= 10) cout << "." << abscents << endl; else cout << "." << '0' << abscents << endl; cout << "Rate: " << rate << "%\ n"; BankAccount::BankAccount(double balance, double rate) : accountdollars(dollarspart(balance)), accountcents(centspart(balance)) setrate(rate); BankAccount::BankAccount(int dollars, int cents, double rate) setbalance(dollars, cents); setrate(rate); BankAccount::BankAccount(int dollars, double rate) : accountdollars(dollars), accountcents(0) setrate(rate); ch 7-32

33 BankAccount::BankAccount( ): accountdollars(0), accountcents(0), rate(0.0) /*Body intentionally empty.*/ void BankAccount::update( ) double balance = accountdollars + accountcents*0.01; balance = balance + fraction(rate)*balance; accountdollars = dollarspart(balance); accountcents = centspart(balance); //Uses iostream: void BankAccount::input( ) double balanceasdouble; cout << "Enter account balance $"; cin >> balanceasdouble; accountdollars = dollarspart(balanceasdouble); accountcents = centspart(balanceasdouble); cout << "Enter interest rate (NO percent sign): "; cin >> rate; setrate(rate); double BankAccount::getBalance( ) const return (accountdollars + accountcents*0.01); int BankAccount::getDollars( ) const return accountdollars; ch 7-33

34 int BankAccount::getCents( ) const return accountcents; void BankAccount::setBalance(double balance) accountdollars = dollarspart(balance); accountcents = centspart(balance); //Uses cstdlib: void BankAccount::setBalance(int dollars, int cents) if ((dollars < 0 && cents > 0) (dollars > 0 && cents < 0)) cout << "Inconsistent account data.\ n"; exit(1); accountdollars = dollars; accountcents = cents; double BankAccount::getRate( ) const return rate; //Uses cstdlib: void BankAccount::setRate(double newrate) if (newrate >= 0.0) rate = newrate; else cout << "Cannot have a negative interest rate.\ n"; exit(1); ch 7-34

35 int BankAccount::dollarsPart(double amount) const return static_cast<int>(amount); //Uses cmath: int BankAccount::centsPart(double amount) const double doublecents = amount*100; int intcents = (round(fabs(doublecents)))%100;//% can misbehave on negatives if (amount < 0) intcents = -intcents; return intcents; //Uses cmath: int BankAccount::round(double number) const return floor(number + 0.5); double BankAccount::fraction(double percent) const return (percent/100.0); ch 7-35

36 Inline Functions For non-member functions: Use keyword inline in function declaration and function heading For class member functions: Place implementation (code) for function IN class definition automatically inline class BankAccount public:... double getbalance() const return (accountdollars + accountcents*0.01); int getdollars() cost return accountdollars;... private: int accountdollars; int accountcents;... ch 7-36

37 Inline Member Functions Member function definitions Typically defined separately, in different file Can be defined IN class definition Makes function "in-line" Code actually inserted in place of call Eliminates overhead More efficient, but only when short! Use for very short functions only More efficient If too long actually less efficient! ch 7-37

38 Static Members Static member variables All objects of class "share" one copy One object changes it all see change Useful for "tracking" How often a member function is called How many objects exist at given time Place keyword static before type ch 7-38

39 Static Functions Member functions can be static If no access to object data needed And still "must" be member of the class Make it a static function Can then be called outside class From non-class objects: E.g., Server::getTurn(); As well as via class objects Standard method: myobject.getturn(); Can only use static data, functions! ch 7-39

40 Static Members Example ch 7-40

41 ch 7-41

42 ch 7-42

43 ch 7-43

44 Summary 7-1 Constructors: automatic initialization of class data Called when objects are declared Constructor has same name as class Default constructor has no parameters Should always be defined Class member variables Can be objects of other classes Require initialization-section ch 7-44

45 Summary 7-2 Constant call-by-reference parameters More efficient than call-by-value Can inline very short function definitions Can improve efficiency Static member variables Shared by all objects of a class ch 7-45

46 Homework Program C++ class for matrix (1) Write a header file Class_Mtrx.h with a class Mtrx with following members: /* Class_Mtrx.h */ class Mtrx public: Mtrx(int msize); Mtrx(double da[], int num_data, int msize); void print(); Mtrx add(mtrx); Mtrx multiply(mtrx); private: int msize; double **dm; double det; ; ch 7-46

47 (2) Write a C++ mtrx.cpp that implements the member functions: (1) Mtrx(int msize); - constructor that dynamically creates two dimensional array for the data member dm[msize][msize], and initialize the dm[][] with initial values of 0.0 (2) Mtrx(double da[], int msize); - constructor that receives an array da[msize * msize], and dynamically creates two dimensional array for the data member dm[msize][msize], and initialize the dm[][] with the given data (3) void print(); - prints out the dm[][] (4) Mtrx add(mtrx ma); - creates a Mtrx mr and calculates the addition of mr.dm[][] = this.dm[][] + ma.dm[][], and returns the mr (5) Mtrx multiply(mtrx); - creates a Mtrx mr and calculates the addition of mr.dm[][] = this.dm[][] x ma.dm[][], and returns the mr ch 7-47

48 (3) Use following main() function, and produce the results. /* main.cpp */ #define SIZE_N 5 void main() double ma[size_n*size_n] = 1.0, 2.0, 3.0, 4.0, 5.0, 2.0, 3.0, 4.0, 5.0, 1.0, 3.0, 2.0, 5.0, 3.0, 2.0, 4.0, 3.0, 2.0, 7.0, 2.0, 5.0, 4.0, 3.0, 2.0, 9.0 ; double mb[size_n*size_n] = 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0 ; Mtrx mtrxa(ma, SIZE_N*SIZE_N, SIZE_N); cout <<"MtrxA:\ n"; mtrxa.print(); Mtrx mtrxb(mb, SIZE_N*SIZE_N, SIZE_N); cout <<"MtrxB:\ n"; mtrxb.print(); ch 7-48

49 Mtrx mtrxc(size_n); cout <<"MtrxC:\ n"; mtrxc.print(); mtrxc = mtrxa.add(mtrxb); cout <<"MtrxC = mtrxa.addmtrx(mtrxb) :\ n"; mtrxc.print(); Mtrx mtrxd(size_n); mtrxd = mtrxa.multiply(mtrxb); cout <<"MtrxD = mtrxa.multiply(mtrxb) :\ n"; mtrxd.print(); // end main() ch 7-49

50 7.2 Programming projects 7-8. (histogram of grades) ch 7-50