struct declaration

Why This Matters

Structures (or structs) are a way to create custom data types in C that can group together related variables of different types. This lesson will explain how to declare and use structures, as well as common mistakes to avoid when working with them.

Why This Matters

Understanding how to work with structures is essential for writing efficient and organized code in C. Structures allow you to create complex data structures that are easier to manage and understand than individual variables. They are particularly useful when dealing with data that needs to be accessed together, such as records in a database or points in a graph.

Prerequisites

Before diving into structs, it's important to have a good understanding of the following C concepts:

• Variables and their basic types (int, float, char)
• Arrays
• Pointers
• Functions

Core Concept

Declaring a Struct

To create a new structure, you first need to define its layout by listing the variables it will contain. Each variable is followed by its data type and a semicolon (;). The entire list of variables is enclosed in curly braces {}. Here's an example of a simple struct called Point that contains two fields: x and y:

struct Point {
int x;
int y;
};

Once the structure is defined, you can create variables of that type by using the keyword struct followed by the structure name. For example:

struct Point p1; // Declaring a variable of type struct Point

Accessing Struct Fields

To access the fields of a struct variable, you use the dot (.) operator followed by the field name. For instance, to set the x value of p1, you would write:

p1.x = 3; // Setting the x field of p1 to 3

Similarly, to print the values of both fields of p1, you can use a loop and the printf() function like this:

printf("p1.x = %d\n", p1.x);
printf("p1.y = %d\n", p1.y);

Initializing Struct Variables

You can also initialize a struct variable when you declare it, by listing the initial values for each field separated by commas and enclosed in curly braces:

struct Point p2 = { 5, 7 }; // Declaring and initializing a new Point with x=5 and y=7

Passing Structs to Functions

Structures can be passed as arguments to functions just like any other data type. Inside the function, you can access the fields of the struct using the dot operator. Here's an example of a function that takes a Point and prints its coordinates:

void print_point(struct Point point) {
printf("x = %d\n", point.x);
printf("y = %d\n", point.y);
}

int main() {
struct Point p3 = { 1, 2 };
print_point(p3); // Calling the function with p3 as an argument
return 0;
}

Worked Example

Let's create a simple program that declares a Student struct containing fields for name, age, and grade point average (GPA), initializes some student data, and prints it out:

#include <stdio.h>

struct Student {
char name[50];
int age;
float gpa;
};

void print_student(struct Student student) {
printf("Name: %s\n", student.name);
printf("Age: %d\n", student.age);
printf("GPA: %.2f\n", student.gpa);
}

int main() {
struct Student s1 = { "John Doe", 20, 3.5 }; // Initializing a new Student with name="John Doe", age=20, and gpa=3.5
print_student(s1); // Printing the student data

struct Student s2;
strcpy(s2.name, "Jane Smith");
s2.age = 22;
s2.gpa = 3.8;
print_student(s2); // Printing another student's data

return 0;
}

Common Mistakes

1. Forgetting the semicolon (;) after the last field in a struct definition. This will cause a syntax error when you try to compile your code.
2. Accessing non-existent fields in a struct. Make sure you know the names and types of all fields in your structs before accessing them.
3. Initializing only some fields in a struct variable. If you initialize only some fields, the remaining ones will be set to default values (0 for integers, 0.0 for floats).
4. Not including the necessary header files. Make sure you include the correct header files (like stdio.h) when working with functions like printf().
5. Forgetting to pass structs by reference. When passing a struct as an argument to a function, make sure to use the address-of operator (&) if you want the function to modify the original variable.

Practice Questions

1. Define a struct called Rectangle that contains fields for width and height. Write a function called area() that calculates and returns the area of a rectangle given its dimensions.
2. Create a struct called Person with fields for name, age, and salary. Write a function called print_person() that prints the details of a person using their Person struct variable.
3. Write a program that declares an array of 5 Student structs, initializes them with some data, and prints out each student's information.

FAQ

1. Why can't I access struct fields without the dot operator? In C, when you declare a struct variable, the compiler creates a new data type that includes all of the fields defined in the struct. The dot operator is used to access the individual fields of this custom data type.
2. Can I use pointers with structs? Yes! Pointers can be used with structs just like any other data type. This allows you to create arrays of structs, pass structs as arguments to functions by reference, and more.
3. What happens if I try to access a field that doesn't exist in my struct? If you try to access a non-existent field in your struct, the behavior is undefined and can lead to unexpected results or errors. Always make sure you know the names and types of all fields in your structs before accessing them.
4. Can I have two structs with the same name? No! In C, a struct must have a unique tag (the name between the curly braces {}). If you try to declare two structs with the same tag, you will get a syntax error.