Back to: C Tutorials For Beginners and Professionals
Structure Real-Time Examples in C Language
In this article, I will discuss Structure Real-time Examples in C Language with Examples. Please read our previous article discussing Structure using Pointer in C with Examples. At the end of this article, you will understand the following examples using Structure in C.
- Student Database System
- Bank Account Management
- Employee Management System
- University Course Management
- Contact Management System
- Vehicle Information System
- Dynamic Employee Management System
- Singly Linked List
- Dynamic Array of Structures
Structure Real-time Examples in C Language
Using structures in C can greatly enhance code organization and readability, particularly when grouping different data types is beneficial. Here are some real-time examples that demonstrate the use of structures without involving pointers:
Example: Student Database System
We’ll create a simple student database system using the structures in this example. This system will hold student information, such as ID, name, and grades.
Struct Definition:
struct Student { int id; char name[50]; float grade; };
Function to Display Student Information:
void displayStudent(struct Student stu) { printf("Student ID: %d\n", stu.id); printf("Student Name: %s\n", stu.name); printf("Student Grade: %.2f\n", stu.grade); }
Main Function:
int main() { struct Student student1; student1.id = 1; strcpy(student1.name, "Alice Smith"); student1.grade = 3.5; displayStudent(student1); return 0; }
In this example, we define a Student structure, populate it with data, and display the information using a function. This approach can be extended to manage many student records, including features like adding, updating, and deleting student data.
Example: Bank Account Management
Here, we’ll visually represent a bank account management system. We’ll use structures to represent bank accounts and perform simple operations.
Struct Definition:
struct BankAccount { int accountNumber; char holderName[100]; double balance; };
Function to Deposit Money:
void deposit(struct BankAccount *account, double amount) { account->balance += amount; }
Function to Withdraw Money:
void withdraw(struct BankAccount *account, double amount) { if (amount <= account->balance) { account->balance -= amount; } else { printf("Insufficient funds.\n"); } }
Main Function:
int main() { struct BankAccount account1 = {123456, "John Doe", 1000.0}; printf("Initial Balance: $%.2f\n", account1.balance); deposit(&account1, 500.0); printf("Balance after deposit: $%.2f\n", account1.balance); withdraw(&account1, 200.0); printf("Balance after withdrawal: $%.2f\n", account1.balance); return 0; }
In this example, we define a BankAccount structure and perform deposit and withdrawal operations. The functions deposit and withdraw modify the account’s balance. This kind of structure-based approach is foundational in creating more complex banking systems.
Example: Employee Management System
In an employee management system, structures can store and manage employee information, such as their ID, name, department, and salary.
Structure Definition:
struct Employee { int id; char name[50]; char department[50]; double salary; };
Function to Display Employee Information:
void printEmployeeInfo(struct Employee emp) { printf("Employee ID: %d\n", emp.id); printf("Employee Name: %s\n", emp.name); printf("Department: %s\n", emp.department); printf("Salary: %.2f\n", emp.salary); }
Main Function:
int main() { struct Employee emp1 = {1, "Alice Johnson", "IT", 75000.00}; printEmployeeInfo(emp1); return 0; }
This program defines an Employee structure, initializes an employee’s data, and displays it. In a real system, you would have more functionality, like adding, updating, or deleting employee records.
Example: University Course Management
In this example, we use structures to represent and manage university courses and student enrollment.
Structure Definitions:
struct Course { int id; char title[100]; int credits; }; struct Student { int id; char name[50]; struct Course enrolledCourses[5]; int enrolledCourseCount; };
Function to Enroll in a Course:
void enrollCourse(struct Student *student, struct Course course) { if (student->enrolledCourseCount < 5) { student->enrolledCourses[student->enrolledCourseCount++] = course; } else { printf("Cannot enroll in more than 5 courses.\n"); } }
Main Function:
int main() { struct Student student1 = {1001, "John Doe", {}, 0}; struct Course course1 = {101, "Introduction to Computer Science", 4}; struct Course course2 = {102, "Data Structures", 3}; enrollCourse(&student1, course1); enrollCourse(&student1, course2); // Display student's enrolled courses printf("Courses enrolled by %s:\n", student1.name); for (int i = 0; i < student1.enrolledCourseCount; i++) { printf("%s\n", student1.enrolledCourses[i].title); } return 0; }
In this program, we define structures for Course and Student. A student can enroll in multiple courses. We demonstrate enrolling a student in courses and then display the enrolled courses.
Example: Contact Management System
In a contact management system, structures can be used to store and manage information about individuals, such as their name, phone number, and email address.
Structure Definition:
struct Contact { char name[100]; char phoneNumber[15]; char email[100]; };
Function to Display Contact Information:
void displayContact(struct Contact c) { printf("Name: %s\n", c.name); printf("Phone Number: %s\n", c.phoneNumber); printf("Email: %s\n", c.email); }
Main Function:
int main() { struct Contact contact1; strcpy(contact1.name, "Alice Johnson"); strcpy(contact1.phoneNumber, "123-456-7890"); strcpy(contact1.email, "alice.johnson@example.com"); displayContact(contact1); return 0; }
In this example, we define a Contact structure, populate it with data, and display the information. This approach can be extended to manage a list of contacts, including features like adding, updating, and deleting contact data.
Example: Vehicle Information System
Here, we’ll create a representation of a vehicle information system. We’ll use structures to represent vehicles and store details like the make, model, and year.
Structure Definition:
struct Vehicle { char make[50]; char model[50]; int year; };
Function to Display Vehicle Information:
void displayVehicle(struct Vehicle v) { printf("Make: %s\n", v.make); printf("Model: %s\n", v.model); printf("Year: %d\n", v.year); }
Main Function:
int main() { struct Vehicle car = {"Toyota", "Corolla", 2020}; displayVehicle(car); return 0; }
In this program, we define a Vehicle structure and display its details. This structure-based approach is foundational in creating more complex systems for managing vehicle-related information, such as fleets in a transportation company.
Example: Dynamic Employee Management System
This example demonstrates a simple employee management system using structures and pointers, where each employee’s information is dynamically allocated.
#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { int id; char name[100]; float salary; } Employee; void printEmployee(Employee *e) { printf("ID: %d, Name: %s, Salary: %.2f\n", e->id, e->name, e->salary); } int main() { Employee *emp = malloc(sizeof(Employee)); if (emp == NULL) { perror("Memory allocation failed"); return 1; } emp->id = 123; strcpy(emp->name, "John Doe"); emp->salary = 50000.0; printEmployee(emp); free(emp); return 0; }
Example: Singly Linked List
A singly linked list is a classic example of using self-referential structures with pointers. It’s a linear collection of data elements, where each element points to the next.
#include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *next; } Node; Node* createNode(int data) { Node *newNode = (Node *)malloc(sizeof(Node)); if (!newNode) return NULL; newNode->data = data; newNode->next = NULL; return newNode; } void printList(Node *head) { while (head != NULL) { printf("%d -> ", head->data); head = head->next; } printf("NULL\n"); } int main() { Node *head = createNode(1); head->next = createNode(2); head->next->next = createNode(3); printList(head); // Freeing the list (not shown for brevity) return 0; }
Example: Dynamic Array of Structures
This example shows how to create and manipulate a dynamic array of structures.
#include <stdio.h> #include <stdlib.h> typedef struct { int x; int y; } Point; int main() { int n = 3; Point *points = (Point *)malloc(n * sizeof(Point)); if (!points) { perror("Memory allocation failed"); return 1; } // Initializing points for (int i = 0; i < n; i++) { points[i].x = i; points[i].y = i * i; } // Printing points for (int i = 0; i < n; i++) { printf("Point %d: (%d, %d)\n", i + 1, points[i].x, points[i].y); } free(points); return 0; }
These examples demonstrate how structures in C can be used to model real-world entities and manage data efficiently. Structures provide a way to group related data together, making it easier to manipulate and maintain. In practice, such applications would be more complex and feature-rich, often involving dynamic memory allocation, file handling, and more sophisticated data management techniques.
In the next article, I will discuss Union in C Language with Examples. In this article, I explain Structure Real-Time Examples in C Language. I hope you enjoy this Structure Real-Time Examples in C Language article. I would like to have your feedback. Please post feedback, questions, or comments about this article.
About the Author: Pranaya Rout
Pranaya Rout has published more than 3,000 articles in his 11-year career. Pranaya Rout has very good experience with Microsoft Technologies, Including C#, VB, ASP.NET MVC, ASP.NET Web API, EF, EF Core, ADO.NET, LINQ, SQL Server, MYSQL, Oracle, ASP.NET Core, Cloud Computing, Microservices, Design Patterns and still learning new technologies.