Lesson 09: Structures

A structure in C/C++, defined using the struct keyword, is a user-defined aggregate data type comprising a collection of data members, which can vary in type. Unlike arrays, where all elements must be the same type, the data members in a structure can include a mix of types like int, float, char, or even another struct. This flexibility allows for a more diverse and complex data organization within a single structure.

Motivation for Structures

In programming, we often encounter situations where we need to manage data about various entities or objects. This data can consist of elements of different data types, such as strings, integers, and floating-point numbers. For instance, consider the information associated with a student, which might include name, address, phone number, number of courses taken, fees payable, student ID, and grades obtained.

Traditional Approach Using Arrays

A conventional approach to handling such data is to employ separate arrays for each field and connect them through indices. For example, name[i], address[i], fees[i], and so on would represent the data for the i_th student.

Drawbacks of the Array-Based Approach

While this method is straightforward, it becomes cumbersome and unwieldy as the number of fields increases. For instance, passing a student's data to a function using the parameter list would involve passing multiple arrays. Additionally, when sorting the data based on the name field, modifying the data in other arrays would be necessary when exchanging two names.

Introduction of Structures in C/C++

To address these limitations, C and C++ provide structures, which are user-defined data types that enable the grouping of related data items of different types into a single unit. This approach offers several advantages:

• Organized Data Representation: Structures provide a more organized and structured representation of data, making it easier to manage and understand.
• Efficient Memory Usage: Structures allow efficient memory allocation by storing related data items in contiguous locations.
• Simplified Data Manipulation: Structures simplify data manipulation by enabling the access and modification of multiple related data items using a single name.

Example: Student Structure

Consider the following example of a structure representing a student:

struct Student {
string name;
string address;
string phoneNumber;
int numberOfCoursesTaken;
float feesPayable;
string studentID;
char grades[6];
};

This structure defines a data type named 'Student' that encapsulates the relevant information about a student. To access the individual data elements, we can use the dot operator (.) followed by the member name. For instance, student.name would access the student's name.

Advantages of Structures

The use of structures offers several advantages over the traditional array-based approach:

• Improved Code Readability: Structures enhance code readability by grouping related data items together, making it easier to understand the program's structure.
• Reduced Code Complexity: Structures reduce code complexity by eliminating the need to manage multiple arrays and their corresponding indices.
• Enhanced Data Encapsulation: Structures promote data encapsulation by encapsulating related data items within a single unit, restricting direct access to individual members, and promoting controlled access through defined methods.

Structures are a powerful tool in C and C++ for organizing, managing, and manipulating data related to various entities or objects. They offer a more structured, efficient, and maintainable approach compared to the traditional array-based method. By utilizing structures, programmers can create more readable, maintainable, and efficient code.

In C++, a structure can contain both functions and data members. The detailed structure in C++ will be discussed in C++ Lesson 02: Classes and Objects.

The format of the struct statement is as follows:

struct structure_name {
type member1;
type member2;
...
} variable_list;

Declare Structure and Structure Variables

A structure variable can either be declared with a structure declaration or a separate declaration like how we declare a variable.

Structure declaration

struct Point {              // Structure Declaration
    int     x;
    int     y;
};

The above statement defines a new data type (struct Point) that can be used in declaring other variables as below:

struct Point p1, p2, p3;

A variable declaration with a structure declaration.

struct Point {              // Structure Declaration
    int     x;
    int     y;
} p1;                       // Define Structure Variable

The above definition actually tells the C compiler two things:

1. The first one is the structure of a "struct Point", which can be used to declare another structure variable.
2. This statement also declares the variable p1ent.

Since the structure of "struct Point" has been defined, it can be used to declare additional variables:

struct Point p2, p3;

Use of typedef in a structure to shorten the names

We can also use typedef to construct shorter or more meaningful names for structures. The following code shows a new data type named Point, which is synonymous with "struct Point":

typedef struct Point {      // Structure Point Declaration
    int     x;
    int     y;
} Point;                    // Data Type Point

We can now declare "structure variables" of type Point, such as the following:

Point p1, p2, p3; // Define Structure Variables

Notice how much shorter and neater this is compared to the following:

