Structures

In C, a structure is a user-defined data type that allows you to group related data items together
under a single name. Each data item within a structure is referred to as a "member" or a "field."
Structures provide a way to organize and manage complex data in a program.

Here's a step-by-step guide on how to work with structures in C:

1. Defining a Structure:
To define a structure, you use the struct keyword followed by the structure name and a set of
curly braces {} containing the members of the structure.

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

In this example, we define a structure called Person with three members: name , age , and
height .

2. Declaring Structure Variables:

Once you have defined a structure, you can declare variables of that structure type.

struct Person person1; // Declare a variable of type Person

struct Person person2; // Declare another variable of type Person

3. Accessing Structure Members:

To access the members of a structure, you use the dot ( . ) operator followed by the member
name.

strcpy(person1.name, "John Doe");

person1.age = 30;
person1.height = 5.9;

4. Initializing Structures:
You can initialize a structure when declaring it.

struct Person person3 = {"Alice", 25, 5.6};

5. Using Structures with Functions:
Structures can be passed as arguments to functions. You can pass a structure as a value or as a
pointer.

void displayPerson(struct Person p) {

printf("Name: %s\n", p.name);
printf("Age: %d\n", p.age);
printf("Height: %.2f\n", p.height);
}

int main() {
struct Person person1 = {"John", 30, 5.9};
displayPerson(person1);

return 0;
}

6. Nested Structures:
A structure can contain another structure as a member, allowing for nested or hierarchical data
structures.

struct Address {
char street[50];
char city[30];
};

struct Employee {
char name[50];
int empId;
struct Address address;
};

7. Arrays of Structures:
You can create arrays of structures to handle multiple instances of the same data structure.

struct Person people[10]; // Array of 10 Person structures

8. Pointer to Structure:
You can create pointers to structures and access members using the arrow ( -> ) operator.

struct Person *ptrPerson = &person1;

printf("Name: %s\n", ptrPerson->name);
1. Example of structure

Sure, here's a simple example of a structure in C to represent a person:

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

// Define a structure to represent a person

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

int main() {
// Declare a variable of type Person
struct Person person1;

// Fill in the details for person1

strcpy(person1.name, "John Doe");
person1.age = 30;
person1.height = 5.9;

// Display the details of person1

printf("Person 1\n");
printf("Name: %s\n", person1.name);
printf("Age: %d\n", person1.age);
printf("Height: %.2f feet\n", person1.height);

return 0;
}

In this example:

We define a structure called Person with members name , age , and height .

We declare a variable person1 of type Person .

We fill in the details (name, age, and height) for person1 .

We display the details of person1 .

Output:

Person 1
Name: John Doe
Age: 30
Height: 5.90 feet

2. Example of structure

Certainly! Here's another example of a structure in C, representing a point in 2D space:

#include <stdio.h>

// Define a structure to represent a point in 2D space

struct Point {
int x;
int y;
};

int main() {
// Declare a variable of type Point
struct Point p1;

// Fill in the details for the point

p1.x = 10;
p1.y = 20;

// Display the details of the point

printf("Point coordinates: (%d, %d)\n", p1.x, p1.y);

return 0;
}

In this example:

We define a structure called Point with members x and y representing coordinates.

We declare a variable p1 of type Point .

We fill in the coordinates for p1 .

We display the coordinates of p1 .

Output:

Point coordinates: (10, 20)

3. Example of Structure

Certainly! Let's create a structure to represent a book with title, author, and price:

#include <stdio.h>

// Define a structure to represent a book

struct Book {
char title[100];
char author[50];
float price;
};

int main() {
// Declare a variable of type Book
struct Book book1;

// Fill in the details for the book

strcpy(book1.title, "The C Programming Language");
strcpy(book1.author, "Brian W. Kernighan and Dennis M. Ritchie");
book1.price = 29.99;

// Display the details of the book

printf("Book Details:\n");
printf("Title: %s\n", book1.title);
printf("Author: %s\n", book1.author);
printf("Price: $%.2f\n", book1.price);

return 0;
}

In this example:

We define a structure called Book with members title , author , and price .

We declare a variable book1 of type Book .

We fill in the details (title, author, and price) for book1 .

We display the details of book1 .

Output:

Book Details:
Title: The C Programming Language
Author: Brian W. Kernighan and Dennis M. Ritchie
Price: $29.99

4. Example of Structure in C

Certainly! Here's another example of a structure in C, representing a student:

#include <stdio.h>

// Define a structure to represent a student

struct Student {
char name[50];
int age;
float gpa;
};

int main() {
// Declare a variable of type Student
struct Student student1;

// Fill in the details for the student

strcpy(student1.name, "Alice");
student1.age = 20;
student1.gpa = 3.8;

// Display the details of the student

printf("Student Details:\n");
printf("Name: %s\n", student1.name);
printf("Age: %d\n", student1.age);
printf("GPA: %.2f\n", student1.gpa);

return 0;
}

In this example:

We define a structure called Student with members name , age , and gpa .

We declare a variable student1 of type Student .

We fill in the details (name, age, and GPA) for student1 .

We display the details of student1 .

Output:

Student Details:
Name: Alice
Age: 20
GPA: 3.80

5. Example of Structure in C

Certainly! Here's another example of a structure in C, representing a car:

#include <stdio.h>

// Define a structure to represent a car

struct Car {
char make[20];
char model[20];
int year;
float price;
};

int main() {
// Declare a variable of type Car
struct Car myCar;

// Fill in the details for the car

strcpy(myCar.make, "Toyota");
strcpy(myCar.model, "Corolla");
myCar.year = 2020;
myCar.price = 20000.00;

// Display the details of the car

printf("Car Details:\n");
printf("Make: %s\n", myCar.make);
printf("Model: %s\n", myCar.model);
printf("Year: %d\n", myCar.year);
printf("Price: $%.2f\n", myCar.price);

return 0;
}

In this example:

We define a structure called Car with members make , model , year , and price .

We declare a variable myCar of type Car .

We fill in the details (make, model, year, and price) for myCar .

We display the details of myCar .

Output:

Car Details:
Make: Toyota
Model: Corolla
Year: 2020
Price: $20000.00

6. Example of Structure

Certainly! Here's an example of a structure in C representing a point in 3D space:

#include <stdio.h>

// Define a structure to represent a point in 3D space

struct Point3D {
float x;
float y;
float z;
};

int main() {
// Declare a variable of type Point3D
struct Point3D point1;

// Fill in the coordinates for the point

point1.x = 1.0;
point1.y = 2.5;
point1.z = -3.7;

// Display the coordinates of the point

printf("Point coordinates:\n");
printf("x: %.2f\n", point1.x);
printf("y: %.2f\n", point1.y);
printf("z: %.2f\n", point1.z);

return 0;
}

In this example:
We define a structure called Point3D with members x , y , and z representing coordinates
in 3D space.

We declare a variable point1 of type Point3D .

We fill in the coordinates for point1 .

We display the coordinates of point1 .

Output:

Point coordinates:
x: 1.00
y: 2.50
z: -3.70

7. Example of Structure

Certainly! Let's consider a structure representing a simple employee with their name, employee
ID, and salary.

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

// Define a structure to represent an employee

struct Employee {
char name[50];
int employeeID;
float salary;
};

int main() {
// Declare a variable of type Employee
struct Employee emp1;

// Fill in the details for the employee

strcpy(emp1.name, "John Doe");
emp1.employeeID = 1001;
emp1.salary = 50000.0;

// Display the details of the employee

printf("Employee Details:\n");
printf("Name: %s\n", emp1.name);
printf("Employee ID: %d\n", emp1.employeeID);
printf("Salary: $%.2f\n", emp1.salary);

return 0;
}

In this example:

We define a structure called Employee with members name , employeeID , and salary .

We declare a variable emp1 of type Employee .

We fill in the details (name, employee ID, and salary) for emp1 .

We display the details of emp1 .

Output:

Employee Details:
Name: John Doe
Employee ID: 1001
Salary: $50000.00

8. Example of Structure

Certainly! Let's create a structure to represent a computer with its specifications:

#include <stdio.h>

// Define a structure to represent a computer

struct Computer {
char brand[20];
char model[20];
int year;
float price;
};

