1. Method Parameters and Overloading

2. Topics The run-time stack Pass-by-value Pass-by-reference
Method overloading
Stub and driver methods

3. Objectives
At the completion of this topic, students should be able to:
Correctly write methods that use pass by value
Correctly write methods that use pass by reference
Explain what a side effect is
Explain what method overloading is, and correctly use
method overloading in a program
Explain how type conversion affects method overloading
Explain what a Driver and a Stub method are, and use them in programs

4. The Execution or Run-Time Stack
An important component in understanding how methods
work is the execution or run-time stack.
The following slides discuss how C# uses the run-time
stack when invoking a method. Note that this is only a
conceptual view of how the stack operates. It is slightly
more complicated than what is shown here, and operation
of the stack depends a great deal on the operating system,
the compiler, and the hardware environment.

5. To get an idea of how the stack works, think of the
plate dispensers that you have seen in a cafeteria
When a plate is removed
from the top of the stack,
all of the other plates
pop up.
When a plate is pushed
onto the stack, all of the
other plates get pushed
down.

6. When a method is called (invoked), the computer
builds a stack frame. The stack frame contains
* the parameters that are being passed to the method
* the address to return to when the method is done
* any local variables declared in the method

7. Any variables declared inside main’s { }
local variables
control returns to
the operating system
Stack frame
for Main( )
return address
parameters
Main( )’s parameters
come from the
command line
The Stack

8. Main( ) calls method ”B” Stack frame for method “B” Stack frame
any variables
declared inside
of B’s { }
local variables
Stack frame
for method “B”
returns to the point
where B was called
from inside of Main
return address
parameters
any parameters
passed to B
local variables
Stack frame
for Main( )
return address
parameters
The Stack

9. its stack frame is removed from the stack.
When method “B” is done,
its stack frame is removed
from the stack.
local variables
Stack frame
for Main( )
return address
parameters
The Stack

10. Main( ) now goes Stack frame on about its work. for Main( ) The Stack
local variables
Main( ) now goes
on about its work.
Stack frame
for Main( )
return address
parameters
The Stack

11. Example

12. using System;
using static System.Console;
class Program {
static void Main()
int a = 5;
int b = 3;
int c = Add(a,b);
WriteLine($"The answer is {c:D}");
ReadKey(true );
}//End Main()
static int Add(int num1, int num2)
int sum = num1 + num2;
return sum; }
}//End class Program

13. WriteLine($"The answer is {c:D}"); ReadKey(true ); }
static void Main() {
int a = 5;
int b = 3;
int c = Add(a,b);
WriteLine($"The answer is {c:D}");
ReadKey(true ); }
a = 5
b = 3
return address
no parameters
The Stack

14. WriteLine($"The answer is {c:D}"); ReadKey(true); }
static void Main() {
int a = 5;
int b = 3;
int c = Add(a,b);
WriteLine($"The answer is {c:D}");
ReadKey(true); }
a = 5
b = 3
return address
no parameters
The Stack

15. WriteLine($"The answer is {c:D}"); ReadKey(true); }
Build a Stack Frame for
the call of Method B and
push it onto the stack
local variables
static void Main() {
int a = 5;
int b = 3;
int c = Add(a,b);
WriteLine($"The answer is {c:D}");
ReadKey(true); }
return address
parameters
a = 5
b = 3
Main’s Stack
Frame
return address
no parameters
The Stack

