Functions and Procedures Arguments

Procedure ShowMe(Length : Double);

Procedure ProcessRectangle(Length : Double; Width : Double);

procedure MbrRegist(Gender, Category: Char; Fee: Double);
begin

end;

Procedure ProcessRectangle(Length : Double; Width : Double);
var
	Perimeter : Double;
	Area : Double;
begin
	Perimeter := 2 * (Length + Width);
	Area := Length * Width;

	writeln('The perimeter of the rectangle is ', Perimeter);
	writeln('The area of the rectangle is ', Area);
end;

program Project1;

{$APPTYPE CONSOLE}

Procedure StopHere(GoodBye: string);
begin
	write(GoodBye);
	readln;
end;

begin
	StopHere;
end.

program Project1;

{$APPTYPE CONSOLE}

Procedure StopHere(GoodBye: string);
begin
	write(GoodBye);
	readln;
end;

begin
	StopHere('Press any key to continue');
end.

program Project1;

{$APPTYPE CONSOLE}

Procedure StopHere(GoodBye: string);
begin
write(GoodBye);
readln;
end;

Function TwoTimes(Nbr: Double) : Double;
begin
Result := Nbr * 2;
end;

var
Number: Double;
Multiplied: Double;
begin
Number := 252.88;
Multiplied := TwoTimes(Number);
Writeln(Multiplied:2:2);

StopHere('Press any key to continue');
end.

There are two ways an argument is passed to a procedure or a function: by value or by reference. The most usual way of passing arguments to a procedure or a function is by value. That is the way we have used arguments on functions so far.

We saw earlier that, to use a function inside of another function, that is, to call a function from another function, specify the name of the function and its list of arguments, if any, inside of parentheses. Consider the following formula to calculate the tax amount applied to an item in a department store;



The formula of calculating the final price of an item is: 

Final Price = Item Price + Tax Amount 

Here is an example of passing arguments by value, the same way we have done so far: 

Here is an example of running the program: 

Arguments by Reference

When you declare a variable in a program, the compiler reserves an amount of space for that variable. If you need to use that variable somewhere in your program, you call it and make use of its value. There are two major issues related to a variable: its value and its location in memory. Imagine you declare a variable named Variable1: 



The location of a variable in memory is referred to as its address. 

If you supply the argument using its name, the compiler only makes a copy of the argument’s value and gives it to the calling function. Although the calling function receives the argument’s value and can use it in any way, it cannot (permanently) alter it. Object Pascal allows a calling function to modify the value of a passed argument if you find it necessary. If you want the calling function to modify the value of a supplied argument and return the modified value, you should pass the argument as reference.

To pass an argument as reference, when declaring the function, precede the name of the argument with the var keyword. You can pass one or more arguments as reference in the program or pass all arguments as reference. The decision as to which argument(s) should be passed by value or by reference is based on whether or not you want the called function to modify the argument and permanently change its value. 

Here are examples of passing some arguments by reference: 

You add the var keyword when declaring a function and when defining it. When calling the procedure or function, supply only the name of the referenced argument(s). The above would be called with: 

You will usually need to know what happens to the value passed to a calling function because the rest of the program may depend on it. Imagine that you write a function that calculates employees weekly salary provided the total weekly hours and hourly rate. The starting program would be as follows:

If you test the program by typing 32 for the weekly hours and 6.45 for the salary, you would notice the weekly values are the same:

Imagine that the employee claims to have worked 42 hours instead of the passed weekly hours. You could create the following function to find out.

If you test the program with a weekly hours value of 35.50 and a salary of 8.50, you would notice that the weekly salary is different inside of the Earnings() function but is kept the same in main section of the program, before and after the Earnings() function: 

Notice that the Weekly salary is the same before and after calling the Eranings procedure. If you want a calling function to modify the value of an argument, you should supply its reference and not its value. You could change the function as follows: 

Here is a new test of the program:

Notice that, this time, once the Earnings procedure has been called, the weekly salary, whose calculation involves the ThisWeek argument passed as reference, has a changed value.

Default Arguments

We mentioned earlier that, whenever a function takes an argument, that argument is required. If the calling function does not provide the (required) argument, the compiler would throw an error. Imagine you write a function that will be used to calculate the final price of an item after discount. The function would need the discount rate in order to perform the calculation. Such a function could look like this:

Since this function expects an argument, if you do not supply it, the following program would not compile: 

Here is an example of running the program:

Most of the time, a function such as ours would use the same discount rate over and over again. Therefore, instead of supplying an argument all the time, Object Pascal allows you to define an argument whose value would be used whenever the function is not provided with the argument. 

To give a default value to an argument, when declaring the function, type the name of the argument followed by the colon operator “:”, followed by the argument’s data type, followed by the equality operator, and followed by the desired default value. The CalculateNetPrice() function, with a default value, could be defined as follows: 

When calling the procedure, you can omit passing a value for the argument. If you do not pass it, the default value would be used. Therefore, you can just call the procedure as follows: 

If a procedure or a function takes more than one argument, you can provide a default argument for each and select which ones would have default values. If you want all arguments to have default values, when defining the procedure or function, type each the = operator for each argument. Here is an example: 

Here is the result produced: 

If a function takes more than one argument and you would like to provide default values for those parameters, the order of appearance of the arguments is very important. 

1/ If a function takes two arguments, you can declare it with default values. We already know how to do that. If you want to provide a default value for only one of the arguments, the argument that would have a default value must be the second in the list. Here is an example: 

When calling such a function, if you supply only one argument, the compiler would assign its value to the first parameter in the list and ignore assigning a value to the second: 

If you define the function and assign a default value to the first argument, if you provide only one argument when calling the function, you would receive an error. 

2/ If the function receives more than two arguments and you would like only some of those arguments to have default values, the arguments that would have default values must be at the end of the list. Regardless of how many arguments would or would not have default values, start the list of arguments without those that would not use default values. 

Function Overloading

A program can involve a great deal of names that represent variables, procedures, and functions of various kinds. The compiler does not allow two entities to share a name. For example, two variables must not have the name in the same function. Although two functions should have unique names in the same program, Object Pascal allows you to use the same name for different functions of the same program following certain rules. The ability to have various functions with the same name in the same program is called function overloading. 

To implement function overloading, make sure that each one of the procedures or functions has a different number or different types of arguments. When declaring or defining the procedure or function, type the overload keyword at the end of its declaration. When calling the procedure or function, the compiler will locate the appropriate procedure or function based on the number of arguments you provide. For example, you can create a function called Area() but define it to calculate the areas of different shapes: 

Here is the result of running the program:

To calculate the moment of inertia with regard to the X axis, change the file as follows:

Constant Arguments

When a routine receives an argument, it performs one of two actions with regards to the value of the argument; it may modify the value itself or only use the argument to modify another argument or another of its own local variables. Consider the following Twice function:

If you know that the routine is not supposed to alter the value of an argument, you should let the compiler know. This is a safeguard that serves at least two purposes. First, the compiler will make sure that the argument supplied stays intact; if the function tries to modify the argument, the compiler would throw an error, letting you know that an undesired operation took place. Second, this speeds up execution. 

To let the compiler know that the value of an argument must stay constant, type the const keyword on the left of the name of the argument. For example, the above Twice function does not alter the value of its argument. Therefore, the argument can be passed as constant and this would be done as follows:

This would produce: 

In the same way, you can pass as many constant arguments as you judge necessary for a routine. You can make just one or more arguments constants, and there is no order on which arguments can be made constant. Here is another function that takes two constant arguments:

This would produce: