C++ Structures, Enumerations, and Typedef Exercises

#include <string>
#include <iostream>

// Define the Book structure
struct Book {
    std::string title;
    std::string author;
    float price;
};

int main() {
    // Example of declaring a variable of type Book
    Book b1;
    b1.title = "The Hitchhiker's Guide to the Galaxy";
    b1.author = "Douglas Adams";
    b1.price = 15.99f; // 'f' suffix denotes a float literal

    std::cout << "Book Title: " << b1.title << std::endl;
    std::cout << "Price: $" << b1.price << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise shows how structures can combine different data types (std::string and float) into one logical unit. The Book structure is a custom data type that effectively models a real-world entity, making the code more readable and organized.
• In C++, structure members are public by default. The display_point function demonstrates how to pass a structure by value to a function and access its individual members using the dot operator.

#include <iostream>
#include <string>
#include <limits> // Required for clearing the input buffer

struct Book {
    std::string title;
    std::string author;
    float price;
};

int main() {
    Book my_book;

    // Read input from the user
    std::cout << "Enter Book Title: ";
    // Use getline to capture titles with spaces
    std::getline(std::cin, my_book.title);

    std::cout << "Enter Author Name: ";
    std::getline(std::cin, my_book.author);

    std::cout << "Enter Price: $";
    std::cin >> my_book.price;

    // Display the data
    std::cout << "\n--- Book Information ---" << std::endl;
    std::cout << "Title: " << my_book.title << std::endl;
    std::cout << "Author: " << my_book.author << std::endl;
    // Set precision for better currency display
    std::cout.precision(2);
    std::cout << std::fixed << "Price: $" << my_book.price << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise demonstrates practical input/output operations with a structure.
• Note the use of std::getline for strings, which is essential when the input may contain spaces. The structure variable my_book holds all three pieces of data, which are accessed and modified using the dot operator

#include <iostream>
#include <string>
#include <limits>

struct Book {
    std::string title;
    std::string author;
    float price;
};

const int MAX_BOOKS = 3;

int main() {
    Book books[MAX_BOOKS];

    // Input loop
    for (int i = 0; i < MAX_BOOKS; ++i) {
        std::cout << "\n--- Enter data for Book " << i + 1 << " ---" << std::endl;

        // Clear the input buffer if necessary from previous numeric input
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

        std::cout << "Title: ";
        std::getline(std::cin, books[i].title);

        std::cout << "Author: ";
        std::getline(std::cin, books[i].author);

        std::cout << "Price: $";
        std::cin >> books[i].price;
    }

    // Output loop
    std::cout << "\n===================================" << std::endl;
    std::cout << "         ALL BOOKS INVENTORY        " << std::endl;
    std::cout << "===================================" << std::endl;

    for (int i = 0; i < MAX_BOOKS; ++i) {
        std::cout << "Book " << i + 1 << ": " << books[i].title
                  << " by " << books[i].author
                  << " ($" << books[i].price << ")" << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• An array of structures is a common way to manage collections of records.
• The books[MAX_BOOKS] declaration creates a contiguous block of memory to store 3 Book objects.
• The for loops iterate over the array, using the index i to access each individual book structure. The members are accessed via the dot operator applied to the array element, e.g., books[i].title.

#include <iostream>
#include <string>

struct Book {
    std::string title;
    std::string author;
    float price;
};

// Function to calculate the total price
float calculate_total_price(const Book books[], int count) {
    float total = 0.0f;
    for (int i = 0; i < count; ++i) {
        total += books[i].price; // Accumulate the price of each book
    }
    return total;
}

int main() {
    const int count = 3;
    Book library[count] = {
        {"Dune", "Frank Herbert", 12.50f},
        {"1984", "George Orwell", 8.99f},
        {"The Hobbit", "J.R.R. Tolkien", 14.00f}
    };

    float grand_total = calculate_total_price(library, count);

    std::cout << "Total price of all " << count << " books: $";
    std::cout.precision(2);
    std::cout << std::fixed << grand_total << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The function calculate_total_price takes the array (which decays to a pointer) and its size.
• The const keyword is a good practice as the function only reads the data. It iterates through the books, sums their price members, and returns the final sum. This shows how structures can be easily manipulated within functions for common data processing tasks.

#include <iostream>
#include <string>

// 1. Define the inner structure
struct DateOfBirth {
    int day;
    int month;
    int year;
};

// 2. Define the outer structure, containing an instance of the inner structure
struct Student {
    std::string name;
    DateOfBirth dob; // Nested structure member
};

int main() {
    // Create an instance and initialize members
    Student s1;
    s1.name = "Ella Fitzgerald";

    // Initialize the nested structure members
    s1.dob.day = 25;
    s1.dob.month = 4;
    s1.dob.year = 2008;

    // Display the data
    std::cout << "Student Name: " << s1.name << std::endl;
    std::cout << "Date of Birth: " << s1.dob.month << "/" << s1.dob.day << "/" << s1.dob.year << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• Nested structures are used to logically group related data.
• Here, the date of birth is a distinct concept within the student’s data.
• Accessing the deepest member (e.g., day) requires using the dot operator multiple times to traverse the hierarchy: from the Student variable (s1) to the DateOfBirth member (dob) and finally to the day member.

#include <iostream>

struct Rectangle {
    float length;
    float width;
};

int main() {
    // Declare a pointer to a Rectangle structure
    Rectangle* rect_ptr;

    // Dynamically allocate memory for a Rectangle
    rect_ptr = new Rectangle;

    // Use the arrow operator (->) to access and set members
    std::cout << "Enter rectangle length: ";
    std::cin >> rect_ptr->length;

    std::cout << "Enter rectangle width: ";
    std::cin >> rect_ptr->width;

    // Use the arrow operator to access and display members
    std::cout << "\nRectangle Dimensions:" << std::endl;
    std::cout << "Length: " << rect_ptr->length << std::endl;
    std::cout << "Width: " << rect_ptr->width << std::endl;

    // Calculate and display area
    float area = rect_ptr->length * rect_ptr->width;
    std::cout << "Area: " << area << std::endl;

    // Free the dynamically allocated memory
    delete rect_ptr;
    rect_ptr = nullptr; // Good practice to set pointer to null

    return 0;
}Code language: C++ (cpp)

Explanation:

• Pointers to structures are essential for dynamic memory management and for passing large structures to functions efficiently (by address).
• The arrow operator (->) is a convenient shortcut for dereferencing the pointer and accessing a member simultaneously. For example, rect_ptr->length is equivalent to (*rect_ptr).length.

#include <iostream>
#include <string>
#include <limits> // <-- ADD THIS LINE to fix the error

struct Book {
    std::string title;
    std::string author;
    float price;
};

int main() {
    // Dynamic allocation of a single Book structure
    Book* new_book = new Book;

    // Clear buffer just in case of leftover newline from previous input
    // The error was fixed by including <limits>
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

    std::cout << "--- Enter New Book Details ---" << std::endl;

    // Input using the pointer
    std::cout << "Title: ";
    std::getline(std::cin, new_book->title);

    std::cout << "Author: ";
    std::getline(std::cin, new_book->author);

    std::cout << "Price: $";
    std::cin >> new_book->price;

    // Display the data using the pointer
    std::cout << "\n--- Confirmation ---" << std::endl;
    std::cout << "Title: " << new_book->title << std::endl;
    std::cout << "Author: " << new_book->author << std::endl;
    std::cout << "Price: $" << new_book->price << std::endl;

    // Crucial step: Free the memory allocated on the heap
    delete new_book;
    new_book = nullptr;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise highlights the difference between stack and heap memory.
• Using new Book allocates memory on the heap and returns a pointer to that location.
• This memory persists until explicitly released with delete. This is common practice when the memory needed is unknown at compile time.

#include <iostream>

struct Point {
    int x;
    int y;
};

// Function that takes a structure by reference
void double_coordinates(Point &p) {
    p.x *= 2; // Directly modifies the original p1 in main
    p.y *= 2; // Directly modifies the original p1 in main
}

int main() {
    Point p1 = {5, 10};

    std::cout << "Original Point: (" << p1.x << ", " << p1.y << ")" << std::endl;

    // Call the function, passing by reference
    double_coordinates(p1);

    std::cout << "Point After Doubling: (" << p1.x << ", " << p1.y << ")" << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• Passing a structure by reference (using Point &p) allows a function to modify the original variable passed from the calling function (main in this case).
• This is more efficient than passing by value (which creates a copy) when dealing with large structures, and it is the necessary method when the function’s purpose is to modify the structure’s data.

#include <iostream>
#include <string>
#include <vector> 

struct Book {
    std::string title;
    std::string author;
    float price;
};

// Function to find the title of the most expensive book
std::string find_most_expensive(const std::vector<Book>& books) {
    if (books.empty()) {
        return "No books available";
    }

    // Start with the first book as the most expensive
    float max_price = books[0].price;
    std::string max_title = books[0].title;

    // Iterate starting from the second book
    for (size_t i = 1; i < books.size(); ++i) {
        if (books[i].price > max_price) {
            max_price = books[i].price; // Update max price
            max_title = books[i].title;  // Update the title
        }
    }

    return max_title;
}

int main() {
    // Initialize a vector of books
    std::vector<Book> library = {
        {"The C++ Programming Language", "Bjarne Stroustrup", 45.99f},
        {"Effective C++", "Scott Meyers", 35.50f},
        {"Design Patterns", "Erich Gamma et al.", 50.00f}
    };

    std::string best_seller = find_most_expensive(library);

    std::cout << "The most expensive book is: " << best_seller << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• The function initializes the maximum price and corresponding title with the data from the first element.
• It then loops through the rest of the elements, performing a comparison on the price member. If a higher price is found, both the max_price and the max_title are updated. This demonstrates accessing specific members of structured data within a comparison loop.

#include <iostream>

// Define the Day enumeration
enum Day {
    Sunday,    // 0
    Monday,    // 1
    Tuesday,   // 2
    Wednesday, // 3
    Thursday,  // 4
    Friday,    // 5
    Saturday   // 6
};

int main() {
    // Declare a variable and assign a value
    Day today = Wednesday;

    std::cout << "The integer value of Wednesday is: ";
    // Cast the enum variable to an int to print its underlying value
    std::cout << static_cast<int>(today) << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• C-style enumerations (enum) provide a set of named integer constants.
• By default, the constants are assigned values sequentially starting from 0.
• The program demonstrates declaration, assignment, and the use of static_cast<int> to explicitly retrieve and print the integer value associated with the enumerator Wednesday (which is 3).

#include <iostream>
#include <string>

// Define the TrafficLight enumeration
enum TrafficLight {
    Red,
    Yellow,
    Green
};

// Function to determine action based on light state
void get_action(TrafficLight light) {
    std::cout << "Light is " << light << ". Action: ";
    switch (light) {
        case Red:
            std::cout << "Stop" << std::endl;
            break;
        case Yellow:
            std::cout << "Prepare to stop" << std::endl;
            break;
        case Green:
            std::cout << "Go" << std::endl;
            break;
    }
}

int main() {
    TrafficLight current_light = Green;
    get_action(current_light);

    current_light = Yellow;
    get_action(current_light);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise shows how enumerations improve code readability by replacing “magic numbers” (like 0, 1, 2) with meaningful names.
• The switch statement uses the enumerator names for clear and robust branching logic, making it easy to see which action corresponds to which traffic light state.

#include <iostream>

enum TrafficLight {
    Red,
    Yellow,
    Green
};

void display_light_status(TrafficLight light) {
    switch (light) {
        case Red: std::cout << "Status: Red - Stop" << std::endl; break;
        case Yellow: std::cout << "Status: Yellow - Caution" << std::endl; break;
        case Green: std::cout << "Status: Green - Go" << std::endl; break;
    }
}

int main() {
    int input_val;

    std::cout << "Enter light code (0=Red, 1=Yellow, 2=Green): ";
    std::cin >> input_val;

    if (input_val >= Red && input_val <= Green) {
        // Safe conversion using static_cast
        TrafficLight user_light = static_cast<TrafficLight>(input_val);
        display_light_status(user_light);
    } else {
        std::cout << "Error: Invalid light code entered." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise demonstrates the mechanism for converting raw user input into a type-safe enumeration. The cast static_cast<TrafficLight>(input_val) tells the compiler to treat the integer as a TrafficLight value.
• The input validation step is important because without it, an invalid input (like 99) would still be converted, leading to undefined behavior or logical errors within the switch statement.

#include <iostream>

// Define the Scoped Enum
enum class TrafficLight {
    Red,
    Yellow,
    Green
};

int main() {
    // Attempt 1: Accessing without scope (will fail compilation)
    // TrafficLight light1 = Red; // ERROR: 'Red' is not declared in this scope

    // Correct Access: Using the scope operator (::)
    TrafficLight light2 = TrafficLight::Green;

    std::cout << "Current light is Green." << std::endl;

    // Accessing integer value requires explicit cast
    std::cout << "Underlying value: " << static_cast<int>(light2) << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• Scoped enumerations (enum class) are strongly typed and ensure that the enumerator names (like Red) are only visible within the scope of the enum class itself (TrafficLight).
• This prevents naming conflicts in large projects (namespace pollution). It also prevents implicit conversion to int, forcing the use of static_cast for type safety.

#include <iostream>

enum class TrafficLight {
    Red,
    Yellow,
    Green
};

void check_status(TrafficLight light) {
    if (light == TrafficLight::Red) {
        std::cout << "The status is Red." << std::endl;
    } else {
        std::cout << "The status is not Red." << std::endl;
    }
}

int main() {
    // 1. Attempt to pass an integer (Will cause a compiler error)
    // check_status(1); // ERROR: Cannot convert 'int' to 'TrafficLight'

    // 2. Correct call: Passing a valid enumerator
    check_status(TrafficLight::Yellow);
    
    // 3. Alternative correct call using static_cast
    check_status(static_cast<TrafficLight>(0)); 

    return 0;
}Code language: C++ (cpp)

Explanation:

• The compiler error, often “cannot convert ‘int’ to ‘TrafficLight’,” confirms the type safety of enum class.
• Unlike C-style enums, scoped enums prevent accidental use of integers where a specific enum type is expected. This strong typing helps catch bugs early and ensures that only valid, named states are used.

#include <iostream>
#include <array>

// Define the Month enumeration (implicitly 0 to 11)
enum Month {
    JAN, FEB, MAR, APR, MAY, JUN,
    JUL, AUG, SEP, OCT, NOV, DEC
};

int main() {
    // Array to hold 12 months of revenue
    std::array<int, 12> monthly_revenue = {0}; // Initialize all to 0

    // Use enum values to index the array
    monthly_revenue[JAN] = 5000;
    monthly_revenue[FEB] = 6200;
    monthly_revenue[MAR] = 7800;

    std::cout << "January Revenue: $" << monthly_revenue[JAN] << std::endl;
    std::cout << "March Revenue: $" << monthly_revenue[MAR] << std::endl;
    
    // Demonstrate a loop using the enum
    for (int m = JAN; m <= MAR; ++m) {
        std::cout << "Revenue for month " << m + 1 << " is $" << monthly_revenue[m] << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• Using enumerators for array indexing significantly improves code clarity.
• Instead of writing monthly_revenue[0], you write monthly_revenue[JAN], which clearly indicates what that index represents. This is possible because the C-style enum values seamlessly convert to their underlying integer indices.

#include <iostream>
#include <string>

// Define the Status enum class
enum class Status {
    Pending,
    Shipped,
    Delivered
};

// Define the Order structure
struct Order {
    int id;
    float amount;
    Status current_status; // Member is of enum class type
};

void display_status(Status s) {
    switch (s) {
        case Status::Pending: std::cout << "Pending"; break;
        case Status::Shipped: std::cout << "Shipped"; break;
        case Status::Delivered: std::cout << "Delivered"; break;
    }
}

int main() {
    Order my_order = {
        1001,
        250.75f,
        Status::Shipped // Initialize the enum member
    };

    std::cout << "Order ID: " << my_order.id << std::endl;
    std::cout << "Amount: $" << my_order.amount << std::endl;
    std::cout << "Status: ";
    display_status(my_order.current_status); // Pass enum to helper function
    std::cout << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This is a practical example of how structures and enumerations are used together to create a complex, meaningful data type.
• The Order structure encapsulates various attributes, and the Status enum ensures that the order’s state can only be one of the pre-defined valid options (Pending, Shipped, or Delivered), preventing invalid data assignment.

#include <iostream>

// Define C-style enum with powers of 2 for bit flags
enum Permissions {
    NONE    = 0,
    READ    = 1,  // 001
    WRITE   = 2,  // 010
    EXECUTE = 4   // 100
};

int main() {
    // Combine READ and WRITE permissions using bitwise OR (|)
    int user_permission = READ | WRITE; // Result is 3 (011 binary)

    std::cout << "User permission value: " << user_permission << std::endl;

    // Check if WRITE permission is set using bitwise AND (&)
    if (user_permission & WRITE) {
        std::cout << "CHECK: WRITE permission IS SET." << std::endl;
    } else {
        std::cout << "CHECK: WRITE permission is NOT set." << std::endl;
    }

    // Check if EXECUTE permission is set
    if (user_permission & EXECUTE) {
        std::cout << "CHECK: EXECUTE permission IS SET." << std::endl;
    } else {
        std::cout << "CHECK: EXECUTE permission is NOT set." << std::endl;
    }

    return 0;
}Code language: C++ (cpp)

Explanation:

• Bit flags are an efficient way to store multiple boolean states in a single integer variable.
• By assigning each permission a unique power-of-2 value, they occupy distinct bit positions.
• Bitwise OR (|) turns on multiple bits, and Bitwise AND (&) is used to check if a specific bit (flag) is set, returning true only if the corresponding bit is 1 in both the variable and the flag.

#include <iostream>
#include <string>

// Use typedef to create type aliases
typedef int Integer;
typedef std::string Text;

int main() {
    // Declare variables using the new aliases
    Integer count = 5;
    Text greeting = "Hello, ";
    Text name = "World!";

    // Demonstrate Integer
    Integer result = count * 2;
    std::cout << "Integer result (5 * 2): " << result << std::endl;

    // Demonstrate Text
    Text full_message = greeting + name;
    std::cout << "Text message: " << full_message << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• By using Integer and Text, the intent of the variables becomes clearer.
• While modern C++ often prefers using aliases (e.g., using Integer = int;), typedef remains fully valid, particularly for compatibility with C codebases.

#include <iostream>

// Typedef for a function pointer: returns int, takes (int, int)
typedef int (*MathFunc)(int, int);

// Functions that match the signature
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int main() {
    // Declare a variable of the function pointer type
    MathFunc operation_ptr;

    // Assign to the add function
    operation_ptr = add;
    int result1 = operation_ptr(10, 5);
    std::cout << "Addition (10 + 5): " << result1 << std::endl;

    // Reassign to the subtract function
    operation_ptr = subtract;
    int result2 = operation_ptr(10, 5);
    std::cout << "Subtraction (10 - 5): " << result2 << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• Function pointers are essential for implementing callbacks or command patterns, but their syntax can be cumbersome.
• The typedef keyword simplifies the declaration of the function pointer variable operation_ptr from a complex line to a clear, single type name (MathFunc).
• This vastly improves the readability of code that uses functions as arguments or variables.

#include <iostream>

// Define the structure and create the alias simultaneously
typedef struct ComplexNumber {
    float real;
    float imaginary;
} CNum; // CNum is the alias

int main() {
    // Declaration using the alias (more concise)
    CNum z1 = {3.0f, 4.0f};

    // Declaration using the original struct name (no 'struct' keyword needed in C++)
    ComplexNumber z2 = {1.5f, -2.5f};

    std::cout << "Complex Number z1: " << z1.real << " + " << z1.imaginary << "i" << std::endl;
    std::cout << "Complex Number z2: " << z2.real << " + " << z2.imaginary << "i" << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• In standard C, the struct keyword is always required when declaring a structure variable (e.g., struct ComplexNumber z;).
• typedef was traditionally used in C to create a new type name that did not require the struct keyword. While C++ relaxes this rule, typedef (or modern using alias) is still helpful for creating short, convenient names like CNum.

#include <iostream>
#include <string>

struct Book {
    std::string title;
    std::string author;
    float price;
};

// Typedef for a pointer to the Book structure
typedef Book* PBook;

int main() {
    // Declare a pointer using the alias PBook
    PBook my_book_ptr = new Book;

    // Assign data using the pointer (arrow operator)
    my_book_ptr->title = "The Odyssey";
    my_book_ptr->author = "Homer";
    my_book_ptr->price = 10.99f;

    // Display data
    std::cout << "Title via PBook alias: " << my_book_ptr->title << std::endl;
    std::cout << "Author: " << my_book_ptr->author << std::endl;

    // Cleanup
    delete my_book_ptr;
    my_book_ptr = nullptr;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise demonstrates the utility of typedef in simplifying pointer declarations, which can often look confusing when combined with structures.
• PBook clearly signals that the variable is a pointer intended to hold a Book object’s address, making pointer use less error-prone and easier to read.

#include <iostream>
#include <string>

// Define struct and typedef alias
typedef struct StudentInfo {
    int ID;
    float GPA;
} Record;

void print_top_gpa(const Record records[], int count) {
    if (count == 0) return;

    float max_gpa = 0.0f;
    int top_index = 0;

    for (int i = 0; i < count; ++i) {
        if (records[i].GPA > max_gpa) {
            max_gpa = records[i].GPA;
            top_index = i;
        }
    }

    std::cout << "\n--- Top Student Record ---" << std::endl;
    std::cout << "ID: " << records[top_index].ID << std::endl;
    std::cout << "GPA: " << records[top_index].GPA << std::endl;
}

int main() {
    const int num_students = 3;
    // Declare and initialize an array of the aliased type 'Record'
    Record class_roster[num_students] = {
        {101, 3.85f},
        {102, 3.92f},
        {103, 3.70f}
    };

    print_top_gpa(class_roster, num_students);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise combines the definition of a structured record with a typedef for convenience.
• The Record alias makes the array declaration Record class_roster[num_students] cleaner.
• The function demonstrates standard structure processing: passing the array as a const pointer and iterating through it to find an extreme value.

#include <iostream>
#include <string>
#include <vector>

// 1. Define Enum Class
enum class ItemType {
    Tool,
    Supply,
    Component
};

// 2. Define Structure and Typedef Alias
typedef struct InventoryItem {
    std::string name;
    float price;
    ItemType type;
} Item; // Item is the alias

// Function to print only items of a specific type
void print_items_by_type(const std::vector<Item>& inventory, ItemType target_type) {
    std::cout << "\n--- Listing Items by Type ---" << std::endl;
    
    for (const auto& item : inventory) {
        if (item.type == target_type) {
            std::cout << "Name: " << item.name << ", Price: $" << item.price << std::endl;
        }
    }
}

int main() {
    std::vector<Item> warehouse = {
        {"Wrench", 15.00f, ItemType::Tool},
        {"Screws", 2.50f, ItemType::Supply},
        {"Gearbox", 55.99f, ItemType::Component},
        {"Hammer", 12.00f, ItemType::Tool}
    };

    // Call function to filter and print
    print_items_by_type(warehouse, ItemType::Tool);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise fully integrates all three concepts. Item (via typedef) makes the container type readable.
• The InventoryItem structure uses ItemType (via enum class) to strictly categorize the items. The filter function’s core logic relies on the safe and explicit comparison of the scoped enum values.

#include <iostream>
#include <string>

// 1. Define Enum Class
enum class Rating {
    G,
    PG,
    PG13,
    R,
    NC17
};

// 2. Define Structure and Typedef Alias
typedef struct Movie {
    std::string title;
    int year;
    Rating age_rating;
} Film; // Film is the alias

void check_age_restriction(const Film& f) {
    std::cout << f.title << " (" << f.year << "): ";
    
    switch (f.age_rating) {
        case Rating::G:
            std::cout << "General Audiences - All ages admitted." << std::endl;
            break;
        case Rating::PG:
            std::cout << "Parental Guidance Suggested." << std::endl;
            break;
        case Rating::PG13:
            std::cout << "Parents Strongly Cautioned." << std::endl;
            break;
        case Rating::R:
            std::cout << "Restricted - Requires adult accompaniment." << std::endl;
            break;
        case Rating::NC17:
            std::cout << "No one 17 and under admitted." << std::endl;
            break;
    }
}

int main() {
    Film my_movie = {"The Martian", 2015, Rating::PG13};
    Film rated_r = {"Pulp Fiction", 1994, Rating::R};

    check_age_restriction(my_movie);
    check_age_restriction(rated_r);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise provides a realistic scenario where typedef makes the main logic easier to follow (Film instead of struct Movie) and the Rating enum strictly enforces valid rating options.
• The function check_age_restriction demonstrates how to use the enum member within the structure to drive complex business logic (age restriction rules).

#include <iostream>

// 1. Structure for color data
struct ColorRGB {
    unsigned char r;
    unsigned char g;
    unsigned char b;
};

// 2. Scoped Enum for presets
enum class PresetColor {
    Red,
    Green,
    Blue
};

// Function that maps enum to struct data
ColorRGB getColor(PresetColor color) {
    switch (color) {
        case PresetColor::Red:
            return {255, 0, 0}; // Initializer list for struct
        case PresetColor::Green:
            return {0, 255, 0};
        case PresetColor::Blue:
            return {0, 0, 255};
        default:
            return {0, 0, 0}; // Black as default
    }
}

int main() {
    // Call the function to get a struct based on the enum
    ColorRGB primary_red = getColor(PresetColor::Red);
    ColorRGB primary_blue = getColor(PresetColor::Blue);

    std::cout << "Red RGB: (" << (int)primary_red.r << ", " 
              << (int)primary_red.g << ", " << (int)primary_red.b << ")" << std::endl;
    
    std::cout << "Blue RGB: (" << (int)primary_blue.r << ", " 
              << (int)primary_blue.g << ", " << (int)primary_blue.b << ")" << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This is a perfect example of using an enum class to enforce limited, meaningful choices (PresetColor) that drive the creation of complex structured data (ColorRGB).
• The function getColor acts as a mapping layer, converting a type-safe constant into a populated data structure. Note the casts to int when printing, as unsigned char might otherwise be printed as a character instead of a number.

#include <iostream>
#include <string>

// 1. Typedef for data type
typedef long long EmployeeID;

// 2. Scoped Enum Class with explicit base type and values
enum class PayGrade : int {
    Junior = 1,
    Mid = 2,
    Senior = 3
};

// 3. Combined Structure
struct Employee {
    EmployeeID id;
    std::string name;
    PayGrade grade;
};

// Function to calculate bonus based on PayGrade
double calculateBonus(const Employee& emp) {
    switch (emp.grade) {
        case PayGrade::Junior:
            return 1000.00;
        case PayGrade::Mid:
            return 2500.00;
        case PayGrade::Senior:
            return 5000.00;
        default:
            return 0.00;
    }
}

int main() {
    Employee emp1 = {10000000001LL, "Alice", PayGrade::Mid};
    Employee emp2 = {10000000002LL, "Bob", PayGrade::Senior};

    std::cout << "Employee: " << emp1.name << ", ID: " << emp1.id 
              << ", Bonus: $" << calculateBonus(emp1) << std::endl;

    std::cout << "Employee: " << emp2.name << ", ID: " << emp2.id 
              << ", Bonus: $" << calculateBonus(emp2) << std::endl;

    return 0;
}Code language: C++ (cpp)

Explanation:

• This exercise provides a capstone on the topic. EmployeeID uses typedef to create a domain-specific name for a large integer type. PayGrade uses an explicit base type (: int) to confirm its storage size and ensures type safety with enum class.
• The Employee structure bundles these elements, and the calculateBonus function demonstrates how to use the strongly typed enum to drive financial logic cleanly and reliably.