Grouping Data with Structs

1. What is a Struct?

So far, we've worked with individual primitive types (int, char, etc.) and arrays of those types. But what if you need to represent a more complex entity? For your music notation project, a single musical note has several related attributes: a pitch (like "C#4"), a duration (like 0.5 seconds), and a velocity (how hard the key was pressed).

An array isn't a good fit here because the data types are different (string, float, int). This is exactly where struct comes in. A struct (short for structure) is a user-defined data type that groups together variables of potentially different types under a single name.

The video below provides a great introduction to the basic syntax and usage.

As you saw, the dot operator (.) is the key to working with struct variables. You use it to "get inside" the structure and access its individual members, whether you're assigning a value to them or reading a value from them.

2. Initialization and typedef

Assigning values to each member one by one can be tedious. C provides more convenient ways to initialize a struct when you declare it. Furthermore, you might have noticed the struct student ... syntax is a bit verbose. There's a common C idiom to make this cleaner.

The next segment of the video covers these two important topics.

To summarize the initialization methods:

• Initializer List: Point p1 = {5, 10};
  • Values are assigned to members in the order they are defined in the struct.
  • Simple, but fragile. If you reorder members in the struct definition, you must update all your initializations.
• Designated Initializers (C99+): Point p2 = {.y = 8, .x = 2};
  • Explicitly names which member gets which value.
  • The order doesn't matter.
  • Highly recommended for clarity and robustness.

3. Under the Hood: Structure Padding

Your interest in how things work at a low level will make this next topic particularly relevant. Let's consider a simple struct:

struct Example {
    char a; // sizeof(char) is 1
    int  b; // sizeof(int) is 4
};

You might logically assume that sizeof(struct Example) would be 1 + 4 = 5 bytes. Let's test that.

#include <stdio.h>

struct Example {
    char a;
    int  b;
};

int main() {
    printf("Size of char: %zu\n", sizeof(char));
    printf("Size of int: %zu\n", sizeof(int));
    printf("Size of struct Example: %zu\n", sizeof(struct Example));
    return 0;
}

// Probable Output:
// Size of char: 1
// Size of int: 4
// Size of struct Example: 8

Why 8 bytes instead of 5? The answer is structure padding.

CPUs are most efficient when they read data from memory addresses that are multiples of their "word size" (e.g., multiples of 4 or 8). To ensure members are properly aligned for fast access, the compiler often inserts unused "padding" bytes into a struct.

This video gives an excellent visual explanation of why this happens and how you can influence it.

The key takeaway for practical purposes is this: As a general rule, define your struct members in descending order of size (e.g., double, int, short, char). This minimizes the need for padding and results in a more compact memory layout, which can be particularly important in memory-constrained environments like the embedded systems you're interested in.

For a comprehensive text reference on all the topics we've covered today—defining, initializing, typedef, and padding—the GeeksforGeeks article on C Structures (LINK) is an excellent resource to bookmark.

Practical Challenge

Let's apply these concepts to your graduation project. Your task is to define a struct that can represent a single musical note.

1. Define a struct named Note that contains the following members:
   • A character array to store the pitch (e.g., "C#4"). Let's give it a size of 4 to be safe.
   • A float for the duration in beats (e.g., 1.0 for a quarter note).
   • An int for the MIDI velocity (0-127).
2. Use typedef so you can declare variables as Note my_note;.
3. In your main function, declare a Note variable and initialize it using designated initializers.
4. Print out the members of your Note variable to confirm it was initialized correctly.

#include <stdio.h>

// 1 & 2: Define the struct and use typedef
typedef struct {
    char pitch[4];
    float duration;
    int velocity;
} Note;

int main() {
    // 3: Declare and initialize a Note variable using designated initializers
    Note note1 = {
        .pitch = "G5",
        .duration = 0.5,
        .velocity = 110
    };

    // 4: Print the members to verify
    printf("Musical Note:\n");
    printf("  Pitch: %s\n", note1.pitch);
    printf("  Duration: %.2f beats\n", note1.duration);
    printf("  Velocity: %d\n", note1.velocity);

    return 0;
}

Conclusion

In this lesson, you've learned how to create your own custom data types in C using struct. This is a fundamental tool for organizing complex data, making your code more readable, and laying the groundwork for advanced data structures.

Key Takeaways:

• struct is used to group related variables (members) of different types into a single unit.
• The dot operator (.) is used to access the members of a struct variable.
• Designated initializers (.member = value) are the safest and most readable way to initialize a struct.
• typedef is a common idiom used to create a simple alias for a struct type, cleaning up variable declarations.
• Structure padding is an optimization where the compiler adds bytes to a struct to align members in memory, improving performance at the cost of some space. Ordering members by size can minimize this.

In our next lesson, we will see how these new data types interact with functions. We'll explore what it means to pass structs to functions by value and by reference (using pointers), a topic that will tie together everything you've learned about pointers, memory, and now, data structures.