HELP
@ UNLOCK YOUR IMAGINATION
How to access the address of a variable in C programming using pointer
When an array is declared in a program, the compiler allocates a base address and sufficient amount of storage to contain all the elements of the array in contiguous (continuous) memory locations. The base address is the location of the first element (index 0) of the array. The compiler also defines the array name as a constant pointer to the first element. Suppose array x is declared as shown below:
1
|
int x[5] = {1,2,3,4,5};
|
Suppose the array is allocated memory as shown below:
The name x is defined as a constant pointer pointing to the first element, x[0] and therefore the value of x is 2000, the location where x[0] is stored.
If we declare p as an integer pointer, then we can make the pointer p point to the array x by the following assignment:
1
|
p = x
|
In a one dimensional array the address of element n can be calculated by using the below expression:
address = base address + (index * scale factor)
In a two dimensional array with m rows and n columns the address of an element can be calculated as shown below:
address = base address + [(i * n + j) * scale factor]
Where i represents ith row and j represents jth column.
Initialization
After declaring a pointer variable we can store the memory address into it. This process is known as initialization. All uninitialized pointers will have some unknown values that will be interpreted as memory addresses. Since compilers do not detect these errors, the programs with uninitialized pointers will produce erroneous results.
Once the pointer variable has been declared, we can use the assignment operator to initialize the variable. Consider the following example:
1
2
3
|
int var = 20;
int *p;
p = &var;
|
In the above example, we are assigning the address of variable var to the pointer variable p by using the assignment operator. We can also combine the declaration and initialization into a single line as shown below:
1
2
|
int var = 20;
int *p = &var;
|
Accessing a Variable Using Pointer
After declaring and initializing a pointer variable, we can access the value of the variable pointed by the pointer variable using the * operator. The * operator is also known as indirection operator or dereferencing operator. Consider the following example:
1
2
3
|
int var = 20;
int *p = &var;
printf(”Var = %d”, *p);
|
In the above example, we are printing the value of the variable var by using the pointer variable palong with the * operator.
Pointer Constants
The memory addresses within a computer are referred to as pointer constants.
Pointer Values
We cannot assign the memory addresses directly to a variable. We can only get the address of a variable by using the address operator (&). The value thus obtained is known as pointer value.
Pointer Variables
Once we obtain the pointer value, we can store it in a variable. Such variable which stores the memory address is known as a pointer variable.
Accessing the Address of a Variable
The actual location of a variable in memory is system dependent. A programmer cannot know the address of a variable immediately. We can retrieve the address of a variable by using the address of(&) operator. Let’s look at the following example:
1
2
3
|
int a = 10;
int *p;
p = &a;
|
In the above example, let the variable a is stored at memory address 5000. This can be retrieved by using the address of operator as &a. So the value stored in variable p is 5000 which is the memory address of variable a. So, both the variable a, and p point to the same memory location.
No comments:
Post a Comment