1.

Define Data Types in C++ Language

Data types in C++ specify the type of data that a variable can hold. Here are the primary

data types in C++:

• Basic Data Types: int, char, float, double, bool.

• Derived Data Types: array, pointer, function.
• Enumeration Data Types: enum.
• User-Defined Data Types: struct, class, union.

Example:

int num = 5;
char letter = 'A';
float decimal = 5.99;
double largeDecimal = 9.87654321;
bool isTrue = true;

2. Define Variables (Life & Scope)

Variables are storage locations with a specific type and associated name. The life and scope

of a variable define its visibility and lifetime within a program.

• Scope: The region of the code where the variable can be accessed. It can be local or global.
• Lifetime: The duration for which the variable exists in memory.

Example:

#include <iostream>
using namespace std;

int globalVar = 10; // Global scope

void myFunction() {
int localVar = 5; // Local scope
cout << localVar << endl;
}

int main() {
myFunction();
cout << globalVar << endl;
return 0;
}

3. Read Array

An array is a collection of items stored at contiguous memory locations. To read an array in C++, you

typically use a loop.

Example:

#include <iostream>
using namespace std;

int main() {
int arr[5] = {1, 2, 3, 4, 5};
for(int i = 0; i < 5; i++) {
cout << arr[i] << " ";
}
return 0;
}
4. Define Pointer

A pointer is a variable that stores the memory address of another variable.

Example:

#include <iostream>
using namespace std;

int main() {
int var = 20;
int *ptr = &var; // Pointer to var
cout << "Value of var: " << var << endl;
cout << "Address of var: " << ptr << endl;
cout << "Value at ptr: " << *ptr << endl; // Dereferencing
return 0;
}

5. Explain Function (Call-by-Value, Call-by-Reference)

Functions in C++ can be called in two ways: call-by-value and call-by-reference.

• Call-by-Value: Copies the actual value of an argument into the formal parameter of the function.
• Changes made to the parameter do not affect the argument.
• Call-by-Reference: Copies the address of an argument into the formal parameter. Changes to the
• parameter affect the argument.

Example:

#include <iostream>
using namespace std;

void callByValue(int x) {
x = 100;
}

void callByReference(int &x) {

x = 100;
}

int main() {
int a = 5;
callByValue(a);
cout << "After callByValue: " << a << endl; // Output: 5

callByReference(a);
cout << "After callByReference: " << a << endl; // Output: 100
return 0;
}

6. Explain Dynamic Memory Allocation (new, delete)

Dynamic memory allocation allows you to allocate memory at runtime using the new operator and

deallocate it using the delete operator.

Example:

#include <iostream>
using namespace std;

int main() {
int *ptr = new int; // Allocate memory
*ptr = 50;
cout << "Value: " << *ptr << endl;
delete ptr; // Deallocate memory
return 0;
}

7. Explain String

In C++, a string is an object that represents a sequence of characters. The std::string class in

the C++ Standard Library provides a set of functions for working with strings.

Example:

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

int main() {
string greeting = "Hello, World!";
cout << greeting << endl;
return 0;
}

8. Discuss the Concepts of Static and Dynamic Object Creation

• Static Object Creation: Objects are created on the stack. Their lifetime is limited to
• the scope in which they are created.
• Dynamic Object Creation: Objects are created on the heap using the new operator.
• They persist until explicitly deleted using the delete operator.

Example:

#include <iostream>
using namespace std;

class MyClass {
public:
void display() {
cout << "Hello, World!" << endl;
}
};

int main() {
MyClass obj; // Static object creation
obj.display();

MyClass *ptr = new MyClass(); // Dynamic object creation

ptr->display();
delete ptr;
return 0;
}

9. Explain Static Variable with an Example

A static variable retains its value between function calls and is initialized only once.

Example:

#include <iostream>
using namespace std;

void increment() {
static int count = 0; // Static variable
count++;
cout << "Count: " << count << endl;
}

int main() {
increment();
increment();
increment();
 return 0;
}

Output:

Copy code
Count: 1
Count: 2
Count: 3

what is Access Specifiers/Visibility Modes

Access specifiers or visibility modes in object-oriented

