1a) Explain what is type conversions?

Define implicit type casting and explicit

type casting with examples.

Type Conversions refer to the process of converting a variable from one data type
to another. This is often necessary when performing operations that involve
different data types.

Implicit Type Casting (also known as automatic type conversion) is performed by the
compiler without any explicit instruction from the programmer. This usually happens
when a smaller data type is converted to a larger data type to prevent data loss.

Example of Implicit Type Casting:

int a = 10;
double b = a; // 'a' is implicitly converted to double

Explicit Type Casting (also known as type casting) is when the programmer
explicitly specifies the type conversion. This is done using casting operators.

Example of Explicit Type Casting:

double a = 10.5;
int b = (int)a; // 'a' is explicitly converted to int

1b) Explain Virtual destructor with the help of a program.

A virtual destructor is a destructor that is declared with the `virtual` keyword in

a base class. It ensures that when an object of a derived class is deleted through
a base class pointer, the derived class's destructor is called, preventing resource
leaks.

Example:

#include <iostream>
using namespace std;

class Base {
public:
virtual ~Base() { // Virtual destructor
cout << "Base destructor called" << endl;
}
};

class Derived : public Base {

public:
~Derived() { // Destructor for derived class
cout << "Derived destructor called" << endl;
}
};

int main() {
Base* b = new Derived(); // Create a Derived object
delete b; // Delete through base class pointer
return 0;
}
Output:

Derived destructor called

Base destructor called

In this example, when `delete b` is called, the destructor of `Derived` is invoked

first, followed by the destructor of `Base`, thanks to the virtual destructor.
1c) Write a C++ program to overload the binary operator '+' to add two complex
numbers using member function and friend function.

Example:

#include <iostream>
using namespace std;

class Complex {
private:
float real;
float imag;

public:
// Constructor
Complex(float r = 0, float i = 0) : real(r), imag(i) {}

// Member function to overload '+' operator

Complex operator+(const Complex& c) {
return Complex(real + c.real, imag + c.imag);
}

// Friend function to overload '+' operator

friend Complex operator+(const Complex& c1, const Complex& c2);

// Function to display the complex number

void display() {
cout << real << " + " << imag << "i" << endl;
}
};

// Friend function implementation

Complex operator+(const Complex& c1, const Complex& c2) {
return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

int main() {
Complex c1(3.5, 2.5), c2(1.5, 4.5);

// Using member function

Complex c3 = c1 + c2; // Calls member function
c3.display();

// Using friend function

Complex c4 = operator+(c1, c2); // Calls friend function
c4.display();

return 0;
}
Output:

5 + 7i
5 + 7i

In this program, the `+` operator is overloaded both as a member function and as a
friend function to add two complex numbers.
2a) Explain Polymorphism and Types of Polymorphism.

Polymorphism is a core concept in object-oriented programming that allows objects

to be treated as instances of their parent class, even though they may be instances
of derived classes. It enables a single interface to represent different underlying
forms (data types).

There are two main types of polymorphism in C++:

1. Compile-time Polymorphism (also known as static polymorphism):

- Achieved through function overloading and operator overloading.
- The function to be invoked is determined at compile time.

Example of Function Overloading:

class Print {
public:
void show(int i) {
cout << "Integer: " << i << endl;
}
void show(double d) {
cout << "Double: " << d << endl;
}
};

2. Run-time Polymorphism (also known as dynamic polymorphism):

- Achieved through function overriding using virtual functions.
- The function to be invoked is determined at runtime based on the type of the
object pointed to by the base class pointer.

Example of Function Overriding:

class Base {
public:
virtual void show() {
cout << "Base class show function called." << endl;
}
};

class Derived : public Base {

public:
void show() override {
cout << "Derived class show function called." << endl;
}
};

2b) How do you declare and define a pure virtual function in C++? Explain with the
help of a program.

A pure virtual function is a function declared in a base class that has no

definition in that class and is intended to be overridden in derived classes. It is
declared by assigning `0` to the function declaration. A class containing at least
one pure virtual function is called an abstract class.

Example:

#include <iostream>
using namespace std;

// Abstract class
class Shape {
public:
// Pure virtual function
virtual void draw() = 0; // No definition in the base class
};

class Circle : public Shape {

public:
void draw() override { // Override the pure virtual function
cout << "Drawing a Circle" << endl;
}
};

class Square : public Shape {

public:
void draw() override { // Override the pure virtual function
cout << "Drawing a Square" << endl;
}
};

int main() {
Shape* shape1 = new Circle(); // Create a Circle object
Shape* shape2 = new Square(); // Create a Square object

shape1->draw(); // Calls Circle's draw

shape2->draw(); // Calls Square's draw

delete shape1;
delete shape2;

return 0;
}

Output:

