OOP Basics: Classes and Objects, Access Specifiers, Member Functions, Constructors and Destructors Questions

Question 1

Define class.

Accepted Answer

A **class** is a blueprint that defines **data members** and **member functions**.

Question 2

Define object.

Accepted Answer

An **object** is an instance of a class that has **actual memory**.

Question 3

What is encapsulation?

Accepted Answer

**Encapsulation** is wrapping data and functions into a single unit (class).

Question 4

What is a constructor?

Accepted Answer

A **constructor** is a special member function that initializes an object automatically.

Question 5

What is a destructor?

Accepted Answer

A **destructor** is a special member function that runs when an object is destroyed to clean resources.

Question 6

Which operator is used to define member function outside class?

Accepted Answer

The **scope resolution operator `::`**.

Question 7

Explain OOP and state any three advantages.

Accepted Answer

**OOP** models programs using **objects** that combine data and behaviour. Advantages (any three):
- better real-world modelling
- improved code organisation and maintenance
- **reusability** of code
- **data hiding** and security
- suitable for large projects

Hence OOP helps build maintainable software.

Question 8

Differentiate between class and object (any three points).

Accepted Answer

Differences (any three):
- **Class** is a blueprint; **object** is an instance.
- Class defines members; object has actual values and memory.
- Many objects can be created from one class.
- Class itself does not store per-object data until objects exist.

Question 9

Explain access specifiers in C++.

Accepted Answer

Access specifiers control accessibility of class members:
- **public**: accessible outside class
- **private**: accessible only inside class
- **protected**: accessible in class and derived classes

They support **data hiding** and encapsulation.

Question 10

Explain constructors and mention their properties.

Accepted Answer

A **constructor** initializes objects. Properties:
- same name as class
- **no return type**
- called automatically on object creation
- can be overloaded (default/parameterized/copy)

Thus constructors ensure valid initial state.

Question 11

When is copy constructor called? (any three situations)

Accepted Answer

Copy constructor is called when:
- a new object is initialized from an existing object
- an object is passed **by value** to a function
- an object is returned **by value** from a function (optimizations may apply)

It creates a copy of an existing object.

Question 12

Explain destructor and its importance.

Accepted Answer

A **destructor** runs when an object is destroyed. It has name `~ClassName()` and no return type.
Importance: used to release resources like dynamic memory/files, preventing leaks and ensuring proper cleanup.

Question 13

Explain class and object with example and diagram.

Accepted Answer

### **Explain class and object with example (and diagram)**

A **class** is a **blueprint/template** that defines **data members** (properties) and **member functions** (behaviour). An **object** is an **instance** of a class that has **actual memory**.

**Example**:
- Class: `Student` (roll, name, marks)
- Objects: `s1`, `s2` (actual students)

| Term | Meaning |
|---|---|
| **Class** | definition/blueprint |
| **Object** | instance with memory |

```text
Class: Student
  - roll
  - name
  + show()

Objects: s1, s2
```

Thus, classes help model real-world entities and objects represent actual entities in memory.

Question 14

Explain constructors and types of constructors with a table/flow.

Accepted Answer

### **Explain constructors and types of constructors (with flow/table)**

A **constructor** is a special member function that initializes an object.

**Properties**:
- name same as class name
- **no return type**
- called **automatically** on object creation
- can be **overloaded**

**Types**:
1) **Default constructor**: no parameters
2) **Parameterized constructor**: takes parameters
3) **Copy constructor**: creates new object from existing object (`ClassName(const ClassName &obj)`)

| Type | Parameters | Purpose |
|---|---|---|
| Default | none | default initialization |
| Parameterized | yes | custom initialization |
| Copy | reference to object | copy initialization |

```text
Create object → matching constructor runs → object becomes ready to use
```

So constructors ensure objects start in a valid and usable state.

Question 15

Explain destructor and object life-cycle with flowchart.

Accepted Answer

### **Explain destructor and object life-cycle (with flow)**

A **destructor** is a special member function called automatically when an object is destroyed.

**Key points**:
- name: `~ClassName()`
- **no return type**
- only **one destructor** (cannot be overloaded)
- used to free resources (dynamic memory, files, etc.)

**Life-cycle flow**:

```text
Object created → Constructor called → Object used → Object destroyed → Destructor called
```

For dynamic objects:

```text
new Object → constructor → use → delete → destructor
```

Thus destructors help prevent resource leaks and perform cleanup at the end of an object’s life.

OOP Basics: Classes and Objects, Access Specifiers, Member Functions, Constructors and Destructors

8 more questions to unlock