Structure and Union

By Notes Vandar

Structure and Union

A structure (also known as a struct) is a user-defined data type that groups variables of different data types under a single name. Each variable in the structure is called a member of the structure.

6.1 Concept of Structure

A structure (also known as a struct) is a user-defined data type that groups variables of different data types under a single name. Each variable in the structure is called a member of the structure.

Syntax of Structure

struct structure_name {
data_type member1;
data_type member2;
…
};

Example: Structure Declaration and Usage

#include <stdio.h>

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

int main() {
struct Person person1;

// Assigning values to members
strcpy(person1.name, “John”);
person1.age = 25;
person1.height = 5.9;

// Accessing and printing members
printf(“Name: %s\n”, person1.name);
printf(“Age: %d\n”, person1.age);
printf(“Height: %.2f\n”, person1.height);

return 0;
}

Accessing Structure Members

  • Use the dot operator (.) to access the members of a structure.
  • You can also use a pointer to a structure and access members using the arrow operator (->).

Example with Pointers:

#include <stdio.h>

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

int main() {
struct Person person1 = {“Alice”, 30};
struct Person *ptr = &person1;

// Accessing structure members using pointers
printf(“Name: %s\n”, ptr->name);
printf(“Age: %d\n”, ptr->age);

return 0;
}

Advantages of Structures

  • Group different data types together under a single name.
  • Can be used to create more complex data types such as linked lists, trees, and graphs.

6.2 Initializing, accessing member of structure

Once a structure is defined in C, you can create variables of that structure type. After creating these structure variables, you can initialize and access their members to work with them.

1. Initializing Structure Members

You can initialize structure members in two main ways:

a. Default Initialization After Declaration

This approach allows you to initialize the structure members after declaring the structure variable.

Example:

#include <stdio.h>

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

int main() {
struct Person person1;

// Initializing structure members
strcpy(person1.name, “Alice”); // Assign a string to ‘name’
person1.age = 25; // Assign an integer to ‘age’
person1.height = 5.6; // Assign a float to ‘height’

return 0;
}

  • In the above example, the structure Person is declared, and then each member (name, age, and height) is assigned a value separately.

b. Initialization During Declaration

You can also initialize a structure at the time of declaration.

Example:

#include <stdio.h>

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

int main() {
// Initializing members while declaring the structure variable
struct Person person1 = {“Alice”, 25, 5.6};

return 0;
}

  • In this case, the structure person1 is initialized when it is declared. Each member (name, age, and height) is given a value right away.

c. Partial Initialization

If you do not provide values for all members during initialization, the remaining members are automatically initialized to zero (for numeric types) or an empty value (for arrays).

Example:

struct Person person1 = {“Alice”}; // ‘age’ and ‘height’ will be set to 0

2. Accessing Members of a Structure

After initializing a structure, you can access its members using the dot operator (.). The dot operator is used to access the members of a structure variable.

Example: Accessing Structure Members

#include <stdio.h>

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

int main() {
struct Person person1 = {“Alice”, 25, 5.6};

// Accessing and printing structure members
printf(“Name: %s\n”, person1.name);
printf(“Age: %d\n”, person1.age);
printf(“Height: %.2f\n”, person1.height);

return 0;
}

Accessing Structure Members with Pointers

When you have a pointer to a structure, you can access its members using the arrow operator (->).

Example:

#include <stdio.h>

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

int main() {
struct Person person1 = {“Alice”, 25, 5.6};
struct Person *ptr = &person1; // Pointer to structure

// Accessing structure members using pointer
printf(“Name: %s\n”, ptr->name);
printf(“Age: %d\n”, ptr->age);
printf(“Height: %.2f\n”, ptr->height);

return 0;
}

  • Here, ptr->name is equivalent to (*ptr).name. The arrow operator simplifies the syntax when working with pointers to structures.

3. Example: Combining Initialization and Accessing

#include <stdio.h>

struct Book {
char title[100];
char author[50];
int pages;
float price;
};

int main() {
// Initializing the structure ‘book1’
struct Book book1 = {“C Programming”, “Dennis Ritchie”, 300, 29.99};

// Accessing and displaying the values of ‘book1’
printf(“Title: %s\n”, book1.title);
printf(“Author: %s\n”, book1.author);
printf(“Pages: %d\n”, book1.pages);
printf(“Price: $%.2f\n”, book1.price);

return 0;
}

In this example, the structure Book is used to represent the properties of a book, and the members are initialized during declaration. The values are then accessed using the dot operator and displayed.

 

6.3 Array of structure

An array of structures is essentially an array where each element is a structure. This allows you to store multiple records of data, each containing several fields. Arrays of structures are useful when you need to work with multiple instances of structured data, such as storing information about several people, books, students, or any other entities