Drawing a Circle
Drawing a Square

In this example, `Shape` is an abstract class with a pure virtual function

`draw()`. The derived classes `Circle` and `Square` provide their own
implementations of the `draw()` function.

2c) Explain the need for operator overloading. Write a C++ program to demonstrate
the use of unary operator overloading.

Need for Operator Overloading:

Operator overloading allows developers to define custom behavior for operators
(like +, -, *, etc.) when they are used with user-defined types (like classes).
This makes the code more intuitive and easier to read, as it allows objects of
user-defined types to be manipulated using standard operators, just like built-in
types.

Example of Unary Operator Overloading:

In this example, we will overload the unary `++` operator to increment a complex
number.

#include <iostream>
using namespace std;

class Complex {
private:
float real;
float imag;

public:
// Constructor
Complex(float r = 0, float i = 0) : real(r), imag(i) {}

// Overloading the unary ++ operator

Complex operator++() { // Prefix increment
++real; // Increment real part
++imag; // Increment imaginary part
return *this; // Return the incremented object
}

// Function to display the complex number

void display() {
cout << real << " + " << imag << "i" << endl;
}
};

int main() {
Complex c1(1.5, 2.5);
cout << "Original Complex Number: ";
c1.display();

++c1; // Using overloaded ++ operator

cout << "After Increment: ";
c1.display();

return 0;
}

Output:

Original Complex Number: 1.5 + 2.5i

After Increment: 2.5 + 3.5i

In this program, the unary `++` operator is overloaded to increment both the real
and imaginary parts of a complex number. The result is that we can use the `++`
operator intuitively with our `Complex` class.

3a) Explain overloading the extraction (>>) and insertion (<<) operator with the
help of a program.

Overloading the extraction (`>>`) and insertion (`<<`) operators allows us to use
these operators to read from and write to objects of user-defined types, such as
classes. This makes it easier to input and output data in a more intuitive way.

Example:
In this example, we will overload the `>>` operator for input and the `<<` operator
for output for a `Complex` class.

#include <iostream>
using namespace std;

class Complex {
private:
float real;
float imag;

public:
// Constructor
Complex(float r = 0, float i = 0) : real(r), imag(i) {}

// Overloading the insertion operator (<<)

friend ostream& operator<<(ostream& out, const Complex& c) {
out << c.real << " + " << c.imag << "i";
return out;
}

// Overloading the extraction operator (>>)

friend istream& operator>>(istream& in, Complex& c) {
cout << "Enter real and imaginary parts: ";
in >> c.real >> c.imag;
return in;
}
};

int main() {
Complex c1;

// Using overloaded >> operator

cin >> c1; // Input complex number

// Using overloaded << operator

cout << "Complex Number: " << c1 << endl;

return 0;
}

Output:

Enter real and imaginary parts: 3.5 4.5

Complex Number: 3.5 + 4.5i

In this program, the `>>` operator is overloaded to read the real and imaginary
parts of a complex number from the user, while the `<<` operator is overloaded to
display the complex number in a user-friendly format.
 3b) What are File Pointers? Explain `seekg()` and `tellg()` functions with syntax.

File Pointers are used to keep track of the current position in a file when
performing read or write operations. In C++, file pointers are managed using the
`fstream` library, which provides functions to manipulate the position of the file
pointer.

`seekg()` Function:
- The `seekg()` function is used to set the position of the get pointer (input
pointer) in a file.
- It can be used to move the pointer to a specific location in the file.

Syntax:

file.seekg(offset, direction);

- `offset`: The number of bytes to move the pointer.

- `direction`: The position from where to move the pointer. It can be:
- `ios::beg`: Beginning of the file.
- `ios::cur`: Current position of the pointer.
- `ios::end`: End of the file.

`tellg()` Function:
- The `tellg()` function returns the current position of the get pointer in the
file.
- It is useful for determining where the next read operation will occur.

Syntax:

streampos pos = file.tellg();

Example:

#include <iostream>
#include <fstream>
using namespace std;

int main() {
// Create and open a text file
ofstream outfile("example.txt");
outfile << "Hello, World!" << endl;
outfile << "Welcome to file handling in C++." << endl;
outfile.close();

// Open the file for reading

ifstream infile("example.txt");

// Move the get pointer to the beginning of the file

infile.seekg(0, ios::beg);
cout << "Current position: " << infile.tellg() << endl; // Should be 0

string line;
while (getline(infile, line)) {
cout << line << endl;
cout << "Current position after reading: " << infile.tellg() << endl;
}
 infile.close();
return 0;
}

Output:

Current position: 0
Hello, World!
Current position after reading: 14
Welcome to file handling in C++.
Current position after reading: 45