struct Point p1, p2, p3; // Define Structure Variables

Since there is hardly any reason to use the "struct Point" form, we could omit Point from the previous declaration and write this:

typedef struct {            // Structure Datatype Declaration
    int     x;
    int     y;
} Point;                    // Data Type Name

Structure in Memory

Consider the following statements:

typedef struct {            // Structure Datatype Declaration
    int     x;
    int     y;
} Point;                    // Datatype Name

Point   p1;                 // Define Structure Variable

When a structure variable, p1, is declared, the definition reserves enough memory space to hold all the members of p1 — namely x and y. In this case, there will be 4 bytes for each of the two ints. Figure 9.1 shows how p1, p2, and p3 look in memory.

Figure 9.1: Structure Members in Memory

typedef struct{
   int heightInches;
   int weightPounds;
} PatientData;

typedef struct {           // Structure Declaration
    int     year;
    int     month;
    int     day;
} Date;

There are two types of operators used for accessing members of a structure:

• Dot Operator . — Directly accessing the structure members of a structure variable
• Indirection Operator * — Indirectly accessing structure members through a structure pointer
• Arrow Operator -> — Indirectly accessing structure members through a structure pointer

typedef struct {            // Structure Declaration
    int     x;
    int     y;
} Point;                        // Data Type: Parts

int main(){
    Point  p1, p2, p3;          // Structure Variables: p1, p2, and p3

    p2.x = 12;
    p2.y = 25;
    ...
}

cout << "x vale of p2 = " << p2.x << endl;
printf("y value of p2 = %d \n", p2.y);

typedef struct Point {      // Structure Datatype Declaration
    int     x;
    int     y;
    int     z;
} Point;                    // Datatype Name

Point   p1;                 // Define Structure Variable
Point   *ptr;               // Define Structure Pointer

ptr      = &p1;
p1.x     = 10;
(*ptr).y = 20;
ptr->z   = 30;

Structure Initialization in C/C++

Structures in C serve as a crucial data type that allows you to group related data items of different data types into a single unit. This facilitates a more organized and flexible way to represent complex data relationships. Initializing structures is an essential step in creating and utilizing structure variables.

struct Employee {
    char    name[50];
    int     age;
    float   salary;
};

struct Employee {
    string  name[50];
    int     age;
    float   salary;
};

struct Employee employee1;

strcpy(employee1.name, "John Smith");
employee1.age = 35;
employee1.salary = 50000.00;

struct Employee employee1;

employee1.name = "John Smith";
employee1.age = 35;
employee1.salary = 50000.00;

struct Employee {
    char    name[50];
    int     age;
    float   salary;
};

struct Employee employee2 = {"John Smith", 35, 50000.00};

struct Employee {
    char    name[50];
    int     age;
    float   salary;
};

struct Employee employee3 = {
    .name   = "Jane Doe",
    .age    = 32,
    .salary = 60000.00

};

struct Employee {
    char    name[50];
    int     age;
    float   salary;
};

struct Employee employee4 = (struct Employee){
    .salary = 60000.00,
    .name   = "Jane Doe",
    .age    = 32
};

struct Employee {
    char    name[50];
    int     age;
    float   salary;
};

struct Employee employee5 = {
    "Jane Doe",
    32,
    60000.00
};

struct Employee {
    char    name[50];
    int     age;
    float   salary;
};

struct Employee employee6 = {};

Initializing structures is an essential aspect of effectively using them in C/C++ programming. Understanding the different initialization methods, including individual assignments, initializer lists, designated initializers, and compound literals, provides flexibility and control in assigning initial values to structure members.

What Is a Bit-Field

• A bit-field allows you to define structure (or union/class) members that occupy a specified number of bits, rather than the full width of the type.
• Declaration syntax:

  type-specifier identifier : width;

  e.g., unsigned int flag : 1; defines flag as a 1-bit wide field.
• In ANSI C, the type-specifier is typically int or unsigned int; in C++ and specific compilers, other integral types (char, short, long, __int64) may be allowed.
• Bit-fields are useful for memory-efficient flags or mapping hardware registers, but they introduce portability issues (bit order, padding, alignment) and may generate less efficient code.

