User-Defined Functions in Programming
1
User Defined Functions Lesson 1
CS1313 Spring 2024
22.
User-Defined Function Example #1
23.
User-Defined Function Example #2
24.
User-Defined Function Example #3
25.
User-Defined Function Example #4
26.
User-Defined Function Example #5
27.
User-Defined Function Example #6
28.
User-Defined Function Example #7
29.
User-Defined Function Example #8
30.
User-Defined Function Example: Run
31.
Another Used-Defined Function #1
32.
Another Used-Defined Function #2
33.
Another Used-Defined Function #3
34.
Another Function Example #1
35.
Another Function Example #2
36.
Another Function Example #3
37.
Function Prototype Declarations #1
38.
Function Prototype Declarations #2
39.
Actual Arguments & Formal Arguments
40.
Actual Arguments
41.
Formal Arguments
42.
Yet Another Function Example #1
43.
Yet Another Function Example #2
44.
Yet Another Function Example #3
1.
User Defined Functions 1 Outline
2.
Standard Library Not Enough #1
3.
Standard Library Not Enough #2
4.
Calling a Function Instead
5.
Why User-Defined Functions?
6.
User-Defined
taxicab_norm
7.
User-Defined Function Properties
8.
Declarations Valid in Own Function #1
9.
Declarations Valid in Own Function #2
10.
Return Type
11.
List of Arguments
12.
Names of Arguments
13.
Array Arguments
14.
Local Variables & Named Constants #1
15.
Local Variables & Named Constants #2
16.
Returning the Return Value #1
17.
Returning the Return Value #2
18.
Declarations Inside Functions #1
19.
Declarations Inside Functions #2
20.
Declarations Inside Functions #3
21.
General Form of Function Definitions
User Defined Functions 1 Outline
2
User Defined Functions Lesson 1
CS1313 Spring 2024
Often, we have a particular kind of value that
we need to calculate over and over again,
under a variety of circumstances.
For instance, in the example program for PP#5,
we have to calculate the taxicab norm of
the elements of each array.
list1_input_value_taxicab_norm = initial_sum;
for (element = first_element;
element < number_of_elements; element++) {list1_input_value_taxicab_norm +=
fabs(list1_input_value[element]);
} /* for element */
list1_input_value_taxicab_norm =
list1_input_value_taxicab_norm / number_of_elements;
Standard Library Not Enough #1
3
User Defined Functions Lesson 1
CS1313 Spring 2024
We know that the algorithm for calculating
the taxicab norm of the elements of an array is
always the same
.
So why should we have to write the same piece of code
over and over and over and over and over?
Wouldn’t it be better if we could
write that piece of code
just once
and then
reuse
it in many applications?
Standard Library Not Enough #2
4
User Defined Functions Lesson 1
CS1313 Spring 2024
So, it’d be nice to replace this code:
list1_input_value_taxicab_norm = initial_sum;
for (element = first_element;
element < number_of_elements; element++) {list1_input_value_taxicab_norm +=
fabs(list1_input_value[element]);
} /* for element */
list1_input_value_taxicab_norm =
list1_input_value_taxicab_norm / number_of_elements;
with calls to a function that would calculate
the taxicab norm for
any
array:
list1_input_value_taxicab_norm =
taxicab_norm(list1_input_value, number_of_elements);
Calling a Function Instead
5
User Defined Functions Lesson 1
CS1313 Spring 2024
list1_input_value_taxicab_norm =
taxicab_norm(list1_input_value, number_of_elements);
...
list2_input_value_taxicab_norm =
taxicab_norm(list2_input_value, number_of_elements);
Obviously, the designers of C weren’t able to anticipate
the zillion things that we might need functions to do –
such as calculate the taxicab norm of the elements of an array.
So there are no standard library functions to calculate something
that is
application-specific
.
Instead, we as C programmers are going to have to
define our own function to do it.
Why User-Defined Functions?
6
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (float* array, int number_of_elements)
{ /* taxicab_norm */const float initial_sum = 0.0;
const int minimum_number_of_elements = 1;
const int first_element = 0;
const int program_failure_code = -1;
float taxicab_norm_value;
int element;
if (number_of_elements < minimum_number_of_elements) { printf("ERROR: can't have an array of length %d:\n",number_of_elements);
printf(" it must have at least %d element.\n",minimum_number_of_elements);
exit(program_failure_code);
} /* if (number_of_elements < ...) */
if (array == (float*)NULL) { printf("ERROR: can't calculate the taxicab norm of "); printf("a nonexistent array.\n");exit(program_failure_code);
} /* if (array == (float*)NULL) */
taxicab_norm_value = initial_sum;
for (element = first_element;
element < number_of_elements; element++) {taxicab_norm_value += fabs(array[element]);
} /* for element */
return taxicab_norm_value;
} /* taxicab_norm */
User-Defined
taxicab_norm
7
User Defined Functions Lesson 1
CS1313 Spring 2024
In general, the definition of a user-defined function
looks a lot like a program, except for the following things:
1.
The function header begins with a
return type
that is appropriate for that function
(for example,
int
,
float
,
char
).
2.
The function has a
name
that is chosen by the programmer.
3.
At the end of the function header is a list of
arguments
,
enclosed in parentheses and separated by commas,
each argument preceded by its data type.
4.
The function may declare
local
named constants and
local
variables.
5.
In the body of the function, the
return
statement
tells the function what value to return to
the statement that called the function.
User-Defined Function Properties
8
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (float* array, int number_of_elements)
{ /* taxicab_norm */const float initial_sum = 0.0;
const int minimum_number_of_elements = 1;
const int first_element = 0;
const int program_failure_code = -1;
float taxicab_norm_value;
int element;
...
} /* taxicab_norm */
The compiler treats each function completely independently
of the others.
Most importantly,
the declarations inside a function
–
including the declarations of its arguments –
apply only to that function
, not to any others.
Declarations Valid in Own Function #1
9
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (float* array, int number_of_elements)
{ /* taxicab_norm */const float initial_sum = 0.0;
const int minimum_number_of_elements = 1;
const int first_element = 0;
const int program_failure_code = -1;
float taxicab_norm_value;
int element;
...
} /* taxicab_norm */
For example:
The declaration of
initial_sum
in the function
taxicab_norm
is visible
only to the function
taxicab_norm
but not to the
main
function, nor to any other function.
If another function wants to have the same named constant,
it has to have its own declaration of that named constant.
Declarations Valid in Own Function #2
10
User Defined Functions Lesson 1
CS1313 Spring 2024
float
taxicab_norm (
float* array, int number_of_elements)
{ /* taxicab_norm */...
} /* taxicab_norm */
In the function header, immediately
before
the function name
is a data type.
This data type specifies the
return type
, which is the data type
of the value that the function will return.
The return type (for now) must be a basic scalar type
(for example,
int
,
float
,
char
).
Notice that the return type of the function
is declared
,
but
in a weird way
(in the function header,
before the function name).
Return Type
11
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (
float* array, int number_of_elements
)
{ /* taxicab_norm */...
} /* taxicab_norm */
At the end of the function header,
immediately after the function name, is a list of arguments,
enclosed in parentheses and separated by commas,
each argument preceded by its data type.
Thus, the function’s arguments
are declared
,
but
not in the function’s declaration section
.
List of Arguments
12
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (
float* array, int number_of_elements
)
{ /* taxicab_norm */...
} /* taxicab_norm */
The names of the arguments in the function definition
DON’T
have to match the names of the arguments
that are passed into the function by the
main
function
(or by whatever other function) that calls the function.
They should be meaningful with respect to
the function in which they occur
,
NOT
with respect to the function(s) that call(s) that function.
Names of Arguments
13
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (
float* array, int number_of_elements
)
When passing an array argument, you must also pass
an argument that represents the
length
of the array.
Not surprisingly, this length argument should be of type
int
.
Also, when passing an array argument, you have two choices
about how to express the argument’s data type.
The first is above; the second is below:
float taxicab_norm (
float array[], int number_of_elements
)
In CS1313, we prefer
*
notation to
[]
notation.
Array Arguments
14
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (float* array, int number_of_elements)
{ /* taxicab_norm */const float initial_sum = 0.0;
const int minimum_number_of_elements = 1;
const int first_element = 0;
const int program_failure_code = -1;
float taxicab_norm_value;
int element;
...
} /* taxicab_norm */
The function’s declaration section may contain
declarations of
local
named constants and
local
variables.
These names that are valid ONLY within
the function that is being defined.
On the other hand, these same names can be used with
totally different meanings by other functions
(and by the calling function).
Local Variables & Named Constants #1
15
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (float* array, int number_of_elements)
{ /* taxicab_norm */const float initial_sum = 0.0;
const int minimum_number_of_elements = 1;
const int first_element = 0;
const int program_failure_code = -1;
float taxicab_norm_value;
int element;
...
} /* taxicab_norm */
Good programming style requires declaring:
1.
local named constants
, followed by
2.
local variables
inside the function definition.
Note that these declarations should occur in the usual order.
Local Variables & Named Constants #2
16
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (float* array, int number_of_elements)
{ /* taxicab_norm */...
taxicab_norm_value = initial_sum;
for (element = first_element;
element < number_of_elements; element++) {taxicab_norm_value += fabs(array[element]);
} /* for element */
return taxicab_norm_value;
} /* taxicab_norm */
In the body of the function, the
return
statement
tells the function to return the
return value
.
If the function does not return a value, then the compiler may
get upset.
The return value is returned to the statement that called
the function, and in some sense “replaces” the function call
in the expression where the function call appears.
Returning the Return Value #1
17
User Defined Functions Lesson 1
CS1313 Spring 2024
float taxicab_norm (float* array, int number_of_elements)
{ /* taxicab_norm */...
taxicab_norm_value = initial_sum;
for (element = first_element;
element < number_of_elements; element++) {taxicab_norm_value += fabs(array[element]);
} /* for element */
return taxicab_norm_value;
} /* taxicab_norm */
The return value is returned to the statement that called
the function, and in some sense “replaces” the function call in
the expression where the function call appears.
list1_input_value_taxicab_norm =
taxicab_norm(list1_input_value, number_of_elements);
...
list2_input_value_taxicab_norm =
taxicab_norm(list2_input_value, number_of_elements);
Returning the Return Value #2
18
User Defined Functions Lesson 1
CS1313 Spring 2024
The following point is EXTREMELY important:
For our purposes
, the only user-defined identifiers that
a given function is aware of –
whether it’s the
main
function or some other function –
are those that are
explicitly declared in the function
’s declaration section,
or in the function’s argument list.
(The above statement isn’t literally true,
but is true enough for our purposes.)
Declarations Inside Functions #1
19
User Defined Functions Lesson 1
CS1313 Spring 2024
Thus, a function is aware of:
1.
its arguments, if any;
2.
its local named constants, if any;
3.
its local variables, if any;
4.
other functions that it has declared
prototypes
for, if any
(described later).
Declarations Inside Functions #2
20
User Defined Functions Lesson 1
CS1313 Spring 2024
The function knows
NOTHING AT ALL
about
variables or named constants declared inside any other function.
It isn’t aware that they exist and cannot use them.
Therefore, the
ONLY
way to send information from one function
to another is by passing arguments
from the calling function to the called function.
Declarations Inside Functions #3
21
User Defined Functions Lesson 1
CS1313 Spring 2024
returntype funcname
(
datatype1 arg1
,
datatype2 arg2
,
...
)
{ /* funcname
*/
const
localconst1type
localconst1
=
localvalue1
;
const
localconst2type
localconst2
=
localvalue2
;
...
localvar1type
localvar1
;
localvar2type
localvar2
;
...
[ function body: does stuff ]
return
returnvalue
;
} /*
funcname
*/
General Form of Function Definitions
22
User Defined Functions Lesson 1
CS1313 Spring 2024
Function prototype
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main ()
DON’T COPY-AND-PASTE!
{ /* main */const int minimum_number_of_elements = 1;
const int first_element = 0;
const int program_success_code = 0;
const int program_failure_code = -1;
float* list1_input_value = (float*)NULL;
float* list2_input_value = (float*)NULL;
float list1_input_value_taxicab_norm;
/* DON’T COPY-AND-PASTE!
float list2_input_value_taxicab_norm;
int number_of_elements;
DON’T COPY-AND-PASTE!
int eḽement;
float taxicab_norm(float* array, int number_of_elements);
User-Defined Function Example #1
User-Defined Function Example #2
printf("Î'm going to calculate the taxicab norm of\n"); printf(" a pair of lists of values that you input.\n"); printf("These lists will have the same length.\n");/* DON’T COPY-AND-PASTE! */
User Defined Functions Lesson 1
CS1313 Spring 2024
23
User-Defined Function Example #3
printf("How many values would you like to\n"); printf(" calculate the taxicab norm of in each list?\n"); scanf("%d", &number_of_elements); if (number_of_elements < minimum_number_of_elements) { printf("ERROR: Can't calculate the taxicab norm of %d",number_of_elements);
/* DON’T COPY-AND-PASTE! */ DON’T C
printf(" values.\n");exit(program_failure_code);
} /* if (number_of_elements < minimum_ňumber_of_elements) */
User Defined Functions Lesson 1
CS1313 Spring 2024
24
User-Defined Function Example #4
list1_input_value =
(float*)malloc(sizeof(float) * number_of_elements);
if (list1_input_value == (float*)NULL) { printf("ERROR: Can't allocate the 1st float array\n"); printf(" of length %d.\n", number_of_elements);exit(program_failure_code);
} /* if (list1_input_value == (float*)NULL) */
/* DON’T COPY-AND-PASTE! */
list2_input_value =
(float*)malloc(sizeof(float) * number_of_elements);
if (list2_input_value == (float*)NULL) { printf("ERROR: Can't allocate the 2nd float array\n"); printf(" of length %d.\n", number_of_elements);exit(program_failure_code);
} /* if (list2_input_value == (float*)NULL) */
User Defined Functions Lesson 1
CS1313 Spring 2024
25
User-Defined Function Example #5
printf("What are the pair of lists of %d values each\n",number_of_elements);
printf(" to calculate the taxicab norm of?\n");for (element = first_element;
element < number_of_elements; element++) { scanf("%f %f", DON’T COPY-AND-PASTE!
&list1_input_value[element],
&list2_input_value[element]);
} /* for element */
/* DON’T COPY-AND-PASTE! */ DON’T COPY-AND-PASTE
!
User Defined Functions Lesson 1
CS1313 Spring 2024
26
27
User Defined Functions Lesson 1
CS1313 Spring 2024
Function calls
list1_input_value_taxicab_norm =
taxicab_norm(list1_input_value, number_of_elements);
list2_input_value_taxicab_norm =
taxicab_norm(list2_input_value, number_of_elements);
User-Defined Function Example #6
User-Defined Function Example #7
printf("The %d pairs of input values are:\n",number_of_elements);
for (element = first_element;
element < number_of_elements; element++) { printf("%f %f\n",list1_input_value[element],
list2_input_value[element]);
} /* for element */
/* DON’T COPY-AND-PASTE! */ DON’T COPY-AND-
printf(“The taxicab norm of the 1st list of %d input values is %f.\n",
number_of_elements, list1_input_value_taxicab_norm);
printf(“The taxicab norm of the 2nd list of %d input values is %f.\n",
number_of_elements, list2_input_value_taxicab_norm);
User Defined Functions Lesson 1
CS1313 Spring 2024
28
User-Defined Function Example #8
free(list2_input_value);
list2_input_value = (float*)NULL;
free(list1_input_value);
DON’T COPY-AND-PASTE!
list1_input_value = (float*)NULL;
return program_success_code;
} /* mai
ņ
*/
/* DON’T COPY-AND-PASTE! */
[The function definition for
taxicab_norm
,
as shown on slide #6, goes here,
AFTER
the block close for the
main
function.]
User Defined Functions Lesson 1
CS1313 Spring 2024
29
User-Defined Function Example: Run
%
gcc -o taxicab_norm_function taxicab_norm_function.c -lm
%
taxicab_norm_function
I'm going to calculate the taxicab norm of
a pair of lists of values that you input.
These lists will have the same length.
How many values would you like to
calculate the taxicab norm of in each list?
5
What are the pair of lists of 5 values each
to calculate the taxicab norm of?
1.1 11.11
2.2 22.22
3.3 33.33
4.4 44.44
9.9 99.99
The 5 pairs of input values are:
1.100000 11.110000
2.200000 22.219999
3.300000 33.330002
4.400000 44.439999
9.900000 99.989998
The taxicab norm of the 1st list of 5 input values is 20.900000.
The taxicab norm of the 2nd list of 5 input values is 211.090000.
User Defined Functions Lesson 1
CS1313 Spring 2024
30
31
User Defined Functions Lesson 1
CS1313 Spring 2024
float cube_root (float base)
{ /* cube_root */const float cube_root_power = 1.0 / 3.0;
return pow(base, cube_root_power);
} /* cube_root */
What can we say about this user-defined function?
1.
Its name is
cube_root
.
2.
Its return type is
float
.
3.
It has one argument,
base
, whose type is
float
.
4.
It has one local named constant,
cube_root_power
.
5.
It has no local variables.
6.
It calculates and returns the cube root of the incoming
argument.
Another Used-Defined Function #1
32
User Defined Functions Lesson 1
CS1313 Spring 2024
float cube_root (float base)
{ /* cube_root */const float cube_root_power = 1.0 / 3.0;
return pow(base, cube_root_power);
} /* cube_root */
So,
cube_root
calculates the cube root of
a
float
argument and returns a
float
result
whose value is the cube root of the argument.
Notice that
cube_root
simply calls the C standard library
function
pow
, using a specific named constant for the
exponent.
We say that
cube_root
is a
wrapper
around
pow
,
or more formally that
cube_root
encapsulates
pow
.
Another Used-Defined Function #2
33
User Defined Functions Lesson 1
CS1313 Spring 2024
float cube_root (float base)
{ /* cube_root */const float cube_root_power = 1.0 / 3.0;
return pow(base, cube_root_power);
} /* cube_root */
Does the name of a user-defined function have to be
meaningful?
From the compiler’s perspective, absolutely not;
you could easily have a function named
square_root
that always returns 12.
But from the perspective of programmers,
that’d be a
REALLY REALLY BAD IDEA
, and
you’d get a
VERY BAD GRADE
.
Another Used-Defined Function #3
34
User Defined Functions Lesson 1
CS1313 Spring 2024
Function
prototype
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main ()
{ /* main */const int number_of_elements = 3;
const int program_success_code = 0;
float input_value1, cube_root_value1;
float input_value2, cube_root_value2;
float input_value3, cube_root_value3;
float cube_root(float base);
printf("What %d real numbers would you\n",number_of_elements);
printf(" like the cube roots of?\n"); scanf("%f %f %f",&input_value1, &input_value2,
&input_value3);
Another Function Example #1
35
User Defined Functions Lesson 1
CS1313 Spring 2024
Function calls
cube_root_value1 =
cube_root(input_value1);
cube_root_value2 =
cube_root(input_value2);
cube_root_value3 =
cube_root(input_value3);
printf("The cube root of %f is %f.\n",input_value1, cube_root_value1);
printf("The cube root of %f is %f.\n",input_value2, cube_root_value2);
printf("The cube root of %f is %f.\n",input_value3, cube_root_value3);
return program_success_code;
} /* main */
Another Function Example #2
36
User Defined Functions Lesson 1
CS1313 Spring 2024
%
gcc -o cube_root_scalar \
cube_root_scalar.c cube_root.c -lm
%
cube_root_scalar
What 3 real numbers would you
like the cube roots of?
1 8 25
The cube root of 1.000000 is 1.000000.
The cube root of 8.000000 is 2.000000.
The cube root of 25.000000 is 2.924018.
Another Function Example #3
37
User Defined Functions Lesson 1
CS1313 Spring 2024
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main ()
{ /* main */const int number_of_elements = 3;
const int program_success_code = 0;
float input_value1, cube_root_value1;
float input_value2, cube_root_value2;
float input_value3, cube_root_value3;
float cube_root(float base);
...
} /* main */
Notice this declaration:
float cube_root(float base);
This declaration is a
function prototype
declaration.
Function Prototype Declarations #1
38
User Defined Functions Lesson 1
CS1313 Spring 2024
float cube_root(float base);
This declaration is a
function prototype
declaration.
The function prototype declaration tells the compiler that
there’s a function named
cube_root
with
a return type of
float
, and that it’s declared
external
to (outside of) the function that’s calling
the
cube_root
function.
You
MUST
declare prototypes for the functions that
you’re calling.
Otherwise, the compiler will assume that, by default,
the function returns an
int
and has no arguments.
If that turns out not to be the case (that is, most of the time),
then the compiler will become
ANGRY
.
Function Prototype Declarations #2
39
User Defined Functions Lesson 1
CS1313 Spring 2024
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main ()
{ /* main */...
cube_root_value1 = cube_root(input_value1);
cube_root_value2 = cube_root(input_value2);
cube_root_value3 = cube_root(input_value3);
...
} /* main */
float cube_root (float base)
{ /* cube_root */...
} /* cube_root */
When we talk about the arguments of a function,
we’re actually talking about
two very different kinds
of
arguments:
actual arguments
and
formal arguments
.
Actual Arguments & Formal Arguments
40
User Defined Functions Lesson 1
CS1313 Spring 2024
#include <stdio.h>
#include <math.h>
int main ()
{ /* main */...
cube_root_value1 = cube_root(input_value1);
cube_root_value2 = cube_root(input_value2);
cube_root_value3 = cube_root(input_value3);
...
} /* main */
The arguments that appear in the
call
to the function –
for example,
input_value1
,
input_value2
and
input_value3
in the program fragment above –
are known as
actual arguments
, because they’re the values
that
actually
get passed to the function.
Mnemonic
: The a
C
tual arguments are in the function
C
all.
Actual Arguments
41
User Defined Functions Lesson 1
CS1313 Spring 2024
float cube_root (float base)
{ /* cube_root */...
} /* cube_root */
The arguments that appear in the
definition
of the function –
for example,
base
, in the function fragment above –
are known as
formal arguments
, because they’re the names
that are used in the
formal definition
of the function.
Jargon
:
Formal arguments
are also known as
dummy arguments
.
Mnemonic
: The
F
ormal arguments are in the function de
F
inition.
Formal Arguments
42
User Defined Functions Lesson 1
CS1313 Spring 2024
#include <stdio.h>
#include <math.h>
int main ()
{ /* main */const int first_element = 0;
const int number_of_elements = 5;
const int program_success_code = 0;
float input_value[number_of_elements];
float cube_root_value[number_of_elements];
int element;
float cube_root(float base);
printf("What %d real numbers would you\n",number_of_elements);
printf(" like the cube roots of?\n");for (element = first_element;
element < number_of_elements; element++) { scanf("%f", &input_value[element]);} /* for element */
Yet Another Function Example #1
43
User Defined Functions Lesson 1
CS1313 Spring 2024
for (element = first_element;
element < number_of_elements; element++) {cube_root_value[element] =
cube_root(input_value[element]);
} /* for element */
for (element = first_element;
element < number_of_elements; element++) { printf("The cube root of %f is %f.\n",input_value[element],
cube_root_value[element]);
} /* for element */
return program_success_code;
} /* main */
Yet Another Function Example #2
44
User Defined Functions Lesson 1
CS1313 Spring 2024
%
gcc -o cube_root_array \
cube_root_array.c cube_root.c -lm
%
cube_root_array
What 5 real numbers would you
like the cube roots of?
1 8 25 27 32
The cube root of 1.000000 is 1.000000.
The cube root of 8.000000 is 2.000000.
The cube root of 25.000000 is 2.924018.
The cube root of 27.000000 is 3.000000.
The cube root of 32.000000 is 3.174802.
Yet Another Function Example #3
Explore the significance of user-defined functions in programming by learning how they can optimize code reusability and simplify complex tasks. From creating custom functions to calling them, discover the power and flexibility they offer in enhancing code efficiency.
Download Presentation
Please find below an Image/Link to download the presentation.
The content on the website is provided AS IS for your information and personal use only. It may not be sold, licensed, or shared on other websites without obtaining consent from the author. Download presentation by click this link. If you encounter any issues during the download, it is possible that the publisher has removed the file from their server.
E N D
Presentation Transcript
User Defined Functions 1 Outline 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. User Defined Functions 1 Outline Standard Library Not Enough #1 Standard Library Not Enough #2 Calling a Function Instead Why User-Defined Functions? User-Defined taxicab_norm User-Defined Function Properties Declarations Valid in Own Function #1 Declarations Valid in Own Function #2 Return Type List of Arguments Names of Arguments Array Arguments Local Variables & Named Constants #1 Local Variables & Named Constants #2 Returning the Return Value #1 Returning the Return Value #2 Declarations Inside Functions #1 Declarations Inside Functions #2 Declarations Inside Functions #3 General Form of Function Definitions 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. User-Defined Function Example #1 User-Defined Function Example #2 User-Defined Function Example #3 User-Defined Function Example #4 User-Defined Function Example #5 User-Defined Function Example #6 User-Defined Function Example #7 User-Defined Function Example #8 User-Defined Function Example: Run Another Used-Defined Function #1 Another Used-Defined Function #2 Another Used-Defined Function #3 Another Function Example #1 Another Function Example #2 Another Function Example #3 Function Prototype Declarations #1 Function Prototype Declarations #2 Actual Arguments & Formal Arguments Actual Arguments Formal Arguments Yet Another Function Example #1 Yet Another Function Example #2 Yet Another Function Example #3 User Defined Functions Lesson 1 CS1313 Spring 2024 1
Standard Library Not Enough #1 Often, we have a particular kind of value that we need to calculate over and over again, under a variety of circumstances. For instance, in the example program for PP#5, we have to calculate the taxicab norm of the elements of each array. list1_input_value_taxicab_norm = initial_sum; for (element = first_element; element < number_of_elements; element++) { list1_input_value_taxicab_norm += fabs(list1_input_value[element]); } /* for element */ list1_input_value_taxicab_norm = list1_input_value_taxicab_norm / number_of_elements; User Defined Functions Lesson 1 CS1313 Spring 2024 2
Standard Library Not Enough #2 We know that the algorithm for calculating the taxicab norm of the elements of an array is always the same. So why should we have to write the same piece of code over and over and over and over and over? Wouldn t it be better if we could write that piece of code just once and then reuse it in many applications? User Defined Functions Lesson 1 CS1313 Spring 2024 3
Calling a Function Instead So, it d be nice to replace this code: list1_input_value_taxicab_norm = initial_sum; for (element = first_element; element < number_of_elements; element++) { list1_input_value_taxicab_norm += fabs(list1_input_value[element]); } /* for element */ list1_input_value_taxicab_norm = list1_input_value_taxicab_norm / number_of_elements; with calls to a function that would calculate the taxicab norm for any array: list1_input_value_taxicab_norm = taxicab_norm(list1_input_value, number_of_elements); User Defined Functions Lesson 1 CS1313 Spring 2024 4
Why User-Defined Functions? list1_input_value_taxicab_norm = taxicab_norm(list1_input_value, number_of_elements); ... list2_input_value_taxicab_norm = taxicab_norm(list2_input_value, number_of_elements); Obviously, the designers of C weren t able to anticipate the zillion things that we might need functions to do such as calculate the taxicab norm of the elements of an array. So there are no standard library functions to calculate something that is application-specific. Instead, we as C programmers are going to have to define our own function to do it. User Defined Functions Lesson 1 CS1313 Spring 2024 5
User-Defined taxicab_norm float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ const float initial_sum = 0.0; const int minimum_number_of_elements = 1; const int first_element = 0; const int program_failure_code = -1; float taxicab_norm_value; int element; if (number_of_elements < minimum_number_of_elements) { printf("ERROR: can't have an array of length %d:\n", number_of_elements); printf(" it must have at least %d element.\n", minimum_number_of_elements); exit(program_failure_code); } /* if (number_of_elements < ...) */ if (array == (float*)NULL) { printf("ERROR: can't calculate the taxicab norm of "); printf("a nonexistent array.\n"); exit(program_failure_code); } /* if (array == (float*)NULL) */ taxicab_norm_value = initial_sum; for (element = first_element; element < number_of_elements; element++) { taxicab_norm_value += fabs(array[element]); } /* for element */ return taxicab_norm_value; } /* taxicab_norm */ User Defined Functions Lesson 1 CS1313 Spring 2024 6
User-Defined Function Properties In general, the definition of a user-defined function looks a lot like a program, except for the following things: 1. The function header begins with a return type that is appropriate for that function (for example, int, float, char). 2. The function has a namethat is chosen by the programmer. 3. At the end of the function header is a list of arguments, enclosed in parentheses and separated by commas, each argument preceded by its data type. 4. The function may declare localnamed constants and localvariables. 5. In the body of the function, thereturnstatement tells the function what value to return to the statement that called the function. User Defined Functions Lesson 1 CS1313 Spring 2024 7
Declarations Valid in Own Function #1 float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ const float initial_sum = 0.0; const int minimum_number_of_elements = 1; const int first_element = 0; const int program_failure_code = -1; float taxicab_norm_value; int element; ... } /* taxicab_norm */ The compiler treats each function completely independently of the others. Most importantly, the declarations inside a function including the declarations of its arguments apply only to that function, not to any others. User Defined Functions Lesson 1 CS1313 Spring 2024 8
Declarations Valid in Own Function #2 float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ const float initial_sum = 0.0; const int minimum_number_of_elements = 1; const int first_element = 0; const int program_failure_code = -1; float taxicab_norm_value; int element; ... } /* taxicab_norm */ For example: The declaration of initial_sum in the function taxicab_norm is visible only to the function taxicab_norm but not to the main function, nor to any other function. If another function wants to have the same named constant, it has to have its own declaration of that named constant. User Defined Functions Lesson 1 CS1313 Spring 2024 9
Return Type float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ ... } /* taxicab_norm */ In the function header, immediately before the function name is a data type. This data type specifies the return type, which is the data type of the value that the function will return. The return type (for now) must be a basic scalar type (for example, int, float, char). Notice that the return type of the function is declared, but in a weird way (in the function header, before the function name). User Defined Functions Lesson 1 CS1313 Spring 2024 10
List of Arguments float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ ... } /* taxicab_norm */ At the end of the function header, immediately after the function name, is a list of arguments, enclosed in parentheses and separated by commas, each argument preceded by its data type. Thus, the function s arguments are declared, but not in the function s declaration section. User Defined Functions Lesson 1 CS1313 Spring 2024 11
Names of Arguments float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ ... } /* taxicab_norm */ The names of the arguments in the function definition DON Thave to match the names of the arguments that are passed into the function by the main function (or by whatever other function) that calls the function. They should be meaningful with respect to the function in which they occur, NOT with respect to the function(s) that call(s) that function. User Defined Functions Lesson 1 CS1313 Spring 2024 12
Array Arguments float taxicab_norm (float* array, int number_of_elements) When passing an array argument, you must also pass an argument that represents the length of the array. Not surprisingly, this length argument should be of type int. Also, when passing an array argument, you have two choices about how to express the argument s data type. The first is above; the second is below: float taxicab_norm (float array[], int number_of_elements) In CS1313, we prefer * notation to [] notation. User Defined Functions Lesson 1 CS1313 Spring 2024 13
Local Variables & Named Constants #1 float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ const float initial_sum = 0.0; const int minimum_number_of_elements = 1; const int first_element = 0; const int program_failure_code = -1; float taxicab_norm_value; int element; ... } /* taxicab_norm */ The function s declaration section may contain declarations of localnamed constants and localvariables. These names that are valid ONLY within the function that is being defined. On the other hand, these same names can be used with totally different meanings by other functions (and by the calling function). User Defined Functions Lesson 1 CS1313 Spring 2024 14
Local Variables & Named Constants #2 float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ const float initial_sum = 0.0; const int minimum_number_of_elements = 1; const int first_element = 0; const int program_failure_code = -1; float taxicab_norm_value; int element; ... } /* taxicab_norm */ Good programming style requires declaring: 1. local named constants, followed by 2. local variables inside the function definition. Note that these declarations should occur in the usual order. User Defined Functions Lesson 1 CS1313 Spring 2024 15
Returning the Return Value #1 float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ ... taxicab_norm_value = initial_sum; for (element = first_element; element < number_of_elements; element++) { taxicab_norm_value += fabs(array[element]); } /* for element */ return taxicab_norm_value; } /* taxicab_norm */ In the body of the function, thereturnstatement tells the function to return the return value. If the function does not return a value, then the compiler may get upset. The return value is returned to the statement that called the function, and in some sense replaces the function call in the expression where the function call appears. User Defined Functions Lesson 1 CS1313 Spring 2024 16
Returning the Return Value #2 float taxicab_norm (float* array, int number_of_elements) { /* taxicab_norm */ ... taxicab_norm_value = initial_sum; for (element = first_element; element < number_of_elements; element++) { taxicab_norm_value += fabs(array[element]); } /* for element */ return taxicab_norm_value; } /* taxicab_norm */ The return value is returned to the statement that called the function, and in some sense replaces the function call in the expression where the function call appears. list1_input_value_taxicab_norm = taxicab_norm(list1_input_value, number_of_elements); ... list2_input_value_taxicab_norm = taxicab_norm(list2_input_value, number_of_elements); User Defined Functions Lesson 1 CS1313 Spring 2024 17
Declarations Inside Functions #1 The following point is EXTREMELY important: For our purposes, the only user-defined identifiers that a given function is aware of whether it s the main function or some other function are those that are explicitly declared in the function s declaration section, or in the function s argument list. (The above statement isn t literally true, but is true enough for our purposes.) User Defined Functions Lesson 1 CS1313 Spring 2024 18
Declarations Inside Functions #2 Thus, a function is aware of: 1. its arguments, if any; 2. its local named constants, if any; 3. its local variables, if any; 4. other functions that it has declared prototypesfor, if any (described later). User Defined Functions Lesson 1 CS1313 Spring 2024 19
Declarations Inside Functions #3 The function knows NOTHING AT ALL about variables or named constants declared inside any other function. It isn t aware that they exist and cannot use them. Therefore, the ONLY way to send information from one function to another is by passing arguments from the calling function to the called function. User Defined Functions Lesson 1 CS1313 Spring 2024 20
General Form of Function Definitions returntype funcname (datatype1 arg1,datatype2 arg2, ... ) { /* funcname */ const localconst1typelocalconst1 = localvalue1; const localconst2typelocalconst2 = localvalue2; ... localvar1typelocalvar1; localvar2typelocalvar2; ... [ function body: does stuff ] returnreturnvalue; } /* funcname */ User Defined Functions Lesson 1 CS1313 Spring 2024 21
User-Defined Function Example #1 #include <stdio.h> #include <stdlib.h> #include <math.h> int main () DON T COPY-AND-PASTE! { /* main */ const int minimum_number_of_elements = 1; const int first_element = 0; const int program_success_code = 0; const int program_failure_code = -1; float* list1_input_value = (float*)NULL; float* list2_input_value = (float*)NULL; float list1_input_value_taxicab_norm; /* DON T COPY-AND-PASTE! float list2_input_value_taxicab_norm; int number_of_elements; DON T COPY-AND-PASTE! int e ement; float taxicab_norm(float* array, int number_of_elements); Function prototype User Defined Functions Lesson 1 CS1313 Spring 2024 22
User-Defined Function Example #2 printf(" 'm going to calculate the taxicab norm of\n"); printf(" a pair of lists of values that you input.\n"); printf("These lists will have the same length.\n"); /* DON T COPY-AND-PASTE! */ User Defined Functions Lesson 1 CS1313 Spring 2024 23
User-Defined Function Example #3 printf("How many values would you like to\n"); printf(" calculate the taxicab norm of in each list?\n"); scanf("%d", &number_of_elements); if (number_of_elements < minimum_number_of_elements) { printf("ERROR: Can't calculate the taxicab norm of %d", number_of_elements); /* DON T COPY-AND-PASTE! */ DON T C printf(" values.\n"); exit(program_failure_code); } /* if (number_of_elements < minimum_ umber_of_elements) */ User Defined Functions Lesson 1 CS1313 Spring 2024 24
User-Defined Function Example #4 list1_input_value = (float*)malloc(sizeof(float) * number_of_elements); if (list1_input_value == (float*)NULL) { printf("ERROR: Can't allocate the 1st float array\n"); printf(" of length %d.\n", number_of_elements); exit(program_failure_code); } /* if (list1_input_value == (float*)NULL) */ /* DON T COPY-AND-PASTE! */ list2_input_value = (float*)malloc(sizeof(float) * number_of_elements); if (list2_input_value == (float*)NULL) { printf("ERROR: Can't allocate the 2nd float array\n"); printf(" of length %d.\n", number_of_elements); exit(program_failure_code); } /* if (list2_input_value == (float*)NULL) */ User Defined Functions Lesson 1 CS1313 Spring 2024 25
User-Defined Function Example #5 printf("What are the pair of lists of %d values each\n", number_of_elements); printf(" to calculate the taxicab norm of?\n"); for (element = first_element; element < number_of_elements; element++) { scanf("%f %f", DON T COPY-AND-PASTE! &list1_input_value[element], &list2_input_value[element]); } /* for element */ /* DON T COPY-AND-PASTE! */ DON T COPY-AND-PASTE! User Defined Functions Lesson 1 CS1313 Spring 2024 26
User-Defined Function Example #6 list1_input_value_taxicab_norm = taxicab_norm(list1_input_value, number_of_elements); list2_input_value_taxicab_norm = taxicab_norm(list2_input_value, number_of_elements); Function calls User Defined Functions Lesson 1 CS1313 Spring 2024 27
User-Defined Function Example #7 printf("The %d pairs of input values are:\n", number_of_elements); for (element = first_element; element < number_of_elements; element++) { printf("%f %f\n", list1_input_value[element], list2_input_value[element]); } /* for element */ /* DON T COPY-AND-PASTE! */ DON T COPY-AND- printf( The taxicab norm of the 1st list of %d input values is %f.\n", number_of_elements, list1_input_value_taxicab_norm); printf( The taxicab norm of the 2nd list of %d input values is %f.\n", number_of_elements, list2_input_value_taxicab_norm); User Defined Functions Lesson 1 CS1313 Spring 2024 28
User-Defined Function Example #8 free(list2_input_value); list2_input_value = (float*)NULL; free(list1_input_value); DON T COPY-AND-PASTE! list1_input_value = (float*)NULL; return program_success_code; } /* mai */ /* DON T COPY-AND-PASTE! */ [The function definition for taxicab_norm, as shown on slide #6, goes here, AFTER the block close for the main function.] User Defined Functions Lesson 1 CS1313 Spring 2024 29
User-Defined Function Example: Run % gcc -o taxicab_norm_function taxicab_norm_function.c -lm % taxicab_norm_function I'm going to calculate the taxicab norm of a pair of lists of values that you input. These lists will have the same length. How many values would you like to calculate the taxicab norm of in each list? 5 What are the pair of lists of 5 values each to calculate the taxicab norm of? 1.1 11.11 2.2 22.22 3.3 33.33 4.4 44.44 9.9 99.99 The 5 pairs of input values are: 1.100000 11.110000 2.200000 22.219999 3.300000 33.330002 4.400000 44.439999 9.900000 99.989998 The taxicab norm of the 1st list of 5 input values is 20.900000. The taxicab norm of the 2nd list of 5 input values is 211.090000. User Defined Functions Lesson 1 30 CS1313 Spring 2024
Another Used-Defined Function #1 float cube_root (float base) { /* cube_root */ const float cube_root_power = 1.0 / 3.0; return pow(base, cube_root_power); } /* cube_root */ What can we say about this user-defined function? 1. Its name is cube_root. 2. Its return type is float. 3. It has one argument, base, whose type is float. 4. It has one local named constant, cube_root_power. 5. It has no local variables. 6. It calculates and returns the cube root of the incoming argument. User Defined Functions Lesson 1 CS1313 Spring 2024 31
Another Used-Defined Function #2 float cube_root (float base) { /* cube_root */ const float cube_root_power = 1.0 / 3.0; return pow(base, cube_root_power); } /* cube_root */ So, cube_root calculates the cube root of a float argument and returns a float result whose value is the cube root of the argument. Notice that cube_root simply calls the C standard library function pow, using a specific named constant for the exponent. We say that cube_root is a wrapperaround pow, or more formally that cube_root encapsulatespow. User Defined Functions Lesson 1 CS1313 Spring 2024 32
Another Used-Defined Function #3 float cube_root (float base) { /* cube_root */ const float cube_root_power = 1.0 / 3.0; return pow(base, cube_root_power); } /* cube_root */ Does the name of a user-defined function have to be meaningful? From the compiler s perspective, absolutely not; you could easily have a function named square_root that always returns 12. But from the perspective of programmers, that d be a REALLY REALLY BAD IDEA, and you d get a VERY BAD GRADE. User Defined Functions Lesson 1 CS1313 Spring 2024 33
Another Function Example #1 #include <stdio.h> #include <stdlib.h> #include <math.h> int main () { /* main */ const int number_of_elements = 3; const int program_success_code = 0; float input_value1, cube_root_value1; float input_value2, cube_root_value2; float input_value3, cube_root_value3; float cube_root(float base); printf("What %d real numbers would you\n", number_of_elements); printf(" like the cube roots of?\n"); scanf("%f %f %f", &input_value1, &input_value2, &input_value3); Function prototype User Defined Functions Lesson 1 CS1313 Spring 2024 34
Another Function Example #2 cube_root_value1 = cube_root(input_value1); cube_root_value2 = cube_root(input_value2); cube_root_value3 = cube_root(input_value3); printf("The cube root of %f is %f.\n", input_value1, cube_root_value1); printf("The cube root of %f is %f.\n", input_value2, cube_root_value2); printf("The cube root of %f is %f.\n", input_value3, cube_root_value3); return program_success_code; } /* main */ Function calls User Defined Functions Lesson 1 CS1313 Spring 2024 35
Another Function Example #3 % gcc -o cube_root_scalar \ cube_root_scalar.c cube_root.c -lm % cube_root_scalar What 3 real numbers would you like the cube roots of? 1 8 25 The cube root of 1.000000 is 1.000000. The cube root of 8.000000 is 2.000000. The cube root of 25.000000 is 2.924018. User Defined Functions Lesson 1 CS1313 Spring 2024 36
Function Prototype Declarations #1 #include <stdio.h> #include <stdlib.h> #include <math.h> int main () { /* main */ const int number_of_elements = 3; const int program_success_code = 0; float input_value1, cube_root_value1; float input_value2, cube_root_value2; float input_value3, cube_root_value3; float cube_root(float base); ... } /* main */ Notice this declaration: float cube_root(float base); This declaration is a function prototypedeclaration. User Defined Functions Lesson 1 CS1313 Spring 2024 37
Function Prototype Declarations #2 float cube_root(float base); This declaration is a function prototypedeclaration. The function prototype declaration tells the compiler that there s a function named cube_root with a return type of float, and that it s declared externalto (outside of) the function that s calling the cube_root function. You MUST declare prototypes for the functions that you re calling. Otherwise, the compiler will assume that, by default, the function returns an int and has no arguments. If that turns out not to be the case (that is, most of the time), then the compiler will become ANGRY. User Defined Functions Lesson 1 CS1313 Spring 2024 38
Actual Arguments & Formal Arguments #include <stdio.h> #include <stdlib.h> #include <math.h> int main () { /* main */ ... cube_root_value1 = cube_root(input_value1); cube_root_value2 = cube_root(input_value2); cube_root_value3 = cube_root(input_value3); ... } /* main */ float cube_root (float base) { /* cube_root */ ... } /* cube_root */ When we talk about the arguments of a function, we re actually talking about two very different kinds of arguments: actual arguments and formal arguments. User Defined Functions Lesson 1 CS1313 Spring 2024 39
Actual Arguments #include <stdio.h> #include <math.h> int main () { /* main */ ... cube_root_value1 = cube_root(input_value1); cube_root_value2 = cube_root(input_value2); cube_root_value3 = cube_root(input_value3); ... } /* main */ The arguments that appear in the call to the function for example, input_value1, input_value2 and input_value3 in the program fragment above are known as actual arguments, because they re the values that actually get passed to the function. Mnemonic: The aCtual arguments are in the function Call. User Defined Functions Lesson 1 CS1313 Spring 2024 40
Formal Arguments float cube_root (float base) { /* cube_root */ ... } /* cube_root */ The arguments that appear in the definition of the function for example, base, in the function fragment above are known as formal arguments, because they re the names that are used in the formal definition of the function. Jargon: Formal arguments are also known as dummy arguments. Mnemonic: The Formal arguments are in the function deFinition. User Defined Functions Lesson 1 CS1313 Spring 2024 41
Yet Another Function Example #1 #include <stdio.h> #include <math.h> int main () { /* main */ const int first_element = 0; const int number_of_elements = 5; const int program_success_code = 0; float input_value[number_of_elements]; float cube_root_value[number_of_elements]; int element; float cube_root(float base); printf("What %d real numbers would you\n", number_of_elements); printf(" like the cube roots of?\n"); for (element = first_element; element < number_of_elements; element++) { scanf("%f", &input_value[element]); } /* for element */ User Defined Functions Lesson 1 CS1313 Spring 2024 42
Yet Another Function Example #2 for (element = first_element; element < number_of_elements; element++) { cube_root_value[element] = cube_root(input_value[element]); } /* for element */ for (element = first_element; element < number_of_elements; element++) { printf("The cube root of %f is %f.\n", input_value[element], cube_root_value[element]); } /* for element */ return program_success_code; } /* main */ User Defined Functions Lesson 1 CS1313 Spring 2024 43
Yet Another Function Example #3 % gcc -o cube_root_array \ cube_root_array.c cube_root.c -lm % cube_root_array What 5 real numbers would you like the cube roots of? 1 8 25 27 32 The cube root of 1.000000 is 1.000000. The cube root of 8.000000 is 2.000000. The cube root of 25.000000 is 2.924018. The cube root of 27.000000 is 3.000000. The cube root of 32.000000 is 3.174802. User Defined Functions Lesson 1 CS1313 Spring 2024 44
