# Nested Structure in C

In C programming, a nested structure is a structure that is defined within another structure. It allows you to create complex data structures by combining multiple related structures together.

Here’s an example to illustrate the concept of nested structures:

```#include <stdio.h>

// Outer structure
struct Date {
int day;
int month;
int year;
};

// Inner structure
struct Person {
char name[20];
struct Date birthdate;
};

int main() {
// Declare and initialize a nested structure
struct Person person1 = {"John Doe", {10, 5, 1990}};

// Accessing the nested structure members
printf("Name: %s\n", person1.name);
printf("Birthdate: %d-%d-%d\n", person1.birthdate.day, person1.birthdate.month, person1.birthdate.year);

return 0;
}
```

In the above example, there are two structures: `Date` and `Person`. The `Date` structure represents a date with day, month, and year. The `Person` structure contains a name (an array of characters) and another structure, `birthdate`, of type `Date`.

By nesting the `Date` structure within the `Person` structure, we can access the birthdate of a person through the `Person` structure, as shown in the `main` function.

Nested structures are useful when you have a hierarchical or composite data structure where one structure is a part of another. It allows you to organize and represent complex data relationships in a more intuitive and convenient manner.

### 1) Separate structure:

Certainly! In addition to nested structures, you can also define separate structures in C. Separate structures are independent structures that are not defined within another structure. Here’s an example:

```#include <stdio.h>

// Structure for representing a point in 2D space
struct Point {
int x;
int y;
};

// Structure for representing a rectangle
struct Rectangle {
struct Point topLeft;
struct Point bottomRight;
};

int main() {
// Declare and initialize separate structures
struct Point p1 = {3, 5};
struct Rectangle rect = {{1, 2}, {6, 4}};

// Accessing the members of separate structures
printf("Point: (%d, %d)\n", p1.x, p1.y);
printf("Rectangle Top Left: (%d, %d)\n", rect.topLeft.x, rect.topLeft.y);
printf("Rectangle Bottom Right: (%d, %d)\n", rect.bottomRight.x, rect.bottomRight.y);

return 0;
}
```

In this example, there are two separate structures: `Point` and `Rectangle`. The `Point` structure represents a point in 2D space with x and y coordinates. The `Rectangle` structure contains two points, `topLeft` and `bottomRight`, both of type `Point`.

Separate structures are useful when you want to define and manipulate different types of data structures independently. In the example above, the `Point` structure can be used in various contexts unrelated to rectangles, and the `Rectangle` structure can be used to represent rectangles independently without being tied to any other structure.

By using separate structures, you can organize and work with different types of data in a modular and flexible way.

### 2) Embedded structure:

Certainly! In C programming, an embedded structure refers to the concept of including one structure as a member of another structure. This is different from nested structures, as the embedded structure is not defined separately but rather directly within another structure. Here’s an example to illustrate embedded structures:

```#include <stdio.h>

// Structure for representing a date
struct Date {
int day;
int month;
int year;
};

// Structure for representing a person
struct Person {
char name[20];
struct {
int streetNumber;
char city[20];
char state[20];
int zipCode;
struct Date birthdate;
};

int main() {
// Declare and initialize an embedded structure
struct Person person1 = {
"John Doe",
{123, "Cityville", "Stateville", 12345},
{10, 5, 1990}
};

// Accessing the embedded structure members
printf("Name: %s\n", person1.name);
printf("Birthdate: %d-%d-%d\n",
person1.birthdate.day,
person1.birthdate.month,
person1.birthdate.year);

return 0;
}
```

In the above example, there are two structures: `Date` and `Person`. The `Date` structure represents a date with day, month, and year. The `Person` structure contains a name (an array of characters), an embedded structure `address` representing the person’s address, and the `birthdate` structure of type `Date`.

By embedding the `address` structure directly within the `Person` structure, we can access the address members using the dot operator (`.`) as shown in the `main` function.

Embedded structures are useful when you want to include a smaller, related structure within another structure to represent a specific attribute or feature. It provides a way to group related data together within a larger structure for easier organization and access.

### Accessing Nested Structure:

