Accessing Structs in C

In C programming, when we need to combine data of various types (such as integers, floating-point numbers, characters, etc.) into a cohesive whole with a specific meaning, the struct is an indispensable tool. It allows developers to define custom data types, thereby expressing the logical relationships between data structures more clearly. For example, in a student information system, a student's name might be of string type, age as an integer, and grade as a double-precision floating-point type. By defining a struct, we can encapsulate these scattered data into a unified entity, significantly enhancing code readability and maintainability.
The core of declaring and using structs in C lies in using the struct keyword combined with curly braces {} to wrap member variables. The compiler arranges these heterogeneous members sequentially in memory space according to their order of definition. This compact storage method makes it possible to access individual elements via pointers, while also implying that alignment rules for different data types affect the final memory occupancy size.

#include <stdio.h>

// Define a struct type named Student
struct Student {
    char name[20]; // Name: string array
    int age;       // Age: integer
    float score;   // Score: floating-point number
};

int main() {
    return 0;
}

In the above code, name, age, and score are defined as members of the struct. It is worth noting that while we logically consider them belonging to the same object, at the memory level, they are contiguous sequences of bytes. Understanding this point is crucial for performance optimization or low-level development.

Direct Access: Using the Dot Operator (.) and Square Brackets []

Once a struct variable is defined and data is initialized, the most direct and common method to retrieve member values is by utilizing the dot operator (.) in conjunction with the variable name. This approach applies to all defined struct instances, regardless of whether the instance was created via ordinary declaration or through a pointer.

Accessing Members by Reference

When we directly create a struct variable on the stack, we can modify or read its internal data as follows:

struct Student s1; // Uninitialized local variable

// Assume we have assigned certain values to s1, now perform output operations
printf("Name: %s\n", s1.name); 
printf("Age: %d\n", s1.age);
printf("Grade: %f\n", s1.score);

Here, the . operator signifies "retrieve this member from the current object". If a struct contains multiple fields with the same name, square brackets ([]) must be used in conjunction with an index to distinguish them. This is particularly common when handling two-dimensional arrays or complex structures with attributes of the same name:

struct Point {
    int x;
    int y;
};

// Define two point objects whose member names are both x and y
struct Point p1 = { .x = 10, .y = 20 }; // C99 standard supports initialization list shorthand
struct Point p2 = { .x = 30, .y = 40 };

// Access same-name members using square brackets to avoid ambiguity
printf("p1.x: %d\n", p1.x); 

Indirect Access: Accessing Struct Members via Pointer Operations

In addition to direct reference to variables, C provides a powerful pointer mechanism to access struct contents. This approach offers significant advantages when handling large data structures or when passing complex data between functions, as it avoids unnecessary memory copy overhead (i.e., the cost of "value passing" copies).

Using the Arrow Operator (->) and Star Dereference

When we possess a pointer variable p pointing to a struct variable, accessing its members requires the arrow operator (->). This operator is essentially a combination of two operations: first finding the target address via the pointer, then retrieving the value in memory via the dot operator. In contrast, using square brackets with an index to distinguish same-name fields remains valid, but this is typically used for more complex nested scenarios or specific language feature support.

struct Student s2; // Define struct variable without assignment
s2.name[0] = 'A'; 
// ... (other initialization operations)

// Create a pointer to this variable
struct Student *pStudent = &s2; 

// Access members using the arrow operator (recommended method)
printf("Accessing name via pointer: %s\n", pStudent->name);

If the struct contains arrays or dynamically allocated memory, this indirect access mechanism also applies. For instance, if a struct contains a pointer to another struct, we can recursively apply the above rules to traverse the entire data tree in depth:

struct Address {
    char city[50];
};

struct Person {
    struct Name name; // Name struct (containing first, last)
    int age;
    struct Address address;
};

// ... (definition and initialization)

struct Person *personPtr = &myPerson;
printf("City: %s\n", personPtr->address.city); 

Practical Application: Encapsulation and Function Parameter Passing

A typical scenario for using structs in actual programming logic is passing data between functions. Compared to passing multiple variables as individual parameters, directly passing a struct pointer can simplify interface design and improve execution efficiency. Furthermore, combining this with pointers modified by the const keyword can implement a read-only access protection mechanism, preventing callers from accidentally modifying internal state.

// Define function prototype for outputting information
void printStudentInfo(struct Student *s); 

int main() {
    struct Student s; 
    // ... (initialize data) 
    
    // Pass struct address to function
    printStudentInfo(&s);
    
    return 0;
}

// Implement function logic using const to prevent modification of original data
void printStudentInfo(const struct Student *s) {
    printf("Student Information:\n");
    printf("- Name: %s\n", s->name); 
    printf("- Age: %d\n", s->age);
}

Through this method, we not only achieve modular encapsulation of data but also ensure the safety of function calls. This pattern is widely present in the design of modern C applications, especially in scenarios requiring frequent interaction with complex data structures such as network protocol parsing, file I/O operations, and graphical interface rendering.