Skip to main content

Implementation of pointer variable in Data Structures through C Language

            Implementation of pointer variable with example

Pointer Operations

One can do only possible two operations on pointers One is assignment and another one is simple addition or subtraction of values with pointer variables. No other operation is permitted to perform on the pointer variables because they simply contain the memory addresses or locations not the variables.

Assignment operation:

      The assignment operation is nothing but assigning a pointer variable with the memory address. The memory address must be known (static or dynamic). A pointer can be assigned with the address stored in another pointer variable. To perform assignment operation the two “pointer variables” must be of the same type. The pointer must point to memory locations that contain the similar type values like integers, floating-point number, characters etc. If ‘a’ is an integer variable then the address of ‘a’ can be assigned to any pointer variable of the type integer.

Example:
Void main()
{
Int*p, a=120;
 /* p is a pointer variable, a is a simple variable*/
Printf(“Address = %Id, Value = %d\n”,&a,a);
P = &a;
/*p is assigned with address of a */
Printf(“Address = %Id, Value = %d”,p*p);
/*Both of the above printf statements Display the same values*/

In the above example, the pointer variable is assigned with the memory address that is already allocated by the system to other variable. In this type of simple assignment  the address of variable ‘a’ is stored in pointer p. You can also note that the data type of both the variables, ‘a’ and ‘b’ is similar i.e. ‘int’.

       If the pointer variable is used to change the value at the memory location, then it automatically changes the value of the non-pointer variable ‘a’. This is the concept that comes into picture when ‘call-by-reference’ is used (i.e. when the formal parameters are pointer types)
Example:
Main()
{
Int *p,a=10;
Printf(“Value of a, before pointer operation: %d”,a);
/*10*/
P=&a;
*p=26;
Printf(“Value of a, after pointer operation: %d”,a);
/*26*/
}
In the example the address of a variable (a) is assigned to a pointer variable (p). When the content of memory is changed by the pointer variable it affects the original variable. It is mainly because both the variables refer the same memory location or address.
Example to show the effect of ‘call-by-reference’:
Void fun (int a, int *b)
/*a is a value parameter, b is a reference parameter*/.
{
a++;
/*’a’ local variable of fun() incremented by 1*/
*b = *b + a; /* pointer ‘b’ points to the memory location of variable ‘b’ of main()*/
}
main()
{
Int a=10, b=12;
Printf(“a=%d, b=%d\n”,a,b);
fun(a,&b);
printf(“a=%d,b=%d”,a,b);

}


 

The parameter ‘b’ of function fun() is a pointer. So, it changes the value of variable ‘b’ of main(). Both refer to same memory.
Example:
Main()
{
Int *p1, *p2, a=10;
Printf(“a=%d\n”,a);          /*a=10 is displayed*/
p1=&a;    /*pointer p1 is assigned with address of variable ‘a’*/
p2=p1;    /*pointer p2 is assigned with value of p1 (address of a). another way of assignement */
printf(“Value at p1=%d\n”,*p1);     /* 10 is displayed */
printf(“Value at p2=%d\n”,*p2);      /* 10 is displayed */
}
The above example is self-explaining via comments. You can mainly note that the non-pointer variable ‘a’, pointer p1 and p2 are of same type (int). Now let us see an example of dynamic memory allocation:
Main()
{
Int*p;
p=(int*) malloc(sizeof(int)); *p=10; printf(“%d”,*p);
}
In this example the pointer variable p is assigned with the address that is returned from the malloc(). An example of assigning dynamically allocated memory. The dynamically allocated memory  stores integer and the pointer is also of the type integer.

Comments

Popular posts from this blog

difference between structure and union in C Language

In c language article we will see the difference between union and structure. Both are the user define datatype in c language. See the table which is mentioned below: ASP.NET Video Tutorial Series Structure Union1.The keywordstruct is used to define a structure 1. The keyword union is used to define a union. 2. When a variable is associated with a structure, the compiler allocates the memory for each member. The size of structure is greater than or equal to the sum ofsizes of its members. The smaller members may end with unused slack bytes. 2. When a variable is associated with a union, thecompiler allocates thememory by considering the size of the largest memory. So, size of union is equal to the size of largest member. 3. Each member within a structure is assigned unique storage area of location. 3. Memory allocated is shared by individual members of union. 4. The address of each member will be in ascending order This indicates that memory for each member will start at different offset v…

Difference between Linear search and Binary Search in c language

SQL Video Channel : Download all SQL Video



Binary Search Linear Search Works only on sorted items. such as  1,2,3,4,5,6  etc
Works on sorted as well as unsorted items. 12,4,5,3,2,1 etc Very efficient if the items are sorted Very efficient if the items are less and present in the beginning of the list. such as Suppose your list items are : 12,3,4,5,1 and you want to search 12 number then you get beginning in the list. Works well with arrays and not on linked lists. Works with arrays and linked lists.
Number of comparisons are less More number of comparisons are required if the items are present in the later part of the array or its elements are more.

Memory representation of Linked List Data Structures in C Language

Memory representation of Linked List

             In memory the linked list is stored in scattered cells (locations).The memory for each node is allocated dynamically means as and when required. So the Linked List can increase as per the user wish and the size is not fixed, it can vary.

               Suppose first node of linked list is allocated with an address 1008. Its graphical representation looks like the figure shown below:


      Suppose next node is allocated at an address 506, so the list becomes,



  Suppose next node is allocated with an address with an address 10,s the list become,


The other way to represent the linked list is as shown below:




 In the above representation the data stored in the linked list is “INDIA”, the information part of each node contains one character. The external pointer root points to first node’s address 1005. The link part of the node containing information I contains 1007, the address of next node. The last node …