16. The return address that goes on the stack is
right here … before the assignment part of
this statement.
local variables
static void Main() {
int a = 5;
int b = 3;
int c = Add(a,b);
WriteLine($"The answer is {c:D}“);
ReadKey(true); }
a = 5
b = 3
B’s Stack
Frame
return address
return address
parameters
a = 5
b = 3
no parameters
Main’s Stack
Frame
return address
no parameters
The Stack
The Stack

17. Put the parameters in the stack frame. These
are copies of the values stored in a and b.
local variables
static void Main() {
int a = 5;
int b = 3;
int c = Add(a,b);
WriteLine($"The answer is {c:D}");
ReadKey(true); }
a = 5
b = 3
B’s Stack
Frame
return address
return address 3 5 3 5
return address
a = 5
b = 3
a = 5
b = 3
no parameters
Main’s Stack
Frame
return address
return address
no parameters
no parameters
The Stack

18. In the Add method, we use these names to refer to the parameters
Sum is a local variable
declared inside of the
Add method
In the Add method, we use these
names to refer to the parameters
that were passed to the method.
sum
a = 5
b = 3
B’s Stack
Frame
return address
return address 3 5
num2 3 5
static int Add(int num1, int num2) {
int sum;
sum = num1 + num2;
return sum, }
return address
num1
a = 5
b = 3
a = 5
b = 3
no parameters
Main’s Stack
Frame
return address
return address
no parameters
no parameters
The Stack

19. static int Add(int num1, int num2) { int sum; sum = num1 + num2;
Sum is a local variable
declared inside of the
Add method
sum 8
a = 5
b = 3
B’s Stack
Frame
return address
return address 3 5
num2 3 5
static int Add(int num1, int num2) {
int sum;
sum = num1 + num2;
return sum, }
return address
num1
a = 5
b = 3
a = 5
b = 3
no parameters
Main’s Stack
Frame
return address
return address
no parameters
no parameters
The Stack

20. static int Add(int num1, int num2) { int sum; sum = num1 + num2;
Sum is a local variable
declared inside of the
Add method
Copy the value of sum
into the eax register
sum 8 8
a = 5
b = 3
B’s Stack
Frame
return address
return address 3 5
num2 3 5
static int Add(int num1, int num2) {
int sum;
sum = num1 + num2;
return sum, }
return address
num1
a = 5
b = 3
a = 5
b = 3
no parameters
Main’s Stack
Frame
return address
return address
no parameters
no parameters
Values returned from a method
are passed in a special hardware
register
The Stack
eax

21. static int Add(int num1, int num2) { int sum; sum = num1 + num2;
Get the return address 8
sum 8
a = 5
b = 3
B’s Stack
Frame
return address
return address 3 5
num2 3 5
static int Add(int num1, int num2) {
int sum;
sum = num1 + num2;
return sum, }
return address
num1
a = 5
b = 3
a = 5
b = 3
no parameters
Main’s Stack
Frame
return address
return address
no parameters
no parameters
Values returned from a method
are passed in a special hardware
register
The Stack 8
eax

22. Remove B’s stack frame from the stack
and go to where the return address points
a = 5
b = 3
no parameters
a = 5
b = 3
Main’s Stack
Frame
return address
return address
int Add(int num1, int num2) {
int sum;
sum = num1 + num2;
return sum, }
no parameters
no parameters
Values returned from a method
are passed in a special hardware
register
The Stack 8
eax

23. WriteLine($"The answer is {c:D}"); ReadKey(true); }
control returns here
static void Main() {
int a = 5;
int b = 3;
int c = Add(a,b);
WriteLine($"The answer is {c:D}");
ReadKey(true); }
a = 5
b = 3
c = ?
return address
no parameters 8
eax
The Stack

24. WriteLine($"The answer is {c:D}"); ReadKey(true); }
static void Main() {
int a = 5;
int b = 3;
int c = add(a,b);
WriteLine($"The answer is {c:D}");
ReadKey(true); }
a = 5
b = 3
c = 8 8
return address
no parameters
The Stack

25. Pass By Value When a parameter is passed by value, a copy
of the value is made and passed to the method
on the run-time stack.

26. static double Divide(int n, int d) { double r = (double)n / d; n++;
These names are local to the method Divide( ).
The parameters passed to the method are
given these names so that we can use
them inside of the method.
static double Divide(int n, int d) {
double r = (double)n / d;
n++;
d++;
return r; }

27. Write("Enter in an integer value: "); num = int.Parse(ReadLine());
static void Main() {
int num = 0, den = 0; do
Write("Enter in an integer value: ");
num = int.Parse(ReadLine());
Write("Enter in another integer value: ");
den = int.Parse(ReadLine());
if (den != 0)
double result = Divide(num, den);
WriteLine($"{num:D}/{den:D} = {result:F2}"); }
} while (den != 0);
ReadKey(true);
}//End Main()
num and den are called the
actual parameters, or arguments.

28. double result = Divide (num, den);
let the value of num = 9
and the value of den = 7
return here
if (den != 0) {
WriteLine("{num:D}/{den:D} = {result:F2}"); }
num = 9
den = 7
double result = Divide (num, den);
return address
no parameters
The Stack

29. static double Divide(int n, int d) { double r = (double)n / d; n++;
return r; }
r = 1.285
return address d 8 10 7 9 n
num = 9
den = 7
Notice that the original
values in main’s stack
frame don’t change.
This is because n and d
are names that are local
to the Divide method.
return address
no parameters
The Stack

30. Control now returns to the point where the
1.285
eax
double result = Divide (num, den);
num = 9
den = 7
result = 1.285
Control now returns to the point where the
function was called. In this case, the return
value, in eax register, is then copied to “result”.
return address
no parameters
The Stack

31. Pass By Reference When a parameter is passed by reference, a reference
to the value is made and passed to the method
on the run-time stack.

32. static double Divide(ref int n, ref int d) { double r = (double)n / d;
the keyword ref denotes that this
parameter is passed by reference!
static double Divide(ref int n, ref int d) {
double r = (double)n / d;
n++;
d++;
return r; }

33. The Stack double result = Divide (ref num, ref den);
WriteLine($"{num:D}/{den:D} = {result:F2}");
num = 9
den = 7
result = ?
return address
no parameters
The Stack

34. Build the stack frame to call the divide method
Return here when
done executing the
function
return address
ref to den
ref to num
double result = Divide (ref num, ref den);
WriteLine($"{num:D}/{den:D} = {result:F2}");
num = 9
den = 7
result = ?
return address
no parameters
The Stack

35. static double Divide(ref int n, ref int d) { double r = (double)n / d;
return address d
ref to den
ref to num
static double Divide(ref int n, ref int d) {
double r = (double)n / d;
n++;
d++;
return r; } n
num = 9
den = 7
result = ?
return address
no parameters
The Stack

36. static double Divide(ref int n, ref int d) { double r = (double)n / d;
return address n
ref to den
ref to num
static double Divide(ref int n, ref int d) {
double r = (double)n / d;
n++;
d++;
return r; }
num = 10
den = 8
These local variables, in main’s
Stack frame, change, because
d and n refer to them.
result = ?
return address
no parameters
The Stack

37. Rule of Thumb If you are passing simple data to a method,
you should use pass-by-value
avoids side effects!

38. When Should You Pass by Reference?
If you need to change data in the calling
method, for example swapping two values,
then pass-by-reference.
If a method has to return more than one value.
Objects are automatically passed by reference
because it is more efficient.

39. Example of Using a Side Effect
Problem: Write a method that exchanges the values
of two variables.

40. The exchange code ……… value1 = value2; value2 = value1;
for exchanging integers
value1 = value2;
value2 = value1;
int temp = value1;
value1 = value2;
value2 = temp;

41. Using pass by value … These are n2 int num1 = 5; copies of n1
temp = 7
return address
These are
copies of
num1 and num2 n2 n1 5 7 7 5
int num1 = 5;
int num2 = 7;
Swap (num1, num2);
num1 = 5
num2 = 7
void Swap (int n1, int n2) {
int temp = n1;
n1 = n2;
n2 = temp; }
return address
no parameters
The Stack

42. Only the local variables allocated in Swap’s stack frame get swapped.
The original values are not changed.
To make the Swap work correctly, pass the parameters
by reference.

43. Using pass by reference …
temp = 7
return address
These are
references to
num1 and num2
int num1 = 5;
int num2 = 7;
Swap (ref num1, ref num2); n2 n1
ref to num2
ref to num1
num1 = 5
num2 = 7
void Swap (ref int n1, ref int n2) {
int temp = n1;
n1 = n2;
n2 = temp; }
return address
no parameters
The Stack

44. Using pass by reference …
temp = 7
return address
int num1 = 5;
int num2 = 7;
Swap (ref num1, ref num2); n2 n1
ref to num2
ref to num1
num1 = 7
num2 = 5
So … the changes
occur to num1 and
num2
void Swap (ref int n1, ref int n2) {
int temp = n1;
n1 = n2;
n2 = temp; }
return address
no parameters
The Stack

45. Mixed Parameter Lists It is perfectly valid to mix pass-by-value and
pass-by-reference parameters in the same method:
void MethodTwo (ref int num1, int num2);

46. Method Overloading In C# you can give two different methods the
identical method name (but with different parameters)
This is called method overloading.
When a method is invoked, the compiler figures
out which of the methods to use, based on the
method name and the number, type and order
of parameters.

47. Example static int Max (int n1, int n2, int n3) { if ( n1 < n2 )
this method has three parameters
Example
static int Max (int n1, int n2, int n3) {
if ( n1 < n2 )
if ( n2 < n3 )
return n3;
else
return n2;
if ( n1 < n3 )
return n1; }
this method has two parameters
static int Max (int n1, int n2) {
if ( n1 < n2 )
return n2;
else
return n1; }
int biggest = Max (5, 3);
int largest = Max (5,3,7);
this code will invoke this method
this code will invoke this method

48. Method Signature A method’s signature refers to the method name
and the number, sequence and type of parameters.
A method is overloaded when the methods have the
Same name but have different signatures.

49. Type Conversion and Overloading
static double Mpg (double miles, double gallons) {
return (miles / gallons); }
if this method is called with the following code …
int m = 15;
int g = 3;
double result = Mpg (m, g);
m and g will be converted to double
when they are passed to the method.

50. ? So … what happens if you also have this method in your program?
int Mpg (int goals, int misses) {
return ( goals – misses); }
and you make the method call
int miles = 2;
int gallons = 8;
int result = Mpg (m,g); ?

51. Rules for Resolving Overloading
If there is a method whose signature exactly matches the parameters in the method call, than that method is selected first.
Otherwise, if there is a method whose signature matches the parameters of the method call, after doing some type upcasting conversion, then that method is selected.

52. Drivers When programming a large project, it is common
to code each method independently and then write
a driver method that tests that method. A driver is simply a
Method that invokes through its code the method being tested
in different ways to insure that the method works as expected.
Driver methods are temporary code that are not part of the
finished program, so they don’t have to be fancy.

53. Example // calcArea method
// purpose: calculate the area of a rectangular region
// parameters: a integer length l and an integer width w
// returns: an integer result = l * w
static int CalcArea (int l, int w) {
return l * w; }

54. the Driver method int main( ) { int height=0, width=0, area=0;
char yes_no = ‘N’; do
WriteLine(“ ";
Write(“Enter an integer height: “);
height = int.Parse(ReadLine( ) );
Write(“Enter an integer width: “);
width = int.Parse(ReadLine( ) );
area = CalcArea (height, width);
WriteLine($“The area = {area:D}“);
Write(“Test another pair of values (y or n): “);
yes_no = char.Parse(ReadLine( ) );
yes_no = char.ToLower(yes_no); }
while (yes_no == 'y');
}//End Main()

55. Once a method has been debugged and you are
satisfied that it contains no errors, then move on
to creating and testing the next method.
Each method should be tested in a program where
it is the only untested component in the program.
Thus, if the program fails, you know where to look
for the error.

56. Stub Methods Sometimes it is impossible to test one method
without using some other method which may not
yet be written or debugged.
In these cases you can write a simplified version of
the required method that only delivers sufficient
data to test the other method. These simplified
methods are called stubs.
Another purpose of a stud method is to be skeleton
as a place holder to remind us that we need to write
such a method.

57. Example If we were testing some method that depended on
the CalcArea method, and the CalcArea method had
not yet been written and tested, we could provide
a stub that might look like this --
int CalcArea ( int w, int l) {
return 100; }
the method does not calculate the area
correctly, but just getting some data
returned might be sufficient to test the
other method.

58. Practice Write a method, Add( ), that takes two integer
parameters. The parameters are passed by value.
The method returns the sum as an integer.

59. Practice Write a method, Add( ), that takes two integer
parameters. The parameters are passed by reference.
The method returns the sum as an integer.

60. Practice Write a Main( ) method that gets two values from the user
and then calls the Add method. Pass the parameters by value.
Then get two more values from the user. Call the add method
but this time pass the parameters by reference.

61. Practice Write a program that converts time in 24 hour notation to
its equivalent time in 12 hour notation. For example, 1320
would convert to 1:20pm. Write a method that does the
conversion. How will you pass the parameters? Could you
have used this method in the first project that you did?

62. Practice We want to write a program that tells what coins to give for
any amount of change from 1 to 99 cents. For example, for
86 cents, the program should output something like
86 cents can be given as
3 quarter(s) 1 dime(s) and 1 penny(pennies)
Only use coin denominations of 25 cents ( quarters ), 10 cents
( dimes ), and 1 cent ( pennies ).
Your program should use a method of the following form:
void ComputeCoins ( int coinValue, ref int number, ref int left );
For example, if the amount left is 86 cents, and the coinValue is 25,
the value of number will be 3 and the new amount left will be 11.