Friends, Overloaded Operators, and Arrays in Classes

Trang 2

Chapter 11

Friends, Overloaded Operators,

and Arrays in Classes

Trang 3

11.1 Friend Functions

11.2 Overloading Operators

11.3 Arrays and Classes

11.4 Classes and Dynamic Arrays

Trang 4

11.1

Friend Functions

Trang 5

Friend Function

 Class operations are typically implemented

as member functions

 Some operations are better implemented as

ordinary (nonmember) functions

Trang 6

Slide 11- 6

Program Example:

An Equality Function

 The DayOfYear class from Chapter 6 can

be enhanced to include an equality function

 An equality function tests two objects of

type DayOfYear to see if their values represent

the same date

 Two dates are equal if they represent the same day and month

Trang 7

Declaration of

The equality Function

 We want the equality function to return a value

of type bool that is true if the dates are the same

 The equality function requires a parameter for

each of the two dates to compare

 The declaration is

bool equal(DayOfYear date1, DayOfYear date2);

 Notice that equal is not a member of the class

Trang 8

Slide 11- 8

Defining Function equal

 The function equal, is not a member function

 It must use public accessor functions to obtain the

day and month from a DayOfYear object

 equal can be defined in this way:

bool equal(DayOfYear date1, DayOfYear date2)

Trang 9

Display 11.1 (1) Display 11.1 (2) Display 11.1 (3)

Using The Function equal

 The equal function can be used to compare dates

Trang 10

Slide 11- 10

Is equal Efficient?

 Function equal could be made more efficient

 Equal uses member function calls to obtain the private data values

 Direct access of the member variables would

be more efficient (faster)

Trang 11

A More Efficient equal

 As defined here, equal is more efficient,

but not legal

bool equal(DayOfYear date1, DayOfYear date2){

return (date1.month = = date2.month

&&

date1.day = = date2.day );

}

 The code is simpler and more efficient

 Direct access of private member variables is not legal!

Trang 12

 A friend function is not a member function

 A friend function is an ordinary function

 A friend function has extraordinary access to data members of the class

 As a friend function, the more efficient version

of equal is legal

Trang 13

Declaring A Friend

 The function equal is declared a friend in the

abbreviated class definition here

class DayOfYear {

Trang 14

Slide 11- 14

Display 11.2

Using A Friend Function

 A friend function is declared as a friend in the

class definition

 A friend function is defined as a nonmember

function without using the "::" operator

 A friend function is called without using the

'.' operator

Trang 15

Friend Declaration Syntax

 The syntax for declaring friend function is

Member_Function_Declarations

private:

Private_Member_Declarations

};

Trang 16

Slide 11- 16

Are Friends Needed?

 Friend functions can be written as non-friend

functions using the normal accessor and mutator functions that should be part of the class

 The code of a friend function is simpler and it is

more efficient

Trang 17

Choosing Friends

 How do you know when a function should be

a friend or a member function?

 In general, use a member function if the task

performed by the function involves only one object

 In general, use a nonmember function if the task

performed by the function involves more than

one object

 Choosing to make the nonmember function a friend is

a decision of efficiency and personal taste

Trang 18

Slide 11- 18

Display 11.3 (1 – 5)

Program Example:

The Money Class (version 1)

 Display 11.3 demonstrates a class called Money

 U.S currency is represented

 Value is implemented as an integer

representing the value as if converted to

pennies

 An integer allows exact representation of the value

 Type long is used to allow larger values

 Two friend functions, equal and add, are used

Trang 19

Characters to Integers

 Notice how function input (Display 11.3)

processes the dollar values entered

 First read the character that is a $ or a –

 If it is the -, set the value of negative to true and read the

$ sign which should be next

 Next read the dollar amount as a long

 Next read the decimal point and cents as three

characters

 digit_to_int is then used to convert the cents characters to integers

Trang 20

 A digit, such as '3' is parameter c

 This is the character '3' not the number 3

 The type cast int(c) returns the number that

implements the character stored in c

 The type cast int('0') returns the number that

implements the character '0'

Trang 21

int( c) – int ('0')?

 The numbers implementing the digits are in