1. Declaration of Array of Structures

The syntax for declaring an array of structures is similar to that of arrays, except the data type is a structure.

Syntax

struct structure_name {
data_type member1;
data_type member2;
…
};

struct structure_name array_name[size];

  • structure_name: The name of the structure you have defined.
  • array_name: The name of the array of structures.
  • size: The number of elements in the array.

Example: Declaring an Array of Structures

#include <stdio.h>

// Define a structure ‘Person’
struct Person {
char name[50];
int age;
float height;
};

int main() {
// Declare an array of structures of size 3
struct Person people[3];

return 0;
}

In this example, people is an array of 3 Person structures, where each element of the array can store data for one person.

2. Initializing an Array of Structures

Just like normal arrays, you can initialize an array of structures in two ways: by initializing members individually or by initializing the entire array at once.

a. Initializing Members Individually

You can initialize each structure in the array individually by accessing each member with the dot operator.

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

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

int main() {
struct Person people[3];

// Initializing the first person
strcpy(people[0].name, “Alice”);
people[0].age = 30;
people[0].height = 5.5;

// Initializing the second person
strcpy(people[1].name, “Bob”);
people[1].age = 25;
people[1].height = 6.0;

// Initializing the third person
strcpy(people[2].name, “Charlie”);
people[2].age = 28;
people[2].height = 5.9;

return 0;
}

b. Initializing the Array of Structures at Declaration

You can initialize the array of structures at the time of declaration as well:

#include <stdio.h>

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

int main() {
// Declare and initialize an array of structures
struct Person people[3] = {
{“Alice”, 30, 5.5},
{“Bob”, 25, 6.0},
{“Charlie”, 28, 5.9}
};

return 0;
}

3. Accessing Members of an Array of Structures

To access the members of a specific structure in the array, use the array index and the dot operator (.).

Example: Accessing and Displaying Structure Members

#include <stdio.h>

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

int main() {
struct Person people[3] = {
{“Alice”, 30, 5.5},
{“Bob”, 25, 6.0},
{“Charlie”, 28, 5.9}
};

// Access and display the details of the first person
printf(“Person 1: \n”);
printf(“Name: %s\n”, people[0].name);
printf(“Age: %d\n”, people[0].age);
printf(“Height: %.2f\n\n”, people[0].height);

// Access and display the details of the second person
printf(“Person 2: \n”);
printf(“Name: %s\n”, people[1].name);
printf(“Age: %d\n”, people[1].age);
printf(“Height: %.2f\n\n”, people[1].height);

return 0;
}

Output:

Person 1:
Name: Alice
Age: 30
Height: 5.50

Person 2:
Name: Bob
Age: 25
Height: 6.00

Using Loops to Access Array of Structures

You can use loops to iterate through the array of structures and access each structure’s members.

#include <stdio.h>

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

int main() {
struct Person people[3] = {
{“Alice”, 30, 5.5},
{“Bob”, 25, 6.0},
{“Charlie”, 28, 5.9}
};

// Loop through the array of structures and print the details
for (int i = 0; i < 3; i++) {
printf(“Person %d: \n”, i + 1);
printf(“Name: %s\n”, people[i].name);
printf(“Age: %d\n”, people[i].age);
printf(“Height: %.2f\n\n”, people[i].height);
}

return 0;
}

Output:

Person 1:
Name: Alice
Age: 30
Height: 5.50

Person 2:
Name: Bob
Age: 25
Height: 6.00

Person 3:
Name: Charlie
Age: 28
Height: 5.90

4. Advantages of Array of Structures

  • Efficient Data Storage: It allows you to store multiple records (each a structure) in a contiguous block of memory.
  • Easier to Manage: Array of structures makes it easier to manage multiple sets of related data.
  • Combined Power: Combines the power of arrays and structures to handle structured data in bulk, such as a list of students, employees, or products.

6.4 Pointer to structure

If you have defined a derived data type using the keyword struct, then you can declare a variable of this type. Hence, you can also declare a pointer variable to store its address. A pointer to struct is thus a variable that refers to a struct variable. In C, a pointer to a structure is used to hold the address of a structure. This allows you to manipulate the structure without copying the entire structure’s contents. Here’s a basic example of how you can use pointers to structures in C:

Defining a structure:

#include <stdio.h>

// Define a structure called Person
struct Person {
char name[50];
int age;
float height;
};

Using a pointer to a structure:

