Java C Functions Test 1 – Java C Functions Question and Answers

The keyword return is used to transfer control from a function back to the calling function.
Example:

#include
int add(int, int); /* Function prototype */

int main()
{
int a = 4, b = 3, c;
c = add(a, b);
printf(“c = %d “, c);
return 0;
}
int add(int a, int b)
{
/* returns the value and control back to main() function */
return (a+b);
}
Output:
c = 7

KR Notation means Kernighan and Ritche Notation.

True, A function can be called either call by value or call by reference.

Example:
Call by value means c = sub(a, b); here value of a and b are passed.
Call by reference means c = sub(&a, &b); here address of a and b are passed.

A call stack or function stack is used for several related purposes, but the main reason for having one is to keep track of the point to which each active subroutine should return control when it finishes executing.

A stack overflow occurs when too much memory is used on the call stack.

Here function main() is called repeatedly and its return address is stored in the stack. After stack memory is full. It shows stack overflow error.

True, A function cannot return more than one value at a time. because after returning a value the control is given back to calling function.

True, A function may have any number of return statements each returning different values and each return statements will not occur successively.

A function cannot be defined inside the another function, but a function can be called inside a another function.

Any function including main() can be called recursively.

True, If two function are declared in a same name, it gives “Error: Multiple declaration of function_name())”.

Yes. If a function contains two return statements successively, the compiler will generate “Unreachable code” warnings.

Example:

#include
int mul(int, int); /* Function prototype */

int main()
{
int a = 4, b = 3, c;
c = mul(a, b);
printf(“c = %d “, c);
return 0;
}
int mul(int a, int b)
{
return (a * b);
return (a – b); /* Warning: Unreachable code */
}
Output:
c = 12

No, If a function return type is declared as void it cannot return any value.

Yes, too many recursive calls may result into stack overflow. because when a function is called its return address is stored in stack.

After sometime the stack memory will be filled completely. Hence stack overflow error will occur.

Yes, It will return the value 20*20 = 400

Example:

#include
int f1(int, int); /* Function prototype */
int f2(int); /* Function prototype */

int main()
{
int a = 2, b = 3, c;
c = f1(a, b);
printf(“c = %d “, c);
return 0;
}

int f1(int a, int b)
{
return ( f2(20) );
}

int f2(int a)
{
return (a * a);
}
Output:
c = 400

No, In a function two return statements can occur but not successively.

Example:

#include
int mul(int, int); /* Function prototype */

int main()
{
int a = 0, b = 3, c;
c = mul(a, b);
printf(“c = %d “, c);
return 0;
}

/* Two return statements in the mul() function */
int mul(int a, int b)
{
if(a == 0 || b == 0)
{
return 0;
}
else
{
return (a * b);
}
}
Output:
c = 0

When a recursive call is made, the function/process clones itself and then process that funtion. This leads to time and space constrains.

In a loop, there is no recursive call involved that saves a lot of time and space too.

No, C can accept upto 127 maximum number of arguments in a function.

The correct form of function f prototype is float f(int, float);

A function can return floating point value.

Example:

#include
float sub(float, float); /* Function prototype */

int main()
{
float a = 4.5, b = 3.2, c;
c = sub(a, b);
printf(“c = %f “, c);
return 0;
}
float sub(float a, float b)
{
return (a – b);
}
Output:
c = 1.300000

In printf(“%p “, main()); it calls the main() function and then it repeats infinetly, untill stack overflow.