in order

 int('0') + 1 is equivalent to int('1')

 int('1') + 1 is equivalent to int('2')

Trang 22

Slide 11- 22

Leading Zeros

 Some compilers interpret a number with a

leading zero as a base 8 number

 Base 8 uses digits 0 – 7

 Using 09 to represent 9 cents could cause an error

 the digit 9 is not allowed in a base 8 number

 The ANSI C++ standard is that input should be interpreted

as base 10 regardless of a leading zero

Trang 23

Parameter Passing Efficiency

 A call-by-value parameter less efficient than a

call-by-reference parameter

 The parameter is a local variable initialized to the

value of the argument

 This results in two copies of the argument

 A call-by-reference parameter is more efficient

 The parameter is a placeholder replaced by the

argument

 There is only one copy of the argument

Trang 24

Slide 11- 24

Class Parameters

 It can be much more efficient to use

call-by-reference parameters when the parameter

is of a class type

 When using a call-by-reference parameter

 If the function does not change the value of the parameter, mark the parameter so the compiler knows it should not be changed

Trang 25

const Parameter Modifier

 To mark a call-by-reference parameter so it

cannot be changed:

 Use the modifier const before the parameter

type

 The parameter becomes a constant parameter

 const used in the function declaration and

definition

Trang 26

Slide 11- 26

const Parameter Example

 Example (from the Money class of Display 11.3):

 A function declaration with constant parameters

 friend Money add(const Money& amount1,

const Money& amount2);

 A function definition with constant parameters

 Money add(const Money& amount1,

const Money& amount2) {

… }

Trang 27

const Considerations

 When a function has a constant parameter,

the compiler will make certain the parameter

cannot be changed by the function

 What if the parameter calls a member function?

Money add(const Money& amount1,

const Money& amount2)

Trang 28

Slide 11- 28

const

And Accessor Functions

 Will the compiler accept an accessor function

call from the constant parameter?

Money add(const Money& amount1, const Money& amount2)

{ …

amount1.output(cout);

}

 The compiler will not accept this code

 There is no guarantee that output will not change the value of the parameter

Trang 29

const Modifies Functions

 If a constant parameter makes a member function

call…

 The member function called must be marked so

the compiler knows it will not change the parameter

 const is used to mark functions that will not change

the value of an object

 const is used in the function declaration and the

function definition

Trang 30

Slide 11- 30

Function Declarations

With const

 To declare a function that will not change the

value of any member variables:

 Use const after the parameter list and

just before the semicolon

Trang 31

Function Definitions

With const

 To define a function that will not change the

value of any member variables:

 Use const in the same location as the function declaration

void Money::output(ostream& outs) const

{

// output statements

}

Trang 32

Slide 11- 32

const Problem Solved

 Now that output is declared and defined using

the const modifier, the compiler will accept

this code

 Money add(const Money& amount1,

const Money& amount2)

{ …

amount1.output(cout);

}

Trang 33

Display 11.4

const Wrapup

 Using const to modify parameters of class types

improves program efficiency

 const is typed in front of the parameter's type

 Member functions called by constant parameters

must also use const to let the compiler know

they do not change the value of the parameter

 const is typed following the parameter list in the

declaration and definition

Trang 34

Slide 11- 34

Use const Consistently

 Once a parameter is modified by using const to

make it a constant parameter

 Any member functions that are called by the

parameter must also be modified using const to

tell the compiler they will not change the parameter

 It is a good idea to modify, with const, every

member function that does not change a member

variable

Trang 35

Section 11.1 Conclusion

 Can you

 Describe the promise that you make to the

compiler when you modify a parameter with const?

 Explain why this declaration is probably not

Trang 36

11.2

Overloading Operators

Trang 37

 In the Money class, function add was used to

add two objects of type Money

 In this section we see how to use the '+' operator

to make this code legal:

Money total, cost, tax;

…total = cost + tax;

// instead of total = add(cost, tax);

Trang 38

 With a binary operator, the arguments are on either

side of the operator

cost + tax

Trang 39

Operator Overloading

 Operators can be overloaded

 The definition of operator + for the Money

