C Programming Functions Online Test, C Programming Online Tests

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\n", 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.

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.

Turbo C (Windows): The return value of the function is taken from the Accumulator _AX=1990.

But it may not work as expected in GCC compiler (Linux).

Step 1: int i=5, j=2; Here variable i and j are declared as an integer type and initialized to 5 and 2 respectively.

Step 2: fun(&i, &j); Here the function fun() is called with two parameters &i and &j (The & denotes call by reference. So the address of the variable i and j are passed. )

Step 3: void fun(int *i, int *j) This function is called by reference, so we have to use * before the parameters.

Step 4: *i = *i**i; Here *i denotes the value of the variable i. We are multiplying 5*5 and storing the result 25 in same variable i.

Step 5: *j = *j**j; Here *j denotes the value of the variable j. We are multiplying 2*2 and storing the result 4 in same variable j.

Step 6: Then the function void fun(int *i, int *j) return back the control back to main() function.

Step 7: printf(“%d, %d”, i, j); It prints the value of variable i and j.

Hence the output is 25, 4.

Step 1: int i; The variable i is declared as an integer type.

Step 1: int fun(); This prototype tells the compiler that the function fun() does not accept any arguments and it returns an integer value.

Step 1: while(i) The value of i is not initialized so this while condition is failed. So, it does not execute the while block.

Step 1: printf(“Hello\n”); It prints “Hello”.

Hence the output of the program is “Hello”.

Step 1: int no=5; The variable no is declared as integer type and initialized to 5.

Step 2: reverse(no); becomes reverse(5); It calls the function reverse() with ‘5’ as parameter.

The function reverse accept an integer number 5 and it returns ‘0’(zero) if(5 == 0) if the given number is ‘0’(zero) or else printf(“%d,”, no); it prints that number 5 and calls the function reverse(5);.

The function runs infinetely because the there is a post-decrement operator is used. It will not decrease the value of ‘n’ before calling the reverse() function. So, it calls reverse(5) infinitely.

Note: If we use pre-decrement operator like reverse(–n), then the output will be 5, 4, 3, 2, 1. Because before calling the function, it decrements the value of ‘n’.

Step 1: int fun(int); Here we declare the prototype of the function fun().

Step 2: int i = fun(10); The variable i is declared as an integer type and the result of the fun(10) will be stored in the variable i.

Step 3: int fun(int i){ return (i++); } Inside the fun() we are returning a value return(i++). It returns 10. because i++ is the post-increement operator.

Step 4: Then the control back to the main function and the value 10 is assigned to variable i.

Step 5: printf(“%d\n”, –i); Here –i denoted pre-increement. Hence it prints the value 9.

There is an error in this line i>=45 ? return(*p): return(*q);. We cannot use return keyword in the terenary operators.

Step 1: int i=1; The variable i is declared as an integer type and initialized to 1(one).

Step 2: if(!i) Here the !(NOT) operator reverts the i value 1 to 0. Hence the if(0) condition fails. So it goes to else part.

