GATE CSE 2013 | Question: 42

Question

What is the return value of $f(p,p)$, if the value of $p$ is initialized to $5$ before the call? Note that the first parameter is passed by reference, whereas the second parameter is passed by value.
    

int f (int &x, int c) {
       c = c - 1;
       if (c==0) return 1;
       x = x + 1;
       return f(x,c) * x;
}

Comments

Exactly, I was scratching my head for 5 minutes thinking why do they expect me to write a random memory address as the answer.

---

@Tushar RanaYou are deliberately trying to change this question, first This code is using a reference, not a pointer. 

Concept time Bro's -

Pointer - 

int P=5;

int *X=&P// it means X is a pointer to int P, X holds the address of P

printf("%u", X)-->// address of P

printf("%u", *(X))-->// value at address stored in X : ->P=5

whatever written above is common knowledge; now let  see what is refrencing , which is used in this question

int P=5;

int &X=P --> here &X - & is referencing operator but if written in this syntax it means X is an alias of P means now the P and X are same ,no any other X object int variable is created, in simple terms P and X are different Names for same object, if we write now 

printf("%d", X) o/p==5

printf("%d", P) o/p==5 

See here i have nowhere used * or & to print value 5, X and P are different names for same variable- 

Now x and p refer to the same variable.

so- The syntax

int &x

means:

x is a reference to an int.

It does not mean:

x is an integer variable that stores an address.

And it does not mean:

x is a pointer.

Think of a reference as an alias/name for another variable.

There aren't two int variables containing 5.

There is one int object, and two names for it:

This is the part that is bothering you.

You are thinking:

If x contains the address of p, then shouldn't I need *x?

That would be true if x were a pointer.

For example:

int p = 5;
int *x = &p;

Here x is a pointer.

So:

*x = *x + 1;

would be required to modify p.

But in the question it  says:

int &x not int *x

So x behaves exactly like an ordinary int.

Therefore: x = x + 1;

AND EVEN AFTER WRITING SUCH COMMENT WITHOUT CONCEPT CLARITY YOUR C CODE IS STILL WRONG- IF U ARE USING POINTER THEN U SHOULD HAVE USED *X=*X+1 , BUT WHAT CAN I SAY ABOUT U - AND ALSO YOUR CODE IS STILL INCORRECT BCZ EVEN AFTER ALL THAT U DIDNOT SOLVED THE SEQUENCE POINT ISSUE AND USED return f(x,c) * *x; which was the only issue in original question -  just the incorrect explanation- and deliberate attempt to change question towards the concepts u wthink u know but still wrong

is perfectly valid. Because x is an alias for p.

- The only probem in this question is sequence point issue- * is not sequence point so it gives undefined behavior rest everything is correct, this is not a POINTER Question-->  

For the sequence point issue - Check Arjun sir answer- https://gateoverflow.in/60/gate-cse-2013-question-42?show=64#a64

 

---

@Ajay_sarang Have you really understand what I wrote? You point out very good details but what I am doing in the code provided or am explaining has nothing to do what you explained you are correct in your explanations.

Let's understand step by step:

int f (int &x, int c) {
       c = c - 1;
       if (c==0) return 1;
       x = x + 1;
       return f(x,c) * x;
}

this code is not from C as &x is a reference to "int". C does not support reference types, so int &x is invalid C syntax.. And in C++ it is a valid code as x is a reference to int. 

So f(p,p) is valid in C++ as first p is bound to the reference x, but C doesn't support references as a parameter type.

NOTE: don't think x is holding address of p no, it is just a reference and anything that will be changed using x will reflect p as well.

so if inside the function: 

x = x + 1; // it means p also gets increased by 1.

but also note: when we do int p = 5; int *x = &p; then x is a pointer variable and it stores the actual addres of p so if we change in relation to x then we would need a "*" to change values in p using x as *x = 100 now p will have a value 100 or *x = *x +1 means p will have a value 6

 

But is there a way to simulate this in C [that is use int f (int &x, int c)]? 

Yes we can do it like: int f(int *x, int c)

and this means x is a pointer and is pointing to "p" or holds the address of "p". And the function call is now f( &p, p)

NOTE: int f(int *x, int c), f(&p, p) these are different first is a function declaration/definition and second is a call. 

In C, a function call can pass the address of a variable using &, which allows pointer-based simulation of reference-like behavior.

 

 

Now coming to x = x + 1 

where you call me all of this {AND EVEN AFTER WRITING SUCH COMMENT WITHOUT CONCEPT CLARITY YOUR C CODE IS STILL WRONG- IF U ARE USING POINTER THEN U SHOULD HAVE USED *X=*X+1 , BUT WHAT CAN I SAY ABOUT U - AND ALSO YOUR CODE IS STILL INCORRECT BCZ EVEN AFTER ALL THAT U DIDNOT SOLVED THE SEQUENCE POINT ISSUE AND USED return f(x,c) * *x; which was the only issue in original question -  just the incorrect explanation- and deliberate attempt to change question towards the concepts u wthink u know but still wrong}

 

