Tài liệu Module 6 A Closer Look at Functions doc

1

C++ A Beginner’s Guide by Herbert Schildt

Module6

A Closer Look at Functions

Table of Contents

CRITICAL SKILL 6.1: Know the two approaches to argument passing...........................................................2

CRITICAL SKILL 6.2: How C++ Passes Arguments ..........................................................................................2

CRITICAL SKILL 6.3: Using a Pointer to Create a Call-by-Reference ..............................................................3

CRITICAL SKILL 6.4: Reference Parameters...................................................................................................4

CRITICAL SKILL 6.5: Returning References....................................................................................................9

CRITICAL SKILL 6.6: Independent References.............................................................................................12

CRITICAL SKILL 6.7: Function Overloading ..................................................................................................13

CRITICAL SKILL 6.8:Default Function Arguments........................................................................................26

CRITICAL SKILL 6.9: Function Overloading and Ambiguity..........................................................................29

This module continues our examination of the function. It discusses three of C++’s most important

function-related topics: references, function overloading, and default arguments. These features vastly

expand the capabilities of a function. A reference is an implicit pointer. Function overloading is the

quality that allows one function to be implemented two or more different ways, each performing a

separate task. Function overloading is one way that C++ supports polymorphism. Using a default

argument, it is possible to specify a value for a parameter that will be automatically used when no

corresponding argument is specified. We will begin with an explanation of the two ways that arguments

can be passed to functions, and the implications of both methods. An understanding of argument

passing is needed in order to understand the reference.

2

C++ A Beginner’s Guide by Herbert Schildt

CRITICAL SKILL 6.1: Know the two approaches to argument

passing

In general, there are two ways that a computer language can pass an argument to a subroutine. The first

is call-by-value. This method copies the value of an argument into the parameter of the subroutine.

Therefore, changes made to the parameter of the subroutine have no effect on the argument used to

call it.

Call-by-reference is the second way a subroutine can be passed arguments. In this method, the address

of an argument (not its value) is copied into the parameter. Inside the subroutine, this address is used to

access the actual argument specified in the call. This means that changes made to the parameter will

affect the argument used to call the subroutine.

CRITICAL SKILL 6.2: How C++ Passes Arguments

By default, C++ uses call-by-value for passing arguments. This means that the code inside a function

cannot alter the arguments used to call the function. In this book, all of the programs up to this point

have used the call-by-value method. For example, consider the reciprocal( ) function in this program:

takes place inside reciprocal( ), the only thing modified is the local variable x. The variable t used as an

argument will still have the value 10 and is unaffected by the operations inside the function.

3

C++ A Beginner’s Guide by Herbert Schildt

CRITICAL SKILL 6.3: Using a Pointer to Create a

Call-by-Reference

Even though C++’s default parameter-passing convention is call-by-value, it is possible to manually

create a call-by-reference by passing the address of an argument (that is, a pointer) to a function. It is

then possible to change the value of the argument outside of the function. You saw an example of this in

the preceding module when the passing of pointers was discussed. As you know, pointers are passed to

functions just like any other values. Of course, it is necessary to declare the parameters as pointer types.

To see how passing a pointer allows you to manually create a call-by-reference, consider a function

called swap( ) that exchanges the values of the two variables pointed to by its arguments. Here is one

way to implement it:

The swap( ) function declares two pointer parameters, x and y. It uses these parameters to exchange the

values of the variables pointed to by the arguments passed to the function. Remember, *x and *y refer

to the variables pointed to by x and y. Thus, the statement

*x = *y;

puts the value of the object pointed to by y into the object pointed to by x. Consequently, when the

function terminates, the contents of the variables used to call the function will be swapped.

Since swap( ) expects to receive two pointers, you must remember to call swap( ) with the addresses of

the variables you want to exchange. The correct method is shown in this program: