What Is Structures In C: How to Create & Declare Them

In C, structures offer a powerful way to group related data under a single name. This makes your code more organized, readable, and easier to manage, especially when dealing with complex information.

What are Structures?

Imagine you're creating a program to manage student records. Each student has a roll number, name, course, and marks obtained. Rather than declaring separate variables for each student, you can use a structure to store all their information together.

Declaring Structures

Here's the basic syntax for declaring a structure:

struct structure_tag {
  data_type member1;
  data_type member2;
  // ... more members
};

• struct keyword: This keyword tells the compiler that you're defining a new structure type.
• structure_tag: This is an optional name (tag) you can give to the structure. It makes the code more readable and allows you to declare multiple variables of the same structure type later.
• data_type: This specifies the data type of each member variable within the structure (e.g., int, char, float).
• member variables: These are variables that hold the actual data within the structure. Each member can have a different data type.

Example: Student Database Structure

Let's create a structure named student to represent a student record:

struct student {
  int roll_no;
  char name[20]; // Array to hold the student's name (up to 20 characters)
  char course[20]; // Array to hold the course name (up to 20 characters)
  int marks_obtained;
};

Creating Structure Variables

Now that you've defined the structure template, you can create variables of that type to store actual student data:

struct student stud1, stud2; // Two instances (variables) of the student structure

This code creates two empty structures named stud1 and stud2 to hold information about two students. When you create structure variables, memory is allocated based on the combined size of all the member variables.

Alternative Declaration Without a Tag

Here's a valid but less flexible way to declare structures without a tag:

struct {
  int roll_no;
  char name[20];
  char course[20];
  int marks_obtained;
} stud1, stud2;

While this works, you lose the benefit of having a reusable structure type. You cannot declare more variables of this structure later in the program.

Combined Declaration and Definition

For small structures that you only need within a single program file, you can combine the declaration and definition:

struct telephone {
  int tele_no;
  int cust_code;
  char cust_address[40];
  int bill_amt;
} tele1, tele2, tele3; // Three instances created directly

This declares the structure telephone and creates three instances (tele1, tele2, tele3) in one step.

Using typedef for Structure Aliases

The typedef keyword allows you to create an alias (nickname) for a structure type:

typedef struct country {
  char name[20];
  int population;
  char language[10];
} Country;

Now, you can use either struct country or Country to declare structure variables:

Country Mexico, Canada, Brazil;

Key Points to Remember:

• Structures help organize related data under a single name.
• The structure declaration defines the blueprint, not allocating memory.
• An optional tag allows you to create multiple structure variables of the same type.
• typedef provides an alias for a structure type.

Benefits of Using Structures

• Improved Code Organization: Structures make your code more readable and maintainable by grouping related data together.
• Easier Data Handling: You can pass entire structures to functions, simplifying data transfer.
• Memory Efficiency: Compared to separate variables, structures can sometimes use memory more efficiently, especially when dealing with large amounts of related data.

Practice Exercises

Absolutely! Here's the continuation of the blog post, incorporating practice exercises and additional tips:

1. Create a structure to represent a book with its title, author, ISBN number, and number of pages:

struct book {
  char title[50];
  char author[50];
  long long int isbn; // Using long long int for larger ISBN numbers
  int num_pages;
};

1. Write a function that takes a student structure as an argument and displays the student's information:

void display_student_info(struct student stud) {
  cout << "Roll Number: " << stud.roll_no << endl;
  cout << "Name: " << stud.name << endl;
  cout << "Course: " << stud.course << endl;
  cout << "Marks Obtained: " << stud.marks_obtained << endl;
}

Additional Tips**

• Structure Arrays: You can create arrays of structures to store information about multiple entities of the same type. For example, an array of student structures can hold data for a whole class.
• Nested Structures: Structures can contain other structures as members. This allows you to create more complex data hierarchies when needed.
• Unions in Structures: Unions let you store different data types in the same memory location. They are useful for saving space when only one member will hold a value at any given time.

Beyond the Basics

As you become more comfortable with structures, explore their advanced capabilities:

• Initialization: You can initialize structure variables during declaration or using member initialization lists.
• Accessing Members: Access structure members using the dot (.) operator.
• Passing Structures to Functions: Pass structures by value (copies the entire structure) or by reference (passes the memory address).
• Structure Unions: Unions allow you to store different data types in the same memory location, useful for space optimization when you know only one member will have a value at a time.

By understanding and effectively using structures, you can write more organized, efficient, and reusable C code!