Learnings of the Week

Submitted by:

Joyce Niko D. Perez
IV-RIZAL

November 17-21, 2008

In this week, we learned about

STRUCTURED PROGRAMMING USING FUNCTIONS

• A function is a self-contained block of code with a specific purpose.

• A function has a name that both identifies it and is used to call it for execution in a program.

• Functions which perform different actions should generally have different names.

Why Do You Need Functions?

• Functions can be executed as many times as necessary from different points in a program.

• Without the ability to package a block of code into a function, programs would end up being
much larger, since you would typically need to replicate the same code at various points in
your program.

• But the real reason that you need functions is to modularize your program into easily
manageable chunks.

Functions

• Functions allow a program to be segmented so that it can be written piecemeal, and each piece tested independently before bringing it together with the other pieces.

• It also allows the work to be divided among members of a programming team, with each team
member taking responsibility for a tightly specified piece of the program, with a well defined
functional interface to the rest of the code.

• Real world large scale programming projects are developed using this approach

• The name of a function is governed by the same rules as those for a variable.

• You pass information to a function using its arguments which are specified when you invoke
or call it.

• The arguments need to correspond with parameters appearing in the definition of the function.

• The arguments replace the parameters used in the function definition when the function is executed.

• The code in the function then executes as though it was written using your argument values.

Structure of Functions using Function Definition

• A Function Definition is the “self-contained block of code with a specific purpose”.

• A functions definition has to two distinct parts: a function header, followed by the body of the function.

• Functions Header which identifies the function – Tells the compiler what the function is and its return
type

• Function Body between curly braces containing the executable code for the function
– the actual executable part of the function.

The General Form of a Function Header

• Function header consists of three parts:
– the type of the return value
– the name of the function,
– the parameters of the function enclosed between
parentheses.

• The general form of a function header can be written as
follows:
return_type
FunctionName(parameter_list)

• No semicolon is required at the end of the function header.

Function Prototypes

• Before you can use a function in a program, you must declare the function using a statement called a function prototype.

• Function prototype informs the compiler of the framework for that function.

• A prototype of a function provides the basic information that the compiler needs to check that a function is used correctly.

• It specifies:
– the parameters to be passed to the function,
– the function name, and
– the type of the return value;

• it contains essentially the same information as appears in the function header, with the addition
of a semicolon.

• a semicolon is required at the end of a function prototype.

• The number of parameters and their types must be the same in the function prototype as they are in the function header in the definition of the function.

• The prototypes for the functions used in a program must appear before the statements calling the functions.

Naming of Parameters in function header and prototype

• A parameter name in the function prototype should provide an understanding about why it is
used.

• You can specified different names for the parameters in the function prototype to those
used in the function header when you defined the function.

• Most often, the same names are used in the prototype and in the function header in the
definition of the function, but this doesn't have to be so.

Header Files for Function

Prototypes

• Header files is a C++ files that has a .h extension, appear between <> in a #include statement.

• The header files which we've been including for standard library functions include the prototypes of the functions provided by the library.

• If your code uses a lot of functions, it is a good idea to place all function prototypes in a header
file.

• In the header file, the function prototypes are stored along with a brief description of the
purpose of the function.

What is returned by a Function

• A function communicates back with the rest of the program using its return statement

• The return_type can be any legal type.

• The return value is returned to the calling function when the function is executed, so when
the function is called

• The return type will have the same type as in the declaration of the function.

• A copy of the value being returned is made automatically, it is available to the return point in
the program.

The return Statement

• The return statement returns a value to the calling program at the point where the function

• The general form of the return statement is as follows, return expression;

• expression must evaluate to a value of the type specified in the function header for the return value.

• The expression can be any expression you want, as long as you end up with a value of the required type.

• If the type of return value has been specified as void, there must be no expression appearing in the return statement. It must be written simply as: return

Keyword void used in functions

• If the function does not return a value, the return type is specified by the keyword void.

• The keyword void is also used to indicate that a function has no parameters and doesn't return a value void MyFunction(void)

• An empty parameter list also indicates that a function takes no arguments, so you could omit the keyword void between the parentheses as follows: void MyFunction()

• A function with a return type specified as void should not be used in an expression in the calling program.

Function Body

• Functions should begin with { and end with }.

• All the variables declared within the body of a function, as well as the parameters, are local to the function.

• The scope of variables declared within a function is determined in the same way that we have already discussed.

• A variable is created at the point at which it is defined and ceases to exist at the end of the block containing it.

• Be careful about masking global variables with local variables of the same name.

Function Arguments

• Parameters are used in the function prototype but functions receive input from the rest of the
program using arguments.

• Arguments can be any expression, or variables as long as a value of the correct type is
ultimately produced.

• The arguments substitute the parameters that were used in the definition of the function.

Calling a Function

• When you call a function, you are telling the compiler branch off and execute the piece of code
that defines the function.

• The computation is performed using these values, then a copy of the result, will be returned to the calling function which stores it in the appropriate argument.

• You can think of the function as having this value in the statement or expression in which it appears

• To call a function, use the function name followed by arguments enclosed in parenthesis.

