Object Oriented Programming (OOP) is a programming paradigm based on the concept of “objects,” which are

instances of classes. These objects contain data (attributes) and methods (functions) that operate on the data. OOP
helps in organizing code, promoting reusability, scalability, and maintainability.

🔑 Key Concepts of OOP:

1. Class: A blueprint for creating objects.

2. Object: An instance of a class.

3. Encapsulation: Hiding internal details and exposing only what’s necessary.

4. Abstraction: Showing only essential features.

5. Inheritance: One class can inherit features from another.

6. Polymorphism: One function behaves differently based on context (overloading/overriding).

✅ Example in C++ (OOP):

cpp

CopyEdit

#include <iostream>

using namespace std;

class Animal {

public:

void sound() {

cout << "Animal makes sound" << endl;

};

class Dog : public Animal {

public:

void sound() {

cout << "Dog barks" << endl;

};

int main() {

Dog d;

d.sound(); // Output: Dog barks

 Animal is a class

 Dog is a subclass of Animal (inheritance)

 sound() is overridden (polymorphism)

🆚 OOP vs Object-Based Programming

Feature Object Oriented Programming (OOP) Object Based Programming

Inheritance ✅ Supported ❌ Not supported

Polymorphism ✅ Supported ❌ Not supported

Encapsulation ✅ Supported ✅ Supported

Example Languages C++, Java, Python JavaScript (ES5), VBScript

Class support ✅ Has classes and objects ❌ No classes (uses objects only)

Reusability High Moderate

💡 Example of Object-Based Programming (JavaScript ES5):

javascript

CopyEdit

var person = {

name: "Alice",

age: 25,

greet: function() {

console.log("Hello, " + this.name);

};

person.greet(); // Output: Hello, Alice

 Uses objects, but no classes, inheritance, or polymorphism

🔚 Summary:

 OOP is more powerful and feature-rich (supports inheritance and polymorphism).

 Object-based programming is simpler, with just objects and no complex structure.

Let me know if you want a real-life analogy too!

(i) Methods

(ii) Abstract Classes

🔸 (i) Methods

✳️Definition:

A method is a function that is defined inside a class and operates on the objects of that class. Methods are used to
define behaviors or actions that an object can perform. They help achieve encapsulation and improve code
modularity.

✳️Types of Methods:

 Instance methods – operate on individual objects.

 Static methods – belong to the class, not to objects.

 Constructors/Destructors – special methods for object creation and cleanup.

✳️Key Features:

 Can access private/public members of the class.

 Can return values or be void.

 Can be overloaded (same method name, different parameters).

✅ Example (C++):
cpp

CopyEdit

#include <iostream>

using namespace std;

class Student {

private:

string name;

int age;

public:

// Method to set data

void setData(string n, int a) {

name = n;

age = a;

// Method to display data

void displayData() {

cout << "Name: " << name << ", Age: " << age << endl;

};

int main() {

Student s1;

s1.setData("Adity", 20); // Calling method to set data

s1.displayData(); // Calling method to display data

return 0;

✳️Output:

yaml

CopyEdit

Name: Adity, Age: 20

🔸 Real-life Analogy:
Think of a remote control. The buttons are methods — each one performs a specific task (like increasing volume or
changing channels). The TV is the object being controlled.

🔸 (ii) Abstract Classes

✳️Definition:

An abstract class is a class that cannot be instantiated directly. It is meant to be inherited by other classes. It serves
as a template or base for other classes.

An abstract class must contain at least one pure virtual function – a function declared with = 0.

✳️Features:

 Promotes abstraction.

 Provides common interface for all derived classes.

 Helps in achieving runtime polymorphism.

 Used when you want to enforce a contract (rules) that derived classes must follow.

✅ Example (C++):

cpp

CopyEdit

#include <iostream>

using namespace std;

// Abstract class

class Shape {

public:

// Pure virtual function

virtual void draw() = 0;

};

// Derived class

class Circle : public Shape {

public:

void draw() {

cout << "Drawing a Circle" << endl;

};
// Another Derived class

class Square : public Shape {

public:

void draw() {

cout << "Drawing a Square" << endl;

};

int main() {

Shape* s1;

Circle c;

Square s;

s1 = &c;

s1->draw(); // Output: Drawing a Circle

s1 = &s;

s1->draw(); // Output: Drawing a Square

return 0;

✳️Output:

css

CopyEdit

Drawing a Circle

Drawing a Square

🔸 Real-life Analogy:

Imagine Shape is a general concept. You can’t "draw" a generic shape — it must be specified (like a Circle or Square).
Similarly, an abstract class cannot be used directly; it needs a specific implementation in derived classes.

🟩 Conclusion:

Feature Methods Abstract Classes

Purpose Define behavior of an object Provide a base for derived classes

Contains Logic to manipulate object data One or more pure virtual functions
Feature Methods Abstract Classes

Usage Called using object Cannot be instantiated directly

Supports Encapsulation, Overloading Abstraction, Inheritance, Polymorphism

🔹 What is a Function? How to declare and define functions in C++? Explain with examples.

🔸 Definition of a Function:

A function in C++ is a block of code that performs a specific task. Functions are used to divide a large program into
smaller, manageable, and reusable pieces.

It helps in:

 Code reusability

 Modularity

 Readability

🔸 Types of Functions in C++:

1. Library Functions (e.g., sqrt(), printf()): Predefined in header files.

2. User-defined Functions: Created by the programmer for specific tasks.

🔸 Function Components:

1. Declaration (Prototype)

2. Definition

3. Call
✅ 1. Function Declaration (Prototype):

Tells the compiler about the function name, return type, and parameters before it is used.

cpp

CopyEdit

return_type function_name(parameter_list);

🔹 Example:

cpp

CopyEdit

int add(int a, int b); // Declaration

✅ 2. Function Definition:

Contains the actual code (body) of the function.

cpp

CopyEdit

int add(int a, int b) {

return a + b;

✅ 3. Function Call:

Used to execute the function.

cpp

CopyEdit

int result = add(5, 3);

🔸 Complete Example:

cpp

CopyEdit

#include <iostream>

using namespace std;

// Declaration

int add(int, int);

// Definition
int add(int a, int b) {

return a + b;

int main() {

int x = 5, y = 10;

int sum = add(x, y); // Function Call

cout << "Sum: " << sum << endl;

return 0;

🔹 Output:

makefile

CopyEdit

Sum: 15

🔸 Types of User-Defined Functions:

Function Type Description Example

No arguments, no return value Takes nothing, returns nothing void greet()

Arguments, no return value Takes values, returns nothing void display(int)

No arguments, with return value Takes nothing, returns value int getNumber()

Arguments with return value Takes values, returns value int add(int a, int b)

✅ Example: No arguments, no return value

cpp

CopyEdit

void greet() {

cout << "Hello!" << endl;

int main() {

greet();

return 0;

}
🔸 Advantages of Using Functions:

 Avoids repetition

 Makes code modular and easy to debug

 Supports top-down programming

 Makes code easier to understand and maintain

🟩 Conclusion:

A function is a reusable, named block of code that performs a specific task. In C++, functions improve the
organization, readability, and efficiency of code. Knowing how to declare, define, and call functions is a fundamental
skill in C++ programming.

🔹 3. List and explain the different variables and operations used in C++ with examples. Explain briefly the
importance of Scope Resolution Operator.

🔸 I. Variables in C++

A variable in C++ is a named memory location used to store data that can be modified during program execution.

✅ Types of Variables in C++:

Type Description Example

Local Variable Declared inside a function/block, accessible only there int x = 10; inside main()
Type Description Example

Global Variable Declared outside all functions, accessible globally int count = 0; at top of program

Static Variable Retains its value between function calls static int n = 0;

Register Variable Stored in CPU register for faster access register int speed = 10;

External Variable Declared using extern, defined elsewhere extern int x;

Constant Variable Value cannot be changed once assigned (const) const float pi = 3.14;

✅ Example:

cpp

CopyEdit

#include <iostream>

using namespace std;

int globalVar = 100; // Global variable

void show() {

static int count = 0; // Static variable

count++;

cout << "Count: " << count << endl;

int main() {

int localVar = 10; // Local variable

cout << "Global: " << globalVar << ", Local: " << localVar << endl;

show(); // Count: 1

show(); // Count: 2

return 0;

🔸 II. Operations in C++

C++ supports many types of operators to perform operations on variables and data.
✅ 1. Arithmetic Operators:

Used to perform mathematical operations.

Operator Meaning Example

+ Addition a+b

- Subtraction a-b

* Multiplication a * b

/ Division a/b

% Modulus a%b

✅ 2. Relational Operators:

Used to compare two values.

Operator Meaning Example

== Equal to a == b

!= Not equal to a != b

> Greater than a > b

< Less than a<b

✅ 3. Logical Operators:

Used to perform logical operations.

Operator Meaning Example

&& Logical AND (a > 0 && b > 0)

` `

! NOT !(a > b)

✅ 4. Assignment Operators:

Operator Meaning Example

= Assign value a = 10;

+= Add and assign a += 5;

-= Subtract and assign a -= 2;

✅ 5. Increment/Decrement Operators:

Operator Description Example

++ Increment by 1 a++ or ++a

-- Decrement by 1 a-- or --a

✅ 6. Bitwise Operators:

Operate on bits directly.

Operator Meaning

& AND

` `

^ XOR

~ NOT

<< Left Shift

>> Right Shift

✅ 7. Ternary Operator:

cpp

CopyEdit

(condition) ? expression1 : expression2;

Example:

cpp

CopyEdit

int max = (a > b) ? a : b;

🔸 III. Scope Resolution Operator ::

✅ Definition:

The scope resolution operator (::) is used to:

 Access global variables when local variables with the same name exist.

 Define functions outside a class.

 Access class members in different scopes.

✅ Example 1: Accessing Global Variable

cpp

CopyEdit

#include <iostream>

using namespace std;

int main() {

int x = 20; // Local variable

cout << "Local x: " << x << endl;

cout << "Global x: " << ::x << endl;

return 0;

Output:

sql

CopyEdit

Local x: 20

Global x: 50

✅ Example 2: Defining Class Function Outside

cpp

CopyEdit

class MyClass {

public:

void display();

};

void MyClass::display() {

cout << "Hello from MyClass" << endl;

🔹 Importance of Scope Resolution Operator:

 Helps avoid ambiguity between local and global variables.

 Enables class method definitions outside the class.

 Provides namespace control (in advanced use).

🟩 Conclusion:
C++ provides various types of variables and operators to manipulate data efficiently. Functions like the Scope
Resolution Operator are crucial for maintaining clear scope control and improving code structure, especially in
object-oriented and modular programming.

🔹 4. What is an Inline Function? How is it different from a Normal Function?

✅ Definition of Inline Function:

An inline function is a function where the compiler replaces the function call with the actual code of the function at
compile-time (if possible).
It is suggested to the compiler using the inline keyword.

🔸 Syntax:

cpp

CopyEdit

inline return_type function_name(parameters) {

// function body

✅ Example:

cpp

CopyEdit

#include <iostream>

using namespace std;

inline int square(int x) {

return x * x;

}
int main() {

cout << "Square of 4: " << square(4) << endl;

return 0;

🔸 Output:

scss

CopyEdit

Square of 4: 16

Here, instead of calling square(4), the compiler replaces it with 4 * 4.

✅ How Inline Functions Work:

 When a function is called, normally the control jumps to that function, executes the code, and returns back
— this causes overhead.

 With inline functions, this jump is avoided, as the code is inserted directly where the function is called (like a
macro).

 This can increase execution speed for small functions, but may increase code size (if overused).

🔸 Differences Between Inline Function and Normal Function

Feature Inline Function Normal Function

Definition Declared with inline keyword No inline keyword

Function Call Code is inserted at call location Control jumps to function code

Speed Faster execution for small functions Slower due to function call overhead

Memory Usage May increase memory (code duplication) Less memory as function exists once

Best For Small, frequently used functions Large or complex functions

Compiler Behavior Just a suggestion — not guaranteed Always a function call

Debugging Harder to debug due to no actual call Easier to trace and debug

✅ Example of Normal Function:

cpp

CopyEdit

int square(int x) {

return x * x;

}
int main() {

int result = square(5); // function call happens here

✅ Same as Inline:

cpp

CopyEdit

inline int square(int x) {

return x * x;

But here, the call is replaced by 5 * 5 during compilation (if compiler agrees).

🔸 When NOT to Use Inline Functions:

 If function contains loops or recursion

 If function is large in size

 If function uses static variables

 When used excessively — can lead to code bloat

🟩 Conclusion:

An inline function helps to reduce function call overhead and is useful for small, simple functions. However, it
should be used wisely to avoid increased code size.
The main difference from a normal function is that inline functions avoid jumping to a separate block of code by
replacing the function call with its actual body during compile time.

🔹 7. Explain C++ Tokens and Reference Variables in C++ with Examples.

✅ Definition:

Tokens are the smallest individual units in a C++ program. When we write a C++ program, the compiler breaks it
down into meaningful elements called tokens.

✅ Types of Tokens in C++:

Token Type Description Example

Keywords Reserved words with special meaning in C++ int, return, if, class

Identifiers Names of variables, functions, classes, etc. sum, main, Student

Constants/Literals Fixed values that do not change 10, 3.14, 'A', "Hello"

Operators Symbols used to perform operations +, -, *, /, =

Punctuators Symbols to structure code ;, ,, {}, (), []

Comments Non-executed lines to explain code // comment, /* multi-line */

✅ Example:

cpp

CopyEdit

#include <iostream> // Keyword, Identifier, Punctuator

using namespace std; // Keyword, Identifier

int main() { // Keyword, Identifier, Punctuator

int a = 10; // Keyword, Identifier, Operator, Constant, Punctuator

cout << a; // Identifier, Operator, Punctuator

return 0; // Keyword, Constant, Punctuator

In the above program, each word/symbol is a token used by the compiler to understand the structure of the code.

🔸 Part 2: Reference Variables in C++

✅ Definition:

A reference variable is an alias (another name) for an already existing variable.

✅ Syntax:

cpp
CopyEdit

type &refVar = originalVar;

Here, refVar is just another name for originalVar.

✅ Example:

cpp

CopyEdit

#include <iostream>

using namespace std;

int main() {

int x = 10;

int &ref = x; // ref is a reference to x

cout << "x: " << x << endl;

cout << "ref: " << ref << endl;

ref = 20; // Changing ref also changes x

cout << "x after modifying ref: " << x << endl;

return 0;

🔹 Output:

yaml

CopyEdit

x: 10

ref: 10

x after modifying ref: 20

✅ Use Cases of Reference Variables:

 Function parameters (to avoid copying values)

 Returning values from functions

 Working with classes and objects

 Useful in operator overloading and memory efficiency

cpp

CopyEdit

void swap(int &a, int &b) {

int temp = a;

a = b;

b = temp;

int main() {

int x = 5, y = 10;

swap(x, y);

cout << "x: " << x << ", y: " << y << endl; // Output: x: 10, y: 5

a and b are reference variables — changes made inside the function affect the original variables.

🟩 Conclusion:

 Tokens are the building blocks of a C++ program. Without them, the compiler can't understand the code.

 Reference variables offer an efficient way to manipulate data without copying. They improve performance
and help write cleaner, more efficient programs.