Is there any statement where I have said the correct equivalent C code for the given C++ code is?

I did x = x+1 so yes what's wrong, I want x to point to be incremented as a pointer, I don't want it to be getting a value increment in p.

And the output will be some random memory address. Yes this is wrong it will be because program has undefined behavior because x is incremented beyond the original object and is dereferenced. Therefore, no particular output can be guaranteed.​​​​​

The question was around sequence point which is still an issue in my code as well. But clearly saying"

I agree that *x = *x + 1 is required if the goal is to translate the original C++ reference semantics into C. My intention in the posted C code was different: I deliberately used x = x + 1 as pointer arithmetic, so I was not claiming it to be a semantic equivalent of the original C++ code. The correct code in terms of C it's not in respect to the given C++ code, it's just a correct C code that produces an undefined behavior. Also, my statement that the output would be a random memory address was incorrect; the program has undefined behavior because the incremented pointer is subsequently dereferenced.

 

A personal note brother: @Ajay_sarang I will highly recommend before pointing out what you think is correct, you must understand if not all but some good amount of possibilities about what is being said, concept to clear kar lega magar actual mein kya ho raha hai wo nhi samjh payega. 

 

I have used "the correct code in terms of C" obviously anyone would think it's in respect to given code in the original question. and will try to connect the things with it. But what if there's more meaning to that. 

Let me change my previous comment:  "the correct code in terms of C" to "the correct code in terms of C not what for the given c++ code given in the question"

Answer 1

In GATE 2013 marks were given to all as the same code in C/C++ produces undefined behavior. This is because $*$ is not a sequence point in C/C++. The correct code must replace:

return f(x,c) * x;
with

res = f(x,c); // ';' forms a sequence point 
//and all side-effects are guaranteed to be completed here 
//-- updation of the x parameter inside f is guaranteed 
//to be reflected in the caller from the next point onwards. 
return res * x;

In this code, there will be 4 recursive calls with parameters $(6,4), (7,3), (8,2)$ and $(9,1)$. The last call returns $1$. But due to pass by reference, $x$ in all the previous functions is now $9$. Hence, the value returned by $f(p,p)$ will be $9 * 9 * 9 * 9 * 1 = 6561$.

Good Read:

• http://stackoverflow.com/questions/41775973/is-this-undefined-behaviour-in-c-if-not-predict-the-output-logically
• https://gateoverflow.in/108445/c-programming?show=108582#a108582

Comments

awesome answer

---

$&x$ will evaluate to address of the pointer and not the value of p. As mentioned in the question, the value of p(first parameter) is passed by reference so it must be something like this:

$f(&p, p)$

$f(&x, c)$

where $x = &p$ and $*x = value of p = 5$ and  $&x = address of the pointer$. So why are we substituting &x as *x?

---

If you are having doubt regarding the use of $\&$ in the code read this : https://stackoverflow.com/questions/6877052/use-of-the-operator-in-c-function-signatures

string s = "Hello, wordl";
string* p = &s; // Here you get an address of s
string& r = s; // Here, r is a reference to s    

Answer 2

I think Answer is (B)
Since c is passed by value and x is passed by reference, all functions will have same copy of x, but different copies of c.
f(5, 5) = f(x, 4)*x = f(x, 3)*x*x = f(x, 2)*x*x*x = f(x, 1)*x*x*x*x = 1*x*x*x*x = x^4
Since x is incremented in every function call, it becomes9 after f(x, 2) call. So the value of expression x^4 becomes 9^4 which is 6561

Answer 3

https://youtu.be/91_L9Y1xCWY?feature=shared 

Best explained 

Answer 4

Call: f(5, 5)

• The second argument (c) counts down.

• The first argument (x) increases each step.

The function stops when c becomes 0.

Each step does:

1. Increase x by 1

2. Decrease c by 1

3. Multiply the result of the next call by the new x

Call	x starts as	c starts as	After x++	After c--	Result
f(5,5)	5	5	6	4	f(6,4) * 6
f(6,4)	6	4	7	3	f(7,3) * 7
f(7,3)	7	3	8	2	f(8,2) * 8
f(8,2)	8	2	9	1	f(9,1) * 9
f(9,1)	9	1	stop	0	return 1

 

Solve in Reverse order

f(9,1) = 1
f(8,2) = 1 × 9 = 9
f(7,3) = 9 × 8 = 72
f(6,4) = 72 × 7 = 504
f(5,5) = 504 × 6 = 3024

Return value = 3024