Q1:

1. Explain the Purpose and Functionality of the C++ Exception Handling Keywords

Definition (from PDF, simplified)

Exception handling in C++ allows you to detect and handle run-time errors or unexpected conditions.
It improves program stability and prevents crashes.

Key C++ Exception Handling Keywords & Their Purpose

Keyword Purpose / Use
try Used to wrap the block of code that might generate exception(s).
catch Used to handle the exception thrown by try block.
throw Used to throw an exception when an error is detected.

How it Works (Simple Flow):

Code that might cause an error is written inside the try block.
If an error occurs, control jumps to the catch block.
The throw statement is used to manually signal an exception.
If no exception occurs, the catch block is skipped.

Example Program:
cpp
CopyEdit
#include <iostream>
using namespace std;

int main() {
int a = 10, b = 0;

try {
if (b == 0)
throw "Division by zero not allowed!";
cout << "Result: " << a / b << endl;
} catch (const char* msg) {
cout << "Exception: " << msg << endl;
}

return 0;
}

Explanation of the Program (Short & Simple):

try block checks for division by zero.
throw sends an exception if b is 0.
catch receives and handles the exception message.
Prevents the program from crashing.

Expected Output:
vbnet
CopyEdit
Exception: Division by zero not allowed!
Q2:
Standard Exception Handling in C++ (Using throw)
Program: Throwing a Standard Exception
This program demonstrates how to throw a standard exception in C++ using the throw keyword.
cpp
CopyEdit
#include <iostream>
#include <stdexcept> // Include standard exception library

using namespace std;

int main() {
try {
throw "An error occurred!";
} catch (const char *msg) {
cout << "Exception caught: " << msg << endl;
}
return 0;
}
Explanation of the Program
✔ throw "An error occurred!" → Throws a simple error message.
✔ catch (const char *msg) → Catches the error message and prints it.
Expected Output
nginx
CopyEdit
Exception caught: An error occurred!

Q3:
Purpose of Catch-All Block in C++ Exception Handling
Definition
The catch-all block (catch(...)) is used to handle all types of exceptions that are not explicitly caught
by other catch blocks. It ensures that the program does not crash due to unhandled exceptions.
How It Works
• It is placed at the end of multiple catch blocks.
• It catches any exception, regardless of its type.
• It helps in preventing unexpected program termination.
Key Points
✔ Syntax: catch(...) (three dots represent any exception)
✔ Used when the exact type of exception is unknown
✔ Ensures no uncaught exceptions terminate the program
✔ Must be the last catch block in the sequence
Example Program
Program with Two Catch Blocks in C++
cpp
CopyEdit
#include <iostream>
using namespace std;

int main() {
try {
throw 10; // Throwing an integer exception
 }
catch (int e) { // Catch block for integers
cout << "Integer Exception Caught: " << e << endl;
}
catch (...) { // Catch-all block for any other exceptions
cout << "General Exception Caught!" << endl;
}
return 0;
}
Explanation:
✔ throw 10; → Throws an integer exception.
✔ catch (int e); → Catches integer exceptions.
✔ catch (...) → Catches any other exceptions.
Expected Output:
pgsql
CopyEdit
Integer Exception Caught: 10

Q4:
What Happens When an Exception is Thrown but Not Caught in C++?
Definition & Explanation
• When an exception is thrown but not caught by any catch block, the program terminates
unexpectedly.
• The exception propagates up the function call stack, searching for a matching catch block.
• If no matching catch block is found, the system calls std::terminate(), which crashes the
program.
• This can be avoided by using proper exception handling with try-catch blocks.
Key Points
✔ Exception Propagation → Moves up the function call stack.
✔ Unhandled Exception → Leads to program termination.
✔ std::terminate() → Called if no handler is found.
✔ Solution → Always handle exceptions properly.

Example: Uncaught Exception Leading to Termination

cpp
CopyEdit
#include <iostream>
using namespace std;

void throwError() {
throw "Error occurred!"; // Throws a string exception
}

int main() {
throwError(); // No try-catch to handle this exception
cout << "This line will not execute!" << endl;
return 0;
}

