University of Management and Technology

Department of Artificial Intelligence

CC1021L Programming Fundamentals Lab
Fall 2023
Participant ID: Participant Name:

Date: Total Marks: Obtained Marks:

Lab # 11: Union and Enumeration in C++

Learning Objectives
 Implement a C++ program that reads data from a text file, processes the information, and
writes the modified data back to a new file.
 Understand the fundamental concepts of data file handling in C++, including the roles of
ifstream and ofstream, file opening modes, and the implications of using different file
stream flags.
Union in C++
In C++, a union is a user-defined data type that allows you to store different data types in the
same memory location. Unlike structures, where each member has its own memory space,
members of a union share the same memory space. The size of a union is determined by the size
of its largest member. Here's a basic example of a union in C++:
#include <iostream>
using namespace std;

union MyUnion {
int intValue;
float floatValue;
char charValue;
};

int main() {
MyUnion myUnion;

myUnion.intValue = 42;
cout << "Int value: " << myUnion.intValue << endl;

myUnion.floatValue = 3.14f;
cout << "Float value: " << myUnion.floatValue << endl;

myUnion.charValue = 'A';
cout << "Char value: " << myUnion.charValue << endl;

return 0;
}
In this example, the MyUnion union has three members: intValue of type int, floatValue
of type float, and charValue of type char. Despite having different types, they share the same
memory space. When you modify one member, it may affect the values of the other members
because they are stored in the same location.
In a union, all members share the same memory space. When you assign a value to one member
of the union, it will overwrite the current contents of the memory. Therefore, only the last
assigned value will be stored in the union. This behavior is intentional and characteristic of how
unions work.

Advantages of Union
Unions in C++ offer several advantages, primarily related to memory efficiency and flexibility in
certain programming scenarios. Here are some of the advantages of using unions:
1. Memory Efficiency: Unions allow different data types to share the same memory space.
This can be useful when you need to conserve memory, especially in embedded systems
or applications with strict memory constraints.
2. Space Optimization: Since the size of a union is determined by its largest member,
unions can help optimize memory usage when you have a group of variables, and at any
 given time, only one of them needs to be active. This is particularly beneficial in
situations where memory is a critical resource.
3. Versatility: Unions provide a flexible way to interpret the same memory location
differently based on the active member. This versatility can be useful in scenarios where
you want to represent different types of data in a single variable.
4. Interoperability: Unions can be handy when working with low-level programming, such
as interfacing with hardware or dealing with binary data. They allow you to interpret the
same memory location as different types, facilitating data manipulation.
5. Simplifying Code: In some situations, unions can help simplify code by allowing you to
use a single variable to represent multiple types. This can make the code more concise
and readable.
Despite these advantages, it's important to use unions judiciously and be aware of their potential
pitfalls. Unions lack type safety, and accessing the wrong member can lead to unpredictable
behavior or bugs. They should be used only when you are confident about how the data is being
manipulated and when the potential benefits in terms of memory efficiency outweigh the risks
associated with type safety.

Practical Application of Union

Unions find practical applications in various scenarios where memory efficiency, versatility, and
interoperability are essential. Some common use cases for unions include:
1. Packet Parsing in Networking: When dealing with network packets, where data may be
represented in different formats (integers, floating-point numbers, characters), unions can
be used to efficiently parse and interpret the packet data.
2. Graphics Programming: In graphics programming or when working with pixel data,
unions can be employed to represent color values as a combination of individual channels
(red, green, blue, alpha). This allows for memory-efficient storage and manipulation of
pixel data.
3. File Format Handling: Unions are useful in scenarios where different types of data need
to be read from or written to a file. They can help interpret a block of binary data in
different ways depending on the context.
4. Embedded Systems Programming: In resource-constrained environments, such as
embedded systems, unions can be employed to manage memory efficiently. For example,
representing different sensor readings in a union when only one sensor is active at a time.
5. Interfacing with Hardware: When interacting with hardware at a low level, unions can
be used to interpret memory-mapped registers in different ways. This is common in
device drivers or firmware development.
6. Implementation of Variant Types: Unions can be used to implement variant types or
tagged unions where a single variable can represent different types. This is useful in
scenarios where the type of data can change dynamically.
 7. Efficient Data Structures: In certain situations, unions can be part of efficient data