In this example, we create a file and write some text to it. We then open the file
for reading, use `seekg()` to set the position of the get pointer, and use
`tellg()` to display the current position of the pointer after reading each line.

3c) Write a program that emulates the DOS COPY command. The program should copy
the contents of a text file to another file. Invoke the program with two command-
line arguments—the source file and the destination file. Check that the user has
typed the correct number of command-line arguments and that the specified files can
be opened.

Example Program:

#include <iostream>
#include <fstream>
#include <cstdlib> // For exit()
using namespace std;

int main(int argc, char* argv[]) {

// Check for the correct number of command-line arguments
if (argc != 3) {
cerr << "Usage: " << argv[0] << " <source_file> <destination_file>" <<
endl;
return 1;
}

// Open the source file

ifstream sourceFile(argv[1]);
if (!sourceFile) {
cerr << "Error: Could not open source file " << argv[1] << endl;
return 1;
}

// Open the destination file

ofstream destFile(argv[2]);
if (!destFile) {
cerr << "Error: Could not open destination file " << argv[2] << endl;
return 1;
}

// Copy contents from source file to destination file

string line;
while (getline(sourceFile, line)) {
destFile << line << endl;
}
 // Close the files
sourceFile.close();
destFile.close();

cout << "File copied successfully from " << argv[1] << " to " << argv[2] <<
endl;
return 0;
}
File copied successfully from source.txt to destination.txt

This program checks for the correct number of command-line arguments, attempts to
open the specified files, and copies the contents of the source file to the
destination file line by line.

4a) List and explain different mode bits used in the `open()` function while
opening a file. (Any five)

When opening a file in C++, the `open()` function can take various mode bits that
determine how the file will be accessed. Here are five commonly used mode bits:

1. `ios::in`:
- Opens the file for reading.
- If the file does not exist, the open operation fails.

2. `ios::out`:
- Opens the file for writing.
- If the file already exists, its contents are truncated (cleared).
- If the file does not exist, a new file is created.

3. `ios::app`:
- Opens the file for writing, but all output operations are performed at the end
of the file.
- This mode does not truncate the file; it preserves existing content.

4. `ios::binary`:
- Opens the file in binary mode.
- This is used for reading or writing binary files, which allows for non-text
data to be processed correctly.

5. `ios::trunc`:
- If the file is opened for output and it already exists, its contents are
discarded (truncated).
- This mode is often used in conjunction with `ios::out`.

Example of Using Mode Bits:

#include <iostream>
#include <fstream>
using namespace std;

int main() {
// Open a file for writing (truncating if it exists)
ofstream outfile("example.txt", ios::out | ios::trunc);
outfile << "Hello, World!" << endl;
outfile.close();

// Open the same file for reading

ifstream infile("example.txt", ios::in);
string line;
 while (getline(infile, line)) {
cout << line << endl;
}
infile.close();

return 0;
}

In this example, we use `ios::out | ios::trunc` to open a file for writing, which
truncates it if it already exists. We then open the same file for reading using
`ios::in`.

4b) Define a class `Book` that has three attributes: `bookname`, `author`, and
`price`. Write a C++ program that writes an object to a file and reads an object
from a file.

Example Program:

#include <iostream>
#include <fstream>
using namespace std;

class Book {
private:
string bookname;
string author;
float price;

public:
// Constructor
Book(string bname = "", string auth = "", float pr = 0.0)
: bookname(bname), author(auth), price(pr) {}

// Function to display book details

void display() {
cout << "Book Name: " << bookname << endl;
cout << "Author: " << author << endl;
cout << "Price: $" << price << endl;
}

// Function to write book details to a file

void writeToFile(ofstream& outFile) {
outFile << bookname << endl;
outFile << author << endl;
outFile << price << endl;
}

// Function to read book details from a file

void readFromFile(ifstream& inFile) {
getline(inFile, bookname);
getline(inFile, author);
inFile >> price;
inFile.ignore(); // Ignore the newline character after reading price
}
};

int main() {
// Create a Book object
 Book book1("The Great Gatsby", "F. Scott Fitzgerald", 10.99);

// Write the book object to a file

ofstream outFile("book.txt");
book1.writeToFile(outFile);
outFile.close();

// Create another Book object to read data into

Book book2;

// Read the book object from the file

ifstream inFile("book.txt");
book2.readFromFile(inFile);
inFile.close();

// Display the book details

cout << "Book Details from File:" << endl;
book2.display();

return 0;
}

Output:

Book Details from File:

Book Name: The Great Gatsby
Author: F. Scott Fitzgerald
Price: $10.99

In this program, we define a `Book` class with attributes for the book name,
author, and price. We implement methods to write the book details to a file and
read them back from a file. The program demonstrates writing a `Book` object to a
file and then reading it back to display the details.