programming define the accessibility or scope of a member

(data member or member function) of a class. The main

access specifiers are:

Public: Members declared as public are accessible from

outside the class.

Private: Members declared as private are accessible only

within the class.

Protected: Members declared as protected are accessible

within the class and by derived class.

Examples:
cpp
Copy code
#include <iostream>
using namespace std;

class Base {
public:
int publicVar; // Public access specifier

protected:
int protectedVar; // Protected access specifier

private:
int privateVar; // Private access specifier
};

class Derived : public Base {

public:
void show() {
publicVar = 1; // Accessible
protectedVar = 2; // Accessible
// privateVar = 3; // Not Accessible
}
};

int main() {
Base b;
b.publicVar = 1; // Accessible
// b.protectedVar = 2; // Not Accessible
// b.privateVar = 3; // Not Accessible
return 0;
}
Constructors and Its Types

A constructor is a special member function of a class that

initializes objects of the class. It is called automatically

when an object is created.

Types of Constructors:

Default Constructor: A constructor with no parameters.

Parameterized Constructor: A constructor that takes arguments

to initialize an object.

Copy Constructor: A constructor that initializes an object using

another object of the same class.

Syntax and Examples:

#include <iostream>
using namespace std;

class Example {
public:
int a, b;

// Default Constructor
Example() {
a = 0;
b = 0;
cout << "Default Constructor Called" << endl;
}

// Parameterized Constructor
Example(int x, int y) {
a = x;
b = y;
cout << "Parameterized Constructor Called" << endl;
}

// Copy Constructor
Example(const Example &obj) {
a = obj.a;
b = obj.b;
cout << "Copy Constructor Called" << endl;
}
};

int main() {
Example e1; // Default Constructor
Example e2(10, 20); // Parameterized Constructor
Example e3 = e2; // Copy Constructor
return 0;
}

what is destructor ? explain with the suitable example

A destructor is a special member function of a class that is executed

when an object of that class is destroyed. It has the same name as the
class, preceded by a tilde (~).

Syntax and Example:

cpp
Copy code
#include <iostream>
using namespace std;

class Example {
public:
Example() {
cout << "Constructor Called" << endl;
}

~Example() {
cout << "Destructor Called" << endl;
}
};

int main() {
Example e1;
return 0;
}

Can a Constructor Be Overloaded?

Yes, a constructor can be overloaded. Constructor overloading is the

process of having more than one constructor in a class with different

parameters. This allows objects to be initialized in different ways.

Example:

#include <iostream>
using namespace std;

class Example {
public:
int a, b;

// Default Constructor
Example() {
a = 0;
b = 0;
}

// Parameterized Constructor
Example(int x, int y) {
a = x;
b = y;
}

// Another Parameterized Constructor

Example(int x) {
a = x;
b = 0;
}
};

int main() {
Example e1; // Calls Default Constructor
Example e2(10, 20); // Calls Parameterized Constructor
Example e3(30); // Calls Another Parameterized Constructor
return 0;
}

Friend Class and Friend Function

A friend class or friend function can access private and protected members
of another class. Declaring a friend breaks the encapsulation principle of

OOP, as it allows external access to the class's private data.

Friend Function Example:

#include <iostream>
using namespace std;

class Example {
private:
int a;

public:
Example() : a(10) {}
friend void showA(Example &e);
};

void showA(Example &e) {

cout << "Value of a: " << e.a << endl;
}

int main() {
Example e;
showA(e);
return 0;
}
Friend Class Example:

#include <iostream>
using namespace std;

class ClassB;

class ClassA {
private:
int a;

public:
ClassA() : a(10) {}
friend class ClassB;
};

class ClassB {
public:
void showA(ClassA &obj) {
cout << "Value of a: " << obj.a << endl;
}
};

int main() {
ClassA objA;
ClassB objB;
objB.showA(objA);
return 0;
}

6.Define the this keyword with example

The this keyword is a pointer to the current object instance of a class.

It is used to access members of the current object.

Example:
#include <iostream>
using namespace std;