Syntax & Declaration Rules

• The width must be a constant integer expression.
• In C, the bit‐field type specifier is limited to int/unsigned int; in C++ more types are allowed.
• If a bit‐field is declared without an identifier (anonymous bit‐field), the bits are allocated but cannot be accessed by name — useful for padding or reserved bits.
• A zero‐width bit‐field forces allocation to the next underlying storage unit’s boundary.
• You cannot take the address of a bit‐field member (e.g., &mystruct.x is invalid when x is a bit‐field) because the compiler cannot guarantee it lies on a byte boundary.

Advantages & Limitations

Advantages

• Fine‐grained control of bit‐level fields in structures, saving memory and improving readability for flag fields or hardware registers.
• Access via named members instead of manual bit masks and shifts.

Limitations / Warnings

• The layout of bit‐fields — which bit comes first, packing across storage units, alignment, padding — is implementation‐defined or undefined. Therefore, portability is limited.
• Bit‐fields may lead to less optimal code compared to explicit mask/shift operations.
• You cannot take the address of a bit‐field member, and there are limitations on allowable types and widths.
• For mapping hardware registers (especially volatile registers with strict layout), careful verification of layout and padding is required.

Bit Fields allow the packing of data in a structure. This is especially useful when memory or data storage is at a premium. Typical examples include −

• Packing several objects into a machine word, e.g., 1-bit flags, can be compacted.
• Reading external file formats -- non-standard file formats could be read in, e.g., 9-bit integers.

C allows us to do this in a structure definition by putting: bit length after the variable. For example −

#include stdint.h

/* Assume a hardware control register with the following bit layout:
   Bit 0:     enable (1 = enable, 0 = disable)
   Bits 1–3:  mode (0–7)
   Bit 4:     error flag
   Bits 5–7:  reserved
   Bits 8–15: data field
*/

typedef struct {
    unsigned int enable : 1;    // bit 0
    unsigned int mode   : 3;    // bits 1–3
    unsigned int error  : 1;    // bit 4
    unsigned int        : 3;    // bits 5–7, unnamed padding
    unsigned int data   : 8;    // bits 8–15
} packet_struct;

Here, the packed_struct contains 5 members: Two 1-bit flags (enable and error), one 3-bit mode, one 3-bit unnamed, and an 8-bit data.

C automatically packs the above bit fields as compactly as possible, provided that the field's maximum length is less than or equal to the integer word length of the computer. If this is not the case, then some compilers may allow memory overlap for the fields, while others would store the next field in the next word.

Best Practice Notes

• Always use an unsigned type (e.g., unsigned int, uint8_t) for bit-fields, unless you explicitly need signed behavior.
• Use anonymous (unnamed) bit-fields to skip unused or reserved bits.
• A zero-width bit-field (e.g., unsigned int : 0;) forces the next field to start on a new storage boundary—helpful for register alignment.
• When mapping hardware registers (especially with volatile), verify how your compiler arranges bit order, packing, and alignment. Never assume layout consistency across compilers.
• If the exact bit layout must match hardware, it is often safer to use explicit bit masks and shifts rather than bit-fields. For example:

  #define ENABLE_MASK (1u << 0)
  #define MODE_MASK   (0x7u << 1)
  #define ERROR_MASK  (1u << 4)
  

  Using masks provides complete control and avoids compiler-specific alignment issues.

#include <stdio.h>

struct Example {
    unsigned int a : 3;
    unsigned int b : 3;
    unsigned int c : 2;
};

int main()
{
    struct Example e = {1, 2, 3};

    unsigned int *p = (unsigned int*) &e;
    printf("Raw value = 0x%08X\n", *p);

    return 0;
}

a = 001 (bit 2..0)
b = 010 (bit 5..3)
c = 11  (bit 7..6)

#include <iostream>
#include <iomanip>
#include <cstdint> // For uint16_t, uint8_t

using namespace std;

// 1. Define the bit-field struct we want to test.
// Let's pack 16 bits into three fields: 4, 8, and 4 bits.
struct MyBitFields {
    // We use uint16_t as the base type.
    // The compiler will pack these into a 16-bit unit.
    uint16_t field_a : 4;  // First field
    uint16_t field_b : 8;  // Second field
    uint16_t field_c : 4;  // Third field
};

