讲解1305ENG、辅导C/C++程序语言、辅导c++、讲解Programming
讲解Java程序|辅导Python程序
1305ENG (Programming Laboratory 4) Page 1 of 6
1305ENG: Engineering Programming
Programming Laboratory 4: Functions
Instructions:
This laboratory is designed to introduce you to functions. Functions are important for modularising
your program to improve its readability, maintainability, and re-usability. They are also a crucial part
of the software design process. There is an assessable exercise at the end of the laboratory.
Homework Questions (for presentation):
These questions should be completed prior to the lab session. You may be called to present one of
these questions in front of the class during the first half hour of the session, and this presentation will
count for 5% of your final grade for the course. You will be called to do two such presentations during
the trimester, at random times. Note that you will need to write and explain your solution on a
whiteboard, not on a computer, so if you need to refer to code it should be on paper. Each question
should take only a few minutes to complete, and you may be asked a few simple questions while
presenting. If you are not present in the laboratory when you are due to present, you will receive 0
for this assessment item.
1. Write a C function called min which takes 2 integers as input, and returns the smallest
as the result.
2. Write a C function called is_vowel which takes a single character as an input and returns
1 if that character is a vowel (‘a’, ‘e’, ‘i’, ‘o’ or ‘u’) or 0 otherwise.
3. Can a C function modify the value of its input arguments in the calling function? Explain
your answer and write a small program to demonstrate that it is correct.
4. Write a C definition (prototype) for a function called power which takes a float and an
integer as inputs, and returns an integer as a result.
5. Write the body of the function from (1). This function should raise the first argument to
the power of the second, by multiplying it by itself that many times. Do not worry about
“special” cases like negative powers.
6. Write a C function called display_dollar which takes a floating point number as input,
and displays this is a dollar value to the screen. This means that it should have a ‘$’ in
front of it, and be displayed to exactly two decimal places in non-scientific form. Your
function should not put spaces or newlines before or after the output.
Code re-usability and maintenance
The use of functions in programming provides for the modularisation of a large C program, in order
to improve code re-usability and maintenance. Let us look at why these two features are important.
Suppose you have written a very efficient C program for computing the square root of a number and
would like to re-use it in your future projects. Alternatively, your colleague would probably like to
use it for their C project as well. Sending them your complete C program is tedious, since they would
need to strip out the unnecessary code sections and copy the square root code into their program.
Another problem is if we needed to compute lots of square roots in order to achieve the required
result. This means we would need to copy and paste the code multiple times, which is also very
tedious. Imagine what would happen if we found an error in our code. We would need to correct 1305ENG (Programming Laboratory 4) Page 2 of 6
the error multiple times. Your colleague probably wouldn’t be impressed if you asked them to make
the correction multiple times either!
Both of these situations require a way of packaging C code, which performs a single important task,
into a self-contained module that can be re-used again later on. Also if an error is found, the correction
is applied only to the module so subsequent programs that call this module will incorporate this fix
as well. This allows the code to be easily maintained.
In C, the mechanism for packaging code into a self-contained module is called a function.
Functions in C
Up until now, all the C programs that you have written have contained one function called main. The
main function is special because it is called automatically when your executable is run. It contains
the code to be executed from the beginning to the end of the program. We define the main function
by writing statements that are enclosed within the curly brackets {}.
We have also called numerous functions too. For example, printf is a function for writing output to
the screen. The scanf function was used to read input from the keyboard. There were also the
mathematical functions, such as sin and cos. These functions required input (in the form of a variable
or constants) and some of them (such as sin and cos) returned an output. In general, C functions can
accept inputs that are processed by statements within the function, and return the result as an output.
Notice the distinction between defining and calling a function. Defining a function allows us to
specify what instructions are to be performed using C statements. Calling a function is when we wish
to use it in our code.
Let us look at the general structure of a C function definition:
return_type function_name(input_parameters) /* This is the header */
{
statement1; /* body of the
statement2; function */
…
return (var);
}
Firstly, the top of the function is called the function header. The header contains important
information about the function, such as its name, input parameters, etc. We need to give the function
a name (function_name). This can be any name that has not been used for another function or
variable. We specify the inputs to the function (input_parameters) as a comma-separated list of data
types followed by variable names (much like how we declare variables, in fact).
The body of the function contains C statements (including variable declarations). Results are returned
by using the return statement. The data type of the result to be returned by the function is specified
by the return_type.
Here is an example of a function definition called add_numbers:1305ENG (Programming Laboratory 4) Page 3 of 6
float add_numbers(float num1, float num2)
{
float result;
result = num1 + num2;
return (result);
}
Notice in the body of a function that it contains a variable declaration. Just like in all the C code we
have written previously, all variables that we use need to be declared with their data types. But notice
that only the variable result needs to be declared. But what about num1 and num2?
? Discuss with your classmates and demonstrator as to why num1 and num2 aren’t
declared as variables within the function.
It is important to note that all variables declared within a function (e.g. num1, num2, result) are only
visible to statements within that function. These are known as local variables. Similarly, all the
variables that you declare in the main function are only visible or local to main. This is called the
scope of the variables.
Where to put the function definition?
Now it is time to put the function definition inside a C program and call it from within the main
function. There are two places to put the function definition: before main and after main. Both of
these cases are shown below.
#include
float add_numbers(float num1, float num2);
int main(void)
{
float a = 3.5, b = 9.34, c;
c = add_numbers(a, b);
printf(“The result is %f\n”, c);
return (0);
}
float add_numbers(float num1, float num2)
{
float result;
result = num1 + num2;
return (result);
}
#include
float add_numbers(float num1, float num2)
{
float result;
result = num1 + num2;
return (result);
}
int main(void)
{
float a = 3.5, b = 9.34, c;
c = add_numbers(a, b);
printf(“The result is %f\n”, c);
return (0);
}1305ENG (Programming Laboratory 4) Page 4 of 6
Type out both these programs and verify that they produce the same result.
Notice that within the function call statement in main, we do not need to specify the datatypes of the
inputs and output.
The guiding principle here is that C needs to know the name of the function, the types of the input
arguments (if any), and the type of the returned output (if any), before calling the function.
In the first program, the function definition appears before main. This is acceptable because the
header of the function definition provides the required information before it is called in main.
In the second program, the function definition appears after main. In order to satisfy the guiding
principle above, we specify just the function header terminated by a semicolon (;). This is called a
function prototype (hightlighted in blue). You can think of it as ‘declaring’ the function before it is
called.
Try removing the function prototype from the second program and see what compiler
errors you get.
The second program demonstrates the preferred way of using functions in C programming. That is,
we place all function prototypes at the top before main, and the corresponding function definitions,
either below main or in a separate file. The reason is that it facilitates code re-usability, where the
function definition can be provided in a separate file or compiled object file (e.g. in an external
library) and the function prototypes are stored in a header file (*.h files), which are included using
#include. You’ve seen stdio.h and math.h before. These are header files that contain the function
prototypes of all functions that are defined in their corresponding libraries. This allows one to hide
or ‘obfuscate’ their code. For example, your colleague may only interested in calling your square
root function, but not how you’ve implemented it. So you provide them with the header file
(containing the function prototypes) as well as the object code, which they can link into their program.
Writing a factorial function
Now it’s time to write your own function. Fill in the missing blanks to complete the
factorial function.
#include
int find_factorial(int x);
int main(void)
{
int x, fx;
printf(“Enter the value to find the factorial of: “);
scanf(“%i”, &x);
???? /* call the factorial function and save result in fx */1305ENG (Programming Laboratory 4) Page 5 of 6
printf(“The factorial of %i is %i\n”, x, fx);
}
int find_factorial(int x)
{….
return ();
}
Notice that for relatively small values of x, the factorial can become so large, it exceeds the maximum
value of integer.
Modify the previous program and function to compute the factorial as floating-point
number, while keeping the input to the function as an integer.
Assessable questions
1. Write a program that computes the volume of a sphere and prints the answer out. The
user should enter the radius of the sphere. A function called compute_sphere_volume
should be written that performs the computation and returns the value of the volume.
The prototype for this function is given below:
float compute_sphere_volume(float radius);
2. Write a program to compute the reactance of a capacitor. The user should enter the
capacitance C and frequency f. A function called compute_reactance should be written
that performs the computation and returns the value of the reactance. The prototype
for this function is given below:
double compute_cap_reactance(double cap, double freq);
The main program should display the answer in scientific notation to 3 decimal places
(Hint: The maths library has a built-in constant for π called M_PI). The
reactance of a capacitor is given by:
Here is the required output (keyboard inputs are underlined):
This program computes the reactance of a given capacitor and
frequency.
Please enter the capacitance (in F): 10e-6
Please enter the frequency (in Hz): 1.5e3
The reactance of the capacitor is equal to 1.061e+01 ohms1305ENG (Programming Laboratory 4) Page 6 of 6
3. Write a C function which takes two integers as inputs, and returns the sum of all the
numbers between those two integers (inclusive). So for example if the inputs are 1 and
10, the output will be 55. If the first number is larger than the second, 0 should be
returned instead.
Write a small main program which reads two numbers from the keyboard, passes
these numbers to the function, then displays the result. Note that your function should
not read anything from the keyboard, nor display anything to the screen, only the main
function should do this.