If you have defined a derived data type using the keyword struct, then you can declare a variable of this type. Hence, you can also declare a pointer variable to store its address. A pointer to struct is thus a variable that refers to a struct variable.

Syntax: Defining and Declaring a Structure

This is how you will define a new derived data type using the “struct” keyword −

struct type {
   type var1;
   type var2;
   type var3;
   ...
   ...
};

You can then declare a variable of this derived data type as following −

struct type var;

You can then declare a pointer variable and store the address of var. To declare a variable as a pointer, it must be prefixed by “*“; and to obtain the address of a variable, we use the “&” operator.

struct type *ptr = &var;

Accessing the Elements of a Structure

To access the elements of a structure with pointer, we use a special operator called the indirection operator (→) .

Here, we define a user-defined struct type called book. We declare a book variable and a pointer.

struct book{
   char title[10];
   double price;
   int pages;
};
struct book b1 = {"Learn C", 675.50, 325},
struct book *strptr;

To store the address, use the & operator.

strptr = &b1;

Using the Indirection Operator

In C programming, we use the indirection operator (“→“) with struct pointers. It is also called the “struct dereference operator”. It helps to access the elements of a struct variable to which the pointer references to.

To access an individual element in a struct, the indirection operator is used as follows −

strptr -> title;
strptr -> price;
strptr -> pages;

The struct pointer uses the indirection operator or the dereference operator to fetch the values of the struct elements of a struct variable. The dot operator (“.“) is used to fetch the values with reference to the struct variable. Hence,

b1.title is the same as strpr -> title
b1.price is the same as strptr -> price
b1.pages is the same as strptr -> pages

Example: Pointers to Structures

The following program shows the usage of pointers to structures. In this example, “strptr” is a pointer to the variable “struct book b1”. Hence, “strrptr → title” returns the title, similar to “b1.title” does.

#include <stdio.h>
#include <string.h>

struct book{
   char title[10];
   double price;
   int pages;
};

int main(){
   
   struct book b1 = {"Learn C", 675.50, 325};
   struct book *strptr;
   strptr = &b1;
   
   printf("Title: %sn", strptr -> title);
   printf("Price: %lfn", strptr -> price);
   printf("No of Pages: %dn", strptr -> pages);

   return 0;
}

Output

Title: Learn C
Price: 675.500000
No of Pages: 325

Points to Note

• The dot operator (.) is used to access the struct elements via the struct variable.
• To access the elements via its pointer, we must use the indirection operator (→).

Example

Let”s consider another example to understand how pointers to structures actually work. Here, we will use the keyword struct to define a new derived data type called person and then we will declare a variable of its type and a pointer.

The user is asked to input the name, age and weight of the person. The values are stored in the structure elements by accessing them with the indirection operator.

#include <stdio.h>
#include <string.h>

struct person{
   char *name;
   int age;
   float weight;
};

int main(){

   struct person *personPtr, person1;

   strcpy(person1.name, "Meena");
   person1.age = 40;
   person1.weight = 60;

   personPtr = &person1;

   printf("Displaying the Data: n");
   printf("Name: %sn", personPtr -> name);
   printf("Age: %dn", personPtr -> age);
   printf("Weight: %f", personPtr -> weight);
   
   return 0;
}

Output

When you runt this program, it will produce the following output −

Displaying the Data: 
Name: Meena
Age: 40
weight: 60.000000

C allows you to declare an “array of struct” as well as an “array of pointers”. Here, each element in the struct pointer array is a reference to a struct variable.

A struct variable is like a normal variable of primary type, in the sense that you can have an array of struct, you can pass the struct variable to a function, as well as return a struct from a function.

Note: You need to prefix “struct type” to the name of the variable or pointer at the time of declaration. However, you can avoid it by creating a shorthand notation using the typedef keyword.

Why Do We Need Pointers to Structures?

Pointers to structures are very important because you can use them to create complex and dynamic data structures such as linked lists, trees, graphs, etc. Such data structures use self-referential structs, where we define a struct type having one of its elements as a pointer to the same type.

An example of a self-referential structure with a pointer to an element of its own type is defined as follows −

struct mystruct{
   int a;
   struct mystruct *b;
};

We shall learn about self-referential structures in the next chapter.