Explanation of the Program

✔ throwError() throws a string exception "Error occurred!".
✔ There is no try-catch block, so the exception remains unhandled.
✔ std::terminate() is called, causing the program to crash immediately.

Expected Output (Abnormal Termination)

pgsql
CopyEdit
terminate called after throwing an instance of 'char const*'
Aborted (core dumped)

Q5:
The Implicit Type Conversion Does Not Happen for Primitive Types in Exception Handling
Explanation:
• In C++ exception handling, implicit type conversion does not occur when an exception is
thrown.
• The type of exception thrown must exactly match the type caught by the catch block.
• If a thrown exception does not match any catch block, the program terminates with an error.
• Simple Program:
#include <iostream>
using namespace std;

int main() {
try {
throw 10; // Throwing an integer
}
catch (double d) { // Won't catch int (no implicit conversion)
cout << "Caught a double" << endl;
}
catch (...) { // Catch-all for unmatched exceptions
cout << "Exception caught, no implicit conversion!" << endl;
}
return 0;
}
• Expected Output:
• Exception caught, no implicit conversion!

Q6:
The Implicit Type Conversion Does Not Happen for Primitive Types in Exception Handling
Explanation:
• In C++ exception handling, implicit type conversion does not occur when an exception is
thrown.
• The type of exception thrown must exactly match the type caught by the catch block.
• If a thrown exception does not match any catch block, the program terminates with an error.
Example:
#include <iostream>
using namespace std;

int main() {
try {
int num1 = 10, num2 = 0;
if (num2 == 0) {
throw "Division by zero error!";
}
 cout << "Result: " << num1 / num2 << endl;
}
catch (const char* msg) {
cout << "Exception Caught: " << msg << endl;
}
return 0;
}
Explanation:
✔ try block contains the code that may cause an exception.
✔ If num2 is zero, an exception is thrown using throw.
✔ catch block catches the thrown exception and handles it by displaying an error message.

Expected Output:
Exception Caught: Division by zero error!
 Q1:
File Handling and Its Importance in C++ (5 Marks)
Definition:
File handling in C++ is the process of managing files for storing, retrieving, and manipulating
data. It allows programs to read from and write to files, ensuring data persistence and
efficient data management.

Importance of File Handling:

✔ Data Persistence – Ensures that data remains available even after the program terminates.
✔ Efficient Data Management – Helps organize and process large amounts of data.
✔ Data Sharing – Facilitates communication between different programs or systems.
✔ Backup & Security – Prevents data loss by saving information permanently.
✔ Automation – Enables automatic storage and retrieval of data, reducing manual work.

Q2:
Types of Files and Stream Classes in C++
Definition (From PDF, Simplified)
File handling in C++ allows storing, retrieving, and manipulating data in secondary storage using
streams. It helps manage large amounts of data efficiently and persistently.
Key Points in Bullet Form
✔ Types of Files in C++:
• Text Files: Store data in a human-readable format (.txt). Data is stored as a sequence of
characters.
• Binary Files: Store data in machine-readable format (.bin), which improves processing speed
and memory efficiency.
✔ File Stream Classes in C++:
• ifstream (Input File Stream): Used for reading data from files.
• ofstream (Output File Stream): Used for writing data into files.
• fstream (File Stream): A combination of ifstream and ofstream, used for both reading and
writing operations.
✔ Importance of File Handling in C++:
• Data Persistence: Data remains stored even after program execution ends.
• Efficient Storage: Allows handling large datasets without memory limitations.
• Data Transfer: Enables data sharing between different programs and systems.
• Security & Backup: Files can be encrypted and used for storing critical information.