int main() {
// Declare a variable of type Computer
struct Computer myComputer;

// Fill in the details for the computer

strcpy(myComputer.brand, "Dell");
strcpy(myComputer.model, "XPS 13");
myComputer.year = 2021;
myComputer.price = 1200.00;

// Display the details of the computer

printf("Computer Details:\n");
printf("Brand: %s\n", myComputer.brand);
printf("Model: %s\n", myComputer.model);
printf("Year: %d\n", myComputer.year);
printf("Price: $%.2f\n", myComputer.price);

return 0;
}

In this example:

We define a structure called Computer with members brand , model , year , and price .

We declare a variable myComputer of type Computer .

We fill in the details (brand, model, year, and price) for myComputer .

We display the details of myComputer .

Output:

Computer Details:
Brand: Dell
Model: XPS 13
Year: 2021
Price: $1200.00

9. Example of Structure

Certainly! Here's an example of a structure in C representing a simple bank account:

#include <stdio.h>

// Define a structure to represent a bank account

struct BankAccount {
char accountNumber[15];
char accountHolderName[50];
float balance;
};

int main() {
// Declare a variable of type BankAccount
struct BankAccount account1;

// Fill in the details for the bank account

strcpy(account1.accountNumber, "123456789");
strcpy(account1.accountHolderName, "Alice Smith");
account1.balance = 1500.00;

// Display the details of the bank account

printf("Bank Account Details:\n");
printf("Account Number: %s\n", account1.accountNumber);
printf("Account Holder: %s\n", account1.accountHolderName);
printf("Balance: $%.2f\n", account1.balance);

return 0;
}

In this example:

We define a structure called BankAccount with members accountNumber ,

accountHolderName , and balance .

We declare a variable account1 of type BankAccount .

We fill in the details (account number, account holder name, and balance) for account1 .

We display the details of account1 .

Output:
Bank Account Details:
Account Number: 123456789
Account Holder: Alice Smith
Balance: $1500.00

10. Example of Structure

Certainly! Here's another example of a structure in C representing a rectangle:

#include <stdio.h>

// Define a structure to represent a rectangle

struct Rectangle {
float length;
float width;
};

int main() {
// Declare a variable of type Rectangle
struct Rectangle rect1;

// Fill in the details for the rectangle

rect1.length = 5.0;
rect1.width = 3.0;

// Calculate and display the area of the rectangle

float area = rect1.length * rect1.width;
printf("Rectangle Details:\n");
printf("Length: %.2f units\n", rect1.length);
printf("Width: %.2f units\n", rect1.width);
printf("Area: %.2f square units\n", area);

return 0;
}

In this example:

We define a structure called Rectangle with members length and width .

We declare a variable rect1 of type Rectangle .

We fill in the details (length and width) for rect1 .

We calculate and display the area of the rectangle.

Output:

Rectangle Details:
Length: 5.00 units
Width: 3.00 units
Area: 15.00 square units
Array of Structures
An array of structures in C is an arrangement where each element of the array is a structure. This
allows you to group multiple instances of a structure together, creating a collection of related
data.

Here's an example of an array of structures representing students:

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

#define MAX_STUDENTS 3

// Define a structure to represent a student

struct Student {
char name[50];
int id;
};

int main() {
// Declare an array of Student structures
struct Student students[MAX_STUDENTS];

// Fill in the details for each student

strcpy(students[0].name, "Alice");
students[0].id = 1001;

strcpy(students[1].name, "Bob");
students[1].id = 1002;

strcpy(students[2].name, "Charlie");
students[2].id = 1003;

// Display the details of each student

printf("Student Details:\n");
for (int i = 0; i < MAX_STUDENTS; i++) {
printf("Student %d:\n", i + 1);
printf("Name: %s\n", students[i].name);
printf("ID: %d\n", students[i].id);
}

return 0;
}

In this example:

We define a structure called Student with members name and id .

We declare an array students of type Student , allowing for MAX_STUDENTS (here, 3)

students.

We fill in the details (name and id) for each student in the array.

We display the details of each student using a loop.

Output:

Student Details:
Student 1:
Name: Alice
ID: 1001
Student 2:
Name: Bob
ID: 1002
Student 3:
Name: Charlie
ID: 1003

Example 1: Array of Structure

Certainly! Here's an example of an array of structures in C, representing multiple students:

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

// Define a structure to represent a student

struct Student {
char name[50];
int age;
float gpa;
};

