GATE CSE 2001 | Question: 2.18

Question

Consider the following three C functions:

$[P1]$ 

int *g(void)
{
    int x = 10;
    return (&x);
}

$[P2]$ 

int *g(void)
{
    int *px;
    *px = 10;
    return px;
}

$[P3]$ 

int *g(void)
{
    int *px;
    px = (int*) malloc (sizeof(int));
    *px = 10;
    return px;
}

Which of the above three functions are likely to cause problems with pointers?

• A. Only $P3$
• B. Only $P1$ and $P3$
• C. Only $P1$ and $P2$
• D. $P1, P2$ and $P3$

Comments

Then too its not a problem. 

I tried this 

int *g(void)
{
    int *px;
    px = (int*) malloc (sizeof(int));
    *px = NULL;
    return px;
}

it doesn't give error.

Its a fact that functions can return null pointers.

Anyways handling the NULL pointer is a must thing in case of malloc and it should be ignored.

---

Although P3 could also cause segmentation fault, but thats like once in a blue moon. P1 and P2 have logical problems, while P3 is not dependent on logic. So, yes, C looks more convincing here over D. But again, D is not wrong either implementation wise as malloc could yeild null. They should’ve provided some context on this.

---

in P1 there is a possibility of dangling pointer

Answer 1

$[P1]$ may cause an error because the function is returning the address of a locally declared variable.

$[P2]$ will cause a problem because px is an int pointer that is not assigned with any address and we are doing dereferencing.

$[P3]$ will work because the memory in bytes of the size of an int will be reserved and its address will be stored in px that can be further used, once function execution completes, this m/m will still exist in Heap until we free it using $free()$ function.

Hence, the answer is (C).

Comments

Abhrajyoti00

ohh yes! I forgot why I was confused that time.

but malloc returning NULL is very less likely to happen, so P3 will run properly.

---

@Pranavpurkar happens with me also xD

---

but in p3, we are giving integer as input to a pointer rather than int address. will that not create a problem??

Answer 2

P1 might cause issues.

int *g(void)
{
    int x = 10; 
/* "x" is a local variable.
The lifetime of x is only until the execution of g().
So, we're returning an address which will soon expire. It screams runtime error.
*/
    return (&x);
}

 

P2 might cause issues.

int *g(void)
{
    int *px; 
/* px is a local pointer variable.
 The value of a local variable, if not initialized, is garbage value.
Hence, the content of px is currently garbage*/
    *px = 10;
/* Here, we're trying to access the garbage contents of px. So, Runtime error. */
    return px;
}

 

P3 might cause issues.

int *g(void)
{
    int *px; 
/* Local pointer variable px. Currently, it's content is garbage value, because not initialized yet. */
    px = (int*) malloc (sizeof(int));
/* Now, we initialized px, hence it's content isn't garbage anymore.
What we did is, assigned a block of memory from heap. In case the heap is full,
initialization fails. So, in the worst case, contents of px remain garbage value */
    *px = 10;
/* Trying to access garbage value. Runtime error. */
    return px;
}

 

Correct Answer, Option D.

But if we focus on the word "likely" in the question, then almost all modern computing systems use Virtual Memory, which provides an illusion of a huge amount of addressing space to each process. Hence, they see an almost unlimited heap at their disposal. So, malloc() is extremely unlikely to return NULL. So, the answer could be Option C, too — and I'm more inclined to option C.

 

 

Comments

good explanation

Answer 3

p1  will cause problem as x is a local variable and the return address will be returned the value of x which will be null after function ends.

p2 will cause problem as the pointer is not initialised.

p3 will cause error as if no memory is allocated by the OS the malloc function will return Null and it will be dangling pointer problem.

 

so right answer is D.

Comments

Please share the link.

---

https://www.youtube.com/watch?v=mrZFSSK8Ejg&list=PLsFENPUZBqipuTJXgm7xAOR0UnY_8OY07&index=43

---

Thanks for the link :D