// 2. Define a union to inspect the memory.
// This union will let us access the same 16 bits of memory as:
//  a) Our bit-field struct (data.bits)
//  b) A single 16-bit integer (data.full_int)
//  c) An array of two 8-bit bytes (data.bytes)
union BitFieldInspector {
    MyBitFields bits;
    uint16_t    full_int;
    uint8_t     bytes[2];
};

int main() {
    // 3. Create an instance of the union and initialize it to zero.
    BitFieldInspector data;
    data.full_int = 0; // Clear all 16 bits to 0

    // 4. Assign values to the bit-fields by name.
    data.bits.field_a = 0x1;  // Binary: 0001
    data.bits.field_b = 0x23; // Binary: 0010 0011
    data.bits.field_c = 0x4;  // Binary: 0100

    // 5. Print the results in hexadecimal.

    // Set up std::cout for hex output
    cout << hex << setfill('0');

    cout << "--- Bit-Field Layout Inspector ---" << endl;

    // Print the 16-bit integer representation
    cout << "Full 16-bit integer (hex): 0x"
         << setw(4) << data.full_int << endl;

    // Print the raw bytes. This helps visualize endianness.
    cout << "Raw bytes (hex):           " << endl;
    cout << "  Byte 0 [Address 0]: 0x"
         << setw(2) << (int)data.bytes[0] << endl;
    cout << "  Byte 1 [Address 1]: 0x"
         << setw(2) << (int)data.bytes[1] << endl;

    return 0;
}

#include <cstdint>
// Define masks and shifts for our fields
// We are defining our *own* standard, typically big-endian
// Total 16 bits: [ a: 4 | b: 8 | c: 4 ]
#define MASK_A  0xF000  // 1111 0000 0000 0000
#define SHIFT_A 12

#define MASK_B  0x0FF0  // 0000 1111 1111 0000
#define SHIFT_B 4

#define MASK_C  0x000F  // 0000 0000 0000 1111
#define SHIFT_C 0

// Function to set field A
void set_field_a(uint16_t* reg, uint16_t value) {
    *reg = (*reg & ~MASK_A) | ((value << SHIFT_A) & MASK_A);
}

// Function to get field A
uint16_t get_field_a(uint16_t reg) {
    return (reg & MASK_A) >> SHIFT_A;
}

// ... (repeat for fields B and C) ...

// __BYTE_ORDER__ and __ORDER_LITTLE_ENDIAN__ are common macros
// defined by compilers like GCC and Clang.

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    // Little-endian version (LSB-to-MSB packing)
    struct MyBitFields {
        uint16_t field_a : 4;
        uint16_t field_b : 8;
        uint16_t field_c : 4;
    };
#else
    // Big-endian version (MSB-to-LSB packing)
    struct MyBitFields {
        uint16_t field_c : 4;
        uint16_t field_b : 8;
        uint16_t field_a : 4;
    };
#endif

struct Padded {
    unsigned char a : 4;
    unsigned int  b : 4; // may start on a new 32-bit boundary
};

#define FLAG_A_MASK 0x01
#define FLAG_B_MASK 0x06
#define FLAG_C_MASK 0x18

unsigned char flags;
flags = (1 << 0) | (2 << 1);

#include <stdio.h>

struct Bits {
    unsigned int x : 1;
    unsigned int y : 2;
    unsigned int z : 3;
};

int main() {
    struct Bits b = {1, 2, 3};

    printf("x=%u y=%u z=%u\n", b.x, b.y, b.z);
    printf("Raw bytes:\n");

    unsigned char *p = (unsigned char*)&b;

    for (size_t i = 0; i < sizeof(b); ++i)
        printf("%02X ", p[i]);
    printf("\n");
}

Summary table

✅ Bottom line:

• C and C++ leave bit-field ordering up to the implementation.
• You can rely on named access (flags.a) but not on memory layout.
• For binary compatibility or networking, always use masks/shifts explicitly.

Arrays of structures are a powerful data structure in C/C++ that combines the flexibility of arrays with the organization of structures. They allow you to store multiple instances of a structure in a single array, enabling efficient access to and manipulation of multiple related data items.