4c) What do you mean by file handling? Explain the following functions with syntax
and an example:
i) `open()`
ii) `read()`
iii) `write()`

File Handling in C++ refers to the process of creating, opening, reading, writing,
and closing files. It allows programs to store data permanently and retrieve it
later. C++ provides the `fstream` library to handle file operations.

# i) `open()`
The `open()` function is used to open a file. It can take a filename and a mode
(like read, write, etc.) as arguments.

Syntax:

fstream file;
file.open("filename.txt", ios::in | ios::out | ios::app);

# ii) `read()`
The `read()` function is used to read data from a file. It can read a specified
number of bytes from the file into a buffer.
Syntax:

file.read(buffer, size);

# iii) `write()`
The `write()` function is used to write data to a file. It writes a specified
number of bytes from a buffer to the file.

Syntax:

file.write(buffer, size);

Example Program:

#include <iostream>
#include <fstream>
using namespace std;

int main() {
// Writing to a file
ofstream outFile;
outFile.open("example.txt", ios::out); // Open file for writing
if (!outFile) {
cerr << "Error opening file for writing!" << endl;
return 1;
}
string data = "Hello, World!";
outFile.write(data.c_str(), data.size()); // Write data to file
outFile.close(); // Close the file

// Reading from a file

ifstream inFile;
inFile.open("example.txt", ios::in); // Open file for reading
if (!inFile) {
cerr << "Error opening file for reading!" << endl;
return 1;
}
char buffer[50];
inFile.read(buffer, sizeof(buffer)); // Read data from file
buffer[inFile.gcount()] = '\0'; // Null-terminate the string
cout << "Data read from file: " << buffer << endl; // Display the data
inFile.close(); // Close the file

return 0;
}

Output:

Data read from file: Hello, World!

In this example, we demonstrate file handling by writing a string to a file using

the `write()` function and then reading it back using the `read()` function. The
`open()` function is used to open the file for both writing and reading.
 5a) Explain the fundamentals of exceptions in C++ with a suitable example.

Exceptions in C++ are a way to handle errors or exceptional conditions that occur
during the execution of a program. The main goal of exception handling is to
separate error-handling code from regular code, making the program easier to read
and maintain.

The fundamental components of exception handling in C++ are:

1. Throwing an Exception: When an error occurs, an exception is thrown using the

`throw` keyword.
2. Catching an Exception: The thrown exception can be caught using a `try` block
followed by one or more `catch` blocks.
3. Handling the Exception: The code inside the `catch` block is executed to handle
the exception.

Example:

#include <iostream>
using namespace std;

void divide(int a, int b) {

if (b == 0) {
throw runtime_error("Division by zero error!"); // Throwing an exception
}
cout << "Result: " << a / b << endl;
}

int main() {
try {
divide(10, 0); // This will throw an exception
} catch (const runtime_error& e) {
cout << "Caught an exception: " << e.what() << endl; // Catching the
exception
}

return 0;
}

Output:

Caught an exception: Division by zero error!

In this example, the `divide` function checks if the denominator is zero. If it is,
it throws a `runtime_error` exception. In the `main` function, we use a `try` block
to call `divide`, and if an exception is thrown, it is caught in the `catch` block,
where we print the error message.

5b) Discuss class templates with a suitable example in C++.

Class Templates in C++ allow us to create a blueprint for a class that can work
with any data type. This enables code reusability and type safety, as we can define
a class once and use it with different data types without rewriting the code.

Syntax:
template <typename T>
class ClassName {
// Class definition using type T
};

Example:
In this example, we will create a simple class template for a `Pair` that holds two
values of the same type.

#include <iostream>
using namespace std;

template <typename T>

class Pair {
private:
T first;
T second;

public:
// Constructor
Pair(T f, T s) : first(f), second(s) {}

// Function to display the pair

void display() {
cout << "First: " << first << ", Second: " << second << endl;
}

// Function to get the sum of the pair

T sum() {
return first + second;
}
};

int main() {
// Create a Pair of integers
Pair<int> intPair(10, 20);
intPair.display();
cout << "Sum: " << intPair.sum() << endl;

// Create a Pair of doubles

Pair<double> doublePair(10.5, 20.5);
doublePair.display();
cout << "Sum: " << doublePair.sum() << endl;

return 0;
}

Output:

First: 10, Second: 20

Sum: 30
First: 10.5, Second: 20.5
Sum: 31

In this example, we define a class template `Pair` that can hold two values of the
same type `T`. We create instances of `Pair` for both `int` and `double` types,
demonstrating how the same class template can be used with different data types.
The `display` function shows the values, and the `sum` function calculates the sum
of the two values.

5c) Write a program in C++ to demonstrate a Divide by Zero exception.

In this example, we will create a simple program that performs division and
demonstrates how to handle a "divide by zero" exception using C++ exception
handling.