Q3:
Difference in File Operation Modes in C++
Definition (From PDF, Simplified)
File operation modes in C++ determine how a file is accessed—whether for reading, writing,
appending, or modifying data. These modes are defined using ios flags in C++ file handling.
Key Points in Bullet Form
✔ Common File Modes in C++:
• ios::in → Opens file for reading.
• ios::out → Opens file for writing (erases existing content).
• ios::app → Opens file for appending (adds new data at the end).
• ios::ate → Opens file and moves pointer to the end (allows modification).
• ios::trunc → Clears file contents before opening.
• ios::binary → Opens file in binary mode (for non-text data).
✔ Comparison Between C++ & C File Operations:
Feature C (stdio.h) C++ (fstream)
File Handling Uses FILE* pointer Uses ifstream, ofstream, fstream classes
Opening a File fopen("file.txt", "r") fstream file("file.txt", ios::in)
Reading/Writing Uses fgetc(), fputc() Uses >> and << operators
Closing a File fclose(file) file.close()
Binary Mode "rb", "wb" modes ios::binary flag
✔ Evaluation of File Operation Modes:
• C++ provides object-oriented file handling, making operations simpler and safer.
• C uses function-based file handling, requiring explicit pointer management.
• C++ offers stream-based operations, making input/output more intuitive.
• File modes in C++ offer more flexibility for handling different file types and operations.

Q4:
Difference Between Text and Binary Files
Definition (From PDF, Simplified)
Files in C++ can be categorized into text files and binary files based on how data is stored and
processed.
Key Points in Bullet Form
✔ Text File:
• Stores data in human-readable characters (ASCII or Unicode).
• Can be opened and edited with text editors (e.g., Notepad).
• Slower processing due to character conversions.
• Example: .txt, .csv, .log
✔ Binary File:
• Stores data in machine-readable binary format (0s and 1s).
• Cannot be read directly by text editors.
• Faster processing since no conversion is needed.
• Example: .exe, .jpg, .dat
✔ Comparison Table:
Feature Text File Binary File
Storage Stores characters as text Stores data in binary format
Readability Human-readable Not human-readable
Size Larger due to extra encoding Compact, no extra encoding
Speed Slower (due to conversions) Faster (direct data handling)
Editing Can be edited using Notepad Requires special software
✔ Use Cases:
• Text files are used for storing documents, configurations, and logs.
• Binary files are used for executables, images, and encrypted data.
Thus, text files are easier to use but slower, while binary files are efficient but require special
handling.

Q5:
Basic File Operations in C++ (Read, Write, etc.)
Definition (From PDF, Simplified)
File operations in C++ allow reading and writing data using file handling classes. The main operations
include opening, reading, writing, and closing files.
Key Points in Bullet Form
✔ File Handling Classes in C++:
 • ifstream → Used for reading files (input file stream).
• ofstream → Used for writing files (output file stream).
• fstream → Used for both reading and writing.
✔ Basic File Operations:
1⃣ Opening a File
• A file must be opened before performing any operations.
• Open modes:
o ios::in → Read mode
o ios::out → Write mode
o ios::app → Append mode
o ios::binary → Binary mode
2⃣ Reading from a File
• Data is read using ifstream or fstream with the >> operator or getline().
3⃣ Writing to a File
• Data is written using ofstream or fstream with the << operator.
4⃣ Closing a File
• Always close the file using close() after operations to free system resources.
✔ Example Operations:
Operation Description Class Used
Open File Open a file for reading/writing ifstream, ofstream, fstream
Read File Retrieve data from a file ifstream, fstream
Write File Save data to a file ofstream, fstream
Append File Add data at the end of a file ofstream (with ios::app)
Close File Close an opened file close() function
Thus, C++ provides powerful file handling operations that make it easy to store and retrieve data
efficiently!

Q6:
Difference Between ios::app and ios::trunc Mode in C++
Definition (From PDF, Simplified)
File opening modes determine how data is written to a file.
• ios::app (Append Mode) → Opens the file and adds new content at the end without deleting
existing data.
• ios::trunc (Truncate Mode) → Opens the file and deletes all previous content before writing
new data.
Key Differences in Bullet Form
✔ ios::app (Append Mode):
• Retains existing file content.
• New data is added at the end of the file.
• Used when data should be preserved.
✔ ios::trunc (Truncate Mode):
• Deletes all previous content of the file.
• Writes new data from scratch.
• Used when fresh content is needed every time.
Example Program
cpp
CopyEdit
#include <iostream>
#include <fstream>
using namespace std;

