Structure Pointer in C
Structure Pointer in C
In the C programming language, a structure pointer is defined as a pointer that points to the memory block address that stores a structure. Like C standard language consist of an array of integers, an array of pointers, and so on, we can also have an array of structure variables. To use the array of structure variables efficiently, we can use pointers of structure type. A programmer can also have a pointer to a single structure variable, but it is mainly used when dealing with an array of structure variables.
Structures can be accessed in two ways:
- Using a normal structure variable
- Using a pointer variable.
A dot (.) operator is used to access the data using a normal structure variable, while arrow (->) is used to access the data using a pointer variable.
E.g.:
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct point
{
int value;
};
int main()
{
struct point p;
struct point *ptr = &s;
return 0;
}
In the above code, s is an instance of struct point, and ptr is a struct pointer because it will store the structure’s address.
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct point
{
int x; //declaration of the structure
int y;
};
struct rect //structure declaration for a rectangle function program.
{
struct point left; //an object left is declared along with a point
struct point right; // an object right is declared along with a point
};
void areaOfRectangle (struct rect r) //function to calculate the area of a rectangle
{
int area = (r.right.x - r.left.x) * ( r.right.y - r.left.y);
/* finding the area of a rectangle using variables of point structure where
the variables of the point structure is being accessed by left and right
objects*/
printf (“%d”,area);
}
int main()
{
struct rect r = { {0, 0}, {1, 1}}; //initialize the variable r with sides of a rectangle
areaOfRectangle(r);
return 0;
}
Output:
1
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct student
{
int usn;
char name[20];
float percentage;
int phone;
char address[50];
};
int main ()
{
int i;
struct student detail1 = {1, “Alex”, 97.2, 992880293, “No. 12 church street”};
struct student *ptr;
ptr = &detail1;
printf (“ The details of student 1 are: \n”);
printf (“USN of the student 1 is: %d \n”, ptr->id);
printf (“Name of the student 1 is: %s \n”, ptr->name);
printf (“Percentage of the student 1 is: %f \n”, ptr->percentage);
printf (“Phone number of the student 1 is: %d \n”, ptr->phone);
printf (“Address of the student 1 is: %s \n”, ptr->address);
return 0;
}
Output:
The details of student 1 are: USN of the student 1 is: 1 Name of the student 1 is: Alex Percentage of the student 1 is: 97.2 Phone number of the student 1 is: 992880293 Address of the student 1 is: No. 12 church street.
The above code represents the way to store details of a student, which is present in a structure; this structure contains all the information of students such as their USN (University Seat Number), name, percentage, phone number, and address. A programmer’s requirement is to create a method to write the information into the structure. You can also write the memory dynamically, that is, can perform dynamic memory allocation. For efficiency, a pointer to a structure is generally passed to the functions. The members of structures passed within the functions can be accessed to perform dereferencing the structure pointer and then selecting a member using a dot operator (.). It will be very strenuous to dereference the structure pointer every time it is used. This is why the C standard provides a special pointer operator arrow (->) to access the member of a structure pointed by the pointer variable. The arrow operator is a combination of a minus symbol (-) followed by a greater-than symbol (>).
Dynamic memory allocation of structure pointer can be done in the following way:
Sometimes the number of struct variables declared may be insufficient. Hence memory needs to be allocated during run-time.
E.g.:
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
struct student
{
int usn;
char name[20];
float percentage;
int phone;
char address[50];
};
int main()
{
struct student *ptr;
int i, n;
printf (“Enter the number of students:”);
scanf (“%d”, &n); //allocating memory for ‘n’ students
ptr = (struct student*) malloc(n * sizeof(struct student));
for (i = 0; i < n; ++i)
{
printf (“Enter the USN of the first student:”);
scanf (“%d”, &(ptr+i)->usn );
printf (“Enter the name of the first student:”);
scanf (“%s”, &(ptr+i)->name);
printf (“Enter the percentage of the first student:”);
scanf (“%f”, &(ptr+i)->percentage);
printf (“Enter the phone of the first student:”);
scanf (“%d”, &(ptr+i)->phone);
printf (“Enter the address of the first student:”);
scanf (“%s”, &(ptr+i)->address);
}
printf (“Details of students are: \n”);
for (i = 0; i < n; i++)
printf (“USN: %d \t Name: %d \t Percentage: %d \t Phone number: %d \t Address: %d \n”, (ptr+i)->usn, (ptr+i)->name, (ptr+i)->percentage, (ptr+i)->phone, (ptr+i)->address);
return 0;
}
Output:
Enter the USN of the first student: 2 Enter the name of the first student: Beth Enter the percentage of the first student: 95.33 Enter the phone number of the first student: 8388422 Enter the address of the first student: No. 15 church street Details of students are: USN: 1 Name: Alex Percentage:97.2 Phone number: 72779392 Address:No. 12 church street. USN: 2 Name: Bev Percentage:95.33 Phone number: 8388422 Address:No. 15 church street.