Transcript Functions Recursion

Perl Chapter 6
Functions
Subprograms
• In Perl, all subprograms are functions
– returns 0 or 1 value
– although may have “side-effects”
• optional function declaration
– heading, no code
sub fn_name;
• function definition
– heading, has code
– can be ANYWHERE, except inside another function
sub fn_name { ….}
C:\>perl
C:\>perl
declaration
sub print_header;
print_header();
print_header();
sub print_header{
print “\n Hello\n”;
}
^Z
sub print_header{
print “\n Hello\n”;
}
definition
^Z
call
Output:
Hello
Note:
Hello
If function declaration used, can call
print_header;
#with no ()s
Textbook’s Style
• function definitions first, then program.
Value returning functions
• Two ways
1. predefined function return
2. returns value of last expression evaluated
sub foo {
return (expr);
}
(1)
sub foo {
expr;
}
(2)
• return function can be called anywhere in
function (and in more than one place, but…)
Context of function call
• context of call (scalar or list) dictates context
of evaluation of returned value
def:
sub sub1{
@result =(1,3,5);
}
call:
$scalar = sub1();
#$scalar assigned 3
@list = sub1();
#@list assigned (1,3,5)
Scope and Lifetime
• scope – range of statements over which
variable is visible (spatial concept)
• lifetime – begins when created and ends when
no longer can be used (temporal concept)
• global scope
– variable visible in whole program file
– not good inside a function (name conflicts)
2 kinds of Local variables
1. my – static local
•
just inside function or block
2. local – dynamic local
•
•
inside function or block and any functions called within
block
dangerous
sub sub1{
my $sum=0;
…
}
# scope of static local
# is just function sub1
$sum
• Advantage: local variables give slightly faster
access than global variables
• For readability - declare local variables at
beginning of function
• To disallow non-static scoped variables
use strict ‘vars’;
#also forces all program
#variables to be declared
• my is a function in some situations
my ($a, @list) = (3,2,7,6);
Parameters
• actual parameters (arguments)
– specified in call to a function
• formal parameters
– variables in function corresponding to actuals
• pass by value
• pass by reference (2 ways)
Pass by reference – 1st way
• Done through implicit array variable @_ or
@ARG
• For @ARG (use statement use English; in
program)
• At time of call, values of actual parameters are
copied into @ARG
• At time of return, values from @ARG copied
back.
@list =(1,3,5);
fun (6, @list);
sub fun{
…
}
#@ARG  (6,1,3,5)
• if hash  flattened into array (better to pass
by reference 2nd way)
• number of actual doesn’t have to match
number of formals
– too many, ignores
– too few, undef
sub addto{
$ARG[0] += $ARG[1];
}
$a=5;
addto($a, 7);
• What is $a now?
12
• What happens if we try to change $ARG[1]?
ignores it, can’t change 7
sub adder{
++$ARG[0];
++$ARG[1];
}
$ARG[0]=7
[1]=1
[2]=3
[3]=5
 8
 2
$x=7;
@list=(1,3,5);
adder($x, @list);
$x now 8
@list now (2,3,5)
sub swap{
($ARG[1], $ARG[0] = ($ARG[0], $ARG[1]);
}
swap ($a, $b);
Pass by value
• Copy @ARG’s values to static locals
sub sub1{
my ($x, $y, $z) = @ARG;
…
}
• passing hashes by value – make it ONLY
parameter
sub sub1{
my %my_people = @ARG;
…
}
…
sub1(%people);
Passing references as parameters –
2nd way
• pass references to actual parameters
– ref to array  single scalar assigned to @ARG
– array  copies ALL elements to @ARG
sub do_array{
my $ref_list = $ARG[0];
…
}
…
do_array (\@list);
#same with a hash \%table
Apply function to list of parameters
sub do_list{
my @list = @ARG;
…
return @list;
}
($count, $sum, @totals)=do_list($count, $sum, @totals);
ARRAY LAST!
indirect calls
• if you have one of five different functions to
be called depending on a string value of scalar
variable
– simulated switch or
– construct hash of string key => address of
function
predefined functions
• abs, chr, exit, exp, ord, log, rand, sqrt
• warn instead of die
• ….
sort function (again)
• additional parameter specifies comparison
operator
sort @list;
#default was ascending cmp on strings
• for numbers, use <=> as comparison operator
• array of numbers in ascending order
@list = sort {$a <=> $b;} @list;
#book typo
• array of numbers in descending order
@list = sort{$b <=> $a;} @list;
• array of strings in descending order
@list = sort{$b cmp $a;} @list;
Handout
• A subroutine defined or declared without
parameter list can be called without any
restrictions on the number or type of
parameters passed
• A subroutine defined with a parameter list
MUST be called with exactly the parameters
specified or compilation error results
Sample parameter lists
• () zero parameters required or accepted
• ($) 1 scalar parameter required
• ($; \@) 1 scalar parameter required, 2nd
parameter optional, but must be array
(reference)
• ($$$@) First 3 scalar, remaining actual put in
ending put in ending array
• (\@\%$;$$) array reference, hash reference,
scalar, 2 optional scalars
sub subp (\@$\@\%$){
my ($arrayRef1, $size, $arrayRef2, $hashRef,
$scalar)=@ARG;
}
subp(@list, $size, @digits, %table, $tableSize);
Future
• Skip chapter 7 for now (Pattern Matching)
• Did 8
• Go to 9 on Monday on CGI programming w/
Perl