Example Program:

#include <iostream>
#include <stdexcept> // For std::runtime_error
using namespace std;

double divide(double numerator, double denominator) {

if (denominator == 0) {
throw runtime_error("Error: Division by zero!"); // Throwing an exception
}
return numerator / denominator;
}

int main() {
double num, denom;

cout << "Enter numerator: ";

cin >> num;
cout << "Enter denominator: ";
cin >> denom;

try {
double result = divide(num, denom); // Attempt to divide
cout << "Result: " << result << endl;
} catch (const runtime_error& e) {
cout << e.what() << endl; // Catching and displaying the exception message
}

return 0;
}

Output:

Enter numerator: 10
Enter denominator: 0
Error: Division by zero!

In this program, the `divide` function checks if the denominator is zero. If it is,
it throws a `runtime_error` exception. In the `main` function, we prompt the user
for input and attempt to perform the division. If a division by zero occurs, the
exception is caught, and an appropriate error message is displayed.

6a) Write a program to demonstrate user-defined exceptions in C++.

In this example, we will create a user-defined exception class to handle specific

error conditions. We will demonstrate how to throw and catch this custom exception.
Example Program:

#include <iostream>
#include <string>
using namespace std;

// User-defined exception class

class DivisionByZeroException {
public:
const char* what() const {
return "Error: Division by zero!";
}
};

double divide(double numerator, double denominator) {

if (denominator == 0) {
throw DivisionByZeroException(); // Throwing user-defined exception
}
return numerator / denominator;
}

int main() {
double num, denom;

cout << "Enter numerator: ";

cin >> num;
cout << "Enter denominator: ";
cin >> denom;

try {
double result = divide(num, denom); // Attempt to divide
cout << "Result: " << result << endl;
} catch (const DivisionByZeroException& e) {
cout << e.what() << endl; // Catching and displaying the user-defined
exception message
}

return 0;
}

Output:

Enter numerator: 10
Enter denominator: 0
Error: Division by zero!

In this program, we define a user-defined exception class

`DivisionByZeroException`. The `divide` function checks if the denominator is zero
and throws this exception if it is. In the `main` function, we prompt the user for
input and attempt to perform the division. If a division by zero occurs, the custom
exception is caught, and an appropriate error message is displayed.

6b) What is a template in C++? Discuss templates with multitype parameters in C++.

Templates in C++ are a powerful feature that allows developers to create generic
classes and functions. This means that you can write a function or class that can
operate with any data type without needing to rewrite the code for each type.
Templates enable code reusability and type safety.

There are two main types of templates in C++:

1. Function Templates: Allow you to create a function that can work with any data
type.
2. Class Templates: Allow you to create a class that can work with any data type.

Multitype Parameters in Templates: C++ also supports templates with multiple type
parameters, allowing you to define functions or classes that can accept more than
one type.

Example of a Class Template with Multitype Parameters:

#include <iostream>
using namespace std;

// Class template with two type parameters

template <typename T1, typename T2>
class Pair {
private:
T1 first;
T2 second;

public:
// Constructor
Pair(T1 f, T2 s) : first(f), second(s) {}

// Function to display the pair

void display() {
cout << "First: " << first << ", Second: " << second << endl;
}
};

int main() {
// Create a Pair of int and double
Pair<int, double> intDoublePair(10, 20.5);
intDoublePair.display();

// Create a Pair of string and char

Pair<string, char> stringCharPair("Hello", 'A');
stringCharPair.display();

return 0;
}

Output:

First: 10, Second: 20.5

First: Hello, Second: A

In this example, we define a class template `Pair` that takes two type parameters,
`T1` and `T2`. This allows us to create pairs of different types, such as an `int`
and a `double`, or a `string` and a `char`. The `display` function shows the values
of the pair.
6c) Write a program to demonstrate function templates in C++.

Function templates allow you to create a single function definition that can work
with different data types. This is useful for writing generic functions that can
operate on various types without code duplication.

Example Program:
In this example, we will create a function template to find the maximum of two
values.

#include <iostream>
using namespace std;

// Function template to find the maximum of two values

template <typename T>
T findMax(T a, T b) {
return (a > b) ? a : b; // Return the greater value
}

int main() {
// Using the function template with int
int int1 = 10, int2 = 20;
cout << "Max of " << int1 << " and " << int2 << " is: " << findMax(int1, int2)
<< endl;

// Using the function template with double

double double1 = 10.5, double2 = 20.5;
cout << "Max of " << double1 << " and " << double2 << " is: " <<
findMax(double1, double2) << endl;

// Using the function template with char

char char1 = 'A', char2 = 'B';
cout << "Max of " << char1 << " and " << char2 << " is: " << findMax(char1,
char2) << endl;

return 0;
}