Step 3: else { i=0; In the else part variable i is assigned to value 0(zero).

Step 4: printf(“C-Program”); It prints the “C-program”.

Step 5: main(); Here we are calling the main() function.

After calling the function, the program repeats from step 1 to step 5 infinitely.

Hence it prints “C-Program” infinitely.

Step 1: int i; The variable i is declared as an global and integer type.

Step 2: int fun1(int); This prototype tells the compiler that the fun1() accepts the one integer parameter and returns the integer value.

Step 3: int fun2(int); This prototype tells the compiler that the fun2() accepts the one integer parameter and returns the integer value.

Step 4: extern int j; Inside the main function, the extern variable j is declared and defined in another source file.

Step 5: int i=3; The local variable i is defines as an integer type and initialized to 3.

Step 6: fun1(i); The fun1(i) increements the given value of variable i prints it. Here fun1(i) becomesfun1(3) hence it prints ‘4’ then the control is given back to the main function.

Step 7: printf(“%d,”, i); It prints the value of local variable i. So, it prints ‘3’.

Step 8: fun2(i); The fun2(i) increements the given value of variable i prints it. Here fun2(i) becomes fun2(3) hence it prints ‘4’ then the control is given back to the main function.

Step 9: printf(“%d,”, i); It prints the value of local variable i. So, it prints ‘3’.

Hence the output is “4 3 4 3”.

Step 1: int k=35; The variable k is declared as an integer type and initialized to 35.

Step 2: k = func1(k=func1(k=func1(k))); The func1(k) increement the value of k by 1 and return it. Here the func1(k) is called 3 times. Hence it increements value of k = 35 to 38. The result is stored in the variable k = 38.

Step 3: printf(“k=%d\n”, k); It prints the value of variable k “38”.

Step 1: int i=3, j=4, k, l; The variables i, j, k, l are declared as an integer type and variable i, j are initialized to 3, 4 respectively.

The function addmult(i, j); accept 2 integer parameters.

Step 2: k = addmult(i, j); becomes k = addmult(3, 4)

In the function addmult(). The variable kk, ll are declared as an integer type int kk, ll;

kk = ii + jj; becomes kk = 3 + 4 Now the kk value is ‘7’.

ll = ii * jj; becomes ll = 3 * 4 Now the ll value is ’12’.

return (kk, ll); It returns the value of variable ll only.

The value 12 is stored in variable ‘k’.

Step 3: l = addmult(i, j); becomes l = addmult(3, 4)

kk = ii + jj; becomes kk = 3 + 4 Now the kk value is ‘7’.

ll = ii * jj; becomes ll = 3 * 4 Now the ll value is ’12’.

return (kk, ll); It returns the value of variable ll only.

The value 12 is stored in variable ‘l’.

Step 4: printf(“%d, %d\n”, k, l); It prints the value of k and l

Hence the output is “12, 12”.

Step 1: int check(int); This prototype tells the compiler that the function check() accepts one integer parameter and returns an integer value.

Step 2: int l=45, c; The variable i and c are declared as an integer type and i is initialized to 45.

The function check(i) return 100 if the given value of variable i is >=(greater than or equal to) 45, else it will return 10.

Step 3: c = check(i); becomes c = check(45); The function check() return 100 and it get stored in the variable c.(c = 100)

Step 4: printf(“%d\n”, c); It prints the value of variable c.

Hence the output of the program is ‘100’.

Since C is a machine dependent language sizeof(int) may return different values.

The output for the above program will be cd in Windows (Turbo C) and gh in Linux (GCC).

To understand it better, compile and execute the above program in Windows (with Turbo C compiler) and in Linux (GCC compiler).

Step 1: int fun(int); This is prototype of function fun(). It tells the compiler that the function fun() accept one integer parameter and returns an integer value.

Step 2: int i=3; The variable i is declared as an integer type and initialized to value 3.

Step 3: fun(i=fun(fun(i)));. The function fun(i) increements the value of i by 1(one) and return it.

Lets go step by step,

=> fun(i) becomes fun(3) is called and it returns 4.

=> i = fun(fun(i)) becomes i = fun(4) is called and it returns 5 and stored in variable i.(i=5)

=> fun(i=fun(fun(i))); becomes fun(5); is called and it return 6 and nowhere the return value is stored.

Step 4: printf(“%d\n”, i); It prints the value of variable i.(5)

Hence the output is ‘5’.

Step 1: int i=0; The variable i is declared as in integer type and initialized to ‘0’(zero).

Step 2: i++; Here variable i is increemented by 1. Hence i becomes ‘1’(one).

Step 3: if(i becomes if(1 . Hence the if condition is satisfied and it enter into if block statements.

Step 4: printf(“IndiaBIX”); It prints “IndiaBIX”.

Step 5: exit(1); This exit statement terminates the program execution.

Hence the output is “IndiaBIx”.

f(int a, int b) The variable a is declared in the function argument statement.

int a; Here again we are declaring the variable a. Hence it shows the error “Redeclaration of a”

The function void f() is not visible to the compiler while going through main() function. So we have to declare this prototype void f(); before to main() function. This kind of error will not occur in modern compilers.