1.

#include <iostream>
#include <string>

class Person {
private:
std::string name;
int age;

public:
// Constructor to initialize the class members
Person(std::string n, int a) : name(n), age(a) {}

// Member function to display the contents of the class members

void display() {
std::cout << "Name: " << name << std::endl;
std::cout << "Age: " << age << std::endl;
}
};

int main() {
// Create an object of the Person class and initialize it
Person person("John Doe", 30);

// Display the contents of the object

person.display();

return 0;
}

2.

#include <iostream>
#include <string>

class Student {
private:
std::string name;
int rollNo;
char grade;

public:
// Constructor to initialize the class members
Student() : name(""), rollNo(0), grade('F') {}

// Member function to read the details of the student

void readDetails() {
std::cout << "Enter name: ";
std::cin >> name;
std::cout << "Enter roll number: ";
std::cin >> rollNo;
std::cout << "Enter grade: ";
std::cin >> grade;
}

// Member function to display the details of the student

 void displayDetails() const {
std::cout << "Name: " << name << ", Roll No: " << rollNo << ", Grade: " << grade << std::endl;
}
};

int main() {
const int numberOfStudents = 3;
Student students[numberOfStudents];

// Read details for each student

for (int i = 0; i < numberOfStudents; ++i) {
std::cout << "Enter details for student " << i + 1 << ":\n";
students[i].readDetails();
}

// Display details for each student

std::cout << "\nStudent Details:\n";
for (int i = 0; i < numberOfStudents; ++i) {
students[i].displayDetails();
}

return 0;
}

3.

#include <iostream>

// Global variable
int value = 10;

class Example {
public:
// Class member variable
static int value;

// Function to display values from different scopes

void displayValues(int value) {
// Local variable (parameter)
std::cout << "Local variable value: " << value << std::endl;
// Class member variable
std::cout << "Class member variable value: " << Example::value << std::endl;
// Global variable
std::cout << "Global variable value: " << ::value << std::endl;
}
};

// Definition of the class member variable

int Example::value = 20;

int main() {
// Local variable in main
int value = 30;

Example ex;
ex.displayValues(value);
 return 0;
}

4.

#include <iostream>
#include <cmath>

// Function to calculate the area of a circle

double calculateArea(double radius) {
return M_PI * radius * radius;
}

// Function to calculate the area of a rectangle

double calculateArea(double length, double width) {
return length * width;
}

// Function to calculate the area of a square

double calculateArea(int side) {
return side * side;
}

// Function to calculate the area of a triangle

double calculateArea(double base, double height, bool isTriangle) {
if (isTriangle) {
return 0.5 * base * height;
}
return -1; // This case will never occur, it's just a safeguard.
}

int main() {
// Circle
double radius = 5.0;
std::cout << "Area of Circle (radius " << radius << "): " << calculateArea(radius) << std::endl;

// Rectangle
double length = 10.0;
double width = 5.0;
std::cout << "Area of Rectangle (length " << length << ", width " << width << "): " <<
calculateArea(length, width) << std::endl;

// Square
int side = 4;
std::cout << "Area of Square (side " << side << "): " << calculateArea(side) << std::endl;

// Triangle
double base = 6.0;
double height = 3.0;
std::cout << "Area of Triangle (base " << base << ", height " << height << "): " << calculateArea(base,
height, true) << std::endl;

return 0;
}

5.
#include <iostream>
class Arithmetic {
public:
// Inline function for addition
inline int add(int a, int b) {
return a + b;
}

// Inline function for subtraction

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

// Inline function for multiplication

inline int multiply(int a, int b) {
return a * b;
}

// Inline function for division

inline double divide(int a, int b) {
if (b != 0) {
return static_cast<double>(a) / b;
} else {
std::cerr << "Error: Division by zero." << std::endl;
return 0;
}
}

// Inline function for modulus

inline int modulus(int a, int b) {
if (b != 0) {
return a % b;
} else {
std::cerr << "Error: Division by zero." << std::endl;
return 0;
}
}
};

int main() {
Arithmetic arith;

int a = 10, b = 5;

std::cout << "Addition of " << a << " and " << b << ": " << arith.add(a, b) << std::endl;
std::cout << "Subtraction of " << a << " and " << b << ": " << arith.subtract(a, b) << std::endl;
std::cout << "Multiplication of " << a << " and " << b << ": " << arith.multiply(a, b) << std::endl;
std::cout << "Division of " << a << " and " << b << ": " << arith.divide(a, b) << std::endl;
std::cout << "Modulus of " << a << " and " << b << ": " << arith.modulus(a, b) << std::endl;

return 0;
}

6.
#include <iostream>

// Function to swap two numbers using call by value

void swapByValue(int a, int b) {
int temp = a;
a = b;
b = temp;
std::cout << "Inside swapByValue function - a: " << a << ", b: " << b << std::endl;
}

int main() {
int num1 = 10;
int num2 = 20;

std::cout << "Before calling swapByValue - num1: " << num1 << ", num2: " << num2 << std::endl;

// Call the swapByValue function

swapByValue(num1, num2);

std::cout << "After calling swapByValue - num1: " << num1 << ", num2: " << num2 << std::endl;

return 0;
}

7.
#include <iostream>
#include <string>