Passing Arguments to a Function

• The arguments specified when a function is called should usually correspond in type and
sequence to the parameters appearing in the definition of the function.

• If the type of an argument specified in a function call doesn't correspond with the type
of parameter in the function definition, then (where possible) it will be converted to the
required type.

Methods of transferring data to a function

• Pass-by-value method of transferring data to a function

– With this mechanism, the variables or constants that you specify as arguments are not passed to a function at all. Instead, copies of the arguments are created and these copies are used as the values to be transferred.

• Pass-by-reference method of transferring date to a function.

– The method used is not pass-by-value where an argument is copied before being passed, but pass-by reference where the parameter acts as an alias for the argument passed.


Pass-by-value method

• Each time you call a function, the compiler arranges for copies of the arguments that you
specify to be stored in a temporary location in memory.

• During execution of the functions, all references to the function parameters will be mapped to these temporary copies of the arguments.

• Clearly, the pass-by-value mechanism provides you with a high degree of protection from having your caller arguments mauled by a rogue function, but it is conceivable that we might actually want to arrange to modify caller arguments.


Passing Arrays to functions

• You can also pass an array to a function, but in this case the array is not copied, even though a pass-by value method of passing arguments still applies.

• The array name is converted to a pointer (is an address of a variable), and a copy of the pointer to the beginning of the array is passed to the function.

• This is quite advantageous, as copying large arrays could be very time and memory consuming.

• To pass an array to a function, just specify the name of the array in the argument list.

• In Multidimensional Arrays follow the same procedure

Other methods of communicating with a function

• Specifying a parameter to a function as a reference changes the method of passing data
for that parameter.

• This eliminates any copying and allows the function to access the caller argument directly.

• It also means that the de-referencing, which is required when passing and using a pointer to a
value, is also unnecessary.

• We will revisit this a method after we introduce pointers and reference

Array Functions

Arrays are a big part of the Perl language and Perl has a lot of functions to help you work with them. Some of the actions arrays perform include deleting elements, checking for the existence of an element, reversing all of the the elements in an array, and sorting the elements. Table 5.2 lists the functions you can use with arrays.

Table 5.2 Array Functions

Function	Description
defined(VARIABLE)	Returns true if VARIABLE has a real value and if the variable has not yet been assigned a value. This is not limited to arrays; any data type can be checked. Also see the exists function for information about associative array keys.
delete(KEY)	Removes the key-value pair from the given associative array. If you delete a value from the %ENV array, the environment of the current process is changed, not that of the parent.
each(ASSOC_ARRAY)	Returns a two-element list that contains a key and value pair from the given associative array. The function is mainly used so you can iterate over the associate array elements. A null list is returned when the last element has been read.
exists(KEY)	Returns true if the KEY is part of the specified associative array. For instance, exists($array{"Orange"}) returns true if the %array associative array has a key with the value of "Orange."
join(STRING, ARRAY)	Returns a string that consists of all of the elements of ARRAY joined together by STRING. For instance, join(">>", ("AA", "BB", "cc")) returns "AA>>BB>>cc".
keys(ASSOC_ARRAY)	Returns a list that holds all of the keys in a given associative array. The list is not in any particular order.
map(EXPRESSION, ARRAY)	Evaluates EXPRESSION for every element of ARRAY. The special variable $ is assigned each element of ARRAY immediately before EXPRESSION is evaluated.
pack(STRING, ARRAY)	Creates a binary structure, using STRING as a guide, of the elements of ARRAY. You can look in Chapter 8 "References," for more information.
pop(ARRAY)	Returns the last value of an array. It also reduces the size of the array by one.
push(ARRAY1, ARRAY2)	Appends the contents of ARRAY2 to ARRAY1. This increases the size of ARRAY1 as needed.
reverse(ARRAY)	Reverses the elements of a given array when used in an array context. When used in a scalar context, the array is converted to a string, and the string is reversed.
scalar(ARRAY)	Evaluates the array in a scalar context and returns the number of elements in the array.
shift(ARRAY)	Returns the first value of an array. It also reduces the size of the array by one.
sort(ARRAY)	Returns a list containing the elements of ARRAY in sorted order. See Chapter 8 "References," for more information.
splice(ARRAY1, OFFSET,	Replaces elements of ARRAY1 with elements
LENGTH, ARRAY2)	in ARRAY2. It returns a list holding any elements that were removed. Remember that the $[ variable may change the base array subscript when determining the OFFSET value.
split(PATTERN, STRING, LIMIT)	Breaks up a string based on some delimiter. In an array context, it returns a list of the things that were found. In a scalar context, it returns the number of things found.
undef(VARIABLE)	Always returns the undefined value. In addition, it undefines VARIABLE, which must be a scalar, an entire array, or a subroutine name.
unpack(STRING, ARRAY)	Does the opposite of pack().
unshift(ARRAY1, ARRAY2)	Adds the elements of ARRAY2 to the front of ARRAY1. Note that the added elements retain their original order. The size of the new ARRAY1 is returned.
values(ASSOC_ARRAY)	Returns a list that holds all of the values in a given associative array. The list is not in any particular order.