Review question’s answer
Chapter no-09(User-Defined Functions)
=========================================================
Question: State
whether the following statements are true or false
(a) C function can return only one
value under their function name.
Answer: False
(b) A function in C should have at
least one argument.
Answer: True
(c) A function can be defined and
placed before the main function.
Answer: False
(d) A function can be defined within
the main function.
Answer: False.
(e) An user-defined function must be
called at least once; otherwise
a warming message will be issue
Answer: True.
(f) Any name can be used as a function
name.
Answer: False.
(g) Only a void type function can have
void as its argument
Answer: False.
(h) When variable values are passed to
function, a copy of them are
created in the memory.
Answer: True.
(i) Program execution always begins in
the main function irrespective of location in the program.
Answer: True.
(j) Global variable are visible in all
blocks and function in the program
Answer: False.
(k) A function can call itself.
Answer: True
(l) A function without a return
statement is illegal.
Answer: False.
(m) Global variable cannot be declared
as auto variables.
Answer: False.
(n) A function prototype must always be
placed outside the calling function.
Answer: True
(o) The return type of a function int
by default.
Answer: True.
(p) The variable names used in
prototype should match those used in the function definition.
Answer: True.
(q) In parameter passing by pointers,
the formal parameters must be prefixed with the symbol * in their declarations.
Answer: True.
(r) In parameter passing by pointers,
the actual parameters in the function call may be variables or constants.
Answer: False.
(s) In passing arrays to function, the
function call must have the name of the array to be passed without brackets.
Answer: False.
(t) In passing strings to function, the
actual parameter must be name of the strings post-fixed with size in brackets.
Answer: True.
Question: Fill in the blanks in the
following statements.
(a) The parameters
used in a function call are called …………….
Answer: actual parameter.
(b) A variable
declared inside a function is called ……….. variable.
Answer: local
(c) By default………….is
the return type of a function.
Answer: int
(d) In passing by
pointers,, the variable of the formal parameters
must be prefixed with …………….operator in
their declaration.
Answer: indirection
(e) In prototype
declaration specifying parameter………... is optional.
Answer: name
(f) …………… refers to
the region where a variable is actually variable for use.
Answer: Prototype
(g) A function that
calls itself is known as a………….. function.
Answer: recursive
(h) If a local variable
has to retain its value between calls to the function, it must be declared as
………...
Answer: void
(i) A data ……….. aids
the compiler to check the matching between the actual arguments and the formal
ones .
Answer: types
(j) A variable
declared inside a function by default assumes …………storage class.
Answer: without
Question: The main is a user-defined
function. How does it differ from other user-defined function?
Answer:
The main is an example of user-defined
function. Printf and scanf belong to the category of library functions. We have
also used other library functions such as sqrt, cos, strcat, etc. The main
distinction between these two categories is that library functions are not
required to be written by us whereas a user-defined function has to be
developed by the user at the time of writing a program.
Question: Describe the two ways of
passing parameters to function .When do you prefer to use each of them?
Answer:
The parameter
list declare the variables that will receive the data sent by the cooling
program. They serve as input data to the function to carry out the specified
task.Since they represent actual input values, they are often referred to as
formal parameters. These parameters can also be used to send values to the cooling
programs. This aspect will be covered later when we discuss more about
functions. The parameters are also known as arguments.
The parameter
list contains declaration of variables separated by commas and surrounded by
parentheses.
Examples;
float
quadratic(int a, int b, int c) {….}
Question: What is prototyping? Why is
it necessary?
Answer:
Prototypes enable the compiler to
provide stronger type checking, somewhat like that provided by languages such
as pascle. When you use prototypes, the compiler can find and report any
questionable the conversions between the arguments used to call a function and
the type of its parameters. The compiler will also catch differences between
the number of arguments used to call a function and the number of parameters in
the function. A function prototype consists of four parts.
(1)Function type
(2)Function name
(3)Parameter list
(4)Terminating semicolon.
The general form of a function
prototype is function-type function-name (parameter list);
It is a good programming style to
declare prototypes in the global declaration section before main. It adds
flexibility, provides as excellent quick reference to the functions used in the
program, and enhances documentation.
Question: Distinguish between the
following:
(a)Actual and formal arguments
Answer:
If the actual parameters are more than
the formal parameters the extra actual arguments will be discarded.
On the other hand, if the actual are
less than the formals, the unmatched formal arguments will be initialized to
some garbage.
(b) Global and local variables
Answer:
A global variable used in a function
will retain its value for future use. A global variable is visible only form
the point of its declaration to the end of the program. A local variable is a
variable that is defined inside a function and used without having any role in
the communication between functions.
(c) Automatic and static variables
Answer:
A variable declared inside a function
without storage class specification default , an automatic variable. For
instance, the storage class of the variable number in the example below is
automatic.
main ( )
{
int number;
-------------
-------------
}
A static variable may be either an
internal type or an external type. Depending on the place of declaration.
Internal static variables are those which are declared inside a function
.Therefore, internal static variables can be used to return values between
function calls. For example, it can be used to count the number of calls made to
a function.
(d) Scope and visibility variables
Answer:
The scope of variables determine s over
what region of the program a variable is actually available for use (active)
.on the other hand the visibility refers to the accessibility of a variable
form the memory.
(e) & operator and * operator
Answer:
The operator & is called the
address operator. On the other hand,
The operator * is known as indirection
operator because it gives an indirect reference to a variable through its
address.
Question: Explain what is
likely to happen when the following situations are encountered in a program.
(a)Actual arguments are less than the
formal arguments in a function.
Answer:
If the actual are less than the
formals, the unmatched formal arguments will be initialized to some garbage.
(b) Data type of one of the actual
arguments does not match with the type of the corresponding formal argument.
Answer:
The formal and actual arguments must
match exactly in type, order and number their names, however, do not need to match.
(c)Data type of one of the argument in
a prototype does not match with the type of the corresponding formal parameter
in the header line.
Answer:
Since the prototype is not available, c
will assume that the return type is an integer and that the types of parameters
match the formal definitions.
If these assumptions are wrong, the
linker will fail and we will have to change the program. The moral is that we
must always include prototype declarations preferably in global declaration
section.
(d)The order of actual parameters in
the function call is different from the order of formal parameters in a
function where all the parameters are of the same type.
Answer:
The parameters used in prototypes and
function definitions are called formal parameters and those used in function
calls are called actual parameters. Actual parameters used in a calling
statement may be simple constants , variables or expressions. The formal and
actual parameters must match exactly in type , order and number . Their names,
however do not need to match.
Question: Which of the following
prototype declarations are invalid? Why?
(a) int (fun) void;
Answer: valid
(b)double fun (void)
Answer: double fun (void);
(c) float fun (x,y,n);
Answer: float fun (float x, float y,
float n);
(d) void fun (void, void);
Answer: void fun (void);
(e)int fun (int a, b);
Answer: int fun (int a, int b);
(f)fun (int, float, char );
Answer: valid
(g)void fun (int a, int &b);
Answer: void fun (int a, int b);
Question: Which of the following header
lines are invalid? Why?
(a) float average ( float x, float y, float
z);
Answer: valid
(b) double power ( double a, int n-1)
Answer: double power (double a, double
n-1);
(c) int product ( int m, 10)
Answer: int product (int m, int 10);
(d) double minimum ( double x; double y;)
Answer: double minimum (double x,
double y);
(e) int mul ( int x , y)
Answer: int mul (int x, int y);
(f) exchange ( int *a, int *b)
Answer: exchange (int *a, int *b);
(g) void sum ( int a, int b, int &c)
Answer: void sum (int a, int b ,int c);
Question: Find errors , if any, in the
following function definitions:
( a) void abc ( int a, int b)
{
int c;
.............
return (c);
}
Answer: void abc (int a,int b)
{
int c;
-------------
}
(b) int abc ( int a, int b)
{
....................
........................
}
Answer: int abc (int a; int b)
{
int c;
-----------
return(c);
}
(c) int abc ( int a, int b)
{
double c = a+b;
return (c);
}
Answer: int abc (int a, int b)
{
int c =a+b;
return (c);
}
(d) void abc ( void)
{
...................
....................
return;
}
Answer: void abc (void)
{
int c;
-------------
}
(e) int abc ( void)
{
...........................
............................
return ;
}
Answer: Error in declaration.
Question: Find errors in the following
function calls:
(a)void xyz();
Answer:
void xyz ( )
(b)xyx (void);
Answer:
void xyx (void)
(c)xyx (int x, int y);
Answer:
int xyx (int x, int y)
(d)xyzz ();
Answer:
int xyzz( )
(e)xyz ()+xyz();
Answer:
int xyz ( ) + int xyz ( )
Question: A Function to divide two
flowing point numbers is as follows:
divide (float x, float y)
{
Return (x/y);
}
What will be the value of the following
function calls
(a) divide (10,2)
Answer: 5.000000.
(b) divide (9,2)
Answer: 4.500000.
(c) divide (4.5,1.5)
Answer: 3.000000.
(d) divide (2.0,3.0)
Answer: .6777777.
Question: What will be the effect on
the above function calls if we change the header line as follow:
(a) int divide (int x,int y)
(b) double divide(float x, float y)
Question: Determine the output of the
following program?
int prod (int m, int n);
main ( )
{
int x=10;
int y=20;
int p, q;
P=prod (x,y);
q=prod (p, prod (x,z));
printf (“%d %d\n”,p,q);
}
int prod (int a,int b)
{
return (a*b);
}
Answer: p=200
q =4000
Question: What will be the output of
the following program?
Void test (int *a);
main( )
{
int x=50;
test ( &x);
printf (“%d\n”, x);
}
void test ( int *a);
{
*a=*a +50;
}
Answer: 100
Question: The function test is coded as
follows:
int test ( int number)
{
int m,n=0;
while (number)
{
m= number % 10;
if ( m% 2 )
n=n +1;
number = number/10;
}
return ( n) ;
}
What will be the values of x and y when
the following statement are executed
int x = test (135);
ans:x=3
int y= test (246 );
Answer: y=o
Question: Enumerate the rules that
apply to a function call.
Answer:
A function call is a postfix
expression. The operator (…) is at a very high level of precedence, therefore,
when a function call is used as a part of an expression , it will be evaluated
first , unless parentheses are used to change the order of precedence.
In a function call, the function name
is the operand and the parameters set (..) which contains the actual parameters
is the operator . The actual parameters must match the functions formal
parameters in type, order and number. Multiple actual parameters must be
separated by commas.
Question: Summarize the rules for
passing parameters to functions by Pointers.
Answer:
The types of the actual and formal
arguments must be same.
The actual arguments must be the addresses
of variables that are local to the calling function.
The formal arguments in the function
header must b\e prefixed by the indirection operator.
In the prototype the arguments must be
prefixed by the symbol *.
To access the value of an actual argument
in the called function, we must use the corresponding formal argument prefixed
with the indirection operator *.
Question: What are the rules that
govern the passing of arrays to functions.
Answer:
The function must be called by passing
only the name of the array.
In the function definition, the formal
parameter must be an array type, the size of the array does not need to be
specified.
The function prototype must show that
the argument is an array.
Question: State the problems we are
likely to encounter when we pass global variables as parameters to functions
Answer:
Since all functions in a program source
file can access global Variables, they can be used for passing values between
the functions. However, using global variables as parameters for passing values
poses certain problems.
The values of global variables which
are sent to the called function may be changed in advariently by the called
functions.
Functions are supposed to be
independent and isolated modules. This character is lost, if they use global
variables.
It is not immediately apparent to the
reader which values are being sent to the called function.
A function that uses global variables
suffers from reusability.
- You can download this file as pdf by clicking below download icon-
- Download
Go head by honesty--->Rm
c
No comments:
Post a Comment