class Employee {
protected:
std::string name;
int emp_id;
double basic_salary;

public:
// Parameterized constructor to initialize data members
Employee(const std::string& empName, int empID, double basicSal)
: name(empName), emp_id(empID), basic_salary(basicSal) {}

// Function to display employee details

void displayEmployeeDetails() const {
std::cout << "Employee Name: " << name << std::endl;
std::cout << "Employee ID: " << emp_id << std::endl;
std::cout << "Basic Salary: " << basic_salary << std::endl;
}
};

class Salary : public Employee {

private:
double gross_pay;
double net_pay;

public:
// Parameterized constructor to initialize base class members
Salary(const std::string& empName, int empID, double basicSal)
: Employee(empName, empID, basicSal), gross_pay(0), net_pay(0) {}

// Function to calculate gross and net pay

void calculatePay() {
// Example calculations for gross and net pay
 // Assume some allowances and deductions for demonstration purposes
double hra = 0.2 * basic_salary; // House Rent Allowance
double da = 0.1 * basic_salary; // Dearness Allowance
double pf = 0.05 * basic_salary; // Provident Fund deduction
double tax = 0.1 * basic_salary; // Tax deduction

gross_pay = basic_salary + hra + da;

net_pay = gross_pay - (pf + tax);
}

// Function to display gross and net pay

void displayPayDetails() const {
std::cout << "Gross Pay: " << gross_pay << std::endl;
std::cout << "Net Pay: " << net_pay << std::endl;
}
};

int main() {
// Create an object of the Salary class
Salary emp("John Doe", 12345, 50000);

// Display employee details

emp.displayEmployeeDetails();

// Calculate and display pay details

emp.calculatePay();
emp.displayPayDetails();

return 0;
}

8.
#include <iostream>
#include <cmath>

// Function to calculate simple interest

double calculateSimpleInterest(double principal, double rate = 5.0, int time = 1) {
return (principal * rate * time) / 100;
}

// Function to calculate compound interest

double calculateCompoundInterest(double principal, double rate = 5.0, int time = 1, int n = 1) {
return principal * pow((1 + rate / (100 * n)), n * time) - principal;
}

int main() {
double principal;
double rate;
int time;
int n;

std::cout << "Enter the principal amount: ";

std::cin >> principal;

std::cout << "Enter the rate of interest (default is 5%): ";

std::cin >> rate;
 std::cout << "Enter the time period in years (default is 1 year): ";
std::cin >> time;

std::cout << "Enter the number of times interest is compounded per year (default is 1): ";
std::cin >> n;

// Calculate simple interest with default rate and time

double simpleInterest = calculateSimpleInterest(principal, rate, time);

// Calculate compound interest with default rate, time, and compounding frequency
double compoundInterest = calculateCompoundInterest(principal, rate, time, n);

std::cout << "\nSimple Interest: " << simpleInterest << std::endl;

std::cout << "Compound Interest: " << compoundInterest << std::endl;

return 0;
}

9.
#include <iostream>

class ObjectCounter {
private:
// Static member to keep track of the number of objects created
static int objectCount;

public:
// Constructor
ObjectCounter() {
objectCount++;
std::cout << "Object created. Total objects: " << objectCount << std::endl;
}

// Destructor
~ObjectCounter() {
objectCount--;
std::cout << "Object destroyed. Total objects: " << objectCount << std::endl;
}

// Static member function to get the current count of objects

static int getObjectCount() {
return objectCount;
}
};

// Initialize static member

int ObjectCounter::objectCount = 0;

int main() {
std::cout << "Entering main block." << std::endl;
{
ObjectCounter obj1;
{
ObjectCounter obj2;
ObjectCounter obj3;
std::cout << "Current object count: " << ObjectCounter::getObjectCount() << std::endl;
}
 std::cout << "Current object count after inner block: " << ObjectCounter::getObjectCount() <<
std::endl;
}
std::cout << "Current object count after main block: " << ObjectCounter::getObjectCount() <<
std::endl;
return 0;
}

10.

#include <iostream>

// Base class Shape

class Shape {
public:
// Virtual function to calculate area
virtual double calculateArea() const = 0; // Pure virtual function
};

// Class Rectangle inheriting from Shape

class Rectangle : public Shape {
protected:
double length;
double width;

public:
// Parameterized constructor
Rectangle(double l, double w) : length(l), width(w) {}

// Function to calculate area of rectangle

double calculateArea() const override {
return length * width;
}
};

// Class Cuboid inheriting from Rectangle and Shape

class Cuboid : public Rectangle {
private:
double height;

public:
// Parameterized constructor
Cuboid(double l, double w, double h) : Rectangle(l, w), height(h) {}

// Function to calculate volume of cuboid

double calculateVolume() const {
return length * width * height;
}

// Function to display area and volume

void display() const {
std::cout << "Area of rectangle base: " << calculateArea() << std::endl;
std::cout << "Volume of cuboid: " << calculateVolume() << std::endl;
}
};

int main() {
 double length, width, height;

// Input dimensions
std::cout << "Enter the length of the cuboid: ";
std::cin >> length;
std::cout << "Enter the width of the cuboid: ";
std::cin >> width;
std::cout << "Enter the height of the cuboid: ";
std::cin >> height;

// Create a Cuboid object

Cuboid cuboid(length, width, height);

// Display the area and volume

cuboid.display();

return 0;
}