Nested Structures in C

---

---

In the programming context, the term "nesting" refers to enclosing a particular programming element inside another similar element. For example, nested loops and nested conditional statements, etc. In this chapter, we will explain in detail about "nested structures".

What is a Nested Structure?

When one of the elements in the definition of a struct type is of another struct type, then we call it a nested structure in C. Nested structures are defined when one of the elements of a struct type is itself a composite representation of one or more types.

A general syntax of a nested structure is as follows −

struct struct1{
   type var1;
   type var2;
   struct struct2 strvar;
}

We can think of nested structures in the following situation. If we want to define a struct type representing a "student" with "name" and "age" as its elements and another struct type called "course" that is characterized by "course ID", "title", and "credit points". Here, the "student" structure has an inner course structure.

struct student{
   char *name;
   int age;
   struct course c1;
};

The "student" variable will be stored in the memory as follows −

The nesting of structures can be performed in two different ways −

• Defining an inline structure
• Including the element of a structure already defined

Let us learn these methods using suitable examples.

Defining an Inline Structure

In this method, we shall define an "employee" data type with one of its elements being "date of birth". C doesn’t have a built-in type for "date". We shall declare the "dob" struct with three "int" types "d", "m" and "y" inside the "employee" structure and its variable "d1" is one of the elements of the outer type.

Example

Take a look at the following example −

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

struct employee{
   char name[10];
   float salary;
   struct dob{
      int d, m, y;
   } d1;
};

int main(){

   struct employee e1 = {"Kiran", 25000, {12, 5, 1990}};
   printf("Name: %s\n", e1.name);
   printf("Salary: %f\n", e1.salary);
   printf("Date of Birth: %d-%d-%d\n", e1.d1.d, e1.d1.m, e1.d1.y);
   
   return 0;
}

Output

When you run this code, it will produce the following output −

Name: Kiran
Salary: 25000.000000
Date of Birth: 12-5-1990

You can see that the variable of "employee" type is initialized with its "date" element having another pair of curly brackets.

Method 2: Including the Element of Another Structure

The other approach for using nested structures is to define the inner struct type first, and then use its variable as one of the elements in the outer struct type, which is defined afterwards.

Here, the "dob" type is defined in the beginning; it has three "int" elements − d, m and y. The "employee" struct type is defined afterwards.

Example 1

Since "dob" is already defined, we can have an element of its type inside "employee".

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

struct dob{
   int d, m, y;
};

struct employee{
   char name[10];
   float salary;
   struct dob d1;
};

int main(){

   struct employee e1 = {"Kiran", 25000, {12, 5, 1990}};
   printf("Name: %s\n", e1.name);
   printf("Salary: %f\n", e1.salary);
   printf("Date of Birth: %d-%d-%d\n", e1.d1.d, e1.d1.m, e1.d1.y);
   
   return 0;
}

Output

Run the code and check its output −

Name: Kiran
Salary: 25000.000000
Date of Birth: 12-5-1990

Note that the inner struct type should be defined before the outer type. We can also declare a variable of "dob" type and then include it in the initialization of "employee" type variable, as shown below −

struct dob d1 = {12, 5, 1990};
struct employee e1 = {"Kiran", 25000, d1};

Example 2

In the following code, the nesting of structure goes upto two levels. In other words, the outer struct type "employee" has one element that is a variable of experience struct type. In turn, the experience structure has two elements of another struct type called "date".

Hence, the memory allocation for "employee" variable can be understood with the following illustration −

Here is the complete code −

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

struct date{
   int d, m, y;
};

struct experience{
   char designation[10];
   struct date from;
   struct date to;
};

struct employee{
   char name[10];
   float salary;
   struct experience exp;
};

int main(){

   struct date d1 = {12, 5, 1990};
   struct date d2 = {31, 3, 2021};
   struct experience exp = {"Clerk", d1, d2};
   struct employee e1 = {"Kiran", 25000, exp};

   printf("Name: %s\n", e1.name);
   printf("Salary: %f\n", e1.salary);
   printf("Experience: Designation: %s\n", e1.exp.designation);
   printf("From:  %d-%d-%d\n", e1.exp.from.d,e1.exp.from.m, e1.exp.from.y);
   printf("To: %d-%d-%d\n", e1.exp.to.d, e1.exp.to.m, e1.exp.to.y );

   return 0;
}

Output

When you run this code, it will produce the following output −

Name: Kiran
Salary: 25000.000000
Experience: Designation: Clerk
From:  12-5-1990
To: 31-3-2021

Pointer to Nested Structure

We know that the address of a struct variable can be stored in a pointer variable. Further, C uses the indirection operator (→) to access the elements of a variable that is referenced by a pointer.

In case of a nested structure, the elements of the inner struct elements are accessed by "ptr → inner_struct_var.element;"

Example

In this example, we have declared a pointer ptr to an employee struct variable. the date, month and year elements of inner dob struct variable are accessed as "ptr -> d1.d", "ptr -> d1.m" and "ptr -> d1.y" expressions.

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

struct employee{
   char name[10];
   float salary;
   struct dob{
      int d, m, y;
   } d1;
};

int main(){

   struct employee e1 = {"Kiran", 25000, {12, 5, 1990}};
   struct employee *ptr = &e1;

   printf("Name: %s\n", ptr -> name);
   printf("Salary: %f\n", ptr -> salary);
   printf("Date of Birth: %d-%d-%d\n", ptr -> d1.d, ptr -> d1.m, ptr -> d1.y);

   return 0;
}

Output

When you run this code, it will produce the following output −

Name: Kiran
Salary: 25000.000000
Date of Birth: 12-5-1990