Concepts and Declaration of Structures

In C programming, a structure is a capability to combine data of different types together. It allows developers to create custom data types, thereby organizing and managing complex datasets more effectively. Through structures, we can encapsulate multiple variables into a single entity, making code logic clearer, modular, and enhancing program maintainability.
The essence of a structure is a user-defined composite data type. Unlike basic data types (such as int, float), a structure can contain member variables of various types; these members can be integers, floating-point numbers, characters, or even other structures themselves. This flexibility makes structures the cornerstone for building complex data models.

In C language, the keyword used to declare a structure is struct. Its basic syntax format is as follows:

struct struct_name {
    type1 member_name_1;
    type2 member_name_2;
    // ... other members
};

For example, we define a structure named Student to store student information:

struct Student {
    int id;          // Student ID number
    char name[50];   // Student name
    float age;       // Age
};

After declaration, the struct name (e.g., Student) can be used as a type subsequently. It is worth noting that prior to the C99 standard, it was typically necessary to immediately surround the structure definition with braces after its definition so that the compiler could correctly parse its scope.

Creating and Accessing Structure Variables

Once a struct type has been defined, specific instances (variables) can be created just like basic data types. This can be accomplished through simple declaration statements, for example:

struct Student s1; // Create a structure variable named s1
struct Student s2 = {1001, "ZhangSan", 20}; // Initialize the variable

Accessing members within a structure requires using the dot operator (.). Assuming we have an s1 variable and wish to modify its age, it can be done as follows:

s1.age = 21;

To get or modify array-type members, use square brackets in conjunction with the dot operator:

strcpy(s1.name, "LiSi"); // Copy string into name member

To simplify syntax and improve readability, the C99 standard introduced the typedef keyword, allowing us to directly define an alias for a structure without needing to write struct Student every time. For example:

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

Person p1 = {2001, "WangWu", 25};
p1.age = 26;

This approach not only reduces code redundancy but also makes type names more intuitive.

Practical Application Examples of Structures

In actual development, structures are commonly used to simulate real-world entities such as users, products, orders, etc. Below is a complete example program demonstrating how to define, initialize, and operate on a structure representing an "Item":

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

// Define the Product structure
struct Product {
    char name[30];   // Item Name
    int price;       // Price
    int quantity;    // Inventory Quantity
};

int main() {
    // Create and initialize two item objects
    struct Product p1 = {"Laptop", 5999, 10};
    struct Product p2 = {"Mouse", 150, 100};

    printf("Item 1: %s, Price: $%d, Inventory: %d\n", 
           p1.name, p1.price, p1.quantity);
    
    // Modify the price of p1
    p1.price = 6999;
    printf("Updated Item 1 Price: $%d\n", p1.price);

    return 0;
}

This program clearly demonstrates how structures help bundle related attributes together, making data operations more intuitive. By modifying the price of p1, we do not need to worry about the specific types of its individual members; instead, we handle the entire object like a single variable.

Summary and Best Practices

Structures are one of the powerful tools in C language, breaking down the limitations of traditional data types in terms of expressiveness. Mastering the definition, declaration, and access methods of structures is crucial for writing efficient, well-structured C programs. In practical applications, it is recommended to follow these best practices:

• Assign descriptive names to structures; avoid using generic prefixes like struct.
• Try to group related fields into the same structure to maintain data logical consistency.
• Use typedef to simplify type declarations and enhance code readability.
• Pay attention to assignment methods for array members during initialization, especially when handling string types.

By reasonably applying structures, developers can build more robust and scalable C language applications, laying a solid foundation for subsequent learning of pointers, memory management, and systems programming.