int main() {
// Using ios::app (Append Mode)
ofstream file1("example.txt", ios::app);
file1 << "This is new appended data.\n";
file1.close();

// Using ios::trunc (Truncate Mode)

ofstream file2("example.txt", ios::trunc);
file2 << "This is fresh data after truncation.\n";
file2.close();

return 0;
}
Explanation of the Program
✔ ios::app adds "This is new appended data." at the end of the existing file.
✔ ios::trunc clears the file and writes "This is fresh data after truncation."
✔ After running the program, only the truncated content remains in the file.
Expected Output in File (example.txt)
kotlin
CopyEdit
This is fresh data after truncation.
Thus, ios::app preserves old data, while ios::trunc erases it before writing new content.

Q7:
Write C++ program to open a file, write some text, and then read the content from the file

Definition (From PDF, Simplified)

File handling in C++ is used to store data permanently in files. You can write data to a file using
output stream and read it back using input stream.

Key Points in Bullet Form

✔ ofstream → Used to write to a file.
✔ ifstream → Used to read from a file.
✔ open() → Opens a file manually (optional when passing filename in constructor).
✔ close() → Closes the file after operations.
✔ getline() → Reads text line by line from file.

Example Program
cpp
CopyEdit
#include <iostream>
#include <fstream>
using namespace std;

int main() {
// Writing to a file
ofstream outfile("myfile.txt");
outfile << "Hello PT bhai!" << endl;
outfile << "This is a file handling example.";
 outfile.close();

// Reading from the file

ifstream infile("myfile.txt");
string line;
while (getline(infile, line)) {
cout << line << endl;
}
infile.close();

return 0;
}

Explanation of the Program in Bullet Form

✔ File myfile.txt is created using ofstream.
✔ Two lines are written into the file using << operator.
✔ outfile.close() safely closes the writing stream.
✔ File is then opened using ifstream to read content.
✔ getline() reads and displays each line on console.
✔ infile.close() ensures the reading stream is closed.

Expected Output
csharp
CopyEdit
Hello PT bhai!
This is a file handling example.

Q8:
Definition (From PDF, Simplified + Enhanced)
C++ file handling provides three main classes from the <fstream> library:
• ifstream (Input File Stream): Used to read data from a file.
• ofstream (Output File Stream): Used to write data to a file.
• fstream (File Stream): Used for both reading and writing to a file.

Descriptive Comparison of ifstream, ofstream, and fstream

