GATE CSE 2000 | Question: 1.16

Question

Aliasing in the context of programming languages refers to

• A. multiple variables having the same memory location
• B. multiple variables having the same value
• C. multiple variables having the same identifier
• D. multiple uses of the same variable

Comments

So Lets take an example of aliasing :

int a = 10 ;

int *p = &a ;

int *q = &a ;

Now pointers p and q are referencing to the same object a .

Hence a is aliased , in simple terms it means that the memory location of a can be accessed using different names p and q .

---

The Answer is A
multiple variables can point to the same memory location in aliasing

---

example: int *p = (int *) malloc(sizeof(int));

int *q;

q = p;

// here q is pointing to the same memory location where p is pointing to, that's why the dynamically allocated memory is aliased and can by accessed using p and q both.

 

Answer 1

Option is $A$.

In computer programming, aliasing refers to the situation where the same memory location can be accessed using different names. For instance, if a function takes two pointers $A$ and $B$ which have the same value, then the name $A$ aliases the name $B.$

Comments

 

Bhartendu Kumar

there is no programing language mentioned in the question.

---

For instance, if a function takes two pointers A and B which have the same value, then the name A aliases the name B.

Can you give a code snippet for the above statement as it will make it more clear .

---

yes kinda same

 

Answer 2

B)multiple variables having the same value

int a=24;
int b=24;
int c=24;

 C)multiple variables having the same identifier

int a=23;
char a='A';

D)multiple uses of the same variable

int a=23;
 a=a*a;

A)multiple variables having the same memory location

int a=20;
int *p=&a;

This example also good http://www.cs.uregina.ca/Links/class-info/cplusplus/Standards/Disk10/aliasing_c.html

Comments

you are right.

---

@srestha the link that you have given, in there, there is the stmt. “ /* call SomeFunction with the Global Variable as a parameter */ ”. how can a global variable be defined inside the main function? Is it a typo?

---

$\text{ This should be the Best  answer.}$

Answer 3

A OPTION

Comments

Call by reference is the best example for that.

---

we can relate to SQL query also...

SQL aliases are used to give a table, or a column in a table, a temporary name.

---

C Programming Language does not allow call by reference.

---

@akash.dinkar12

is sql a programming language as mentioned in the question? SQL (Structured Query Language) is a database management language for relational databases. SQL itself is not a programming language.

Though for argument's shake one may include it as programming language which maybe valid, but the spirit of the question is against it.

Answer 4

int $i=10;$
int $*p=\&i; $
As long as $p$ points to $i, $ we say that $*p$ is an alias for $i.$

Comments

You sure? Because if i has a memory location 100 then p will point to i but p can have a different memory location, say 200.

---

@Sambhrant Maurya

yes and for Option A to be true by this argument, variables here are

1. i

2. p

only. And clearly,

" multiple variables having the same memory location " (option A)

is not the case here. Though the, memory location

&i can be accessed by two ways :
&i and *p.

Logic of UNION gives OPTION A. Not this argument

 

Answer 5

Option A is my answer.

Let us analyze.

"Aliasing" means more than one name for a memory location. If one address can be accessed by two or more "SYMBOLIC NAMES".

Most close option is OPTION A.

"multiple variables having the same memory location"

But, here we have to assume symbolic names to be the same as variable identifiers.

int *ptr;
int i;
/* &i : is a symbolic variable
    *p: is a symbolic variable */
    

But only

/* i and p : are variables */

So, even though we can access the memory location &i, through two symbolic names, this is not the correct argument for OPTION A.

Now, taking the concept of UNION data type solves the issue.

#include <stdio.h>

int main()
{
	union u
	{
		float f;
		unsigned u;
	} fu;
	printf("The address of the variable fu.f : %p\n", &fu.f );
	printf("The address of the variable fu.u : %p\n", &fu.u );
	printf("The address of the variable fu : %p\n", &fu);

	return 0;
}

Produces the output:

The address of the variable fu.f : 0x7fff764ceb84
The address of the variable fu.u : 0x7fff764ceb84
The address of the variable fu   : 0x7fff764ceb84

So, option A has been proved. Here multiple variables are having same memory location.

Though , I would like to point out that the language of OPTION A  has made some common aliasing examples ineligible for argument here:

1. Two pointers pointing to same memory location

2. Pointer to a variable, as both the pointer as well as the variable has access to same memory location

But the positive examples are:

1. UNION

2. ARRAY OVERFLOW

# include <stdio.h>

int main()
{
  int arr[2] = { 1, 2 };
  int i=10;

  /* Write beyond the end of arr. Undefined behaviour in standard C, will write to i in some implementations. */
  arr[2] = 20;

  printf("element 0: %d \t", arr[0]); // outputs 1
  printf("element 1: %d \t", arr[1]); // outputs 2
  printf("element 2: %d \t", arr[2]); // outputs 20, if aliasing occurred
  printf("i: %d \t\t", i); // might also output 20, not 10, because of aliasing, but the compiler might have i stored in a register and print 10
  /* arr size is still 2. */
  printf("arr size: %d \n", (sizeof(arr) / sizeof(int)));
}

Here also the LOCATION OF TWO VARIABLES:

1. arr[2], and

2. i

are same.

 

Comments

As the answer is already long. Here I am commenting why OPTION C is wrong despite having many supporters here.

Yes, a variable identifier can be used multiple times in a program as we have the concept of scope. Multiple variables with same name may exist but they all would have different locations and are all essentially different.

#include<stdio.h>
/* global variable x */
int x ;
int x = 10;
int x;
/* 
all these 3 lines represent same variable in memory
line 2 : declaration
line 3: definition and initialization
line 4: forward declaration
*/
/* global variables are stored in global symbol table of c compiler */
void printing()
{
	printf("Address of GLOBAL x: %p\n", &x);
}

void printing_local_x()
{
	/* local variable x*/
	int x = 11;
	/* definition + initialization */
	printf("Address of LOCAL_2 x: %p\n", &x);
}

int main()
{
    /* local variable x*/
    int x;
    /* int x = 11; wrong */
    /* local variables are STACK VARIABLES and can only be defined/declared once */
    printing();
    printf("Address of LOCAL x: %p\n", &x);
    printing_local_x();
    return 0;
}

The output is:

Address of GLOBAL x: 0x5592945a0010
Address of LOCAL x: 0x7fff9cce20b4
Address of LOCAL_2 x: 0x7fff9cce2094

 

Answer 6

I know this question was asked in 2000 but if asked again its answers would be different, 

Correct answers would be A and C,

 A is called pointer aliasing(C) and C is called (Aliasing or Symbolic Aliasing, like in RUST)