int main() {
// Declare an array of students
struct Student students[3];

// Fill in the details for each student

strcpy(students[0].name, "Alice");
students[0].age = 20;
students[0].gpa = 3.7;

strcpy(students[1].name, "Bob");
students[1].age = 21;
students[1].gpa = 3.5;

strcpy(students[2].name, "Charlie");
students[2].age = 19;
students[2].gpa = 3.9;

// Display the details of each student

printf("Student Details:\n");
for (int i = 0; i < 3; i++) {
printf("Student %d\n", i + 1);
printf("Name: %s\n", students[i].name);
printf("Age: %d\n", students[i].age);
printf("GPA: %.2f\n", students[i].gpa);
printf("\n");
}
return 0;
}

In this example:

We define a structure called Student with members name , age , and gpa .

We declare an array students of type Student to hold multiple students.

We fill in the details for each student in the array.

We display the details of each student using a loop.

Output:

Student Details:
Student 1
Name: Alice
Age: 20
GPA: 3.70

Student 2
Name: Bob
Age: 21
GPA: 3.50

Student 3
Name: Charlie
Age: 19
GPA: 3.90

2. Example array of structure

Certainly! Here's an example of an array of structures in C, representing multiple students:

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

// Define a structure to represent a student

struct Student {
char name[50];
int rollNumber;
float marks;
};

int main() {
// Define an array of structures to hold student information
struct Student students[3]; // Array of 3 students

// Fill in the details for each student

strcpy(students[0].name, "Alice");
students[0].rollNumber = 101;
students[0].marks = 85.5;
strcpy(students[1].name, "Bob");
students[1].rollNumber = 102;
students[1].marks = 78.0;

strcpy(students[2].name, "Charlie");
students[2].rollNumber = 103;
students[2].marks = 92.2;

// Display the details of each student

for (int i = 0; i < 3; i++) {
printf("Student %d Details:\n", i + 1);
printf("Name: %s\n", students[i].name);
printf("Roll Number: %d\n", students[i].rollNumber);
printf("Marks: %.2f\n", students[i].marks);
printf("\n");
}

return 0;
}

In this example:

We define a structure called Student with members name , rollNumber , and marks .

We declare an array students of type Student to hold information for multiple students.

We fill in the details (name, roll number, and marks) for each student in the array.

We then display the details of each student in the array using a loop.

Output:

Student 1 Details:
Name: Alice
Roll Number: 101
Marks: 85.50

Student 2 Details:
Name: Bob
Roll Number: 102
Marks: 78.00

Student 3 Details:
Name: Charlie
Roll Number: 103
Marks: 92.20

3. Example of Array of Structure

Sure! Let's extend the previous example to demonstrate an array of structures representing
multiple rectangles:

#include <stdio.h>

// Define a structure to represent a rectangle

struct Rectangle {
float length;
float width;
};

int main() {
// Define an array of rectangles
struct Rectangle rectangles[3];

// Fill in the details for each rectangle

rectangles[0].length = 5.0;
rectangles[0].width = 3.0;

rectangles[1].length = 7.0;
rectangles[1].width = 4.0;

rectangles[2].length = 4.5;
rectangles[2].width = 2.5;

// Display the details and area of each rectangle

for (int i = 0; i < 3; i++) {
float area = rectangles[i].length * rectangles[i].width;
printf("Rectangle %d Details:\n", i + 1);
printf("Length: %.2f units\n", rectangles[i].length);
printf("Width: %.2f units\n", rectangles[i].width);
printf("Area: %.2f square units\n", area);
printf("\n");
}

return 0;
}

In this example:

We define a structure called Rectangle with members length and width .

We declare an array of type Rectangle named rectangles to store multiple rectangles.

We fill in the details (length and width) for each rectangle.

We calculate and display the area of each rectangle.

Output:

Rectangle 1 Details:
Length: 5.00 units
Width: 3.00 units
Area: 15.00 square units

Rectangle 2 Details:
Length: 7.00 units
Width: 4.00 units
Area: 28.00 square units

Rectangle 3 Details:
Length: 4.50 units
Width: 2.50 units
Area: 11.25 square units

4. Example of Array of Structure

Sure! Here's an example of an array of structures representing employee details in C:

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

// Define a structure to represent an employee