Output:

Max of 10 and 20 is: 20

Max of 10.5 and 20.5 is: 20.5
Max of A and B is: B

In this program, we define a function template `findMax` that takes two parameters
of the same type and returns the maximum of the two. We demonstrate the use of this
function template with different data types: `int`, `double`, and `char`. The same
function works seamlessly with all these types, showcasing the power of function
templates in C++.

7a) Write a program to demonstrate a map in C++.

In C++, a `map` is a part of the Standard Template Library (STL) and is used to
store key-value pairs. It is an associative container that allows fast retrieval of
values based on their keys. The keys in a map are unique, and the map is usually
implemented as a balanced binary tree.
Example Program:
In this example, we will create a map to store the names of students and their
corresponding scores.

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
// Create a map to store student names and their scores
map<string, int> studentScores;

// Inserting data into the map

studentScores["Alice"] = 85;
studentScores["Bob"] = 90;
studentScores["Charlie"] = 78;

// Displaying the contents of the map

cout << "Student Scores:" << endl;
for (const auto& pair : studentScores) {
cout << pair.first << ": " << pair.second << endl; // pair.first is the
key, pair.second is the value
}

// Accessing a specific value using a key

string studentName = "Bob";
cout << studentName << "'s score: " << studentScores[studentName] << endl;

// Checking if a key exists

if (studentScores.find("David") == studentScores.end()) {
cout << "David is not in the map." << endl;
}

return 0;
}

Output:

Student Scores:
Alice: 85
Bob: 90
Charlie: 78
Bob's score: 90
David is not in the map.

In this program, we create a `map` called `studentScores` to store student names as

keys and their scores as values. We insert some data into the map, display the
contents, access a specific score using a key, and check if a key exists in the
map. This demonstrates the basic usage of maps in C++.
7b) Enlist various containers in STL. Explain any one with the help of a program.

The Standard Template Library (STL) in C++ provides several types of containers to
store collections of data. Here are some of the commonly used containers:
1. Vector: A dynamic array that can grow in size. It allows random access to
elements.
2. List: A doubly linked list that allows efficient insertion and deletion of
elements.
3. Deque: A double-ended queue that allows insertion and deletion at both ends.
4. Set: A collection of unique elements, implemented as a balanced binary tree.
5. Map: A collection of key-value pairs, where keys are unique.
6. Multiset: Similar to a set, but allows duplicate elements.
7. Multimap: Similar to a map, but allows duplicate keys.

Explanation of Vector with Example:

A `vector` is a sequence container that encapsulates dynamic size arrays. It
provides the ability to store elements in a contiguous memory location and allows
for efficient access and modification.

Example Program:

#include <iostream>
#include <vector>
using namespace std;

int main() {
// Create a vector of integers
vector<int> numbers;

// Adding elements to the vector

numbers.push_back(10);
numbers.push_back(20);
numbers.push_back(30);
numbers.push_back(40);

// Displaying the elements of the vector

cout << "Elements in the vector: ";
for (int num : numbers) {
cout << num << " ";
}
cout << endl;

// Accessing elements using index

cout << "First element: " << numbers[0] << endl;
cout << "Second element: " << numbers.at(1) << endl; // Using at() for bounds
checking

// Removing the last element

numbers.pop_back();
cout << "After popping the last element: ";
for (int num : numbers) {
cout << num << " ";
}
cout << endl;

return 0;
}

Output:

Elements in the vector: 10 20 30 40

First element: 10
Second element: 20
After popping the last element: 10 20 30

In this program, we create a `vector` of integers and demonstrate various

operations such as adding elements using `push_back()`, displaying the elements,
accessing elements using both index and `at()`, and removing the last element using
`pop_back()`. This showcases the flexibility and ease of use of vectors in C++.

7c) What is STL? Enlist and explain various components of STL.

STL (Standard Template Library) is a powerful set of C++ template classes and
functions that provide general-purpose classes and functions for data structures
and algorithms. It is designed to provide a standard way to manage collections of
data and perform operations on them efficiently.

The main components of STL are:

1. Containers: These are data structures that store objects and data. They can be
classified into:
- Sequence Containers: Store elements in a linear order (e.g., `vector`, `list`,
`deque`).
- Associative Containers: Store elements in a way that allows for fast retrieval
based on keys (e.g., `set`, `map`, `multiset`, `multimap`).
- Unordered Associative Containers: Store elements in a hash table for faster
access (e.g., `unordered_set`, `unordered_map`).

2. Algorithms: STL provides a rich set of algorithms that can be applied to

containers. These include sorting, searching, modifying, and manipulating data.
Examples include `sort()`, `find()`, `copy()`, and `transform()`.

