1. Lecture 11 C Parameters
Richard Gesick

2. Overview A Reminder Why Parameters are Needed How Parameters Work
Value Parameters
Reference Parameters
Out Parameters

3. Parameters (A Reminder)
Functions cannot see each other’s variables (scope)
Special variables used to “catch” data being passed
This is the way functions have to communicate with each other
Located between parentheses ( )
If no parameters are needed, leave the parentheses empty

4. Why Do We Need Parameters
Functions are good
Reuse
Modularity
Good design
Scope is limited
A variable declared in a function is only visible inside that function
Using global variables is a bad idea
So we need a way of passing data between functions

5. Parameter Example Defined: Invoked:
private static void DoSomething(int x, double y, string name)
Invoked:
DoSomething(42, 3.14, “Bob Smith”);
Notice above that there is a 1-1 matching, and the types must match too

6. Parameter Details By default, all primitive types are passed by value
Remember primitive types are all non-class types (int, float, double, string, char, etc.)
The function gets a copy of the variable
So if you change the variable in the function, the original value in the caller will remain unchanged

7. By Value Example
public static void IncreaseByTwo(int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(i); Console.WriteLine("Now the value of i is " + i);

8. The Output
The value of i is 4 The value of x is 6 Now the value of i is 4 The variable “i” is not changed because the function gets a copy of the value. Let’s see this traced out…

9. By Value Example MEMORY
public static void IncreaseByTwo(int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(i); Console.WriteLine("Now the value of i is " + i);
Main i

10. By Value Example MEMORY
public static void IncreaseByTwo(int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(i); Console.WriteLine("Now the value of i is " + i);
Main i 4

11. By Value Example OUTPUT The value of i is 4 MEMORY
public static void IncreaseByTwo(int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(i); Console.WriteLine("Now the value of i is " + i);
Main i 4

12. By Value Example OUTPUT The value of i is 4 MEMORY
public static void IncreaseByTwo(int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(i); Console.WriteLine("Now the value of i is " + i);
IBT x 4
Main i 4
The value in i is copied
into the variable x

13. By Value Example OUTPUT The value of i is 4 MEMORY
public static void IncreaseByTwo(int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(i); Console.WriteLine("Now the value of i is " + i);
IBT x 6
Main i 4
Waiting here

14. By Value Example OUTPUT The value of i is 4 The value of x is 6 MEMORY
public static void IncreaseByTwo(int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(i); Console.WriteLine("Now the value of i is " + i);
IBT x 6
Main i 4
Waiting here

15. By Value Example OUTPUT The value of i is 4 The value of x is 6
Now the value of i is 4
MEMORY
public static void IncreaseByTwo(int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(i); Console.WriteLine("Now the value of i is " + i);
IBT x 6
Main i 4

16. Ref Parameters
We can alter how parameters are handled using the “ref” keyword
This makes the parameter a “By Reference” parameter
Now the parameter IS NOT a copy of the value; it refers to the original

17. By Reference Example
public static void IncreaseByTwo(ref int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(ref i); Console.WriteLine("Now the value of i is " + i);

18. The Output
The value of i is 4 The value of x is 6 Now the value of i is 6 The variable “i” is changed because the function refers to the original variable i. Let’s see this traced out…

19. By Ref Example
MEMORY
public static void IncreaseByTwo(ref int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(ref i); Console.WriteLine("Now the value of i is " + i);
Main i

20. By Ref Example
MEMORY
public static void IncreaseByTwo(ref int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(ref i); Console.WriteLine("Now the value of i is " + i);
Main i 4

21. By Ref Example OUTPUT MEMORY The value of i is 4
public static void IncreaseByTwo(ref int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(ref i); Console.WriteLine("Now the value of i is " + i);
Main i 4

22. By Ref Example OUTPUT MEMORY The value of i is 4 IBT x R
public static void IncreaseByTwo(ref int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(ref i); Console.WriteLine("Now the value of i is " + i);
Main i 4
x is a reference to i

23. By Ref Example OUTPUT MEMORY The value of i is 4 IBT x R
public static void IncreaseByTwo(ref int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(ref i); Console.WriteLine("Now the value of i is " + i);
Main i 6
Waiting here

24. By Ref Example OUTPUT MEMORY The value of i is 4 The value of x is 6
IBT x R
public static void IncreaseByTwo(ref int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(ref i); Console.WriteLine("Now the value of i is " + i);
Main i 6
Waiting here

25. By Ref Example OUTPUT MEMORY The value of i is 4 The value of x is 6
Now the value of i is 6
IBT x R
public static void IncreaseByTwo(ref int x) { x += 2; Console.WriteLine("The value of x is " + x); } static void Main(string[] args) int i; i = 4; Console.WriteLine("The value of i is " + i); IncreaseByTwo(ref i); Console.WriteLine("Now the value of i is " + i);
Main i 6

26. The Necessity of Ref Parameters
What if a function needs to return a value when it is complete?
Use the “return” statement and declare the function of a particular type
Ex: public static int sum(int x, int y) { return x + y; }
But what if the function should return more than one value?
Create a collection of values to return and return the collection
Use ref (by reference) parameters to allow multiple items to be updated/modified

27. Another By-Ref Example (notice we need to return three values, modifying their original values)
public void RGBToGrey (ref byte red, ref byte green, ref byte blue) { byte average; average = (red + green + blue) / 3; red = average; green = average; blue = average; }

28. Out Parameters
We’ve seen parameters that pass information into a function (via copying the value)
We’ve seen parameters that pass information into a function and receive information out of the function (via changed values to a reference)
What about having values come out of a function?
No initial values passed in

29. Out Parameters Think of these similar to ref (by reference) parameters
No initial value passed in
It’s the job of the function to fill in a value for this type of parameter
When the function ends, the calling method will retain the value stored in the parameter

30. Out Parameter Example
public static void getUserInfo(out int age, out string name, out double gpa) { Console.Write(“What is your name? "); name = Console.Read(); Console.Write(“What is your age? "); age = int.Parse(Console.Read()); Console.Write(“What is your GPA? "); gpa = double.Parse(Console.Read()); } static void Main(string[] args) int user_age; string user_name; double user_gpa; getUserInfo(out user_age, out user_name, out user_gpa); // more code follows...

31. Out Parameter Example
public static void getUserInfo(out int age, out string name, out double gpa) { Console.Write(“What is your name? "); name = Console.Read(); Console.Write(“What is your age? "); age = int.Parse(Console.Read()); Console.Write(“What is your GPA? "); gpa = double.Parse(Console.Read()); } static void Main(string[] args) int user_age; string user_name; double user_gpa; getUserInfo(out user_age, out user_name, out user_gpa); // more code follows...

32. Out Parameters “Output” Information
Notice in the preceding example, the “age”, “name” and “gpa” variables must be filled in with values within the funtion
After this is done, the calling method (Main) can make use of these values via the “user_age”, “user_name” and “user_gpa” variables
How is this different from ref (by-reference) parameters?
Notice we couldn’t make use of these parameters (read their values) until we placed some value into them
So the statement Console.WriteLine("The user’s age is" + age); at the beginning of the function (first line of the function) would be illegal because this parameter does not have a value assigned to it yet

33. The Necessity of Out Parameters
Like “ref” parameters, “out” parameters are useful for returning information out from the function
Unlike “ref” parameters, “out” parameters don’t receive values from the caller
No values passed in – the parameters are “empty”
Use “out” parameters when the function is generating the values and returning them to the calling method
Just use the function return type and the “return” statement if the function returns only one value
Use “out” parameters when more than one value is to be generated and returned to the calling method

34. Conclusion
You should have a better/stronger feel on how parameters work
You should understand the difference between by-value, by-reference, and out parameters
Given a section of code, you should be able to “trace through” what the computer would do (and what output would be generated)