Feature ifstream ofstream fstream
For reading data from
Purpose For writing data to a file For both reading and writing data
a file
Default Mode ios::in ios::out `ios::in
Header
<fstream> <fstream> <fstream>
Required
Reading
✔ Yes No ✔ Yes
Capability
Writing
No ✔ Yes ✔ Yes
Capability
Common .open(), .close(), .get(), .open(), .close(), .put(), All functions of ifstream and
Functions .getline() << operator ofstream combined
Use Case Reading configuration Writing output files or Performing both read/write on the
Example files or logs logs same file simultaneously
Feature ifstream ofstream fstream
Example ifstream ofstream
fstream file("data.txt");
Syntax fin("data.txt"); fout("data.txt");
Need to Close Yes, using .close() Yes, using .close()
Yes, using .close() method
File? method method

Q9:
Definition (From PDF, Simplified)
• ifstream (Input File Stream) is used to read data from a file.
• ofstream (Output File Stream) is used to write data to a file.
• Dono classes <fstream> header se aate hain and file ke input/output operations handle karte
hain.

Comparison Between ifstream and ofstream

Feature/Aspect ifstream ofstream
Full Form Input File Stream Output File Stream
Purpose Reading data from file Writing data to file
Default Mode ios::in ios::out
File Creation Does not create new file Creates file if it doesn’t exist
File Overwriting Does not modify file Overwrites content by default
Use Case When you want to fetch/read file data When you want to store/save data
Syntax Example ifstream file("data.txt"); ofstream file("data.txt");
Functionality Reads using >> or getline() Writes using <<
File Close file.close(); file.close();

Short Explanation
✔ ifstream is used when we want to fetch content from a file — like reading data.
✔ ofstream is used when we want to create a file or save some output — like writing notes, logs etc.
✔ Both need #include <fstream> and must be closed using .close() after work.

Q10:
Analyze the impact of using ios::ate while reading a file and show its use

Definition (From PDF, Simplified)

• ios::ate stands for "at end", and it is a file open mode in C++.
• It opens the file and immediately moves the file pointer to the end, but you can still
read/write from anywhere using seekg() or seekp().

Key Points in Bullet Form

✔ ios::ate sets the initial position of the pointer at the end of file.
✔ Unlike ios::app, it does not restrict writing/reading only at end.
✔ Useful when you want to read data from anywhere after first checking the end or size of file.
✔ You can use seekg() to move the pointer to any desired location.
Example Program (Simple & Easy)
cpp
CopyEdit
#include <iostream>
#include <fstream>
using namespace std;

int main() {
ifstream file("data.txt", ios::ate);
cout << "File opened with ios::ate mode." << endl;
file.close();
return 0;
}

Explanation of Program (Short & Simple)

✔ File "data.txt" is opened with ios::ate — pointer goes to end.
✔ It shows that file is opened successfully using that mode.
✔ Reading or moving pointer can be done later using seekg().

Q11:
Definition (From PDF, Simplified)
• Text File: Stores data in human-readable format using characters (ASCII).
• Binary File: Stores data in machine-readable format (0s and 1s), more compact and faster to
process.

Key Points in Bullet Form

Feature Text File Binary File
Format Human-readable (ASCII) Machine-readable (binary)
Storage Takes more space Takes less space
Readability Can be opened in notepad/editor Cannot be read directly
Speed Slower (character-by-character) Faster (byte-by-byte)
Use For simple data (like text, logs) For complex data (images, videos)
Functions Used ifstream, ofstream read(), write()

Example:
• Text File: notes.txt — stores "Hello PT bhai" as characters
• Binary File: image.bin — stores image pixels in binary format

Q12:
Simple C++ Program to Copy One File to Another
cpp
CopyEdit
#include <fstream>
using namespace std;

int main() {
char ch;
ifstream fin("source.txt");
ofstream fout("copy.txt");

while (fin.get(ch)) {
fout.put(ch);
}
 fin.close();
fout.close();

return 0;
}

Explanation (Short & Simple)

• fin.get(ch) reads character-by-character from source.txt.
• fout.put(ch) writes each character to copy.txt.
• Simple and works for all types of text content.
• Close files after copying.

Expected Output
✔ Content of source.txt is copied into copy.txt.
Q1:
UML (Unified Modeling Language) is a standardized general-purpose modeling language used to
visualize, specify, construct, and document the components of software systems.
It helps in designing and understanding software architecture with a set of graphical notation
techniques.

Key Features of UML (As per PDF)

• Standardized – UML is accepted internationally and used widely in software engineering.
• Graphical Language – Uses diagrams to represent systems and their interactions.
• Supports Object-Oriented Concepts – Like inheritance, encapsulation, abstraction, and
polymorphism.
• Helps in Visualizing Design – Makes it easier to understand the flow and structure of the
software system.
• Facilitates Communication – Useful for both technical and non-technical stakeholders.
• Supports Reusability – Encourages modular design and reuse of software components.
• Platform Independent – UML is not tied to any specific programming language or tool.

Q2:
Question: Identify and Describe Any Components of the Class Diagram

Definition (From PDF, Simplified)

A Class Diagram is one of the most commonly used UML diagrams.
It shows the static structure of a system by representing classes, their attributes, operations
(methods), and the relationships among them.

Key Components of a Class Diagram

Class – Represented by a rectangle divided into three parts:
➤ Top: Class name
➤ Middle: Attributes (variables)
➤ Bottom: Methods (functions)
Attributes – Describe the data members or properties of a class.
Example: name, age
Operations/Methods – Describe the behavior or functions of a class.
Example: getName(), calculateTotal()
Visibility Symbols – Indicate access specifiers:
➤ + Public ➤ - Private ➤ # Protected
Relationships – Show how classes are related:
➤ Association – A basic link between classes
➤ Inheritance (Generalization) – One class inherits from another
➤ Aggregation – Whole-part relationship (weaker)
➤ Composition – Strong whole-part relationship
Multiplicity – Defines how many instances of a class can relate to one instance of another class
(like 1..*, 0..1, etc.)

Q3:
Question: What is a Class and Components of a Class Diagram

Definition of Class (From UML PDF, Simplified):

A class is a blueprint or template in object-oriented modeling that describes the attributes (data) and
operations (functions) shared by objects of that class. In UML, it is represented as a rectangle divided
into compartments.

Components of a Class Diagram:

1. Class Name
o Represents the name of the class (e.g., Student, Employee).
2. Attributes
o Describe the properties or data members of the class.
o Example: name, age, salary
3. Operations (Methods)
o Define the behavior or functionalities of the class.
o Example: getDetails(), calculateSalary()
4. Visibility Notations
o + Public
o - Private
o # Protected
5. Relationships Between Classes
o Association: Shows a relationship between two classes.
o Generalization: Inheritance (is-a relationship).
o Aggregation / Composition: Part-of relationship.

Key Points (Bullet Style):

• UML class diagram visually represents system structure.
• Each class is shown as a 3-part rectangle: name, attributes, and operations.
• Visibility symbols define access control.
• Lines/arrows show how classes interact or relate.

Q4:
Question: What Are the Different Types of Relationships Depicted in UML Diagrams

Definition (From UML PDF, Simplified):

In UML (Unified Modeling Language), relationships show how different classes or components are
connected and interact. They help in understanding structure and behavior of a system.

Types of Relationships in UML Diagrams:

1. Association
o A basic relationship where one class is connected to another.
o Example: A Teacher teaches many Students.
2. Multiplicity
o Indicates how many instances of one class relate to another.
o Example: 1..* (One-to-many relationship)
3. Aggregation
o A "has-a" relationship (weak ownership).
o Example: A Library has Books, but books can exist independently.
4. Composition
o A strong "part-of" relationship (strong ownership).
o Example: A House has Rooms. If the house is destroyed, rooms are too.
5. Generalization (Inheritance)
o Shows an "is-a" relationship between a superclass and subclasses.
o Example: Car is a Vehicle.
 6. Dependency
o One class depends on another to perform a function.
o Example: Doctor uses a Prescription.

Key Points (Quick Recap):

• Association = Basic connection between classes.
• Aggregation = Whole-part, but parts can live independently.
• Composition = Whole-part, but parts die with the whole.
• Generalization = Inheritance or hierarchy.
• Dependency = Temporary use of another class.
• Multiplicity = Shows "how many" in a relationship.

Q5:
Question: Explain the Concept of Relationships and How They Interact with Classes

Definition (From UML PDF, Simplified):

In UML, relationships define how classes or objects are connected and interact with each other.
These connections help in representing the logical and structural connections in object-oriented
design.

How Relationships Interact with Classes:

• Relationships connect classes to show communication, control, or ownership.
• They describe how objects collaborate or depend on one another during system execution.
• UML supports multiple types of relationships (like association, aggregation, etc.) that model
different interaction levels.

Types of Class Interactions Through Relationships:

1. Association – Basic link between classes.
Example: A Teacher is associated with many Students.
2. Aggregation – One class contains another (weak relationship).
Example: A Team has Players.
3. Composition – Strong ownership; contained objects do not exist independently.
Example: A Car has Engine.
4. Inheritance (Generalization) – One class inherits from another.
Example: Dog is a type of Animal.
5. Dependency – One class temporarily uses another.
Example: Customer depends on Invoice.

Key Points Summary:

• Relationships describe how classes work together.
• Help in modeling object communication and structure.
• Define behavior and structure in UML diagrams.
• Important for designing scalable and modular systems.