3. Iterators: Iterators are objects that allow you to traverse the elements of a
container. They provide a way to access the elements of a container without
exposing the underlying structure. Iterators can be thought of as generalized
pointers. Types of iterators include:
- Input Iterators: Read elements from a container.
- Output Iterators: Write elements to a container.
- Forward Iterators: Can read and write elements in a single pass.
- Bidirectional Iterators: Can move both forward and backward.
- Random Access Iterators: Can access elements at arbitrary positions.

4. Function Objects (Functors): These are objects that can be called as if they
were functions. They are often used with algorithms to provide custom behavior.

5. Allocators: Allocators are used to manage memory for containers. They define how
memory is allocated and deallocated for the elements stored in the containers.

Example of Using STL Components:

Here’s a simple example that demonstrates the use of a vector (container), an
algorithm (sort), and iterators.

#include <iostream>
#include <vector>
#include <algorithm> // For sort
using namespace std;

int main() {
// Create a vector of integers
 vector<int> numbers = {5, 2, 8, 1, 4};

// Sort the vector using STL sort algorithm

sort(numbers.begin(), numbers.end());

// Display the sorted elements using an iterator

cout << "Sorted numbers: ";
for (vector<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) {
cout << *it << " ";
}
cout << endl;

return 0;
}

Output:

Sorted numbers: 1 2 4 5 8

In this example, we create a vector of integers, sort it using the `sort` algorithm
from STL, and then display the sorted numbers using an iterator. This showcases how
STL components work together to provide efficient data management and manipulation.

8a) What is an iterator? What are the various types of iterators?

Iterator: An iterator is an object that enables a programmer to traverse a

container, particularly lists. It provides a way to access the elements of a
container sequentially without exposing the underlying structure of the container.
Iterators are similar to pointers in that they can be incremented to point to the
next element in the container.

Types of Iterators:

1. Input Iterator:
- Allows reading elements from a container.
- Can be used to read each element only once.
- Supports operations like `++` (increment) and `*` (dereference).

2. Output Iterator:
- Allows writing elements to a container.
- Can be used to write each element only once.
- Supports operations like `++` (increment) and `*` (dereference).

3. Forward Iterator:
- Can read and write elements in a single pass.
- Supports incrementing and dereferencing.
- Can be used to traverse a container in one direction (forward).

4. Bidirectional Iterator:
- Can read and write elements and can move both forward and backward.
- Supports incrementing (`++`) and decrementing (`--`) operations.

5. Random Access Iterator:

- Provides the ability to access elements at arbitrary positions.
- Supports all operations of bidirectional iterators, plus additional operations
like addition and subtraction.
- Allows direct access to elements using an index (similar to pointers).
Example of Using an Iterator:
Here’s a simple example that demonstrates the use of an iterator with a vector.

#include <iostream>
#include <vector>
using namespace std;

int main() {
// Create a vector of integers
vector<int> numbers = {10, 20, 30, 40, 50};

// Using an iterator to traverse the vector

cout << "Elements in the vector: ";
for (vector<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) {
cout << *it << " "; // Dereference the iterator to get the value
}
cout << endl;

return 0;
}

Output:

Elements in the vector: 10 20 30 40 50

In this example, we create a vector of integers and use a bidirectional iterator to

traverse the vector and print its elements. The iterator allows us to access each
element without directly using the index, demonstrating the flexibility and power
of iterators in C++.

8b) What is a Map? Enlist and explain various functions of a map.

A Map in C++ is an associative container that stores elements in key-value pairs.

Each key in a map is unique, and it is used to access the corresponding value. Maps
are typically implemented as balanced binary trees, which allows for efficient
insertion, deletion, and lookup operations.

Key Characteristics of Maps:

- Keys are unique.
- Values can be duplicated.
- Elements are stored in a sorted order based on the keys.
- Provides logarithmic time complexity for search, insertion, and deletion
operations.

Common Functions of a Map:

1. `insert()`:
- Inserts a new key-value pair into the map.
- If the key already exists, the insertion is ignored.
- Syntax: `map.insert(make_pair(key, value));` or `map[key] = value;`

2. `find()`:
- Searches for a key in the map and returns an iterator to the element if found.
- If the key is not found, it returns an iterator to the end of the map.
- Syntax: `map.find(key);`
3. `erase()`:
- Removes an element from the map based on the key.
- Syntax: `map.erase(key);`

4. `size()`:
- Returns the number of elements in the map.
- Syntax: `map.size();`

5. `clear()`:
- Removes all elements from the map.
- Syntax: `map.clear();`

6. `operator[]`:
- Accesses the value associated with a given key. If the key does not exist, it
inserts a new element with the default value.
- Syntax: `map[key];`

7. `begin()` and `end()`:

- Returns iterators to the beginning and end of the map, respectively.
- Syntax: `map.begin();` and `map.end();`

