Structures in C

Structures in C, a struct (short for structure) is a user-defined data type that allows you to group different types of data together under a single name. This is useful when you want to work with a collection of related variables as a single entity.

Here’s a detailed explanation of how structures work in C, including their syntax, usage, and an example to illustrate their practical application.

Definition of a Structure in C

A structure is defined using the struct keyword. Here’s the basic syntax for defining a structure:

struct StructName {
    dataType member1;
    dataType member2;
    // more members
};

• StructName: The name you give to the structure.
• member1, member2: The variables or fields that make up the structure.
• dataType: The type of data each member will hold (e.g., int, float, char).

Declaring and Initializing a Structure Variable

After defining a structure, you can declare variables of that type and initialize them:

struct StructName {
    int age;
    float salary;
    char name[50];
};

// Declare a structure variable
struct StructName employee1;

// Initialize the structure variable
employee1.age = 30;
employee1.salary = 50000.0;
strcpy(employee1.name, "John Doe");  // strcpy is used to copy strings in C

Accessing Structure Members

You can access structure members using the dot operator (.):

printf("Name: %s\n", employee1.name);
printf("Age: %d\n", employee1.age);
printf("Salary: %.2f\n", employee1.salary);

Example: Defining and Using a Structure in C

Let’s look at a complete example of defining a structure and using it in a C program:

#include <stdio.h>
#include <string.h>  // For strcpy function

// Define the structure
struct Student {
    int id;
    char name[50];
    float gpa;
};

int main() {
    // Declare and initialize structure variables
    struct Student student1;
    student1.id = 101;
    strcpy(student1.name, "Alice Johnson");
    student1.gpa = 3.8;

    // Access and display structure members
    printf("Student ID: %d\n", student1.id);
    printf("Student Name: %s\n", student1.name);
    printf("Student GPA: %.2f\n", student1.gpa);

    return 0;
}

Using struct with Functions

Structures can also be passed to functions. Here’s an example:

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

// Define the structure
struct Point {
    int x;
    int y;
};

// Function to print the point's coordinates
void printPoint(struct Point p) {
    printf("Point coordinates: (%d, %d)\n", p.x, p.y);
}

int main() {
    struct Point p1;
    p1.x = 10;
    p1.y = 20;
    
    printPoint(p1);  // Call the function with the structure variable

    return 0;
}

Using Pointers with Structures in C

You can also use pointers to structures:

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

// Define the structure
struct Employee {
    int id;
    char name[50];
};

// Function to display employee details
void displayEmployee(struct Employee *emp) {
    printf("Employee ID: %d\n", emp->id);
    printf("Employee Name: %s\n", emp->name);
}

int main() {
    struct Employee emp1;
    emp1.id = 202;
    strcpy(emp1.name, "Bob Smith");

    // Call function with a pointer to the structure
    displayEmployee(&emp1);

    return 0;
}

Common Operations with Structures in C

• Assigning Values: Directly using the dot operator or initializing during declaration.
• Copying Structures: Structures can be copied using the assignment operator (=).
• Passing to Functions: Structures can be passed by value or by reference (using pointers).

Advanced Concepts

• Nested Structures: Structures can contain other structures.
• Arrays of Structures: You can create arrays where each element is a structure.
• Structure Pointers: You can use pointers to access structure members using the -> operator.

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

struct Employee employees[10];  // Array of structures

struct Employee *ptr = &employees[0];  // Pointer to a structure
ptr->id = 301;  // Accessing member using pointer

Summary Table

This should give you a solid understanding of how to work with structures in C.