int main() {
// Declare and initialize a structure
struct Person person1 = {“John Doe”, 30, 5.9};

// Declare a pointer to the structure
struct Person *ptr;

// Assign the address of person1 to the pointer
ptr = &person1;

// Access and modify structure members using the pointer
printf(“Name: %s\n”, ptr->name);
printf(“Age: %d\n”, ptr->age);
printf(“Height: %.1f\n”, ptr->height);

// Modifying structure members through the pointer
ptr->age = 31;
printf(“Updated Age: %d\n”, ptr->age);

return 0;
}

  • struct Person *ptr;: Declares a pointer to a structure of type Person.
  • ptr = &person1;: Assigns the address of person1 to the pointer ptr.
  • ptr->name, ptr->age, ptr->height: Accesses the members of the structure using the pointer. The -> operator is used to dereference the pointer and access the structure members.

In C, a union is a user-defined data type similar to a struct, but with a key difference: all members of a union share the same memory location. This means that at any given time, a union can hold a value for only one of its members, as they overlap in memory.

Defining and Using a Union:

Here’s an example that demonstrates the basic syntax and usage of a union in C:

Union Definition:

#include <stdio.h>

// Define a union called Data
union Data {
int i;
float f;
char str[20];
};

int main() {
// Declare a union variable
union Data data;

// Assigning values to union members one at a time
data.i = 10;
printf(“data.i: %d\n”, data.i);

data.f = 220.5;
printf(“data.f: %.2f\n”, data.f);

// Note that assigning a new value overwrites the previous value
printf(“After assigning float, data.i: %d\n”, data.i); // Undefined behavior

// Assigning a string to the union
strcpy(data.str, “C Programming”);
printf(“data.str: %s\n”, data.str);

// Again, accessing the integer value now will not be correct
printf(“After assigning string, data.i: %d\n”, data.i); // Undefined behavior

return 0;
}

Explanation:

  • Shared Memory: The members of a union share the same memory. In the above example, data.i, data.f, and data.str all use the same memory location. Therefore, assigning a value to one member will overwrite the value of the other members.
  • Overwriting: When you assign a value to data.f, it overwrites the value in data.i, and similarly, assigning a value to data.str overwrites both the integer and float values.

Memory Size:

The size of a union is determined by the size of its largest member, as all members share the same memory.

Example of memory sharing:

printf(“Size of union Data: %lu bytes\n”, sizeof(data));

If int is 4 bytes, float is 4 bytes, and the string is 20 bytes, the size of the union will be 20 bytes, which is the size of its largest member (char str[20]).

When to use a union:

Unions are useful when you need to handle multiple types of data but only need to store one type at a time. For instance:

  • Efficient memory usage when dealing with multiple data types in a variable.
  • Implementing a variable that can change type during program execution.

6.6 Different between union and structure

In C, both union and struct are user-defined data types that group different types of variables under a single name. However, they differ significantly in how they manage memory and how their members are accessed. Here are the main differences between a union and a struct:

1. Memory Allocation

  • Structure (struct):
    • All members of a struct have their own separate memory locations. This means that the total size of a struct is the sum of the sizes of all its members, plus any padding added for alignment.
    • Example:

      struct Example {
      int i; // 4 bytes
      float f; // 4 bytes
      char str[10]; // 10 bytes
      };

      // Size of struct Example = 4 + 4 + 10 = 18 bytes (plus padding)

  • Union (union):
    • All members of a union share the same memory location. Therefore, the size of a union is equal to the size of its largest member.
    • Example:

      union Example {
      int i; // 4 bytes
      float f; // 4 bytes
      char str[10]; // 10 bytes
      };

      // Size of union Example = max(4, 4, 10) = 10 bytes

2. Member Access

  • Structure (struct):
    • You can access all members of a struct at any time. Each member retains its own value, and updating one member does not affect the others.
    • Example:
      struct Example ex;
      ex.i = 10;
      ex.f = 20.5;
      strcpy(ex.str, “Hello”);
  • Union (union):
    • Only one member of a union can hold a value at any time. Assigning a new value to one member will overwrite the value of the other members.
    • Example:
      union Example ex;
      ex.i = 10;
      ex.f = 20.5; // This will overwrite ex.i
      strcpy(ex.str, “Hello”); // This will overwrite ex.f
      3. Use Cases
  • Structure (struct):
    • Useful when you need to group related variables together, and you want to access all these variables simultaneously.
    • Commonly used to represent complex data entities like records in databases, objects in object-oriented programming, etc.
  • Union (union):
    • Useful when you need to store different types of data in the same memory location but only one type at a time. This can save memory in cases where you have multiple alternative data formats.
    • Commonly used in situations where a variable could be one of several types but only one type is used at a time (e.g., parsing different types of data).

 

Previous Chapter Next Chapter
Important Questions
Comments
Discussion
0 Comments
  Loading . . .