Example Program Using Map Functions:

#include <iostream>
#include <map>
using namespace std;

int main() {
// Create a map to store student names and their scores
map<string, int> studentScores;

// Inserting data into the map

studentScores["Alice"] = 85;
studentScores["Bob"] = 90;
studentScores["Charlie"] = 78;

// Displaying the contents of the map

cout << "Student Scores:" << endl;
for (const auto& pair : studentScores) {
cout << pair.first << ": " << pair.second << endl; // pair.first is the
key, pair.second is the value
}

// Finding a specific key

string studentName = "Bob";
auto it = studentScores.find(studentName);
if (it != studentScores.end()) {
cout << studentName << "'s score: " << it->second << endl; // Accessing the
value using iterator
} else {
cout << studentName << " not found." << endl;
}

// Erasing an element
studentScores.erase("Alice");
cout << "After removing Alice:" << endl;
for (const auto& pair : studentScores) {
cout << pair.first << ": " << pair.second << endl;
 }

// Size of the map

cout << "Total students: " << studentScores.size() << endl;

// Clearing the map

studentScores.clear();
cout << "Total students after clearing: " << studentScores.size() << endl;

return 0;
}

Output:

Student Scores:
Alice: 85
Bob: 90
Charlie: 78
Bob's score: 90
After removing Alice:
Bob: 90
Charlie: 78
Total students: 2
Total students after clearing: 0

In this example, we create a map to store student names and their scores. We
demonstrate various functions such as inserting elements, finding a specific key,
erasing an element, checking the size of the map, and clearing the map. This
showcases the functionality and utility of maps in C++.

8c) What is a vector? Write a C++ program to explain various functions of a

vector.

A vector in C++ is a sequence container that encapsulates dynamic size arrays. It

is part of the Standard Template Library (STL) and provides the ability to store
elements in a contiguous memory location. Vectors are flexible and can grow or
shrink in size as needed, making them a popular choice for managing collections of
data.

Key Characteristics of Vectors:

- Dynamic size: Vectors can grow and shrink automatically as elements are added or
removed.
- Random access: Elements can be accessed using an index, similar to arrays.
- Contiguous memory: Elements are stored in contiguous memory locations, which
allows for efficient access.

Common Functions of a Vector:

1. `push_back()`: Adds an element to the end of the vector.
2. `pop_back()`: Removes the last element from the vector.
3. `size()`: Returns the number of elements in the vector.
4. `capacity()`: Returns the size of the storage space currently allocated for the
vector.
5. `at()`: Accesses an element at a specific index with bounds checking.
6. `operator[]`: Accesses an element at a specific index without bounds checking.
7. `clear()`: Removes all elements from the vector.
8. `insert()`: Inserts an element at a specified position.
9. `erase()`: Removes an element at a specified position.
Example Program Using Vector Functions:

#include <iostream>
#include <vector>
using namespace std;

int main() {
// Create a vector of integers
vector<int> numbers;

// Adding elements to the vector

numbers.push_back(10);
numbers.push_back(20);
numbers.push_back(30);
numbers.push_back(40);

// Displaying the elements of the vector

cout << "Elements in the vector: ";
for (int num : numbers) {
cout << num << " ";
}
cout << endl;

// Accessing elements using index

cout << "First element: " << numbers[0] << endl;
cout << "Second element: " << numbers.at(1) << endl; // Using at() for bounds
checking

// Removing the last element

numbers.pop_back();
cout << "After popping the last element: ";
for (int num : numbers) {
cout << num << " ";
}
cout << endl;

// Inserting an element at the beginning

numbers.insert(numbers.begin(), 5);
cout << "After inserting 5 at the beginning: ";
for (int num : numbers) {
cout << num << " ";
}
cout << endl;

// Erasing the second element

numbers.erase(numbers.begin() + 1);
cout << "After erasing the second element: ";
for (int num : numbers) {
cout << num << " ";
}
cout << endl;

// Size and capacity of the vector

cout << "Size of the vector: " << numbers.size() << endl;
cout << "Capacity of the vector: " << numbers.capacity() << endl;

// Clearing the vector

numbers.clear();
 cout << "Size after clearing: " << numbers.size() << endl;

return 0;
}

Output:

Elements in the vector: 10 20 30 40

First element: 10
Second element: 20
After popping the last element: 10 20 30
After inserting 5 at the beginning: 5 10 20 30
After erasing the second element: 5 20 30
Size of the vector: 3
Capacity of the vector: 4
Size after clearing: 0

In this program, we demonstrate various functions of a vector, including adding

elements, accessing elements, removing elements, inserting elements, erasing
elements, checking the size and capacity, and clearing the vector. This showcases
the flexibility and ease of use of vectors in C++.