class Example {
private:
int a;

public:
Example(int a) {
this->a = a; // Using this to refer to the current object's a
}

void showA() {
cout << "Value of a: " << this->a << endl;
}
};

int main() {
Example e(10);
e.showA();
return 0;
}

1. Define inheritance and its types.

Answer:
Inheritance is a fundamental concept in object-oriented programming
(OOP) where a new class, called a derived or child class, is created
based
on an existing class, known as the base or parent class. The child
class inherits the properties and behaviors (methods) of the parent
class, allowing for code reuse and the creation of hierarchical relationships.
The types of inheritance include:
1. Single Inheritance
2. Multiple Inheritance
3. Multilevel Inheritance
4. Hierarchical Inheritance
5. Hybrid Inheritance
2. Provide a detailed explanation of its types with examples.

Answer:
2.1 Single Inheritance
Single inheritance occurs when a class inherits from one base class.

class Animal {
public:
void eat() {
cout << "Eating" << endl;
}
};

class Dog : public Animal {

public:
void bark() {
cout << "Barking" << endl;
}
};
2.2 Multiple Inheritance
Multiple inheritance occurs when a class inherits from more than one base class.
class Animal {
public:
void eat() {
cout << "Eating" << endl;
}
};

class Bird {
public:
void fly() {
cout << "Flying" << endl;
}
};

class Bat : public Animal, public Bird {

public:
void sound() {
cout << "Screeching" << endl;
}
};
2.3 Multilevel Inheritance
Multilevel inheritance occurs when a class is derived from another derived class, forming
a chain.
class Animal {
public:
void eat() {
cout << "Eating" << endl;
}
};

class Mammal : public Animal {

public:
void walk() {
cout << "Walking" << endl;
}
};

class Dog : public Mammal {

public:
void bark() {
cout << "Barking" << endl;
}
};
2.4 Hierarchical Inheritance
Hierarchical inheritance occurs when multiple classes inherit from
a single base class.
class Animal {
public:
void eat() {
cout << "Eating" << endl;
}
};

class Dog : public Animal {

public:
void bark() {
cout << "Barking" << endl;
}
};

class Cat : public Animal {

public:
void meow() {
cout << "Meowing" << endl;
}
};
2.5 Hybrid Inheritance
Hybrid inheritance is a combination of two or more types of inheritance.

class Animal {
public:
void eat() {
cout << "Eating" << endl;
}
};

class Mammal : public Animal {

public:
void walk() {
cout << "Walking" << endl;
}
};

class Bird : public Animal {

public:
void fly() {
cout << "Flying" << endl;
}
};

class Bat : public Mammal, public Bird {

public:
void sound() {
cout << "Screeching" << endl;
}
};
3. Define virtual base class and explain why we need it.
A virtual base class is a base class that is specified as virtual when
inherited. This is primarily used in multiple inheritance to prevent the
duplication of base class members in derived classes.
When a base class is inherited multiple times indirectly, declaring
it as a virtual base class ensures that only one instance of the base
class is included in the derived class.
Why We Need Virtual Base Class
Without virtual inheritance, multiple copies of the base class arecreated,
leading to ambiguity and redundancy.
Example:

class Animal {
public:
void eat() {
cout << "Eating" << endl;
}
};

class Mammal : virtual public Animal {

public:
void walk() {
cout << "Walking" << endl;
}
};

class Bird : virtual public Animal {

public:
void fly() {
cout << "Flying" << endl;
}
};

class Bat : public Mammal, public Bird {

public:
void sound() {
cout << "Screeching" << endl;
}
};

In this example, Animal is a virtual base class. When Bat inherits

from both Mammal and Bird, only one instance of Animal is included
in Bat, avoiding ambiguity and redundancy. This ensures that when Bat
calls eat(), there is no confusion about which Animal instance is being
referenced.
Using virtual base classes is crucial in complex inheritance hierarchies
to maintain clarity and avoid the diamond problem.

1. Define polymorphism and its types.

Polymorphism is a fundamental concept in object-oriented programming
(OOP) that allows objects to be treated as instances of their parent
class rather than their actual class. The main types of polymorphism are:

Compile-time Polymorphism (Static Polymorphism)

