Class Functions and Conversions

1. 11 Class Functions and Conversions

2. Contents • Assignment • Additional class features • Operator functions • Data type conversions • Random numbers and simulations • Class inheritance • Polymorphism • Common programming errors

3. Assignment • Memberwise assignment: Allows assignment of data member values of an object to their counterparts in another object of the class • Compiler builds this type of default assignment if there are no instructions to the contrary • Assignment operators: • Declared in class declaration section • Defined in class implementation section • Example: a = b; in main() of Program 13.1

4. Assignment Program 11.1: Assignment Example: Declaration #include <iostream> #include <iomanip> using namespace std; // class declaration class Date { private: int month; int day; int year; public: Date(int = 7, int = 4, int = 2005); // constructor prototype void showDate(); // member function to display a Date };

5. Assignment Program 11.1: Assignment Example: Implementation // implementation section Date::Date(int mm, intdd, intyyyy) { month = mm; day = dd; year = yyyy; } void Date::showDate() { cout << setfill ('0') << setw(2) << month << '/' << setw(2) << day << '/' << setw(2) << year % 100; return; }

6. Assignment Program 11.1: Assignment Example: main() int main() { Date a(4,1,1999), b(12,18,2006); // declare two // objects cout << "\nThe date stored in a is originally "; a.showDate(); // display the original date a = b; // assign b's value to a cout << "\nAfter assignment the date stored in a is "; a.showDate(); // display a's values cout << endl; return 0; }

7. Assignment • Assignment operator declaration: • Format:void operator=(Date& ); • Declares simple assignment operator for Date class of Program 11.1 • Add to public section of class declarations • Keyword void: Assignment returns no value • operator= indicates overloading of assignment operator with new version • (className& ): Argument to operator is class reference

8. Assignment • Assignment operator implementation format: void Date::operator=(Date& newdate) { day = newdate.day; // assign the day month = newdate.month; // assign the month year = newdate.year; // assign the year } • Add to implementation section of Program 11.1 • newdate: a reference to the Date class • Reference parameters facilitate overloaded operators • day, month, and year members of newdate: Assigned to corresponding members of current object

9. Assignment • Program 11.2: Program 11.1 + declaration and implementation of overloaded assignment operator (operator=) • Allows for assignments such as: a.operator= (b); • Calls overloaded assignment operator to assign b’s members to a • a.operator = (b)can be replaced with a = b;

10. Assignment • Other issues affecting assignment operators • Use constant reference parameter • Format: void Date::operator=(const Date& secdate); • Precludes inadvertent change to secdate • Assignment returns no value • Cannot be used in multiple assignments such as: a = b = c • Reason: a = b = c equivalent to a = (b = c) • But (b = c) returns no value making assignment to a an error

11. Copy Constructors • Copy constructor: Initializes an object using another object of same class • Example: Two equivalent formats Date b = a; Date b(a); • Default copy constructor: Constructed by compiler if none declared by programmer • Similar to default assignment constructor • Performs memberwise copy between objects • Does not work well with pointer data members

12. Copy Constructors • Format: className(const className&); • Function name must be class name • Parameter is reference to class • Parameter specified as const to prevent inadvertent change • Declaration: Copy constructor for Date class Date(const Date&);

13. Copy Constructors • Implementation: Copy constructor for Date class Date::Date(const Date& olddate) { month = olddate.month; day = olddate.day; year = olddate.year; }

14. Copy Constructors c = a; Date c = a; Assignment Initialization Type definition Figure 11.1: Initialization and assignment

15. Base/Member Initialization • Copy constructor does not perform true initialization • Creates and then assigns • Base/Member initialization list: Initializes an object with no assignment • List can be applied only to constructor functions

16. Base/Member Initialization • Base/Member initialization list construction: Two methods • Construct list in class declaration section: public: Date(int mo = 7, int da = 4, int yr = 2006): month(mo), day(da), year (yr) { }

17. Base/Member Initialization • Base/Member initialization list construction: Two methods (continued) • Declare prototype in declaration section, and create list in implementation section // class declaration section public: Date(int = 7, int = 4, int = 2006); // prototype with defaults // class implementation section Date::Date(int mo, int da, int yr) : month(mo), day(da),year(yr) {}

18. Additional Class Features • Additional features include: • Class scope • Static class members • Granting access privileges to nonmember functions

19. Class Scope • The scope of a variable defines the portion of a program where the variable can be assessed • Local variable scope is defined by any block inside a brace pair, {} • Each class defines an associated class scope • Names of data and function members are local to the scope of their class

20. Class Scope • Global variables can be assessed from their point of declaration throughout the remaining portion of the file containing them with three exceptions • If a local variable has the same name, the global variable must be referenced with the scope resolution operator :: • A global variable’s scope can be extended into another file via the extern keyword • Same global name can be used in another file to define a separate variable via static keyword

21. Class Scope • If global variable name is reused in a class, the global variable is hidden by the class member • Local variables hide the names of class data members having the same name • Member function names can only be used by objects declared for the class

22. Class Scope • Example: scope of variables and functions double rate; // global // class declaration class Test { private: double amount, price, total; // class scope public: double extend(double, double); // class scope }

23. Global(file)scope Classscope Local(block)scope double Test::extend(double amt, double pr) { amount = amt; price = pr; total = rate * amount * price; } Classscope Classscope Global(file)scope Class Scope Figure 11.2 Example of scopes

24. Static Class Members • As each class object is created, it gets its own block of memory for its data members • In some cases, it is convenient for every instantiation of a class to share the same memory location for a specific variable

25. Static Class Members Figure 11.3 Sharing the static data member taxRate

26. Friend Functions • Private variables can be accessed and manipulated through a class’s member functions Figure 11.4a Direct access provided to member functions

27. Friend Functions • External access to private functions can be granted through the friends list mechanism • The friends list members are granted the same privileges as a class’s member functions • Nonmember functions in the list are called friend functions • Friends list: Series of function prototype declarations preceded with the friend keyword

28. Friend Functions • Program 11.6 • #include <iostream> • #include <cmath> • using namespace std; • // class declaration • class Complex • { • // friends list • friend double addreal(Complex&, Complex&); • friend double addimag(Complex&, Complex&); • private: • double real; • double imag; • public: • Complex(double = 0, double = 0); // constructor • void display(); • };

29. Friend Functions • Program 11.6 (Continued) • // implementation section • Complex::Complex(double rl, double im) • { • real = rl; • imag = im; • } • void Complex::display() • { • char sign = '+'; • if(imag < 0) sign = '-'; • cout << real << sign << abs(imag) << 'i'; • return; • }

30. Friend Functions • Program 11.6 (Continued) • // friend implementations • double addreal(Complex &a, Complex &b) • { • return(a.real + b.real); • } • double addimag(Complex &a, Complex &b) • { • return(a.imag + b.imag); • }

31. Friend Functions • Program 11.6 (Continued) • int main() • { • Complex a(3.2, 5.6), b(1.1, -8.4); • double re, im; • cout << "\nThe first complex number is "; • a.display(); • cout << "\nThe second complex number is "; • b.display(); • re = addreal(a,b); • im = addimag(a,b); • Complex c(re,im); // create a new Complex object • cout << "\n\nThe sum of these two complex numbers is "; • c.display(); • cout << endl; • return 0; • }

32. Operator Functions • Only the symbols in Table 11.1 can be used for user-defined purposes • New operator symbols cannot be created • Neither the precedence nor the associativity of the C++ operators can be modified

33. Operator Functions • A user-defined operation is created as a function that redefines C++ built-in operator symbols for class use • Functions that define operations on class objects and use C++ built-in operator symbols are operator functions • Function name connects operator symbol to operation defined by function • Operator function name has format operator<symbol>

34. Operator Functions • Program 11.8 • #include <iostream> • using namespace std; • // class declaration • class Date • { • private: • int month; • int day; • int year; • public: • Date(int = 7, int = 4, int = 2005); //constructor • bool operator == (const Date &); • // declare the operator== function • };

35. Operator Functions • Program 11.8 (Continued) • // implementation section • Date::Date(int mm, intdd, intyyyy) • { • month = mm; • day = dd; • year = yyyy; • } • bool Date::operator==(const Date &date2) • { • if(day == date2.day && month == date2.month && year == date2.year) • return true; • else • return false; • }

36. Operator Functions • Program 11.8 (Continued) • int main() • { • // declare 3 objects • Date a(4,1,2008), b(12,18,2001), c(4,1,2008); • if (a == b) • cout << "\nDates a and b are the same." << endl; • else • cout << "\nDates a and b are not the same." << endl; • if (a == c) • cout << "Dates a and c are the same.\n" << endl; • else • cout << "Dates a and c are not the same.\n" << endl; • return 0; • }

37. Operator Functions as Friends • Functions in Programs 11.7 and 11.8 constructed as class members • All operator functions (except for =, (), [], ->) may be written as friend functions • Example: operator+() function from Program 11.8 • If written as friend, suitable prototype would be friend Date operator+ (Date&, int); • Friend version contains reference to Date object that is not contained in member version • Table 11.2: shows equivalence of functions and arguments required

38. Table 11.2 Operator function argument requirements Operator Functions as Friends

39. Operator Functions as Friends • Program 11.8’s operator+() function, written as a friend Date operator+(Date& op1, int days) { Date temp; // a temporary Date to store the result temp.day = op1.day + days; // add the days temp.month = op1.month; temp.year = op1.year; while (temp.day > 30) // now adjust the months { temp.month++; temp.day -= 30; } while (temp.month > 12) // adjust the years { temp.year++; temp.month -= 12; } return temp; // the values in temp are returned }

40. Operator Functions as Friends • Difference between the member and friend versions of operator+()function: Explicit use of additional Date parameter (op1) • Convention for choosing between friend or member implementation: • Member function: Better for binary functions that modify neither operand (such as ==, +, -) • Friend function: Better for binary functions that modify one of their operands

41. Operator Functions as Friends • Most operator functions can be written as friend functions • Exceptions include =, (), [], and -> • In all cases, the friend version of a member operator function must contain an additional class reference that the member function doesn’t require Table 11.2 Operator Function Argument Requirements

42. Data Type Conversions • Conversion from one built-in data type to another discussed in Chapter 3 • Introduction of user-defined data types expands possibilities to following cases • Conversion from built-in type to built-in type • Conversion from built-in type to class (user-defined) type • Conversion from class (user-defined) type to built-in type • Conversion from class (user-defined) type to class (user-defined) type

43. Data Type Conversions • Conversion from built-in to built-in: • Implicit conversion: Occurs in context of a C++ operation • Example: When double precision number is assigned to integer variable, only integer portion stored • Explicit conversion: Occurs when cast is used • Format dataType (expression)

44. Data Type Conversions • Conversion from built-in to class: Done using constructor functions • Type conversion constructor: Constructor whose first argument is not member of its class and whose remaining arguments, if any, have default values • If the first argument is built-in data type, the constructor can be used to cast built-in data type to class object • Program 11.9 demonstrates this conversion type

45. Data Type Conversions • Program 11.9 • #include <iostream> • #include <iomanip> • using namespace std; • // class declaration • class Date • { • private: • int month, day, year; • public: • Date(int = 7, int = 4, int = 2005); // constructor • Date(long); // type conversion constructor • void showDate(); • };

46. Data Type Conversions • Program 11.9 (Continued) • // implementation section • // constructor • Date::Date(int mm, intdd, intyyyy) • { • month = mm; • day = dd; • year = yyyy; • } • // type conversion constructor from long to date • Date::Date(long findate) • { • year = int(findate/10000.0); • month = int((findate - year * 10000.0)/100.0); • day = int(findate - year * 10000.0 - month * 100.0); • }

47. Data Type Conversions • Program 11.9 (Continued) • // member function to display a date • void Date::showDate() • { • cout << setfill('0') • << setw(2) << month << '/' • << setw(2) << day << '/' • << setw(2) << year % 100; • return; • }

48. Data Type Conversions • Program 11.9 (Continued) • int main() • { • Date a, b(20101225L), c(4,1,1999); // declare 3 objects • cout << "\nDates a, b, and c are "; • a.showDate(); • cout << ", "; • b.showDate(); • cout << ", and "; • c.showDate(); • cout << ".\n"; • a = Date(20110103L); // cast a long to a date • cout << "Date a is now "; • a.showDate(); • cout << ".\n\n"; • return 0; • }

49. Data Type Conversions • Conversion from class to built-in: Done by using: • Conversion operator function: Member operator function that has name of built-in data type or class • When operator function has built-in data type name, it is used to convert from class to built-in data type • Usage of this type of function demonstrated in Program 11.10

50. Data Type Conversions • Conversion from class to class: Done using member conversion operator function • Same as cast from user-defined to built-in data type • In this case, operator function uses class name being converted to rather than built-in data name • Demonstrated in Program 11.11