struct Employee {
char name[50];
int employeeID;
float salary;
};

int main() {
// Declare an array of Employee structures
struct Employee employees[3];

// Fill in the details for each employee

strcpy(employees[0].name, "John Doe");
employees[0].employeeID = 1001;
employees[0].salary = 60000.0;

strcpy(employees[1].name, "Alice Smith");

employees[1].employeeID = 1002;
employees[1].salary = 55000.0;

strcpy(employees[2].name, "Bob Johnson");

employees[2].employeeID = 1003;
employees[2].salary = 58000.0;

// Display the details of each employee

for (int i = 0; i < 3; i++) {
printf("Employee %d Details:\n", i + 1);
printf("Name: %s\n", employees[i].name);
printf("Employee ID: %d\n", employees[i].employeeID);
printf("Salary: $%.2f\n", employees[i].salary);
printf("\n");
}

return 0;
}

In this example:

We define a structure called Employee with members name , employeeID , and salary .

We declare an array of Employee structures to store details for multiple employees.

We fill in the details (name, employee ID, and salary) for each employee.

We use a loop to display the details of each employee.

Output:

Employee 1 Details:
Name: John Doe
Employee ID: 1001
Salary: $60000.00

Employee 2 Details:
Name: Alice Smith
Employee ID: 1002
Salary: $55000.00

Employee 3 Details:
Name: Bob Johnson
Employee ID: 1003
Salary: $58000.00

5. Example of Array of Structure

Certainly! Here's an example of an array of structures in C representing multiple students:

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

// Define a structure to represent a student

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

int main() {
// Declare an array of students
struct Student students[3]; // Assuming we have 3 students

// Fill in the details for each student

strcpy(students[0].name, "Alice");
students[0].age = 20;

strcpy(students[1].name, "Bob");
students[1].age = 21;

strcpy(students[2].name, "Charlie");
students[2].age = 19;

// Display the details of each student

printf("Student Details:\n");
for (int i = 0; i < 3; i++) {
printf("Student %d\n", i + 1);
printf("Name: %s\n", students[i].name);
printf("Age: %d\n", students[i].age);
printf("\n");
}
return 0;
}

In this example:

We define a structure called Student with members name and age .

We declare an array of students ( students ) to store multiple student records.

We fill in the details (name and age) for each student in the array.

We display the details of each student.

Output:

Student Details:
Student 1
Name: Alice
Age: 20

Student 2
Name: Bob
Age: 21

Student 3
Name: Charlie
Age: 19
Problem Statement:

You are asked to create a program that manages information about books. Each book has the
following attributes:

Title (a string)

Author (a string)

ISBN (a string)

Price (a float)

You need to write a C program that does the following:

1. Define a structure named Book to store the information about a book.

2. Create a variable of type Book to represent a book.

3. Write a function to input data for a book (Title, Author, ISBN, and Price) from the user.

4. Write a function to display the information of the book.

Here's a template to get you started:

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

// Define the Book structure

struct Book {
char title[100];
char author[100];
char isbn[20];
float price;
};

// Function to input data for a book

void inputBook(struct Book *book) {
printf("Enter Title: ");
// Input code for title
printf("Enter Author: ");
// Input code for author
printf("Enter ISBN: ");
// Input code for ISBN
printf("Enter Price: ");
// Input code for price
}

// Function to display book information

void displayBook(struct Book book) {
printf("Title: %s\n", book.title);
printf("Author: %s\n", book.author);
printf("ISBN: %s\n", book.isbn);
printf("Price: $%.2f\n", book.price);
}
int main() {
struct Book myBook;

// Input data for the book

inputBook(&myBook);

// Display the book information

printf("\nBook Information:\n");
displayBook(myBook);

return 0;
}

Practice Question:

1. Let's create a program that defines a structure to represent a point in 2D space (x, y
coordinates). The program will then calculate the distance between two points.

Consider the following steps:

Define a structure Point to represent a point in 2D space with x and y coordinates.

Have a function calculateDistance that calculates the distance between two points using
the distance formula: $$ { \sqrt{(x{2}-x{1})^2+(y_{2}-y{1})^2} } $$

In the main function, create two points and calculate the distance between them using the
calculateDistance function.

Finally, display the calculated distance.