structures. For example, when implementing a variant data structure like a tagged union
within a larger data structure.

Enumeration in C++
In C++, an enumeration (enum) is a user-defined data type that consists of a set of named
integral constants. Enums provide a way to create symbolic names for values, making the code
more readable and less error-prone. Here's a simple example of how you can declare and use an
enumeration:
#include <iostream>

// Declaration of an enumeration named Color

enum Color {
RED,
GREEN,
BLUE
};

using namespace std;

int main() {
// Declaring variables of type Color
Color myColor1 = RED;
Color myColor2 = GREEN;
Color myColor3 = BLUE;

// Using the variables

cout << "myColor1 has value " << myColor1 << endl;
cout << "myColor2 has value " << myColor2 << endl;
cout << "myColor3 has value " << myColor3 << endl;

return 0;
}
In this example, Color is an enumeration with three constants: RED, GREEN, and BLUE. Each
constant is assigned an integral value starting from 0. If you don't explicitly assign values, the
compiler will automatically assign consecutive values, incrementing by 1.
Example. This C++ program is a simple menu-driven application for managing student data.
#include <iostream>
#include <string>

using namespace std;

enum MenuOption {
ADD_STUDENT = 1,
MODIFY_STUDENT,
DELETE_STUDENT,
EXIT
};
struct Student {
string name;
int age;
// Add more student data fields as needed
};

void addStudent() {
// Implementation for adding a student
cout << "Adding student data..." << endl;
// Add your code here to get and store student data
}

void modifyStudent() {
// Implementation for modifying a student
cout << "Modifying student data..." << endl;
// Add your code here to modify existing student data
}

void deleteStudent() {
// Implementation for deleting a student
cout << "Deleting student data..." << endl;
// Add your code here to delete existing student data
}

int main() {
int userInput;

do {
// Display the menu
cout << "Menu:" << endl;
cout << "1. Add Student Data" << endl;
cout << "2. Modify Student Data" << endl;
cout << "3. Delete Student Data" << endl;
cout << "4. Exit" << endl;

// Get user input

cout << "Enter your choice (1-4): ";
cin >> userInput;

// Process user choice

switch (static_cast<MenuOption>(userInput)) {
case ADD_STUDENT:
addStudent();
break;
case MODIFY_STUDENT:
modifyStudent();
break;
case DELETE_STUDENT:
deleteStudent();
break;
case EXIT:
cout << "Exiting program." << endl;
break;
default:
 cout << "Invalid selection. Please enter a number
between 1 and 4." << endl;
break;
}

} while (userInput != EXIT);

return 0;
}
Enumeration (MenuOption):
Defines an enumeration named MenuOption with four constants (ADD_STUDENT,
MODIFY_STUDENT, DELETE_STUDENT, and EXIT), each associated with an integer value
starting from 1.
Struct (Student):
Defines a structure named Student to represent student data. It includes a std::string member for
the student's name and an int member for the student's age. Additional data fields can be added
as needed.
Functions (addStudent, modifyStudent, deleteStudent):
Each function represents an operation related to student data.
addStudent(): Displays a message indicating that student data is being added and provides a
comment to indicate where code for getting and storing student data can be added.
modifyStudent(): Displays a message indicating that student data is being modified and
provides a comment for where code to modify existing student data can be added.
deleteStudent(): Displays a message indicating that student data is being deleted and provides a
comment for where code to delete existing student data can be added.
Main Function (main):
Declares a variable userInput to store the user's menu choice.
Uses a do-while loop to repeatedly display a menu and process the user's choice until the user
chooses to exit (EXIT option).
Within the loop:
 Displays the menu options.
 Prompts the user to enter a choice (1-4).
 Converts the user's input to the MenuOption enum using static_cast.
 Uses a switch statement to perform the corresponding action based on the user's choice:
o Calls addStudent() for option 1.
o Calls modifyStudent() for option 2.
o Calls deleteStudent() for option 3.
o Prints an exit message for option 4.
o Prints an error message for an invalid choice.
 Continues looping until the user selects the exit option (EXIT).