To access members of a nested structure in C, you can use the dot operator (`.`) multiple times to navigate through the nested structure hierarchy. Here’s an example:

```#include <stdio.h>

struct Date {
int day;
int month;
int year;
};

struct Person {
char name[20];
struct Date birthdate;
};

int main() {
struct Person person1 = {"John Doe", {10, 5, 1990}};

printf("Name: %s\n", person1.name);
printf("Birthdate: %d-%d-%d\n",
person1.birthdate.day,
person1.birthdate.month,
person1.birthdate.year);

return 0;
}
```

In this example, we have a nested structure where `Date` is nested within `Person`. To access the members of the nested structure, we use the dot operator (`.`) consecutively. In `main()`, we access the name using `person1.name` and the birthdate members using `person1.birthdate.day`, `person1.birthdate.month`, and `person1.birthdate.year`.

By chaining the dot operator, we can traverse the nested structure and access the desired members. Just remember to start with the outermost structure and proceed inward until you reach the desired member.

Nested structures allow you to organize related data and access them in a hierarchical manner, which can be useful for representing complex data structures.

### C Nested Structure example:

Certainly! Here’s an example that demonstrates nested structures in C:

```#include <stdio.h>

// Outer structure
char street[50];
char city[20];
int zipCode;
};

// Inner structure
struct Person {
char name[50];
int age;
};

int main() {
// Declare and initialize nested structures
struct Person person1 = {
"John Doe",
25,
{"123 Main St", "Cityville", 12345}
};

// Accessing the nested structure members
printf("Name: %s\n", person1.name);
printf("Age: %d\n", person1.age);

return 0;
}
```

In this example, we have an outer structure `Address` representing a person’s address and an inner structure `Person` representing a person’s information, including their name, age, and address.

The `Person` structure contains an embedded `Address` structure. By declaring a variable of type `struct Person` (e.g., `person1`), we can access its members using the dot operator (`.`). For example, `person1.name` accesses the name, `person1.age` accesses the age, and `person1.address.street`, `person1.address.city`, and `person1.address.zipCode` access the corresponding members of the nested `Address` structure.

Nested structures are useful when you want to organize related data into a hierarchical structure. They allow you to represent complex relationships and access the individual members at different levels of the structure.

### Passing structure to function:

In C, you can pass a structure to a function by either passing it directly as an argument or by passing a pointer to the structure. Here are examples of both approaches:

Passing Structure Directly:

```#include <stdio.h>

struct Person {
char name[50];
int age;
};

// Function that takes a structure as an argument
void displayPerson(struct Person p) {
printf("Name: %s\n", p.name);
printf("Age: %d\n", p.age);
}

int main() {
struct Person person1 = {"John Doe", 25};

// Call the function and pass the structure
displayPerson(person1);

return 0;
}
```

In this example, the `displayPerson` function takes a `struct Person` as an argument. Inside the function, the members of the structure (`name` and `age`) are accessed using the dot operator (`.`). The `main` function declares a `struct Person` variable `person1`, initializes it, and then passes it to the `displayPerson` function.

Passing Structure Pointer:

```#include <stdio.h>

struct Person {
char name[50];
int age;
};

// Function that takes a pointer to a structure as an argument
void displayPerson(struct Person* p) {
printf("Name: %s\n", p->name);
printf("Age: %d\n", p->age);
}

int main() {
struct Person person1 = {"John Doe", 25};

// Call the function and pass the pointer to the structure
displayPerson(&person1);

return 0;
}
```

In this example, the `displayPerson` function takes a pointer to a `struct Person` as an argument. Inside the function, the structure members are accessed using the arrow operator (`->`) instead of the dot operator since we are working with a pointer to the structure. The `main` function declares a `struct Person` variable `person1`, initializes it, and then passes its address (`&person1`) to the `displayPerson` function.

Both methods allow you to pass a structure to a function for processing or manipulation. The choice between passing the structure directly or using a pointer depends on the specific requirements of your program. Passing a pointer is generally more efficient for large structures, as it avoids making a copy of the entire structure.

Categories C