Declaring Arrays of Structures

To declare an array of structures in C/C++, you follow the same syntax as declaring an array of any other data type. However, instead of specifying the element data type, you specify the structure type. For instance, to declare an array of 10 Employee structures:

struct Employee {
    char    name[50];
    int     age;
    float   salary;
};

struct Employee employees[10];

This declaration creates an array of named employees with up to 10 Employee structures. Each element in the array represents an individual Employee structure.

Initializing Arrays of Structures

You can initialize arrays of structures using the same methods as initializing individual structures. You can use individual assignments, initializer lists, or designated initializers. For example, to initialize the first element of the employees array:

strcpy(employees[0].name, "John Smith");
employees[0].age = 35;
employees[0].salary = 50000.00;

This initializes members' name, age, and salary for the first Employee structure in the array.

Accessing Elements in Arrays of Structures

Accessing elements in arrays of structures is similar to accessing elements in regular arrays. You use the array index followed by the dot '.' operator to access the structure's members. For instance, to access the name of the first employee:

char* firstName = employees[0].name;

This retrieves the value of the name member of the first Employee structure and stores it in the firstName pointer.

Using Range-Based For Loops with Arrays of Structures

Range-based loops in C++ provide a convenient way to iterate over all elements of an array of structures. For example, to print the names of all employees:

for (Employee employee : employees) {
    std::cout << employee.name << std::endl;
}

This loop iterates over each Employee structure in the employees array and prints the value of the name member.

Arrays of structures are versatile data structures extending the capabilities of arrays and structures. They allow you to efficiently organize and manage multiple instances of a complex data type, making them valuable for various programming tasks. Understanding how to declare, initialize, and access elements in arrays of structures is essential for effective C/C++ programming.

Nested Structure in C: Struct inside another struct

Nested structures, or composite structures, are a powerful data structure in C/C++ that allows you to embed one structure within another. This nesting capability provides a way to organize and represent hierarchical relationships between data elements, making them useful for modeling complex data relationships.

Declaring Nested Structures

To declare a nested structure in C/C++, you define one structure within another. For instance, consider a structure named Student that contains a nested structure named Address:

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

struct Student {
    char    name[50];
    int     age;
    float   gpa;
    struct  Address address; // Nested structure 'Address' within 'Student'
};

This declaration creates a Student structure with a nested Address structure. Each Student structure can now hold information about a student's address, including street, city, state, and zip code.

Accessing Nested Structure Members

To access members of a nested structure, you use the dot (.) operator twice. For instance, to access the city member of the address structure within a Student variable named student1:

char* city = student1.address.city;

This statement retrieves the value of the city member of the nested address structure within the student1 structure.

Passing Nested Structures as Arguments

You can pass nested structures as arguments to functions. When passing a nested structure, you pass the entire structure that contains the nested structure. For example, to define a function that takes a Student structure as an argument:

void printStudentDetails(struct Student student) {
    std::cout << "Student Name: " << student.name << std::endl;
    std::cout << "Student Age: " << student.age << std::endl;
    std::cout << "Student GPA: " << student.gpa << std::endl;
    std::cout << "Address: " << std::endl;
    std::cout << " Street: " << student.address.street << std::endl;
    std::cout << " City: " << student.address.city << std::endl;
    std::cout << " State: " << student.address.state << std::endl;
    std::cout << " Zip Code: " << student.address.zipCode << std::endl;
>}

This function takes a Student structure as input and prints the student's details, including their address information.

Nested structures provide a powerful mechanism for organizing complex data relationships in C/C++. They allow you to embed structures within other structures, creating a hierarchical representation of data. Understanding how to declare, access, and pass nested structures is essential for effectively modeling and manipulating complex data in C/C++ programming.

C structures and C++ structures, both fundamental data structures in their respective languages, share similarities in their purpose of data organization. However, they exhibit key distinctions that set them apart in terms of functionality and flexibility. This article delves into the differences between C and C++ structures, highlighting their unique capabilities and limitations.

In summary, C++ structures offer more advanced features than C structures, making them a more powerful tool for data organization and manipulation.