C Fundamentals

Structures

Structures are an important data type in C that allow you to group related data elements together, making your code more organized and easier to work with.

Creating and Using Structures

In C, a structure is defined using the struct keyword, followed by the name of the structure and a block of code enclosed in curly braces {}. Each element within the structure is called a member, and it can be of any valid data type, including other structures, arrays, or pointers.

Here's an example of how to define a structure:

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

In this example, we've defined a Person structure with three members: name (a character array), age (an integer), and height (a floating-point number).

To use a structure, you need to create a variable of the structure type. This is done by using the struct keyword followed by the structure name, and then the variable name:

struct Person person1;

Now, you can access the members of the structure using the dot (.) operator:

person1.name = "John Doe";
person1.age = 35;
person1.height = 1.75;

Structures and Arrays

Structures can also be used in conjunction with arrays. This is useful when you need to store a collection of similar data, such as a list of people or a set of measurements.

Here's an example of an array of Person structures:

struct Person people[5];

In this case, people is an array of 5 Person structures. You can access the members of each structure in the array using the array index and the dot operator:

people[0].name = "John Doe";
people[0].age = 35;
people[0].height = 1.75;

people[1].name = "Jane Smith";
people[1].age = 28;
people[1].height = 1.65;

Nested Structures

Structures can also contain other structures as members. This is known as a nested structure. This can be useful when you need to represent more complex data relationships.

For example, let's say we have a Address structure that contains information about a person's address, and we want to include this information in our Person structure:

struct Address {
    char street[50];
    char city[50];
    char state[50];
    int zipcode;
};

struct Person {
    char name[50];
    int age;
    float height;
    struct Address address;
};

Now, when we create a Person variable, we can access the address information using the dot operator:

struct Person person1;
person1.name = "John Doe";
person1.age = 35;
person1.height = 1.75;
person1.address.street = "123 Main St";
person1.address.city = "Anytown";
person1.address.state = "CA";
person1.address.zipcode = 12345;

Structures and Pointers

Structures can also be used with pointers. This can be useful when you want to pass a structure to a function or when you need to dynamically allocate memory for a structure.

To declare a pointer to a structure, you use the struct keyword followed by the structure name, and then the pointer variable name:

struct Person *personPtr;

You can then use the pointer to access the members of the structure using the arrow (->) operator:

personPtr = &person1;
printf("Name: %s\n", personPtr->name);
printf("Age: %d\n", personPtr->age);
printf("Height: %.2f\n", personPtr->height);

Structures and Functions

Structures can be passed to and returned from functions, just like any other data type. This can be useful when you need to perform operations on a collection of related data.

Here's an example of a function that takes a Person structure as an argument and prints its information:

void printPersonInfo(struct Person person) {
    printf("Name: %s\n", person.name);
    printf("Age: %d\n", person.age);
    printf("Height: %.2f\n", person.height);
}

int main() {
    struct Person person1 = {"John Doe", 35, 1.75};
    printPersonInfo(person1);
    return 0;
}

In this example, the printPersonInfo function takes a Person structure as an argument and prints its members. In the main function, we create a Person structure and pass it to the printPersonInfo function.