Run-time Polymorphism (Dynamic Polymorphism)
2. Define compile-time and run-time polymorphism.
Compile-time Polymorphism
Compile-time polymorphism is achieved through function overloading and
operator overloading. It is resolved during compile time.

Run-time Polymorphism
Run-time polymorphism is achieved through inheritance and virtual functions.
It is resolved during run time.

3. Provide a detailed explanation of function overloading with examples.

Function overloading is a feature that allows multiple functions with the

same name but different parameters to be defined.

Example:

void display(int i) {
cout << "Integer: " << i << endl;
}

void display(double d) {
cout << "Double: " << d << endl;
}
void display(string s) {
cout << "String: " << s << endl;
}
In this example, the display function is overloaded with different
parameter types.

4. Provide a detailed explanation of operator overloading with examples.

Operator overloading allows custom implementation for operators for
user-defined types.

Example:

class Complex {
public:
int real, imag;
Complex(int r, int i) : real(r), imag(i) {}

Complex operator + (const Complex &obj) {

return Complex(real + obj.real, imag + obj.imag);
}
};

Complex c1(1, 2), c2(3, 4);

Complex c3 = c1 + c2; // Uses the overloaded + operator
5. List operators that are overloaded and those that are not.
Overloadable Operators
Arithmetic Operators: +, -, *, /, %
Relational Operators: ==, !=, <, >, <=, >=
Logical Operators: &&, ||
Increment/Decrement: ++, --
Bitwise Operators: &, |, ^, ~, <<, >>
Assignment Operators: =, +=, -=, *=, /=, %=
Function Call Operator: ()
Array Subscript Operator: []
Member Access Operators: ->, .
Non-overloadable Operators
Scope Resolution Operator: ::
Member Selection: .
Member Selection through Pointer: .*
Conditional (Ternary) Operator: ?:

6. Define function overriding.

Function overriding occurs when a derived class provides a specific
implementation for a method that is already defined in its base class.

class Base {
public:
virtual void display() {
cout << "Display from Base" << endl;
}
};

class Derived : public Base {

public:
void display() override {
cout << "Display from Derived" << endl;
}
};

7. Define operator overriding.

Operator overriding is the same as operator overloading. It allows
the redefinition of operators for user-defined types.

8. Difference between function overloading and function overriding.

Function Overloading
Same function name with different parameters.
Resolved at compile time.
Can occur in the same class.
Function Overriding
Same function name and parameters in base and derived class.
Resolved at run time.
Requires inheritance.
9. Define virtual function, pure virtual function, and abstract class
with examples.
Virtual Function
A virtual function is a member function in a base class that can be
overridden in a derived class.

class Base {
public:
virtual void display() {
cout << "Display from Base" << endl;
}
};
Pure Virtual Function
A pure virtual function is a function declared in a base class that
has no definition relative to the base class.

class Base {
public:
virtual void display() = 0; // Pure virtual function
};
Abstract Class
An abstract class is a class that cannot be instantiated and usually
contains at least one pure virtual function.

class Base {
public:
virtual void display() = 0; // Pure virtual function
};

class Derived : public Base {

public:
void display() {
cout << "Display from Derived" << endl;
}
};
10. Define upcasting and downcasting with examples.
Upcasting is casting a derived class pointer or reference to a base
class pointer or reference.

Base *b = new Derived(); // Upcasting

Downcasting
Downcasting is casting a base class pointer or reference to a derived
class pointer or reference.

Derived *d = dynamic_cast<Derived*>(b); // Downcasting

11. Explain how to create a virtual table.

A virtual table (vtable) is an array of pointers to virtual functions.

It is used to support dynamic (run-time) polymorphism.

Steps to Create a Virtual Table:

Declare Virtual Functions: When a class declares or inherits a virtual
function, a vtable is created for that class.
Assign Function Pointers: Each entry in the vtable points to the most
derived function accessible by that class.
Use vptr: Each object of a class with virtual functions contains a
pointer to the vtable (vptr).

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

class Derived : public Base {

public:
void show() override { cout << "Derived" << endl; }
};
In this example, both Base and Derived will have a vtable with a
pointer to their respective `show