class is nearly the same as member function add

 To overload the + operator for the Money class

 Use the name + in place of the name add

 Use keyword operator in front of the +

 Example:

friend Money operator + (const Money& amount1…

Trang 40

Slide 11- 40

Operator Overloading Rules

 At least one argument of an overloaded operator

must be of a class type

 An overloaded operator can be a friend of a class

 New operators cannot be created

 The number of arguments for an operator cannot

be changed

 The precedence of an operator cannot be changed

 , ::, *, and ? cannot be overloaded

Trang 41

Display 11.5 (1) Display 11.5 (2)

Program Example:

 The Money class with overloaded operators

+ and = = is demonstrated in

Trang 42

Slide 11- 42

Automatic Type Conversion

 With the right constructors, the system can do

type conversions for your classes

 This code (from Display 11.5) actually works

Money base_amount(100, 60), full_amount;

full_amount = base_amount + 25;

 The integer 25 is converted to type Money so it

can be added to base_amount!

 How does that happen?

Trang 43

Type Conversion Event 1

 When the compiler sees base_amount + 25,

it first looks for an overloaded + operator to

perform

Money_object + integer

 If it exists, it might look like this

friend Money operator +(const Money& amount1,

const int& amount2);

Trang 44

Slide 11- 44

Type Conversion Event 2

 When the appropriate version of + is not found,

the compiler looks for a constructor that takes

a single integer

 The Money constructor that takes a single parameter

of type long will work

 The constructor Money(long dollars) converts 25

to a Money object so the two values can be added!

Trang 45

Type Conversion Again

 Although the compiler was able to find a

Trang 46

Slide 11- 46

A Constructor For double

 To permit base_amount + 25.67, the following

constructor should be declared and defined

Trang 47

Overloading Unary Operators

 Unary operators take a single argument

 The unary – operator is used to negate a value

x = -y

 ++ and - - are also unary operators

 Unary operators can be overloaded

 The Money class of Display 11.6 can includes

 A binary – operator

 A unary – operator

Trang 48

Slide 11- 48

Display 11.6

Overloading

- Overloading the – operator with two parameters

allows us to subtract Money objects as in

Money amount1, amount2, amount2;

…

amount3 = amount1 – amount2;

 Overloading the – operator with one parameter

allows us to negate a money value like this

amount3 = -amount1;

Trang 49

Operand 1

Operator

Operand 2

Overloading << and >>

 The insertion operator << is a binary operator

 The first operand is the output stream

 The second operand is the value following <<

cout << "Hello out there.\n";

Trang 50

Slide 11- 50

Replacing Function output

 Overloading the << operator allows us to

use << instead of Money's output function

 Given the declaration: Money amount(100);

amount.output( cout );

can become

Trang 51

Display 11.7

What Does << Return?

 Because << is a binary operator

cout << "I have " << amount << " in my purse.";

seems as if it could be grouped as

( (cout << "I have" ) << amount) << "in my purse.";

 To provide cout as an argument for << amount,

(cout << "I have") must return cout

Trang 52

Slide 11- 52

Overloaded << Declaration

 Based on the previous example, << should return

its first argument, the output stream

 This leads to a declaration of the overloaded

<< operator for the Money class:

Trang 53

Overloaded << Definition

 The following defines the << operator

 ostream& operator <<(ostream& outs,

const Money& amount) {

<Same as the body of Money::output in

Display 11.3 (except all_cents is replaced with amount.all_cents) >

return outs;

}

Trang 54

Slide 11- 54

Return ostream& ?

 The & means a reference is returned

 So far all our functions have returned values

 The value of a stream object is not so simple to

return

 The value of a stream might be an entire file, the

keyboard, or the screen!

 We want to return the stream itself, not the

value of the stream

 The & means that we want to return the stream,

not its value

Tiêu đề	Friends, overloaded operators, and arrays in classes
Trường học	Pearson Education, Inc.
Thể loại	bài tập tốt nghiệp
Năm xuất bản	2007
Thành phố	Upper Saddle River

Định dạng
Số trang	127
Dung lượng	3,63 MB